common/repository/amo/amo.go

package amo

import (
	"context"
	"database/sql"
	"encoding/json"
	"gitea.pena/SQuiz/common/dal/sqlcgen"
	"gitea.pena/SQuiz/common/model"
	"gitea.pena/SQuiz/common/pj_errors"
	"time"
)

type AmoRepository struct {
	queries *sqlcgen.Queries
	pool    *sql.DB
}

type Deps struct {
	Queries *sqlcgen.Queries
	Pool    *sql.DB
}

func NewAmoRepository(deps Deps) *AmoRepository {
	return &AmoRepository{
		queries: deps.Queries,
		pool:    deps.Pool,
	}
}

// методы пользователя

func (r *AmoRepository) GettingUserWithPagination(ctx context.Context, req *model.PaginationReq, accountID string) (*model.UserListResp, error) {
	rows, err := r.queries.GetUsersWithPagination(ctx, sqlcgen.GetUsersWithPaginationParams{
		Column2:   req.Page,
		Limit:     req.Size,
		Accountid: accountID,
	})

	if err != nil {
		return nil, err
	}
	var count int64
	var users []model.AmoAccountUser
	for _, row := range rows {
		user := model.AmoAccountUser{
			ID:        row.ID,
			AmoID:     row.Amoid,
			AmoUserID: row.Amouserid,
			Name:      row.Name,
			Email:     row.Email,
			Group:     row.Group,
			Role:      row.Role,
			Deleted:   row.Deleted,
			CreatedAt: row.Createdat,
		}
		count = row.TotalCount

		users = append(users, user)
	}

	resp := model.UserListResp{
		Count: count,
		Items: users,
	}

	return &resp, nil
}

func (r *AmoRepository) SoftDeleteAccount(ctx context.Context, accountID string) error {
	err := r.queries.SoftDeleteAccount(ctx, accountID)
	if err != nil {
		return err
	}
	return nil
}

func (r *AmoRepository) GetCurrentAccount(ctx context.Context, accountID string) (*model.AmoAccount, error) {
	row, err := r.queries.GetCurrentCompany(ctx, accountID)
	if err != nil {
		return nil, err
	}

	user := model.AmoAccount{
		ID:        row.ID,
		AccountID: row.Accountid,
		AmoID:     row.Amoid,
		Name:      row.Name,
		Deleted:   row.Deleted,
		CreatedAt: row.Createdat,
		Subdomain: row.Subdomain,
		Country:   row.Country,
		DriveURL:  row.Driveurl,
	}

	_, err = r.queries.CheckExpiredToken(ctx, accountID)
	if err != nil {
		if err == sql.ErrNoRows {
			user.Stale = false
			return &user, nil
		}
		return nil, err
	}

	user.Stale = true

	return &user, nil
}

func (r *AmoRepository) UpdateCurrentAccount(ctx context.Context, user model.AmoAccount) error {
	err := r.queries.UpdateAmoAccount(ctx, sqlcgen.UpdateAmoAccountParams{
		Accountid: user.AccountID,
		Name:      user.Name,
		Subdomain: user.Subdomain,
		Country:   user.Country,
		Driveurl:  user.DriveURL,
	})
	if err != nil {
		return err
	}
	return nil
}

func (r *AmoRepository) CreateAccount(ctx context.Context, userInfo model.AmoAccount) error {
	err := r.queries.CreateAmoAccount(ctx, sqlcgen.CreateAmoAccountParams{
		Accountid: userInfo.AccountID,
		Amoid:     userInfo.AmoID,
		Name:      userInfo.Name,
		Subdomain: userInfo.Subdomain,
		Country:   userInfo.Country,
		Driveurl:  userInfo.DriveURL,
	})

	if err != nil {
		return err
	}

	return nil
}

// todo возможно стоит обновлять еще и компанию пока не знаю

