amocrm/internal/workers_methods/methods.go

package workers_methods

import (
	"amocrm/internal/models"
	"amocrm/internal/tools"
	"amocrm/pkg/amoClient"
	"context"
	"encoding/json"
	"go.uber.org/zap"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/dal"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/model"
	"sync"
	"time"
)

type Methods struct {
	repo      *dal.AmoDal
	amoClient *amoClient.Amo
	logger    *zap.Logger
}

type Deps struct {
	Repo      *dal.AmoDal
	AmoClient *amoClient.Amo
	Logger    *zap.Logger
}

func NewWorkersMethods(deps Deps) *Methods {
	return &Methods{
		repo:      deps.Repo,
		amoClient: deps.AmoClient,
		logger:    deps.Logger,
	}
}

func (m *Methods) UpdateTokens(ctx context.Context) ([]model.Token, error) {
	allTokens, err := m.repo.AmoRepo.GetAllTokens(ctx)
	if err != nil {
		m.logger.Error("error getting all tokens from db in UpdateTokens", zap.Error(err))
		return nil, err
	}

	for _, oldToken := range allTokens {
		req := models.UpdateWebHookReq{
			GrantType:    "refresh_token",
			RefreshToken: oldToken.RefreshToken,
		}

		resp, err := m.amoClient.CreateWebHook(&req)
		if err != nil {
			m.logger.Error("error create webhook in UpdateTokens", zap.Error(err))
			continue
		}

		newToken := model.Token{
			AccountID:    oldToken.AccountID,
			RefreshToken: resp.RefreshToken,
			AccessToken:  resp.AccessToken,
			Expiration:   time.Now().Unix() + resp.ExpiresIn,
			CreatedAt:    time.Now().Unix(),
		}

		err = m.repo.AmoRepo.WebhookUpdate(ctx, newToken)
		if err != nil {
			m.logger.Error("error update token in db", zap.Error(err))
			return nil, err
		}
	}

	newTokens, err := m.repo.AmoRepo.GetAllTokens(ctx)
	if err != nil {
		m.logger.Error("error getting all new updated tokens from db in UpdateTokens", zap.Error(err))
		return nil, err
	}

	return newTokens, nil
}

func (m *Methods) CheckUsers(ctx context.Context, allTokens []model.Token) error {
	listUser := make(map[string][]models.Users)
	for _, token := range allTokens {
		page := 1
		limit := 250
		userData, err := m.amoClient.GetUserList(models.RequestGetListUsers{
			Page:  page,
			Limit: limit,
		}, token.AccessToken)
		if err != nil {
			m.logger.Error("error fetching list users", zap.Error(err))
			break
		}

		listUser[token.AccountID] = append(listUser[token.AccountID], userData.Embedded.Users...)
	}

	var usersForUpdateAndCreate []model.User
	for accountID, users := range listUser {
		mainAccount, err := m.repo.AmoRepo.GetCurrentAccount(ctx, accountID)
		if err != nil {
			m.logger.Error("error getting current account from db", zap.Error(err))
			return err
		}

		currentUserUsers, err := m.repo.AmoRepo.GetUserUsersByID(ctx, mainAccount.Amouserid)
		if err != nil {
			m.logger.Error("error getting user users by amo user id", zap.Error(err))
			return err
		}

		for _, user := range users {
			if user.ID == mainAccount.AmoID {
				err := m.repo.AmoRepo.CheckMainUser(ctx, model.User{
					Name:  user.Name,
					Role:  int32(user.Rights.RoleID),
					Group: int32(user.Rights.GroupID),
					Email: user.Email,
					AmoID: user.ID,
				})
				if err != nil {
					m.logger.Error("error update main user data in db", zap.Error(err))
					return err
				}
			}

			usersForUpdateAndCreate = append(usersForUpdateAndCreate, model.User{
				AmoID:     user.ID,
				Name:      user.FullName,
				Group:     int32(user.Rights.GroupID),
				Role:      int32(user.Rights.RoleID),
				Email:     user.Email,
				Amouserid: mainAccount.Amouserid,
			})
		}

		var deletedUserIDs []int64
		for _, currentUserUser := range currentUserUsers {
			found := false
			for _, user := range users {
				if currentUserUser.AmoID == user.ID {
					found = true
					break
				}
			}

			if !found {
				deletedUserIDs = append(deletedUserIDs, currentUserUser.ID)
			}
		}

		if len(deletedUserIDs) > 0 {
			err := m.repo.AmoRepo.DeleteUsers(ctx, deletedUserIDs)
			if err != nil {
				m.logger.Error("error deleting users in db", zap.Error(err))
				return err
			}
		}
	}

	err := m.repo.AmoRepo.CheckAndUpdateUsers(ctx, usersForUpdateAndCreate)
	if err != nil {
		m.logger.Error("error update users list data in db", zap.Error(err))
		return err
	}

	return nil
}

