import groovy.json.JsonSlurper;
import groovy.json.StreamingJsonBuilder;
import com.atlassian.jira.issue.fields.CustomField;
import com.atlassian.jira.issue.CustomFieldManager;
import com.atlassian.jira.component.ComponentAccessor;
import com.atlassian.jira.issue.Issue;
import com.atlassian.jira.bc.issue.search.SearchService;
import com.atlassian.jira.jql.parser.JqlQueryParser;
import com.atlassian.jira.web.bean.PagerFilter;
import groovy.json.*;
import com.atlassian.crowd.embedded.api.User
import com.atlassian.jira.security.JiraAuthenticationContext
import com.atlassian.plugin.PluginAccessor
import com.atlassian.jira.user.ApplicationUser
 
////////////////////////////////////////////
// ***** CHANGE VARIABLES HERE *****
////////////////////////////////////////////
 
String authorizationStringCloud = "Basic ==="
 
String jqlQuery = '===='
 
////////////////////////////////////////////
// ***** CHANGE VARIABLES HERE *****
////////////////////////////////////////////
 
 
// find TGE custom fields
PluginAccessor pluginAccessor = ComponentAccessor.getPluginAccessor();
CustomFieldManager customFieldManager = ComponentAccessor.getComponent(CustomFieldManager);
Class tgeConfigManagerClass = pluginAccessor.getClassLoader().findClass("com.idalko.jira.plugins.igrid.api.config.grid.TGEGridConfigManager");
def tgeConfigManager = ComponentAccessor.getOSGiComponentInstanceOfType(tgeConfigManagerClass);
List<Long> tgeCustomFieldIds = tgeConfigManager.getGridCustomFieldIds();
List<Map<Long,String>> tgeCustomFieldNames = tgeCustomFieldIds.collect { [(it) : customFieldManager.getCustomFieldObject(it).name] }
   
// read the grid data
Class dataManagerClass = pluginAccessor.getClassLoader().findClass("com.idalko.jira.plugins.igrid.api.data.TGEGridTableDataManager");
def tgeGridDataManager = ComponentAccessor.getOSGiComponentInstanceOfType(dataManagerClass);
 
// get current user
JiraAuthenticationContext jiraAuthenticationContext = ComponentAccessor.getOSGiComponentInstanceOfType(JiraAuthenticationContext.class);
Object userObject = jiraAuthenticationContext.getLoggedInUser();
User user = userObject instanceof ApplicationUser ? ((ApplicationUser) userObject).getDirectoryUser() : (User) userObject
 
StringBuilder responses = new StringBuilder()
 
def searchService = ComponentAccessor.getComponent(SearchService)
def loggedInUser = ComponentAccessor.getJiraAuthenticationContext().getLoggedInUser()
def queryParser = ComponentAccessor.getComponent(JqlQueryParser)
 
//your query goes here
def query = queryParser.parseQuery(jqlQuery)
 
//gets results of query
def search = searchService.search(loggedInUser, query, PagerFilter.getUnlimitedFilter())
 
//iterate over each returned issue
Collection<Issue> issues = search.results
     
// Cloud URL
def baseURL =  "https://databuckets.net/rest/tgc/api/v1/grids/"
+ gridIdCloud
+ "/issue/" +Get issueKey;all Cloud Grids
 
def instanceNamejsonSlurperAccount = "----"

    //Getting the Grid information from the Data Center Jira instance
    URL url;
    url new JsonSlurper()
URL getGridsURL;
getGridsURL = new URL(baseURL);


   URLConnection connectiongetGridsConnection = urlgetGridsURL.openConnection();
    connectiongetGridsConnection.setRequestMethod("GET")
getGridsConnection.doOutput = true
 connectiongetGridsConnection.setRequestProperty("Authorization", authorizationStringServerauthorizationStringCloud)
getGridsConnection.connect();
 
def connection.doOutputgetGridsResponseCode = true
    connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8")
    connection.connect();

getGridsConnection.getResponseCode()
def gridsList
 
if(getGridsResponseCode != 200){
   String serverData = connection.getInputStream().getText()
    def jsonSlurper = new JsonSlurper()
responses.append("Error while getting the list of Grids in Cloud")
}else{
   def objectgridsList = jsonSlurperjsonSlurperAccount.parseText(serverData)
getGridsConnection.getInputStream().getText());
}
 