func (r *AmoRepository) AddAmoAccountUser(ctx context.Context, user model.AmoAccountUser) error {
	err := r.queries.AddAmoAccountUser(ctx, sqlcgen.AddAmoAccountUserParams{
		Amoid:     user.AmoID,
		Amouserid: user.AmoUserID,
		Name:      user.Name,
		Email:     user.Email,
		Role:      user.Role,
		Group:     user.Group,
	})
	if err != nil {
		return err
	}

	return nil
}

func (r *AmoRepository) UpdateAmoAccountUser(ctx context.Context, user model.AmoAccountUser) error {
	err := r.queries.UpdateAmoAccountUser(ctx, sqlcgen.UpdateAmoAccountUserParams{
		Amoid:     user.AmoID,
		Amouserid: user.AmoUserID,
		Name:      user.Name,
		Email:     user.Email,
		Role:      user.Role,
		Group:     user.Group,
	})
	if err != nil {
		return err
	}

	return nil
}

func (r *AmoRepository) GetTokenByID(ctx context.Context, accountID string) (*model.Token, error) {
	row, err := r.queries.GetTokenById(ctx, accountID)
	if err != nil {
		return nil, err
	}

	return &model.Token{
		AccountID:    row.Accountid,
		RefreshToken: row.Refreshtoken,
		AccessToken:  row.Accesstoken,
	}, nil
}

func (r *AmoRepository) DeleteUsers(ctx context.Context, ids []int64) error {
	err := r.queries.DeleteUsers(ctx, ids)
	if err != nil {
		return err
	}
	return nil
}

func (r *AmoRepository) GetUserUsersByID(ctx context.Context, amoUserID int32) ([]model.AmoAccountUser, error) {
	rows, err := r.queries.GetUserUsersByID(ctx, amoUserID)
	if err != nil {
		return nil, err
	}

	var users []model.AmoAccountUser
	for _, row := range rows {
		user := model.AmoAccountUser{
			ID:        row.ID,
			AmoID:     row.Amoid,
			AmoUserID: row.Amouserid,
			Name:      row.Name,
			Email:     row.Email,
			Group:     row.Group,
			Role:      row.Role,
			Deleted:   row.Deleted,
			CreatedAt: row.Createdat,
		}
		users = append(users, user)
	}

	return users, nil
}

// методы webhook

func (r *AmoRepository) WebhookCreate(ctx context.Context, tokens model.Token) error {
	err := r.queries.CreateWebHook(ctx, sqlcgen.CreateWebHookParams{
		Accountid:    tokens.AccountID,
		Refreshtoken: tokens.RefreshToken,
		Accesstoken:  tokens.AccessToken,
		Authcode:     tokens.AuthCode,
		Expiration:   time.Unix(tokens.Expiration, 0).In(time.Unix(tokens.CreatedAt, 0).Location()),
		Createdat:    sql.NullTime{Time: time.Unix(tokens.CreatedAt, 0), Valid: true},
	})

	if err != nil {
		return err
	}

	return nil
}

func (r *AmoRepository) WebhookUpdate(ctx context.Context, token model.Token) error {
	err := r.queries.WebhookUpdate(ctx, sqlcgen.WebhookUpdateParams{
		Accesstoken:  token.AccessToken,
		Refreshtoken: token.RefreshToken,
		Accountid:    token.AccountID,
		Column3:      token.Expiration,
		Column4:      token.CreatedAt,
	})
	if err != nil {
		return err
	}

	return nil
}

func (r *AmoRepository) GetAllTokens(ctx context.Context) ([]model.Token, error) {
	rows, err := r.queries.GetAllTokens(ctx)
	if err != nil {
		return nil, err
	}

	var tokens []model.Token

	for _, row := range rows {
		token := model.Token{
			AccountID:    row.Accountid,
			AccessToken:  row.Accesstoken,
			RefreshToken: row.Refreshtoken,
			AuthCode:     row.Authcode,
			Expiration:   row.Expiration.Unix(),
			CreatedAt:    row.Createdat.Time.Unix(),
		}

		tokens = append(tokens, token)
	}

	return tokens, nil
}