func (m *Methods) CheckPipelinesAndSteps(ctx context.Context, tokens []model.Token) error {
	for _, token := range tokens {
		user, err := m.repo.AmoRepo.GetCurrentAccount(ctx, token.AccountID)
		if err != nil {
			m.logger.Error("error getting amoUserInfo by account quiz id", zap.Error(err))
			return err
		}
		currentUserPipelines, err := m.repo.AmoRepo.GetUserPipelinesByID(ctx, user.AmoID)
		if err != nil {
			m.logger.Error("error getting user pipelines by amo id", zap.Error(err))
			return err
		}

		currentUserSteps, err := m.repo.AmoRepo.GetUserStepsByID(ctx, user.AmoID)
		if err != nil {
			m.logger.Error("error getting user steps by amo id", zap.Error(err))
			return err
		}

		var receivedSteps []model.Step

		pipelines, err := m.amoClient.GetListPipelines(token.AccessToken)
		if err != nil {
			m.logger.Error("error fetching list pipelines from amo", zap.Error(err))
			continue
		}
		if len(pipelines.Embedded.Pipelines) > 0 {
			receivedPipelines := tools.ToPipeline(pipelines.Embedded.Pipelines)
			err = m.repo.AmoRepo.CheckPipelines(ctx, receivedPipelines)
			if err != nil {
				m.logger.Error("error update list pipelines in db:", zap.Error(err))
				return err
			}

			for _, pipeline := range pipelines.Embedded.Pipelines {
				steps, err := m.amoClient.GetListSteps(pipeline.ID, token.AccessToken)
				if err != nil {
					m.logger.Error("error getting list steps pipeline:", zap.Error(err))
					continue
				}

				receivedStep := tools.ToStep(steps.Embedded.Statuses)
				receivedSteps = append(receivedSteps, receivedStep...)
				err = m.repo.AmoRepo.CheckSteps(ctx, receivedStep)
				if err != nil {
					m.logger.Error("error update pipeline steps in db:", zap.Error(err))
					return err
				}
			}

			var deletedPipelineIDs []int64
			for _, currentUserPipeline := range currentUserPipelines {
				found := false
				for _, receivedPipeline := range receivedPipelines {
					if currentUserPipeline.Amoid == receivedPipeline.Amoid && currentUserPipeline.AccountID == user.AmoID {
						found = true
						break
					}
				}
				if !found {
					deletedPipelineIDs = append(deletedPipelineIDs, currentUserPipeline.ID)
				}
			}

			if len(deletedPipelineIDs) > 0 {
				err := m.repo.AmoRepo.DeletePipelines(ctx, deletedPipelineIDs)
				if err != nil {
					m.logger.Error("error deleting pipelines in db", zap.Error(err))
					return err
				}
			}

			var deletedStepIDs []int64
			for _, currentUserStep := range currentUserSteps {
				found := false
				for _, receivedStep := range receivedSteps {
					if currentUserStep.Amoid == receivedStep.Amoid && currentUserStep.Accountid == user.AmoID && currentUserStep.Pipelineid == receivedStep.Pipelineid {
						found = true
						break
					}
				}
				if !found {
					deletedStepIDs = append(deletedStepIDs, currentUserStep.ID)
				}
			}

			if len(deletedStepIDs) > 0 {
				err := m.repo.AmoRepo.DeleteSteps(ctx, deletedStepIDs)
				if err != nil {
					m.logger.Error("error deleting steps in db", zap.Error(err))
					return err
				}
			}
		}
	}

	return nil
}

