amocrm/internal/tools/construct.go

package tools

import (
	"amocrm/internal/models"
	"encoding/json"
	"fmt"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/model"
	"strings"
	"time"
	"unicode/utf8"
)

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
}

func ConstructField(allAnswers []model.ResultAnswer, result model.AmoUsersTrueResults) ([]models.FieldsValues, []models.Contact, []models.Company, []models.Customer, error) {
	dateCreating := time.Now().Unix()

	entityFieldsMap := make(map[model.EntityType]map[int][]models.Values)
	entityFieldsMap[model.LeadsType] = 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.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: emojiUnicode(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.CompaniesType:
				companyFields = append(companyFields, field)
			case model.CustomersType:
				customerFields = append(customerFields, field)
			}
		}
	}

	var resultInfo model.ResultContent
	err := json.Unmarshal([]byte(result.Content), &resultInfo)
	if err != nil {
		return nil, nil, nil, nil, err
	}

	name := resultInfo.Name
	if name == "" {
		name = fmt.Sprintf("empty name, quiz %d, triggered by answer - %d", result.QuizID, result.AnswerID)
	}

	contactRuleMap := result.FieldsRule.Contact.ContactRuleMap

	contactFields = addContactField(contactFields, resultInfo.Name, model.TypeContactName, contactRuleMap)
	contactFields = addContactField(contactFields, resultInfo.Phone, model.TypeContactPhone, contactRuleMap)
	contactFields = addContactField(contactFields, resultInfo.Text, model.TypeContactText, contactRuleMap)
	contactFields = addContactField(contactFields, resultInfo.Email, model.TypeContactEmail, contactRuleMap)
	contactFields = addContactField(contactFields, resultInfo.Address, model.TypeContactAddress, contactRuleMap)

	return leadFields, []models.Contact{
			{
				Name:               name,
				ResponsibleUserID:  result.PerformerID,
				CreatedBy:          0,
				UpdatedBy:          0,
				CreatedAt:          dateCreating,
				CustomFieldsValues: contactFields,
			},
		}, []models.Company{
			{
				Name:               fmt.Sprintf("Компания %d", result.AnswerID),
				ResponsibleUserID:  result.PerformerID,
				CreatedBy:          0,
				UpdatedBy:          0,
				CreatedAt:          dateCreating,
				CustomFieldsValues: companyFields,
			},
		}, []models.Customer{
			{
				// в амо имя покупателя не может быть пустым, надо как то с этим жить
				Name:              name,
				ResponsibleUserID: result.PerformerID,
				//StatusID:          ,
				CreatedBy:    0,
				UpdatedBy:    0,
				CreatedAt:    dateCreating,
				CustomFields: customerFields,
				RequestID:    fmt.Sprint(result.AnswerID),
			},
		}, nil
}

func isEmoji(r rune) bool {
	// https://symbl.cc/ru/unicode/blocks/emoticons/

	return (r >= 0x1F600 && r <= 0x1F64F) || // эмотикоины
		(r >= 0x1F650 && r <= 0x1F67F) || // орнаментные символы
		(r >= 0x1F680 && r <= 0x1F6FF) || // Транспортные и картографические символы
		(r >= 0x1F700 && r <= 0x1F77F) || // Алхимические символы
		(r >= 0x1F780 && r <= 0x1F7FF) || // Расширенные геометрические фигуры
		(r >= 0x1F800 && r <= 0x1F8FF) || // Дополнительные стрелки — С
		(r >= 0x1F900 && r <= 0x1F9FF) || // Дополнительные символы и пиктограммы
		(r >= 0x1FA00 && r <= 0x1FA6F) || // Шахматные символы
		(r >= 0x1FA70 && r <= 0x1FAFF) || // Расширенные символы и пиктограммы — A
		(r >= 0x1FB00 && r <= 0x1FBFF) || // Символы наследия вычислительной техники
		(r >= 0x20000 && r <= 0x2A6DF) || // Унифицированные идеограммы ККЯ. Расширение B
		(r >= 0x2A700 && r <= 0x2B73F) || // Унифицированные идеограммы ККЯ. Расширение C
		(r >= 0x2B740 && r <= 0x2B81F) || // Унифицированные идеограммы ККЯ. Расширение D
		(r >= 0x2B820 && r <= 0x2CEAF) || // Унифицированные идеограммы ККЯ. Расширение E
		(r >= 0x2CEB0 && r <= 0x2EBEF) || // Унифицированные идеограммы ККЯ. Расширение F
		(r >= 0x2EBF0 && r <= 0x2EE5F) || // CJK Unified Ideographs Extension I
		(r >= 0x2F800 && r <= 0x2FA1F) || // Дополнение к совместимым идеограммам ККЯ
		(r >= 0x30000 && r <= 0x3134F) || // Унифицированные идеограммы ККЯ. Расширение G
		(r >= 0x31350 && r <= 0x323AF) || // Унифицированные идеограммы ККЯ. Расширение H
		(r >= 0xE0000 && r <= 0xE007F) || // Теги
		(r >= 0xE0100 && r <= 0xE01EF) // Дополнение к селекторам вариантов начертания
}

func emojiUnicode(text string) string {
	var result strings.Builder
	for len(text) > 0 {
		r, size := utf8.DecodeRuneInString(text)
		if size == -1 {
			result.WriteString(text[:1])
			text = text[1:]
		} else {
			if isEmoji(r) {
				result.WriteString(fmt.Sprintf(`"0x%x"`, r))
			} else {
				result.WriteRune(r)
			}
			text = text[size:]
		}
	}
	return result.String()
}

func addContactField(contactFields []models.FieldsValues, fieldValue string, fieldType model.ContactQuizConfig, fieldMap map[string]int) []models.FieldsValues {
	if fieldValue != "" {
		contactFields = append(contactFields, models.FieldsValues{
			FieldID: fieldMap[string(fieldType)],
			Values: []models.Values{
				{
					Value: fieldValue,
				},
			},
		})
	}
	return contactFields
}