func (r *AmoRepository) WebhookDelete(ctx context.Context, amoID int) error {
	err := r.queries.WebhookDelete(ctx, int32(amoID))
	if err != nil {
		return err
	}
	return nil
}

// методы pipelines

func (r *AmoRepository) GetPipelinesWithPagination(ctx context.Context, req *model.PaginationReq, accountID string) (*model.UserListPipelinesResp, error) {
	rows, err := r.queries.GetPipelinesWithPagination(ctx, sqlcgen.GetPipelinesWithPaginationParams{
		Accountid: accountID,
		Column2:   req.Page,
		Limit:     req.Size,
	})
	if err != nil {
		return nil, err
	}

	var count int64
	var pipelines []model.Pipeline

	for _, row := range rows {
		count = row.TotalCount
		pipeline := model.Pipeline{
			ID:        row.ID,
			Amoid:     row.Amoid,
			AccountID: row.Accountid,
			Name:      row.Name,
			Isarchive: row.Isarchive,
			Createdat: row.Createdat.Time.Unix(),
		}
		pipelines = append(pipelines, pipeline)
	}

	resp := model.UserListPipelinesResp{
		Count: count,
		Items: pipelines,
	}
	return &resp, nil
}

func (r *AmoRepository) CheckPipelines(ctx context.Context, pipelines []model.Pipeline) error {
	dollar1, err := json.Marshal(pipelines)
	if err != nil {
		return err
	}
	rows, err := r.queries.CheckPipelines(ctx, dollar1)
	if err != nil {
		return err
	}

	if rows != nil {
		var toUpdate []model.Pipeline
		for _, row := range rows {
			to := model.Pipeline{
				Amoid:     row.Amoid,
				AccountID: row.Accountid,
				Name:      row.Name,
				Isarchive: row.Isarchive,
			}
			toUpdate = append(toUpdate, to)
		}
		dollar1, err := json.Marshal(toUpdate)
		if err != nil {
			return err
		}

		err = r.queries.UpdatePipelines(ctx, dollar1)
		if err != nil {
			return err
		}
	}

	return nil
}

func (r *AmoRepository) DeletePipelines(ctx context.Context, ids []int64) error {
	err := r.queries.DeletePipelines(ctx, ids)
	if err != nil {
		return err
	}
	return nil
}

func (r *AmoRepository) GetUserPipelinesByID(ctx context.Context, accountID int32) ([]model.Pipeline, error) {
	rows, err := r.queries.GetUserPipelinesByID(ctx, accountID)
	if err != nil {
		return nil, err
	}

	var pipelines []model.Pipeline

	for _, row := range rows {
		pipeline := model.Pipeline{
			ID:        row.ID,
			Amoid:     row.Amoid,
			AccountID: row.Accountid,
			Name:      row.Name,
			Isarchive: row.Isarchive,
		}
		pipelines = append(pipelines, pipeline)
	}

	return pipelines, nil
}

// методы steps

func (r *AmoRepository) GetStepsWithPagination(ctx context.Context, req *model.PaginationReq, accountID string, pipelineID int32) (*model.UserListStepsResp, error) {
	rows, err := r.queries.GetStepsWithPagination(ctx, sqlcgen.GetStepsWithPaginationParams{
		Accountid:  accountID,
		Column2:    req.Page,
		Limit:      req.Size,
		Pipelineid: pipelineID,
	})
	if err != nil {
		return nil, err
	}

	var count int64
	var steps []model.Step

	for _, row := range rows {
		count = row.TotalCount
		step := model.Step{
			ID:         row.ID,
			Amoid:      row.Amoid,
			Pipelineid: row.Pipelineid,
			Accountid:  row.Accountid,
			Name:       row.Name,
			Color:      row.Color,
			Createdat:  row.Createdat.Time.Unix(),
		}
		steps = append(steps, step)
	}

	resp := model.UserListStepsResp{
		Count: count,
		Items: steps,
	}

	return &resp, nil
}