Map<Long,String> gridCorrespondance Long gridRowsinCloud = -1; //create variable with invalid value just to signal exception and skip condition if failed

    try {

        // Geting Grid info from Cloud to see if it was already uploaded (avoid duplicates[:]
 
for(grid in tgeCustomFieldNames){
    if(gridsList.find { it.name == grid.values()[0].toString() } != null) {
        gridCorrespondance.putAll([(grid.keySet()[0]): (gridsList.find { it.name == grid.values()[0].toString() }.id)])
    }
}
 
for URL(Issue url3;issue : issues){
     
url3 = new URL(baseURL2); for (Long tgeCustomFieldId : tgeCustomFieldIds) {
 
URLConnection connection3 = url3.openConnection();     String issueKey =  connection3issue.setRequestMethodgetKey("GET")
        connection3.doOutputdef issueIdServer = true
        connection3.setRequestProperty("Authorization", authorizationStringCloudissue.getId()
 
      connection3.connect();   def gridIdCloud = gridCorrespondance[tgeCustomFieldId]
   responseCode = connection3.getResponseCode()
        def if(responseCodebaseURL2 != 200){ baseURL + "/" + gridIdCloud + "/issue/" + issueKey
 
 responseMessage
= connection3.getErrorStream().text;       try  }else{
            Stringdef cloudDatacallResult = connection3tgeGridDataManager.getInputStreamreadGridData()issue.getTextgetId(), tgeCustomFieldId, null, null, 0, 10, user);
 
            def jsonSlurperAccountserverDataObject = new JsonSlurpercallResult.getValues()
 
          def cloudjson = jsonSlurperAccount.parseText(cloudData)  // responses.append("Grid ID=" + tgeCustomFieldId + " content: " + callResult.getValues() + "\n");
 
     
    //Long   gridRowsinServer = object.rows.size();   def rowsToAdd = []
 
    gridRowsinCloud = cloudjson.rows.size(); //if it works, change value of variable
if(serverDataObject.size > 0){
       }       } catch(java.io.IOException ex) {
 
       responses.append("!! exception !!");      } for(row in serverDataObject){
     // check if data was already uploaded         if(gridRowsinCloud == 0){
    //if(gridRowsinServer > 0 && gridRowsinCloud == 0){rowsToAdd.add(JsonOutput.toJson(row.collectEntries { [it.key.toString(), (it.value instanceof HashMap) ? it.value.name : it.value] }))
            // Formatting the output so}
that it
fits the POST request body formatting requirements         object.remove("customFieldId")         //Removing Grid ID since does not need to be passed in the request body // Generating the JSON body to pass onto the Cloud API and removing all irrelevant data
 
           object.rows.each { e ->  def cloudJsonObject = jsonSlurperAccount.parseText( '{ "rows":'  //Going through all of the rows from the response+ rowsToAdd.toString() + '}')
 
                cloudJsonObject.rows.each { e.remove("order") ->
 
        // Removing order index         ArrayList<Object> toRemove = new e.remove("rowId")ArrayList<>();
 
          // Removing Row ID since it will be automatically assigned
 e.remove("issueId")
           e.columns.each{ key, value ->   // Unpacking the e.remove("columnsmodified")
section into the previous level of JSON structure              e.remove("id")
 
                 if(value != null || !value.toString().equals("{}") || value != ""){e.each{ key, value ->
                        if(!value instanceof String){ || value === null || value === 'null'){
                          e  toRemove.putadd(key, value))
                        }else
 if(value instanceof org.apache.groovy.json.internal.LazyMap){                 }
 
      if(value.keySet().contains("username")){              for (o in toRemove) {
                        e.remove((String)o);
            // Get user email to match with user in}
Cloud 
                }
          def userManager = ComponentAccessor.getUserManager()    
                 
      def user = userManager.getUserByName(value.username)       // Geting Grid info from Cloud to see if it was already uploaded (avoid duplicates)
 
      if(user != null){        def gridRowsinCloud = -1
 
                try {
 String
email = user.getEmailAddress()                  URL url3;
              // Getting new user info from Cloudurl3 based= on emailnew URL(baseURL2);
                    URLConnection connection3 = url3.openConnection();
        URL urlAccountID           connection3.setRequestMethod("GET")
                    connection3.doOutput urlAccountID= =true
new URL("https://${instanceName}.atlassian.net/rest/api/3/user/search?query=" + email.replace(" ","%20"));                connection3.setRequestProperty("Authorization", authorizationStringCloud)
               URLConnection   connection4 = urlAccountIDconnection3.openConnectionconnect();
 
                    responseCode = connection3.getResponseCode()
 
     connection4.setRequestMethod("GET")               if(responseCode != 200){
                        responseMessage = connection4connection3.setRequestProperty("Authorization", authorizationStringCloudAccountID)getErrorStream().text;
                    }else{
           connection4.doOutput = true           String cloudData = connection3.getInputStream().getText();
                  connection4.connect();      def cloudjson = jsonSlurperAccount.parseText(cloudData)
                        String//Long cloudData1gridRowsinServer = connection4object.getInputStream()rows.getTextsize();
                                def jsonSlurperAccount1 = new JsonSlurper()
      gridRowsinCloud = cloudjson.rows.size(); //if it works, change value of variable
                    }
    def objectAccount1 = jsonSlurperAccount1.parseText(cloudData1)         } catch(java.io.IOException ex) {
                    responses.append("!! exception !!");
                }
 
 
         if(objectAccount1[0] != null){     // Uploading the grid data to the Cloud if the target Grid is empty (non-empty grids are assumed to have been already migrated)
 
       e.put(key, jsonSlurperAccount1.parseText('{"accountId":"' + objectAccount1[0].accountId+'"}'))      if(gridRowsinCloud <= 0){
 
                    try {
} 
                        URL url2;
 }                       url2 = new URL(baseURL2);
}                        URLConnection connection2 = if(valueurl2.keySetopenConnection().contains("label")){;
                        connection2.setRequestMethod("POST")
    e.put(key, value.label)                   connection2.doOutput = true
   }                     }else if(value.toString().length() != 2){connection2.setRequestProperty("Authorization", authorizationStringCloud)
                        econnection2.put(key, value.valuesetRequestProperty("Content-Type", "application/json;charset=UTF-8")
                    }    connection2.outputStream.withWriter("UTF-8") { new StreamingJsonBuilder(it,          cloudJsonObject) }
            }             econnection2.removeconnect("columns");
 
          //  Removing the packed "columns" section as it is redundant and breaks the formattingresponseCode = connection2.getResponseCode()
 
        e.remove("Item Number")         // Remove SEQUENCE type column from the data loadif(responseCode != 201){
         }           try {       responseMessage = connection2.getErrorStream().text + JsonOutput.toJson(cloudJsonObject);
  // Uploading the grid data to the Cloud             URL url2; }else{
           url2 = new URL(baseURL2);             URLConnection connection2responseMessage = url2connection2.openConnectiongetResponseMessage();
            connection2.setRequestMethod("POST")            }
connection2.doOutput =
true             connection2.setRequestProperty("Authorization", authorizationStringCloud)          responses.append(   connection2.setRequestProperty("Content-Type", "application/json;charset=UTF-8")"  ||  IssueKey: " + issueKey +
               connection2.outputStream.withWriter("UTF-8") { new StreamingJsonBuilder(it, object) }             connection2.connect();           " ResponseCode:" + responseCode +
  = connection2.getResponseCode()              if(responseCode != 201){                 responseMessage = connection2.getErrorStream().text + JsonOutput.toJson(object);    " ResponseMessage:" + responseMessage)
 
   }else{                 responseMessage = connection2.getResponseMessage();} catch(java.io.IOException ex) {
 
          }              responses.append("!! exception  !!");
 ||  IssueKey: " + issueKey +              
                   " ResponseCode:"}
+ responseCode
+                    responses.append("\n")
             " ResponseMessage:" + responseMessage)   }
            }
catch(java.io.IOException ex)
{            } catch responses.append("!! exception !!");(Exception e) {
 
            responses.append("Grid ID=" + }tgeCustomFieldId + " data cannot be retrieved: " + e + responses.append("\n");
        }
    }
}
 
return responses