replica.key            = issue.key
replica.type           = issue.type
replica.assignee       = issue.assignee
replica.reporter       = issue.reporter
replica.summary        = issue.summary
replica.description    = issue.description
replica.labels         = issue.labels
replica.comments       = issue.comments
replica.resolution     = issue.resolution
replica.status         = issue.status
replica.parentId       = issue.parentId
replica.priority       = issue.priority
replica.attachments    = issue.attachments
replica.project        = issue.project

//Comment these lines out if you are interested in sending the full list of versions and components of the source project. 
replica.project.versions = []
replica.project.components = []

replica.customFields."Sprint" = issue.customFields."Sprint"
/*
Custom Fields

replica.customFields."CF Name" = issue.customFields."CF Name"
*/

workItem.labels       = replica.labels
workItem.priority     = replica.priority
if(firstSync){
   // Set type name from source entity, if not found set a default
   workItem.typeName = nodeHelper.getIssueType(replica.type?.name)?.name ?: "Task";
}

workItem.summary      = replica.summary
workItem.description  = replica.description
workItem.attachments  = attachmentHelper.mergeAttachments(workItem, replica)
workItem.comments     = commentHelper.mergeComments(workItem, replica)
def getCurrentSprint = { -> replica."Sprint".find {!it.state.equalsIgnoreCase("CLOSED")} }
if (replica."Sprint" != null && !replica."Sprint".empty && getCurrentSprint() != null) {
  def project = connection.trackerSettings.fieldValues."project"    
  def area = workItem.areaPath ?: workItem.project?.key ?: project
  def sprint = getCurrentSprint()
  def iteration = sprint.name
  def iterationPath = area + "\\" + iteration
  if (iterationPath != workItem.iterationPath) {
      //debug.error("fV.p=${connection.fieldValues."project"}")
      //find existing iterations
      //debug.error("methods=${httpClient.getClass().declaredMethods}")
      def existingIterations = httpClient.get("/${project}/_apis/wit/classificationnodes/Iterations?\$depth=1&api-version=5.0", false)?.children
      /*httpClient.http (
          "GET",
          "/${project}/_apis/wit/classificationnodes".toString(),
          null,
          ["\$depth":["1"],"api-version":["5.0"]],
          [:]
        ) { response ->
          if (response.code >= 300) { debug.error("GET /${project}/_apis/wit/classificationnodes/Iterations?\$depth=1&api-version=5.0 failed: ${response.body}") }
          def json = response.body
          if (json.children == null) {
              debug.error("GET /${project}/_apis/wit/classificationnodes/Iterations?\$depth=1&api-version=5.0 didn't find iteration paths: ${response.body}")
          }
          json.children
      }*/
      
        //debug.error("existingIterations=${existingIterations}")
      if (!existingIterations.name.any {it.equalsIgnoreCase(sprint.name)}) {
          //if we need to create iterations
          def await = { f -> scala.concurrent.Await$.MODULE$.result(f, scala.concurrent.duration.Duration.apply(1, java.util.concurrent.TimeUnit.MINUTES)) }
          def creds = await(httpClient.azureClient.getCredentials())
          def token = creds.accessToken()
          def baseUrl = creds.issueTrackerUrl()
          
          def dateFormat = new java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'")
          def createIterationBody = [name:sprint.name]
          def attributes = null
          if(sprint.startDate) {
              def sd = dateFormat.format(sprint.startDate)
              attributes = ["startDate":sd]
          }
          if(sprint.endDate) {
              def ed = dateFormat.format(sprint.endDate)
              attributes = attributes ?: [:]
              attributes."finishDate" = ed
          }
          if(attributes != null) {
              createIterationBody."attributes" = attributes
          }
          
          def createIterationBodyStr = groovy.json.JsonOutput.toJson(createIterationBody)
          def result = await(httpClient.azureClient.ws
            .url(baseUrl+"/${project}/_apis/wit/classificationnodes/Iterations?api-version=5.0")
            .withAuth(token, token, play.api.libs.ws.WSAuthScheme$BASIC$.MODULE$)
            .withBody(play.api.libs.json.Json.parse(createIterationBodyStr), play.api.libs.ws.JsonBodyWritables$.MODULE$.writeableOf_JsValue)
            //.addHttpHeaders([scala.Tuple2.apply("Content-Type", "applicatio")])
            .withMethod("POST")
            .execute())
        debug.error("result=${result} status=${result.status}")
          //httpClient.post("/${project}/_apis/wit/classificationnodes/Iterations?api-version=5.0".toString(), createIterationBodyStr)
          /*httpClient.http(
              "POST",
              "/${project}/_apis/wit/classificationnodes/Iterations".toString(),
              createIterationBodyStr,
              ["api-version":["5.0"]],
              [:]
            ) { response ->
              if (response.code >= 300) { debug.error("POST /${project}/_apis/wit/classificationnodes/Iterations?api-version=5.0 with body: ${createIterationBodyStr} failed: ${response.body}") }
              def json = response.body
              if (json.id == null) {
                  debug.error("POST /${project}/_apis/wit/classificationnodes/Iterations?api-version=5.0 with body: ${createIterationBodyStr} didn't create a sprint: ${response.body}")
              }
              json
          }*/
      }
      
      workItem.iterationPath = iterationPath
  }
  //debug.error("it=${workItem.iterationPath}")
}
/*
Area Path Sync
This also works for iterationPath field

Set Area Path Manually
workItem.areaPath = "Name of the project\\name of the area"

Set Area Path based on remote side drop-down list
Change "area-path-select-list" to actual custom field name
workItem.areaPath = replica.customFields."area-path-select-list"?.value?.value

Set Area Path based on remote side text field
Change "area-path" to actual custom field name
workItem.areaPath = replica.customFields."area-path".value
*/

/*
Status Synchronization

Sync status according to the mapping [remote workItem status: local workItem status]
If statuses are the same on both sides don"t include them in the mapping
def statusMapping = ["Open":"New", "To Do":"Open"]
def remoteStatusName = replica.status.name
workItem.setStatus(statusMapping[remoteStatusName] ?: remoteStatusName)
*/