func (r *AmoRepository) CheckSteps(ctx context.Context, steps []model.Step) error {
	dollar1, err := json.Marshal(steps)
	if err != nil {
		return err
	}

	rows, err := r.queries.CheckSteps(ctx, dollar1)
	if err != nil {
		return err
	}

	if rows != nil {
		var toUpdate []model.Step
		for _, row := range rows {
			to := model.Step{
				Amoid:      row.Amoid,
				Pipelineid: row.Pipelineid,
				Accountid:  row.Accountid,
				Name:       row.Name,
				Color:      row.Color,
			}
			toUpdate = append(toUpdate, to)
		}

		dollar1, err := json.Marshal(toUpdate)
		if err != nil {
			return err
		}

		err = r.queries.UpdateSteps(ctx, dollar1)
		if err != nil {
			return err
		}
	}

	return nil
}

func (r *AmoRepository) DeleteSteps(ctx context.Context, ids []int64) error {
	err := r.queries.DeleteSteps(ctx, ids)
	if err != nil {
		return err
	}
	return nil
}

func (r *AmoRepository) GetUserStepsByID(ctx context.Context, accountID int32) ([]model.Step, error) {
	rows, err := r.queries.GetUserStepsByID(ctx, accountID)
	if err != nil {
		return nil, err
	}

	var steps []model.Step

	for _, row := range rows {
		step := model.Step{
			ID:         row.ID,
			Amoid:      row.Amoid,
			Pipelineid: row.Pipelineid,
			Accountid:  row.Accountid,
			Name:       row.Name,
			Color:      row.Color,
		}
		steps = append(steps, step)
	}

	return steps, nil
}

// методы tags

func (r *AmoRepository) GetTagsWithPagination(ctx context.Context, req *model.PaginationReq, accountID string) (*model.UserListTagsResp, error) {
	rows, err := r.queries.GetTagsWithPagination(ctx, sqlcgen.GetTagsWithPaginationParams{
		Accountid: accountID,
		Column2:   req.Page,
		Limit:     req.Size,
	})
	if err != nil {
		return nil, err
	}

	var count int64
	var tags []model.Tag
	for _, row := range rows {
		count = row.TotalCount

		var entity model.EntityType
		v := string(row.Entity.([]byte))
		entity = model.EntityType(v)

		tag := model.Tag{
			ID:        row.ID,
			Amoid:     row.Amoid,
			Accountid: row.Accountid,
			Entity:    entity,
			Name:      row.Name,
			Color:     &row.Color,
			Createdat: row.Createdat.Time.Unix(),
		}
		tags = append(tags, tag)
	}

	resp := model.UserListTagsResp{
		Count: count,
		Items: tags,
	}

	return &resp, nil
}

func (r *AmoRepository) CheckTags(ctx context.Context, tags []model.Tag, tokenID string) error {
	column2, err := json.Marshal(tags)
	if err != nil {
		return err
	}

	rows, err := r.queries.CheckTags(ctx, sqlcgen.CheckTagsParams{
		Accountid: tokenID,
		Column2:   column2,
	})

	if rows != nil {
		var toUpdate []model.Tag
		for _, row := range rows {
			var entity model.EntityType
			v := string(row.Entity.([]byte))
			entity = model.EntityType(v)
			to := model.Tag{
				Amoid:     row.Amoid,
				Accountid: row.Amoid_2,
				Entity:    entity,
				Name:      row.Name,
				Color:     &row.Color,
			}
			toUpdate = append(toUpdate, to)
		}

		dollar1, err := json.Marshal(toUpdate)
		if err != nil {
			return err
		}

		err = r.queries.UpdateTags(ctx, dollar1)
		if err != nil {
			return err
		}
	}

	if err != nil {
		return err
	}
	return nil
}

func (r *AmoRepository) DeleteTags(ctx context.Context, ids []int64) error {
	err := r.queries.DeleteTags(ctx, ids)
	if err != nil {
		return err
	}
	return nil
}

