amocrm/internal/tools/construct.go

package tools

import (
	"amocrm/internal/models"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/model"
	"time"
)

func ToPipeline(amoPipelines []models.Pipeline) []model.Pipeline {
	var pipelines []model.Pipeline
	for _, p := range amoPipelines {
		pipeline := model.Pipeline{
			Amoid:     int32(p.ID),
			Name:      p.Name,
			Isarchive: p.IsArchive,
			AccountID: int32(p.AccountID),
		}
		pipelines = append(pipelines, pipeline)
	}
	return pipelines
}

func ToStep(amoStatuses []models.Statuses) []model.Step {
	var steps []model.Step
	for _, s := range amoStatuses {
		step := model.Step{
			Amoid:      int32(s.ID),
			Name:       s.Name,
			Pipelineid: int32(s.PipelineID),
			Color:      s.Color,
			Accountid:  int32(s.AccountID),
		}
		steps = append(steps, step)
	}
	return steps
}

func ToTag(amoTag []models.Tag, entity model.EntityType) []model.Tag {
	var tags []model.Tag
	for _, t := range amoTag {
		tag := model.Tag{
			Amoid:  int32(t.ID),
			Entity: entity,
			Name:   t.Name,
			Color:  t.Color,
		}
		tags = append(tags, tag)
	}
	return tags
}

func ToField(amoField []models.CustomField, entity model.EntityType) []model.Field {
	var fields []model.Field
	for _, f := range amoField {
		field := model.Field{
			Amoid:  int32(f.ID),
			Code:   f.Code,
			Name:   f.Name,
			Entity: entity,
			Type:   model.FieldType(f.Type),
		}
		fields = append(fields, field)
	}

	return fields
}

// todo Для добавляемых сущностей (сделка, контакт, компания), можно передать не более 40 значений дополнительных полей.
func ConstructField(allAnswers []model.ResultAnswer, result model.AmoUsersTrueResults) ([]models.FieldsValues, []models.Contact, []models.Company) {
	entityFieldsMap := make(map[model.EntityType]map[int][]models.Values)
	entityFieldsMap[model.LeadsType] = make(map[int][]models.Values)
	entityFieldsMap[model.ContactsType] = make(map[int][]models.Values)
	entityFieldsMap[model.CompaniesType] = make(map[int][]models.Values)
	entityFieldsMap[model.CustomersType] = make(map[int][]models.Values)

	entityRules := make(map[model.EntityType][]model.FieldRule)
	entityRules[model.LeadsType] = result.FieldsRule.Lead
	entityRules[model.ContactsType] = result.FieldsRule.Contact
	entityRules[model.CompaniesType] = result.FieldsRule.Company
	entityRules[model.CustomersType] = result.FieldsRule.Customer

	for entityType, ruleList := range entityRules {
		for _, rule := range ruleList {
			for _, data := range allAnswers {
				if fieldID, ok := rule.Questionid[int(data.QuestionID)]; ok {
					values := entityFieldsMap[entityType][fieldID]
					values = append(values, models.Values{Value: data.Content})
					entityFieldsMap[entityType][fieldID] = values
				}
			}
		}
	}

	var leadFields []models.FieldsValues
	var contactFields []models.FieldsValues
	var companyFields []models.FieldsValues
	var customerFields []models.FieldsValues

	for entityType, fieldMap := range entityFieldsMap {
		for fieldID, values := range fieldMap {
			field := models.FieldsValues{
				FieldID: fieldID,
				Values:  values,
			}
			switch entityType {
			case model.LeadsType:
				leadFields = append(leadFields, field)
			case model.ContactsType:
				contactFields = append(contactFields, field)
			case model.CompaniesType:
				companyFields = append(companyFields, field)
			case model.CustomersType:
				customerFields = append(customerFields, field)
			}
		}
	}

	return leadFields, []models.Contact{
			{
				Name:               result.PerformerName,
				CreatedAt:          time.Now().Unix(),
				UpdatedBy:          0,
				ResponsibleUserID:  result.PerformerID,
				CustomFieldsValues: contactFields,
			},
		}, []models.Company{
			{
				Name:               "OOO PENA CO",
				ResponsibleUserID:  result.PerformerID,
				CreatedBy:          0,
				UpdatedBy:          0,
				CreatedAt:          time.Now().Unix(),
				CustomFieldsValues: companyFields,
			},
		}
}