749 lines
16 KiB
Go
749 lines
16 KiB
Go
package test
|
|
|
|
import (
|
|
"amocrm/internal/models"
|
|
"amocrm/internal/tools"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"github.com/pioz/faker"
|
|
"github.com/stretchr/testify/assert"
|
|
"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/dal"
|
|
"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/model"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func Test_Repository(t *testing.T) {
|
|
ctx := context.Background()
|
|
repo, err := dal.NewAmoDal(ctx, "host=localhost port=35432 user=squiz password=Redalert2 dbname=squiz sslmode=disable")
|
|
|
|
if err != nil {
|
|
fmt.Println("err init postgres")
|
|
panic(err)
|
|
}
|
|
|
|
err = webhookCreate(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = webhookUpdate(ctx, repo)
|
|
assert.NoError(t, err)
|
|
|
|
count := 0
|
|
for {
|
|
if count == 8 {
|
|
break
|
|
}
|
|
time.Sleep(time.Second)
|
|
tokens, err := checkExpired(ctx, repo)
|
|
assert.NoError(t, err)
|
|
if len(tokens) > 0 {
|
|
fmt.Println(tokens)
|
|
count++
|
|
}
|
|
}
|
|
|
|
err = getAllTokens(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
err = createUser(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = updateUser(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = checkUsers(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = gettingUserFromCash(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
err = checkPipelines(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = gettingPipelinesFromCash(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
err = checkSteps(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = gettingStepsFromCash(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
err = checkTags(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = gettingTagsFromCash(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
err = checkFields(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = gettingFieldsFromCash(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
err = saveUtms(ctx, repo)
|
|
assert.NoError(t, err)
|
|
err = gettingUserUtm(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
err = deleteUserUTM(ctx, t, repo)
|
|
assert.NoError(t, err)
|
|
RuleTest(ctx, repo)
|
|
}
|
|
|
|
func createUser(ctx context.Context, repo *dal.AmoDal) error {
|
|
for i := 1; i < 10; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err := repo.AmoRepo.CreateAccount(ctx, accID, model.User{
|
|
AmoID: int32(i),
|
|
Name: "Test" + strconv.Itoa(i),
|
|
Email: "Test" + strconv.Itoa(i) + "@mail.test",
|
|
Amouserid: int32(i),
|
|
Subdomain: "Test",
|
|
Country: "RUSSIA",
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func updateUser(ctx context.Context, repo *dal.AmoDal) error {
|
|
var testUserInfo models.AmocrmUserInformation
|
|
err := json.Unmarshal([]byte(jsonUserInfo), &testUserInfo)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i := 1; i < 10; i++ {
|
|
accID := strconv.Itoa(i)
|
|
info := model.User{
|
|
Name: faker.String(),
|
|
Subdomain: "pena",
|
|
AmoID: 666,
|
|
Amouserid: int32(i),
|
|
Email: faker.Email(),
|
|
Group: int32(i),
|
|
Country: "Russia",
|
|
}
|
|
|
|
if i%2 == 0 {
|
|
info.Role = int32(i)
|
|
info.ID = faker.Int64()
|
|
}
|
|
|
|
err = repo.AmoRepo.CreateAccount(ctx, accID, info)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func checkUsers(ctx context.Context, repo *dal.AmoDal) error {
|
|
var testUserInfo models.AmocrmUserInformation
|
|
err := json.Unmarshal([]byte(jsonUserInfo), &testUserInfo)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i := 1; i < 10; i++ {
|
|
if i%2 != 0 {
|
|
info := model.User{
|
|
Name: faker.String(),
|
|
Email: faker.Email(),
|
|
Group: int32(i),
|
|
}
|
|
info.Role = int32(i)
|
|
|
|
err = repo.AmoRepo.CheckAndUpdateUsers(ctx, info)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
func gettingUserFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
for i := 1; i < 10; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: int32(i),
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GettingUserWithPagination(ctx, &req, "5")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkPipelines(ctx context.Context, repo *dal.AmoDal) error {
|
|
var testPipeline1 models.PipelineResponse
|
|
err := json.Unmarshal([]byte(jsonPipelines), &testPipeline1)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testPipeline2 models.PipelineResponse
|
|
err = json.Unmarshal([]byte(jsonPipelines2), &testPipeline2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for i := 0; i < 9; i++ {
|
|
err = repo.AmoRepo.CheckPipelines(ctx, tools.ToPipeline(testPipeline1.Embedded.Pipelines))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for i := 0; i < 9; i++ {
|
|
err = repo.AmoRepo.CheckPipelines(ctx, tools.ToPipeline(testPipeline2.Embedded.Pipelines))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func gettingPipelinesFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
for i := 1; i < 28; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: int32(i),
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GetPipelinesWithPagination(ctx, &req, "4")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fmt.Println(resp.Items)
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkSteps(ctx context.Context, repo *dal.AmoDal) error {
|
|
var testStep1 models.ResponseGetListSteps
|
|
err := json.Unmarshal([]byte(jsonStep1), &testStep1)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testStep2 models.ResponseGetListSteps
|
|
err = json.Unmarshal([]byte(jsonStep2), &testStep2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for i := 0; i < 9; i++ {
|
|
err = repo.AmoRepo.CheckSteps(ctx, tools.ToStep(testStep1.Embedded.Statuses))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for i := 0; i < 9; i++ {
|
|
err = repo.AmoRepo.CheckSteps(ctx, tools.ToStep(testStep2.Embedded.Statuses))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func gettingStepsFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
for i := 1; i < 46; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: int32(i),
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GetStepsWithPagination(ctx, &req, "3")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fmt.Println(resp.Items)
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkTags(ctx context.Context, repo *dal.AmoDal) error {
|
|
var testLeadsTags models.ResponseGetListTags
|
|
err := json.Unmarshal([]byte(jsonLeadsTags), &testLeadsTags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testLeadsTags2 models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonLeadsTags2), &testLeadsTags2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testContactsTags models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonContactsTags), &testContactsTags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testContactsTags2 models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonContactsTags2), &testContactsTags2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCompaniesTags models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonCompaniesTags), &testCompaniesTags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCompaniesTags2 models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonCompaniesTags2), &testCompaniesTags2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCustomersTags models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonCustomersTags), &testCustomersTags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCustomersTags2 models.ResponseGetListTags
|
|
err = json.Unmarshal([]byte(jsonCustomersTags2), &testCustomersTags2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i := 0; i < 9; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testLeadsTags.Embedded.Tags, model.LeadsType), accID)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testCompaniesTags.Embedded.Tags, model.CompaniesType), accID)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testCustomersTags.Embedded.Tags, model.CustomersType), accID)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testContactsTags.Embedded.Tags, model.ContactsType), accID)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
}
|
|
|
|
for i := 0; i < 9; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testLeadsTags2.Embedded.Tags, model.LeadsType), accID)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testCompaniesTags2.Embedded.Tags, model.CompaniesType), accID)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testCustomersTags2.Embedded.Tags, model.CustomersType), accID)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
err = repo.AmoRepo.CheckTags(ctx, tools.ToTag(testContactsTags2.Embedded.Tags, model.ContactsType), accID)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func gettingTagsFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
for i := 1; i < 73; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: int32(i),
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GetTagsWithPagination(ctx, &req, "2")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fmt.Println(resp.Items)
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkFields(ctx context.Context, repo *dal.AmoDal) error {
|
|
var testLeadsFields models.ResponseGetListFields
|
|
err := json.Unmarshal([]byte(jsonLeadsFields), &testLeadsFields)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testLeadsFields2 models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonLeadsFields2), &testLeadsFields2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testContactsFields models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonContactsFields), &testContactsFields)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testContactsFields2 models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonContactsFields2), &testContactsFields2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCompaniesFields models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonCompaniesFields), &testCompaniesFields)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCompaniesFields2 models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonCompaniesFields2), &testCompaniesFields2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCustomersFields models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonCustomersFields), &testCustomersFields)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var testCustomersFields2 models.ResponseGetListFields
|
|
err = json.Unmarshal([]byte(jsonCustomersFields2), &testCustomersFields2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for i := 0; i < 9; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testLeadsFields.Embedded.CustomFields, model.LeadsType), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testCompaniesFields.Embedded.CustomFields, model.CompaniesType), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testCustomersFields.Embedded.CustomFields, model.CustomersType), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testContactsFields.Embedded.CustomFields, model.ContactsType), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for i := 0; i < 9; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testLeadsFields2.Embedded.CustomFields, model.LeadsType), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testCompaniesFields2.Embedded.CustomFields, model.CompaniesType), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testCustomersFields2.Embedded.CustomFields, model.CustomersType), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = repo.AmoRepo.CheckFields(ctx, tools.ToField(testContactsFields2.Embedded.CustomFields, model.ContactsType), accID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func gettingFieldsFromCash(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
for i := 1; i < 73; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: int32(i),
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GetFieldsWithPagination(ctx, &req, "1")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fmt.Println(resp.Items)
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func webhookCreate(ctx context.Context, repo *dal.AmoDal) error {
|
|
for i := 1; i < 10; i++ {
|
|
accID := strconv.Itoa(i)
|
|
err := repo.AmoRepo.WebhookCreate(ctx, model.Token{
|
|
RefreshToken: faker.UUID(),
|
|
AccessToken: faker.UUID(),
|
|
AccountID: accID,
|
|
AuthCode: faker.String(),
|
|
Expiration: time.Now().Unix() + 10,
|
|
CreatedAt: time.Now().Unix(),
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func webhookUpdate(ctx context.Context, repo *dal.AmoDal) error {
|
|
var tokens []model.Token
|
|
for i := 1; i < 10; i++ {
|
|
accID := strconv.Itoa(i)
|
|
tokens = append(tokens, model.Token{
|
|
RefreshToken: faker.UUID(),
|
|
AccessToken: faker.UUID(),
|
|
AccountID: accID,
|
|
Expiration: time.Now().Unix() + int64(i),
|
|
CreatedAt: time.Now().Unix(),
|
|
})
|
|
}
|
|
|
|
err := repo.AmoRepo.WebhookUpdate(ctx, tokens)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkExpired(ctx context.Context, repo *dal.AmoDal) ([]model.Token, error) {
|
|
tokens, err := repo.AmoRepo.CheckExpired(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return tokens, nil
|
|
}
|
|
|
|
func getAllTokens(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
tokens, err := repo.AmoRepo.GetAllTokens(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
assert.Equal(t, len(tokens), 9)
|
|
|
|
return nil
|
|
}
|
|
|
|
func saveUtms(ctx context.Context, repo *dal.AmoDal) error {
|
|
for i := 1; i < 10; i++ {
|
|
var utms []model.UTM
|
|
for j := 1; j < 50; j++ {
|
|
utm := model.UTM{
|
|
Name: strconv.Itoa(i),
|
|
Quizid: int32(j),
|
|
Accountid: faker.Int32(),
|
|
Amofieldid: int32(j),
|
|
Createdat: time.Now().Unix(),
|
|
}
|
|
utms = append(utms, utm)
|
|
}
|
|
resp, err := repo.AmoRepo.SavingUserUtm(ctx, utms, strconv.Itoa(i))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fmt.Println(resp)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func gettingUserUtm(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
for i := 1; i < 50; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: int32(i),
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GettingUserUtm(ctx, &req, "1", 1)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fmt.Println(resp.Items)
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func deleteUserUTM(ctx context.Context, t *testing.T, repo *dal.AmoDal) error {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: 50,
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GettingUserUtm(ctx, &req, "5", 5)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var fordetete []int32
|
|
for _, r := range resp.Items {
|
|
fordetete = append(fordetete, int32(r.ID))
|
|
}
|
|
err = repo.AmoRepo.DeletingUserUtm(ctx, &model.ListDeleteUTMIDsReq{
|
|
fordetete,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for i := 1; i < 50; i++ {
|
|
req := model.PaginationReq{
|
|
Page: 1,
|
|
Size: int32(i),
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GettingUserUtm(ctx, &req, "5", 5)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fmt.Println(resp.Items)
|
|
fmt.Println(len(resp.Items))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func RuleTest(ctx context.Context, repo *dal.AmoDal) {
|
|
testMap := make(map[int]int)
|
|
testMap[11111] = 11111
|
|
err := repo.AmoRepo.SetQuizSettings(ctx, &model.RulesReq{
|
|
PerformerID: 2,
|
|
PipelineID: 1,
|
|
StepID: 1,
|
|
Utms: make([]int32, 3),
|
|
Fieldsrule: model.Fieldsrule{
|
|
Lead: []model.FieldRule{
|
|
{
|
|
Questionid: testMap,
|
|
},
|
|
},
|
|
Contact: []model.FieldRule{
|
|
{
|
|
Questionid: testMap,
|
|
},
|
|
},
|
|
Company: []model.FieldRule{
|
|
{
|
|
Questionid: testMap,
|
|
},
|
|
},
|
|
Customer: []model.FieldRule{
|
|
{
|
|
Questionid: testMap,
|
|
},
|
|
},
|
|
},
|
|
}, "3", 3)
|
|
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
testMap[222] = 3
|
|
|
|
err = repo.AmoRepo.ChangeQuizSettings(ctx, &model.RulesReq{
|
|
PerformerID: 111,
|
|
PipelineID: 111,
|
|
StepID: 111,
|
|
Utms: make([]int32, 10),
|
|
Fieldsrule: model.Fieldsrule{
|
|
Lead: []model.FieldRule{
|
|
{
|
|
Questionid: testMap,
|
|
},
|
|
},
|
|
Contact: []model.FieldRule{
|
|
{
|
|
Questionid: testMap,
|
|
},
|
|
},
|
|
Company: []model.FieldRule{
|
|
{
|
|
Questionid: testMap,
|
|
},
|
|
},
|
|
Customer: []model.FieldRule{
|
|
{
|
|
Questionid: testMap,
|
|
},
|
|
},
|
|
},
|
|
}, "3", 3)
|
|
|
|
if err != nil {
|
|
fmt.Println(err, "UPDATE")
|
|
}
|
|
|
|
rule3, err := repo.AmoRepo.GettingQuizRules(ctx, 1)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
fmt.Println(rule3)
|
|
}
|
|
|
|
func Test_UTM(t *testing.T) {
|
|
ctx := context.Background()
|
|
repo, err := dal.NewAmoDal(ctx, "host=localhost port=35432 user=squiz password=Redalert2 dbname=squiz sslmode=disable")
|
|
|
|
if err != nil {
|
|
fmt.Println("err init postgres")
|
|
panic(err)
|
|
}
|
|
|
|
var utms []model.UTM
|
|
|
|
for i := 0; i < 10; i++ {
|
|
utm := model.UTM{
|
|
Quizid: int32(i) + 1,
|
|
Accountid: 30228997,
|
|
Name: faker.String(),
|
|
}
|
|
|
|
utms = append(utms, utm)
|
|
}
|
|
|
|
utmss, err := repo.AmoRepo.SavingUserUtm(ctx, utms, "64f2cd7a7047f28fdabf6d9e")
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
var ids []int32
|
|
|
|
for _, id := range utmss.Ids {
|
|
ids = append(ids, int32(id))
|
|
}
|
|
|
|
resp, err := repo.AmoRepo.GetUtmsByID(ctx, ids)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
fmt.Println(resp)
|
|
}
|