func (r *AmoRepository) GetUserTagsByID(ctx context.Context, accountID int32) ([]model.Tag, error) {
	rows, err := r.queries.GetUserTagsByID(ctx, accountID)
	if err != nil {
		return nil, err
	}

	var tags []model.Tag
	for _, row := range rows {
		var entity model.EntityType
		v := string(row.Entity.([]byte))
		entity = model.EntityType(v)

		tag := model.Tag{
			ID:        row.ID,
			Amoid:     row.Amoid,
			Accountid: row.Accountid,
			Entity:    entity,
			Name:      row.Name,
			Color:     &row.Color,
		}
		tags = append(tags, tag)
	}

	return tags, nil
}

// методы fields

func (r *AmoRepository) GetFieldsWithPagination(ctx context.Context, req *model.PaginationReq, accountID string) (*model.UserListFieldsResp, error) {
	rows, err := r.queries.GetFieldsWithPagination(ctx, sqlcgen.GetFieldsWithPaginationParams{
		Accountid: accountID,
		Column2:   req.Page,
		Limit:     req.Size,
	})
	if err != nil {
		return nil, err
	}

	var count int64
	var fields []model.Field

	for _, row := range rows {
		count = row.TotalCount

		var entity model.EntityType
		v := string(row.Entity.([]byte))
		entity = model.EntityType(v)

		var fieldType model.FieldType
		f := string(row.Type.([]byte))
		fieldType = model.FieldType(f)

		field := model.Field{
			ID:        row.ID,
			Amoid:     row.Amoid,
			Code:      row.Code,
			Accountid: row.Accountid,
			Name:      row.Name,
			Entity:    entity,
			Type:      fieldType,
			Createdat: row.Createdat.Time.Unix(),
		}

		fields = append(fields, field)
	}

	resp := model.UserListFieldsResp{
		Count: count,
		Items: fields,
	}

	return &resp, nil
}

func (r *AmoRepository) CheckFields(ctx context.Context, fields []model.Field, tokenID string) error {
	column2, err := json.Marshal(fields)
	if err != nil {
		return err
	}

	rows, err := r.queries.CheckFields(ctx, sqlcgen.CheckFieldsParams{
		Accountid: tokenID,
		Column2:   column2,
	})

	if err != nil {
		return err
	}

	if rows != nil {
		var toUpdate []model.Field
		for _, row := range rows {
			var entity model.EntityType
			v := string(row.Entity.([]byte))
			entity = model.EntityType(v)

			var fieldType model.FieldType
			f := string(row.Type.([]byte))
			fieldType = model.FieldType(f)

			to := model.Field{
				Amoid:     row.Amoid,
				Code:      row.Code,
				Accountid: row.Amoid_2,
				Entity:    entity,
				Type:      fieldType,
				Name:      row.Name,
			}
			toUpdate = append(toUpdate, to)
		}

		dollar1, err := json.Marshal(toUpdate)
		if err != nil {
			return err
		}

		err = r.queries.UpdateFields(ctx, dollar1)
		if err != nil {
			return err
		}
	}
	return nil
}

func (r *AmoRepository) GetUserFieldsByID(ctx context.Context, accountID int32) ([]model.Field, error) {
	rows, err := r.queries.GetUserFieldsByID(ctx, accountID)
	if err != nil {
		return nil, err
	}
	var fields []model.Field
	for _, row := range rows {

		var entity model.EntityType
		v := string(row.Entity.([]byte))
		entity = model.EntityType(v)

		var fieldType model.FieldType
		f := string(row.Type.([]byte))
		fieldType = model.FieldType(f)

		field := model.Field{
			ID:        row.ID,
			Amoid:     row.Amoid,
			Code:      row.Code,
			Accountid: row.Accountid,
			Name:      row.Name,
			Entity:    entity,
			Type:      fieldType,
		}

		fields = append(fields, field)
	}

	return fields, err
}

