func ConvertTasks()

in backend/plugins/teambition/tasks/task_converter.go [43:163]
115 lines of code
19 McCabe index (conditional complexity)

func ConvertTasks(taskCtx plugin.SubTaskContext) errors.Error {
	rawDataSubTaskArgs, data := CreateRawDataSubTaskArgs(taskCtx, RAW_TASK_TABLE)
	db := taskCtx.GetDal()
	logger := taskCtx.GetLogger()
	logger.Info("convert project:%d", data.Options.ProjectId)
	clauses := []dal.Clause{
		dal.From(&models.TeambitionTask{}),
		dal.Where("connection_id = ? AND project_id = ?", data.Options.ConnectionId, data.Options.ProjectId),
	}

	cursor, err := db.Cursor(clauses...)
	if err != nil {
		return err
	}
	defer cursor.Close()
	converter, err := helper.NewDataConverter(helper.DataConverterArgs{
		RawDataSubTaskArgs: *rawDataSubTaskArgs,
		InputRowType:       reflect.TypeOf(models.TeambitionTask{}),
		Input:              cursor,
		Convert: func(inputRow interface{}) ([]interface{}, errors.Error) {
			userTool := inputRow.(*models.TeambitionTask)
			originalEstimateMinutes, timeSpentMinutes, timeRemainingMinutes := calcEstimateTimeMinutes(userTool)
			leadTimeMinutes := uint(calcLeadTimeMinutes(userTool))
			issue := &ticket.Issue{
				DomainEntity: domainlayer.DomainEntity{
					Id: getTaskIdGen().Generate(data.Options.ConnectionId, userTool.Id),
				},
				IssueKey:                userTool.Id,
				Title:                   userTool.Content,
				Description:             userTool.Note,
				Priority:                strconv.Itoa(userTool.Priority),
				ParentIssueId:           userTool.ParentTaskId,
				CreatorId:               userTool.CreatorId,
				OriginalProject:         getProjectIdGen().Generate(data.Options.ConnectionId, data.Options.ProjectId),
				AssigneeId:              userTool.ExecutorId,
				Url:                     fmt.Sprintf("https://www.teambition.com/task/%s", userTool.Id),
				LeadTimeMinutes:         &leadTimeMinutes,
				OriginalEstimateMinutes: &originalEstimateMinutes,
				TimeSpentMinutes:        &timeSpentMinutes,
				TimeRemainingMinutes:    &timeRemainingMinutes,
				ResolutionDate:          userTool.AccomplishTime.ToNullableTime(),
				CreatedDate:             userTool.Created.ToNullableTime(),
				UpdatedDate:             userTool.Updated.ToNullableTime(),
			}
			if storyPoint, ok := strconv.ParseFloat(userTool.StoryPoint, 64); ok == nil {
				issue.StoryPoint = &storyPoint
			}
			if a, err := FindAccountById(db, userTool.CreatorId); err == nil {
				issue.CreatorName = a.Name
			}
			if a, err := FindAccountById(db, userTool.ExecutorId); err == nil {
				issue.AssigneeName = a.Name
			}
			if p, err := FindProjectById(db, userTool.ProjectId); err == nil {
				issue.OriginalProject = p.Name
			}

			stdStatusMappings := getStatusMapping(data)
			if taskflowstatus, err := FindTaskFlowStatusById(db, userTool.TfsId); err == nil {
				issue.OriginalStatus = taskflowstatus.Name
				if v, ok := stdStatusMappings[taskflowstatus.Name]; ok {
					issue.Status = v
				} else {
					switch taskflowstatus.Kind {
					case "start":
						issue.Status = ticket.TODO
					case "unset":
						issue.Status = ticket.IN_PROGRESS
					case "end":
						issue.Status = ticket.DONE
					}
				}
			}
			stdTypeMappings := getStdTypeMappings(data)
			if scenario, err := FindTaskScenarioById(db, userTool.SfcId); err == nil {
				issue.OriginalType = scenario.Name
				if v, ok := stdTypeMappings[scenario.Name]; ok {
					issue.Type = v
				} else {
					switch scenario.Source {
					case "application.bug":
						issue.Type = ticket.BUG
					case "application.story":
						issue.Type = ticket.REQUIREMENT
					case "application.risk":
						issue.Type = ticket.INCIDENT
					}
				}
			}

			result := make([]interface{}, 0, 3)
			result = append(result, issue)
			boardIssue := &ticket.BoardIssue{
				BoardId: getProjectIdGen().Generate(data.Options.ConnectionId, userTool.ProjectId),
				IssueId: issue.Id,
			}
			result = append(result, boardIssue)
			if userTool.SprintId != "" {
				result = append(result, &ticket.SprintIssue{
					SprintId: getSprintIdGen().Generate(data.Options.ConnectionId, userTool.SprintId),
					IssueId:  issue.Id,
				})
			}
			if issue.AssigneeId != "" {
				result = append(result, &ticket.IssueAssignee{
					IssueId:      issue.Id,
					AssigneeId:   issue.AssigneeId,
					AssigneeName: issue.AssigneeName,
				})
			}

			return result, nil
		},
	})

	if err != nil {
		return err
	}

	return converter.Execute()
}