docxTemplater/dal/mongos/amo.go

package mongos

import (
	"amocrm_templategen_back/dal/model"
	"context"
	"errors"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"go.uber.org/zap"
	"time"
)

type Amo struct {
	coll   *mongo.Collection
	logger *zap.Logger
}

func InitAmo(db *mongo.Database, logger *zap.Logger) *Amo {
	return &Amo{coll: db.Collection("amo"), logger: logger}
}

func (d *Amo) InsertOrUpdate(ctx context.Context, record *model.Amo) (string, error) {
	if record.UserID == "" {
		err := errors.New("got empty user id")
		d.logger.Error("ErrorDeleteAmo", zap.Error(err))
		return "", err
	}

	record.CreatedAt = time.Now()
	record.UpdatedAt = time.Now()

	found, err := d.GetByUserID(ctx, record.UserID)
	if err != nil {
		return "", err
	}

	if found == nil {
		result, err := d.coll.InsertOne(ctx, record)
		if err != nil {
			d.logger.Error("ErrorInsertOrUpdateAmo", zap.Error(err))
			return "", err
		}

		return result.InsertedID.(primitive.ObjectID).Hex(), nil
	}

	record.CreatedAt = found.CreatedAt

	err = d.Update(ctx, record)
	if err != nil {
		d.logger.Error("ErrorInsertOrUpdateAmo", zap.Error(err))
		return "", err
	}

	return found.ID, nil
}

func (d *Amo) InsertOrUpdateOLD(ctx context.Context, record *model.Amo) (string, error) {
	now := time.Now()
	record.UpdatedAt = now
	record.CreatedAt = now
	record.IsDeleted = false

	if record.UserID == "" {
		err := errors.New("got empty user id")
		d.logger.Error("ErrorDeleteAmo", zap.Error(err))
		return "", err
	}

	filter := bson.M{"user_id": record.UserID, "is_deleted": false}

	opts := options.FindOneAndUpdate().SetUpsert(true)

	var result model.Amo

	err := d.coll.FindOneAndUpdate(ctx, filter, bson.D{{"$set", record}}, opts).Decode(&result)

	if err != nil {
		if err != mongo.ErrNoDocuments {
			d.logger.Error("ErrorInsertOrUpdateAmo", zap.Error(err))
			return "", err
		}
	}

	return result.ID, nil
}

func (d *Amo) GetByID(ctx context.Context, id string) (*model.Amo, error) {
	objID, err := primitive.ObjectIDFromHex(id)

	if err != nil {
		d.logger.Error("ErrorGetTemplate", zap.Error(err))
		return nil, err
	}

	filter := bson.M{"_id": objID, "is_deleted": false}

	var result model.Amo

	err = d.coll.FindOne(ctx, filter).Decode(&result)

	if err == mongo.ErrNoDocuments {
		return nil, nil
	} else {
		if err != nil {
			d.logger.Error("ErrorGetAmo", zap.Error(err))
			return nil, err
		}
	}

	d.logger.Info("InfoGetAmo", zap.String("id", result.ID))
	return &result, nil
}

func (d *Amo) GetByUserID(ctx context.Context, userID string) (*model.Amo, error) {
	filter := bson.M{"user_id": userID, "is_deleted": false}

	var result model.Amo

	err := d.coll.FindOne(ctx, filter).Decode(&result)

	if err == mongo.ErrNoDocuments {
		return nil, nil
	} else {
		if err != nil {
			d.logger.Error("ErrorGetAmo", zap.Error(err))
			return nil, err
		}
	}

	d.logger.Info("InfoGetAmo", zap.String("id", result.ID))
	return &result, nil
}

func (d *Amo) GetByAccountID(ctx context.Context, accId string) (*model.Amo, error) {
	filter := bson.M{"account_id": accId, "is_deleted": false}

	var result model.Amo

	err := d.coll.FindOne(ctx, filter).Decode(&result)

	if err == mongo.ErrNoDocuments {
		return nil, nil
	} else {
		if err != nil {
			d.logger.Error("ErrorGetAmo", zap.Error(err))
			return nil, err
		}
	}

	d.logger.Info("InfoGetAmo", zap.String("id", result.ID))
	return &result, nil
}

func (d *Amo) Update(ctx context.Context, record *model.Amo) error {
	if record.UserID == "" && record.ID == "" {
		err := errors.New("got empty id and user id")
		d.logger.Error("ErrorUpdateAmo", zap.Error(err))
		return err
	}

	filter := bson.M{"is_deleted": false}

	if record.ID != "" {
		objID, err := primitive.ObjectIDFromHex(record.ID)

		if err != nil {
			d.logger.Error("ErrorUpdateAmo", zap.Error(err))
			return err
		}

		filter["_id"] = objID
	}

	if record.UserID != "" {
		filter["user_id"] = record.UserID
	}

	update := bson.M{"updated_at": time.Now()}

	// Token
	if record.AccessToken != "" {
		update["access_token"] = record.AccessToken
	}

	if record.RefreshToken != "" {
		update["refresh_token"] = record.RefreshToken
	}

	if record.Code != "" {
		update["code"] = record.Code
	}

	if !record.ExpiresIn.IsZero() {
		update["expires_in"] = record.ExpiresIn
	}

	if record.TokenType != "" {
		update["token_type"] = record.TokenType
	}

	// AccessRules
	if record.AccessRules.Visibility != nil || len(record.AccessRules.Visibility) > 0 {
		update["access_rules.visibility"] = record.AccessRules.Visibility
	}

	if record.AccessRules.Creation != nil || len(record.AccessRules.Creation) > 0 {
		update["access_rules.creation"] = record.AccessRules.Creation
	}

	if record.AccessRules.Delete != nil || len(record.AccessRules.Delete) > 0 {
		update["access_rules.delete"] = record.AccessRules.Delete
	}

	_, err := d.coll.UpdateOne(ctx, filter, bson.D{{"$set", update}})

	if err != nil {
		d.logger.Error("ErrorUpdateAmo", zap.Error(err))
		return err
	}

	return nil
}

func (d *Amo) DeleteByUserID(ctx context.Context, userID string) error {
	if userID == "" {
		err := errors.New("got empty user id")
		d.logger.Error("ErrorDeleteAmo", zap.Error(err))
		return err
	}

	filter := bson.M{"user_id": userID, "is_deleted": false}

	update := bson.M{"updated_at": time.Now(), "is_deleted": true}

	_, err := d.coll.UpdateOne(ctx, filter, bson.D{{"$set", update}})
	if err != nil {
		d.logger.Error("ErrorDeleteAmo", zap.Error(err))
		return err
	}

	return nil
}

func (d *Amo) UpdateAccessRules(ctx context.Context, id string, record *model.AmoAccessRules) error {
	objID, err := primitive.ObjectIDFromHex(id)

	if err != nil {
		d.logger.Error("ErrorUpdateAmoAccessRules", zap.Error(err))
		return err
	}

	filter := bson.M{"_id": objID, "is_deleted": false}

	update := bson.M{"updated_at": time.Now()}

	if record.Visibility != nil || len(record.Visibility) > 0 {
		update["access_rules.visibility"] = record.Visibility
	}

	if record.Creation != nil || len(record.Creation) > 0 {
		update["access_rules.creation"] = record.Creation
	}

	if record.Delete != nil || len(record.Delete) > 0 {
		update["access_rules.delete"] = record.Delete
	}

	_, err = d.coll.UpdateOne(ctx, filter, bson.D{{"$set", update}})

	if err != nil {
		d.logger.Error("ErrorUpdateAmoAccessRules", zap.Error(err))
		return err
	}

	return nil
}