func (r *AmoRepository) DeleteFields(ctx context.Context, ids []int64) error {
	err := r.queries.DeleteFields(ctx, ids)
	if err != nil {
		return err
	}
	return nil
}

func (r *AmoRepository) GetFieldByID(ctx context.Context, amoID int32) (*model.Field, error) {
	row, err := r.queries.GetFieldByAmoID(ctx, amoID)
	if err != nil {
		return nil, err
	}

	var entity model.EntityType
	v := string(row.Entity.([]byte))
	entity = model.EntityType(v)

	var fieldType model.FieldType
	f := string(row.Type.([]byte))
	fieldType = model.FieldType(f)

	return &model.Field{
		ID:        row.ID,
		Amoid:     row.Amoid,
		Code:      row.Code,
		Accountid: row.Accountid,
		Name:      row.Name,
		Entity:    entity,
		Type:      fieldType,
	}, nil
}

// методы rules

func (r *AmoRepository) ChangeQuizSettings(ctx context.Context, request *model.RulesReq, accountID string, quizID int) error {
	jsonFieldRule, err := json.Marshal(request.Fieldsrule)
	if err != nil {
		return err
	}
	jsonTagsToAdd, err := json.Marshal(request.TagsToAdd)
	if err != nil {
		return err
	}
	_, err = r.queries.ChangeQuizSettings(ctx, sqlcgen.ChangeQuizSettingsParams{
		Performerid: request.PerformerID,
		Pipelineid:  request.PipelineID,
		Stepid:      request.StepID,
		//Utms:        request.Utms,
		Fieldsrule: jsonFieldRule,
		Tagstoadd:  jsonTagsToAdd,
		Accountid:  accountID,
		Quizid:     int32(quizID),
	})

	if err != nil {
		return err
	}

	return nil
}

func (r *AmoRepository) SetQuizSettings(ctx context.Context, request *model.RulesReq, accountID string, quizID int) error {
	jsonFieldRule, err := json.Marshal(request.Fieldsrule)
	if err != nil {
		return err
	}
	jsonTagsToAdd, err := json.Marshal(request.TagsToAdd)
	if err != nil {
		return err
	}
	_, err = r.queries.SetQuizSettings(ctx, sqlcgen.SetQuizSettingsParams{
		Performerid: request.PerformerID,
		Pipelineid:  request.PipelineID,
		Stepid:      request.StepID,
		//Utms:        request.Utms,
		Fieldsrule: jsonFieldRule,
		Tagstoadd:  jsonTagsToAdd,
		Accountid:  accountID,
		Quizid:     int32(quizID),
	})

	if err != nil {
		return err
	}

	return nil
}

func (r *AmoRepository) GettingQuizRules(ctx context.Context, quizID int) (*model.Rule, error) {
	row, err := r.queries.GetQuizRule(ctx, int32(quizID))
	if err != nil {
		return nil, err
	}

	var fieldsRule model.Fieldsrule
	err = json.Unmarshal(row.Fieldsrule, &fieldsRule)
	if err != nil {
		return nil, err
	}

	var tagsToAdd model.TagsToAdd
	err = json.Unmarshal(row.Tagstoadd, &tagsToAdd)
	if err != nil {
		return nil, err
	}

	return &model.Rule{
		ID:          row.ID,
		Accountid:   row.Accountid,
		Quizid:      row.Quizid,
		Performerid: row.Performerid,
		Pipelineid:  row.Pipelineid,
		Stepid:      row.Stepid,
		//Utms:        row.Utms,
		Fieldsrule: fieldsRule,
		TagsToAdd:  tagsToAdd,
	}, nil
}

func (r *AmoRepository) UpdateFieldRules(ctx context.Context, fieldRules model.Fieldsrule, accountID string, quizID int32) error {
	jsonFieldsRule, err := json.Marshal(fieldRules)
	if err != nil {
		return err
	}
	err = r.queries.UpdateFieldRules(ctx, sqlcgen.UpdateFieldRulesParams{
		Fieldsrule: jsonFieldsRule,
		Accountid:  accountID,
		Quizid:     quizID,
	})

	if err != nil {
		return err
	}

	return nil
}