func (m *Methods) CheckTags(ctx context.Context, tokens []model.Token) error {
	for _, token := range tokens {
		user, err := m.repo.AmoRepo.GetCurrentAccount(ctx, token.AccountID)
		if err != nil {
			m.logger.Error("error getting amoUserInfo by account quiz id", zap.Error(err))
			return err
		}

		currentUserTags, err := m.repo.AmoRepo.GetUserTagsByID(ctx, user.AmoID)
		if err != nil {
			m.logger.Error("error getting user tags by amo id", zap.Error(err))
			return err
		}

		var wg sync.WaitGroup
		wg.Add(4)

		var tagsMap sync.Map
		entityTypes := []model.EntityType{model.LeadsType, model.ContactsType, model.CompaniesType, model.CustomersType}
		for _, entityType := range entityTypes {
			go func(entityType model.EntityType) {
				defer wg.Done()
				page := 1
				limit := 250

				for {
					req := models.GetListTagsReq{
						Page:       page,
						Limit:      limit,
						EntityType: entityType,
					}
					tags, err := m.amoClient.GetListTags(req, token.AccessToken)
					if err != nil {
						m.logger.Error("error getting list of tags", zap.Error(err))
						return
					}

					if tags == nil || len(tags.Embedded.Tags) == 0 {
						break
					}

					tagsMap.Store(entityType, tags.Embedded.Tags)

					page++
				}
			}(entityType)
		}

		wg.Wait()

		var deletedTagIDs []int64
		for _, currentUserTag := range currentUserTags {
			found := false
			for _, entityType := range entityTypes {
				if tags, ok := tagsMap.Load(entityType); ok {
					if len(tags.([]models.Tag)) > 0 {
						receivedTags := tools.ToTag(tags.([]models.Tag), entityType)
						for _, tag := range receivedTags {
							if currentUserTag.Amoid == tag.Amoid && currentUserTag.Accountid == user.AmoID && currentUserTag.Entity == entityType {
								found = true
								break
							}
						}
					}
				}
				if found {
					break
				}
			}

			if !found {
				deletedTagIDs = append(deletedTagIDs, currentUserTag.ID)
			}
		}

		if len(deletedTagIDs) > 0 {
			err = m.repo.AmoRepo.DeleteTags(ctx, deletedTagIDs)
			if err != nil {
				m.logger.Error("error deleting tags in db", zap.Error(err))
				return err
			}
		}

		for _, entityType := range entityTypes {
			if tags, ok := tagsMap.Load(entityType); ok {
				if len(tags.([]models.Tag)) > 0 {
					err := m.repo.AmoRepo.CheckTags(ctx, tools.ToTag(tags.([]models.Tag), entityType), token.AccountID)
					if err != nil {
						switch entityType {
						case model.LeadsType:
							m.logger.Error("error updating leads tags in db", zap.Error(err))
							return err
						case model.ContactsType:
							m.logger.Error("error updating contacts tags in db", zap.Error(err))
							return err
						case model.CompaniesType:
							m.logger.Error("error updating companies tags in db", zap.Error(err))
							return err
						case model.CustomersType:
							m.logger.Error("error updating customer tags in db", zap.Error(err))
							return err
						}
					}
				}
			}
		}
	}
	return nil
}