// методы UTMs

func (r *AmoRepository) DeletingUserUtm(ctx context.Context, request *model.ListDeleteUTMIDsReq) error {
	//err := r.queries.DeletingUTM(ctx, request.Utms)
	//if err != nil {
	//	return err
	//}
	return nil
}

// todo нужно ли тут ограничивать индексом что то
//func (r *AmoRepository) SavingUserUtm(ctx context.Context, utms []model.UTM, accountID string) (*model.ListSavedIDUTMResp, error) {
//	column2, err := json.Marshal(utms)
//	if err != nil {
//		return nil, err
//	}
//	rows, err := r.queries.SaveUTMs(ctx, sqlcgen.SaveUTMsParams{
//		Accountid: accountID,
//		Column2:   column2,
//	})
//
//	var ids []int64
//
//	for _, row := range rows {
//		ids = append(ids, row.ID)
//	}
//
//	return &model.ListSavedIDUTMResp{
//		Ids: ids,
//	}, nil
//
//	return nil, nil
//}
//
//func (r *AmoRepository) GettingUserUtm(ctx context.Context, request *model.PaginationReq, accountID string, quizID int) (*model.GetListUserUTMResp, error) {
//	rows, err := r.queries.GetUTMsWithPagination(ctx, sqlcgen.GetUTMsWithPaginationParams{
//		Accountid: accountID,
//		Column2:   request.Page,
//		Limit:     request.Size,
//		Quizid:    int32(quizID),
//	})
//
//	if err != nil {
//		return nil, err
//	}
//
//	var count int64
//	var utmS []model.UTM
//
//	for _, row := range rows {
//		count = row.TotalCount
//		utm := model.UTM{
//			ID:         row.ID,
//			Amofieldid: row.Amofieldid,
//			Quizid:     row.Quizid,
//			Accountid:  row.Accountid,
//			Name:       row.Name,
//			Deleted:    row.Deleted,
//			Createdat:  row.Createdat.Time.Unix(),
//		}
//
//		utmS = append(utmS, utm)
//	}
//
//	return &model.GetListUserUTMResp{
//		Count: count,
//		Items: utmS,
//	}, nil
//}
//
//func (r *AmoRepository) GetUtmsByID(ctx context.Context, ids []int32) ([]model.UTM, error) {
//	rows, err := r.queries.GetUtmsByID(ctx, ids)
//	if err != nil {
//		return nil, err
//	}
//
//	var utmS []model.UTM
//	for _, row := range rows {
//		utm := model.UTM{
//			ID:         row.ID,
//			Amofieldid: row.Amofieldid,
//			Quizid:     row.Quizid,
//			Accountid:  row.Accountid,
//			Name:       row.Name,
//		}
//
//		utmS = append(utmS, utm)
//	}
//
//	return utmS, nil
//}
//
//func (r *AmoRepository) UpdateUTMs(ctx context.Context, utms []model.UTM) error {
//	dollar1, err := json.Marshal(utms)
//	if err != nil {
//		return err
//	}
//	err = r.queries.UpdateUtms(ctx, dollar1)
//
//	if err != nil {
//		return err
//	}
//
//	return nil
//}
//
//func (r *AmoRepository) UpdateUtmsFields(ctx context.Context, ids []int32) error {
//	err := r.queries.UpdateUtmsFields(ctx, ids)
//	if err != nil {
//		return err
//	}
//
//	return nil
//}