func (m *Methods) CheckFields(ctx context.Context, tokens []model.Token) error {
	for _, token := range tokens {
		user, err := m.repo.AmoRepo.GetCurrentAccount(ctx, token.AccountID)
		if err != nil {
			m.logger.Error("error getting amoUserInfo by account quiz id", zap.Error(err))
			return err
		}

		currentUserFields, err := m.repo.AmoRepo.GetUserFieldsByID(ctx, user.AmoID)
		if err != nil {
			m.logger.Error("error getting user fields by amo id", zap.Error(err))
			return err
		}

		var wg sync.WaitGroup
		wg.Add(4)

		var fieldsMap sync.Map
		entityTypes := []model.EntityType{model.LeadsType, model.ContactsType, model.CompaniesType, model.CustomersType}
		for _, entityType := range entityTypes {
			go func(entityType model.EntityType) {
				defer wg.Done()
				page := 1
				limit := 50

				for {
					req := models.GetListFieldsReq{
						Page:       page,
						Limit:      limit,
						EntityType: entityType,
					}
					fields, err := m.amoClient.GetListFields(req, token.AccessToken)
					if err != nil {
						m.logger.Error("error getting list of fields", zap.Error(err))
						return
					}

					if fields == nil || len(fields.Embedded.CustomFields) == 0 {
						break
					}

					fieldsMap.Store(entityType, fields.Embedded.CustomFields)

					page++
				}
			}(entityType)
		}

		wg.Wait()

		var deletedFieldIDs []int64
		for _, currentUserField := range currentUserFields {
			found := false
			for _, entityType := range entityTypes {
				if fields, ok := fieldsMap.Load(entityType); ok {
					if len(fields.([]models.CustomField)) > 0 {
						receivedFields := tools.ToField(fields.([]models.CustomField), entityType)
						for _, field := range receivedFields {
							if currentUserField.Amoid == field.Amoid && currentUserField.Accountid == user.AmoID && currentUserField.Entity == entityType {
								found = true
								break
							}
						}
					}
				}
				if found {
					break
				}
			}

			if !found {
				deletedFieldIDs = append(deletedFieldIDs, currentUserField.ID)
			}
		}

		if len(deletedFieldIDs) > 0 {
			err = m.repo.AmoRepo.DeleteFields(ctx, deletedFieldIDs)
			if err != nil {
				m.logger.Error("error deleting fields in db", zap.Error(err))
				return err
			}
		}

		for _, entityType := range entityTypes {
			if fields, ok := fieldsMap.Load(entityType); ok {
				if len(fields.([]models.CustomField)) > 0 {
					err := m.repo.AmoRepo.CheckFields(ctx, tools.ToField(fields.([]models.CustomField), entityType), token.AccountID)
					if err != nil {
						switch entityType {
						case model.LeadsType:
							m.logger.Error("error updating leads fields in db", zap.Error(err))
							return err
						case model.ContactsType:
							m.logger.Error("error updating contacts fields in db", zap.Error(err))
							return err
						case model.CompaniesType:
							m.logger.Error("error updating companies fields in db", zap.Error(err))
							return err
						case model.CustomersType:
							m.logger.Error("error updating customer fields in db", zap.Error(err))
							return err
						}
					}
				}
			}
		}
	}

	return nil
}

func (m *Methods) GetTokenByID(ctx context.Context, accountID string) (*model.Token, error) {
	token, err := m.repo.AmoRepo.GetTokenByID(ctx, accountID)
	if err != nil {
		m.logger.Error("error getting token by account id from db", zap.Error(err))
		return nil, err
	}

	return token, nil
}

func (m *Methods) CreateUserFromWebHook(ctx context.Context, accountID string, authCode string) (*model.Token, error) {
	// получаем аксес и рефреш токены по коду авторизации
	forGetTokens := models.CreateWebHookReq{
		GrantType: "authorization_code",
		Code:      authCode,
	}

	tokens, err := m.amoClient.CreateWebHook(&forGetTokens)
	if err != nil {
		m.logger.Error("error getting webhook in CreateUserFromWebHook:", zap.Error(err))
		return nil, err
	}

	// получаем информацию о пользователе по аксес токену
	userInfo, err := m.amoClient.GetUserInfo(tokens.AccessToken)
	if err != nil {
		m.logger.Error("error getting UserInfo in CreateUserFromWebHook:", zap.Error(err))
		return nil, err
	}

	toCreate := model.User{
		Name:      userInfo.Name,
		Subdomain: userInfo.Subdomain,
		AmoID:     userInfo.ID,
		Amouserid: userInfo.ID,
		Country:   userInfo.Country,
	}

	err = m.repo.AmoRepo.CreateAccount(ctx, accountID, toCreate)
	if err != nil {
		m.logger.Error("error create account in db in CreateUserFromWebHook", zap.Error(err))
		return nil, err
	}

	err = m.repo.AmoRepo.WebhookCreate(ctx, model.Token{
		RefreshToken: tokens.RefreshToken,
		AccessToken:  tokens.AccessToken,
		AccountID:    accountID,
		AuthCode:     authCode,
		Expiration:   time.Now().Unix() + tokens.ExpiresIn,
		CreatedAt:    time.Now().Unix(),
	})
	if err != nil {
		m.logger.Error("error adding tokens to db in CreateUserFromWebHook", zap.Error(err))
		return nil, err
	}

	return &model.Token{
		AccountID:    accountID,
		RefreshToken: tokens.RefreshToken,
		AccessToken:  tokens.AccessToken,
	}, nil
}

func (m *Methods) CheckUTMs(ctx context.Context, token, accountID string, ids []int32) ([]model.Field, error) {
	utms, err := m.repo.AmoRepo.GetUtmsByID(ctx, ids)
	if err != nil {
		m.logger.Error("error getting user UTM byList IDs", zap.Error(err))
		return nil, err
	}

	user, err := m.repo.AmoRepo.GetCurrentAccount(ctx, accountID)
	if err != nil {
		m.logger.Error("error getting user data by account id in check utms wc method", zap.Error(err))
		return nil, err
	}

	fields, err := m.repo.AmoRepo.GetUserFieldsByID(ctx, user.AmoID)
	if err != nil {
		m.logger.Error("error getting user fields by amo account id", zap.Error(err))
		return nil, err
	}

	if len(utms) < 0 {
		return fields, nil
	}

	toCreated, toUpdate := tools.ToCreatedUpdate(utms, fields)

	if len(toUpdate) > 0 {
		err = m.repo.AmoRepo.UpdateUtmsFields(ctx, toUpdate)
		if err != nil {
			m.logger.Error("error update utms fields in db", zap.Error(err))
			return nil, err
		}
	}

	if len(toCreated) > 0 {
		createdFields, err := m.amoClient.AddFields(toCreated, model.LeadsType, token)
		if err != nil {
			m.logger.Error("error created amo fields", zap.Error(err))
			return nil, err
		}

		newFields := tools.ToField(createdFields.Embedded.CustomFields, model.LeadsType)

		err = m.repo.AmoRepo.CheckFields(ctx, newFields, accountID)
		if err != nil {
			m.logger.Error("error created amo fields in db", zap.Error(err))
			return nil, err
		}

		forUpdate := tools.MatchingUTMs(utms, createdFields.Embedded.CustomFields)
		err = m.repo.AmoRepo.UpdateUTMs(ctx, forUpdate)
		if err != nil {
			m.logger.Error("error update utms in db", zap.Error(err))
			return nil, err
		}

		fields = append(fields, newFields...)
	}

	return fields, nil
}