func (r *AmoRepository) GettingAmoUsersTrueResults(ctx context.Context) ([]model.AmoUsersTrueResults, error) {
	rows, err := r.queries.GettingAmoUsersTrueResults(ctx)
	if err != nil {
		return nil, err
	}

	var results []model.AmoUsersTrueResults

	for _, row := range rows {
		var fieldsRule model.Fieldsrule
		err = json.Unmarshal(row.Fieldsrule, &fieldsRule)
		if err != nil {
			return nil, err
		}

		var utm model.UTMSavingMap
		err = json.Unmarshal(row.Utm.([]byte), &utm)
		if err != nil {
			return nil, err
		}

		var tagsToAdd model.TagsToAdd
		err = json.Unmarshal(row.Tagstoadd, &tagsToAdd)
		if err != nil {
			return nil, err
		}

		result := model.AmoUsersTrueResults{
			QuizID:        row.QuizID,
			AnswerID:      row.ID,
			Result:        row.Result.Bool,
			QuestionID:    row.QuestionID,
			Content:       row.Content.String,
			Session:       row.Session.String,
			AccessToken:   row.Accesstoken,
			AmoAccountID:  row.Accountid,
			UTMs:          utm,
			FieldsRule:    fieldsRule,
			TagsToAdd:     tagsToAdd,
			PerformerID:   row.Performerid,
			StepID:        row.Stepid,
			PipelineID:    row.Pipelineid,
			PerformerName: row.PerformerName,
			SubDomain:     row.Subdomain,
			QuizAccountID: row.Accountid_2,
			DriveURL:      row.Driveurl,
		}

		results = append(results, result)
	}

	return results, nil
}

type SaveDealAmoDeps struct {
	DealID      int32
	AnswerID    int64
	Status      string
	AccessToken string
}

func (r *AmoRepository) SaveDealAmoStatus(ctx context.Context, deps SaveDealAmoDeps) error {
	err := r.queries.SettingDealAmoStatus(ctx, sqlcgen.SettingDealAmoStatusParams{
		Dealid:      deps.DealID,
		Answerid:    deps.AnswerID,
		Status:      deps.Status,
		Accesstoken: deps.AccessToken,
	})

	if err != nil {
		return err
	}

	return nil
}

func (r *AmoRepository) UpdatingDealAmoStatus(ctx context.Context, deps SaveDealAmoDeps) error {
	err := r.queries.UpdatingDealAmoStatus(ctx, sqlcgen.UpdatingDealAmoStatusParams{
		Status:      deps.Status,
		Accesstoken: deps.AccessToken,
		Dealid:      deps.DealID,
	})

	if err != nil {
		return err
	}

	return nil
}

// методы для contact в амо

func (r *AmoRepository) GetExistingContactAmo(ctx context.Context, accountID int32, fields []string) (map[int32][]model.ContactAmo, error) {
	rows, err := r.queries.GetExistingContactAmo(ctx, sqlcgen.GetExistingContactAmoParams{
		Accountid: accountID,
		Column2:   fields,
	})

	if err != nil {
		if err == sql.ErrNoRows {
			return nil, pj_errors.ErrNotFound
		}
		return nil, err
	}

	result := make(map[int32][]model.ContactAmo)

	for _, row := range rows {
		result[row.Amoid] = append(result[row.Amoid], model.ContactAmo{
			ID:        row.ID,
			AmoID:     row.Amoid,
			AccountID: row.Accountid,
			Field:     row.Field,
		})
	}

	return result, nil
}

func (r *AmoRepository) InsertContactAmo(ctx context.Context, val model.ContactAmo) (int32, error) {
	amoID, err := r.queries.InsertContactAmo(ctx, sqlcgen.InsertContactAmoParams{
		Accountid: val.AccountID,
		Amoid:     val.AmoID,
		Field:     val.Field,
	})

	if err != nil {
		return 0, err
	}

	return amoID, err
}

func (r *AmoRepository) UpdateAmoContact(ctx context.Context, id int64, field string, newAmoID int32) error {
	err := r.queries.UpdateAmoContact(ctx, sqlcgen.UpdateAmoContactParams{
		Field: field,
		ID:    id,
		Amoid: newAmoID,
	})

	if err != nil {
		return err
	}

	return nil
}