func (m *Methods) CheckFieldRule(ctx context.Context, token string, accountID string, req models.KafkaRule, currentFields []model.Field) error {
	var (
		leadIDs, companyIDs, customerIDs                   []int32
		leadQuestions, companyQuestions, customerQuestions []model.Question
		questionsTypeMap                                   = make(map[model.EntityType][]model.Question)
		newFields                                          []model.Field
		lead, company, customer                            []model.FieldRule
		currentFieldsRule                                  = req.Fieldsrule
		err                                                error
	)

	quiz, err := m.repo.QuizRepo.GetQuizById(ctx, accountID, uint64(req.QuizID))
	if err != nil {
		m.logger.Error("error getting quiz by quizID and accountID", zap.Error(err))
		return err
	}

	var quizConfig model.QuizContact
	err = json.Unmarshal([]byte(quiz.Config), &quizConfig)
	if err != nil {
		m.logger.Error("error serialization quizConfig to model QuizContact", zap.Error(err))
		return err
	}

	leadIDs = tools.ToQuestionIDs(req.Fieldsrule.Lead)
	customerIDs = tools.ToQuestionIDs(req.Fieldsrule.Customer)
	companyIDs = tools.ToQuestionIDs(req.Fieldsrule.Company)

	getQuestions := func(questionIDs []int32, questions *[]model.Question) {
		if len(questionIDs) > 0 {
			*questions, err = m.repo.QuestionRepo.GetQuestionListByIDs(ctx, questionIDs)
			if err != nil {
				m.logger.Error("error getting questions", zap.Error(err))
				return
			}
		}
	}

	getQuestions(leadIDs, &leadQuestions)
	getQuestions(customerIDs, &customerQuestions)
	getQuestions(companyIDs, &companyQuestions)

	questionsTypeMap[model.LeadsType] = append(questionsTypeMap[model.LeadsType], leadQuestions...)
	questionsTypeMap[model.CustomersType] = append(questionsTypeMap[model.CustomersType], customerQuestions...)
	questionsTypeMap[model.CompaniesType] = append(questionsTypeMap[model.CompaniesType], companyQuestions...)

	toCreated, toUpdate := tools.ToCreatedUpdateQuestionRules(questionsTypeMap, currentFields)
	contactFieldsToCreate, forAdding := tools.ForContactRules(quizConfig, currentFields)

	for entity, fields := range toCreated {
		if len(fields) == 0 {
			continue
		}

		createdFields, err := m.amoClient.AddFields(fields, entity, token)
		if err != nil {
			m.logger.Error("error adding fields to amo", zap.Any("type", entity), zap.Error(err))
			continue
		}
		newFields = append(newFields, tools.ToField(createdFields.Embedded.CustomFields, entity)...)
	}

	if len(contactFieldsToCreate) > 0 {
		createdFields, err := m.amoClient.AddFields(contactFieldsToCreate, model.ContactsType, token)
		if err != nil {
			m.logger.Error("error adding fields to amo", zap.Any("type", model.ContactsType), zap.Error(err))
		}

		contructedFields := tools.ToField(createdFields.Embedded.CustomFields, model.ContactsType)

		newFields = append(newFields, contructedFields...)

		for _, field := range contructedFields {
			if _, ok := forAdding[field.Name]; ok {
				forAdding[field.Name] = int(field.Amoid)
			}
		}
	}

	if len(newFields) > 0 {
		err = m.repo.AmoRepo.CheckFields(ctx, newFields, accountID)
		if err != nil {
			m.logger.Error("error updating fields rule in db Check Fields", zap.Error(err))
			return err
		}
	}

	constructFieldRules := func(fieldRuleArrCurrent []model.FieldRule, questions []model.Question, fieldRule *[]model.FieldRule) {
		for _, rules := range fieldRuleArrCurrent {
			for questionID := range rules.Questionid {
				for _, question := range questions {
					if fieldID, ok := toUpdate[questionID]; ok {
						ruleMap := make(map[int]int)
						ruleMap[questionID] = fieldID
						*fieldRule = append(*fieldRule, model.FieldRule{Questionid: ruleMap})
						break
					}
					if questionID == int(question.Id) {
						for _, field := range newFields {
							if question.Title == field.Name {
								ruleMap := make(map[int]int)
								ruleMap[questionID] = int(field.Amoid)
								*fieldRule = append(*fieldRule, model.FieldRule{Questionid: ruleMap})
							}
						}
					}
				}
			}
		}
	}

	constructFieldRules(currentFieldsRule.Lead, leadQuestions, &lead)
	constructFieldRules(currentFieldsRule.Customer, customerQuestions, &customer)
	constructFieldRules(currentFieldsRule.Company, companyQuestions, &company)

	err = m.repo.AmoRepo.UpdateFieldRules(ctx, model.Fieldsrule{
		Lead:     lead,
		Customer: customer,
		Company:  company,
		Contact:  model.ContactRules{ContactRuleMap: forAdding},
	}, accountID, req.QuizID)

	if err != nil {
		m.logger.Error("error updating fields rule in db", zap.Error(err))
		return err
	}

	return nil
}