treasurer/dal/paywayPayment.go

package dal

import (
	"context"
	"errors"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

// @TODO: Rename to PayWayRefill

type PayWayPayment struct {
	ID         string    `bson:"_id"` // PayWay-ApiId
	ApiId      string    `bson:"api_id"`
	Name       string    `bson:"name"`
	PayWay     string    `bson:"payWay"`
	Currency   string    `bson:"currency"`
	Commission float64   `bson:"commission"`
	Minimum    float64   `bson:"minimum"`
	Maximum    float64   `bson:"maximum"`
	Status     string    `bson:"status"` // active, inactive
	CreatedAt  time.Time `bson:"created_at"`
	UpdatedAt  time.Time `bson:"updated_at"`
}

func (mc *MongoConnection) InsertPayWayPayment(ctx context.Context, record PayWayPayment) (string, error) {
	now := time.Now()

	if record.ApiId == "" {
		err := errors.New("got empty apiId")
		mc.hl.Emit(ErrorInsertPayWayPayment{err})
		return "", err
	}

	if record.PayWay == "" {
		err := errors.New("got empty payWay")
		mc.hl.Emit(ErrorInsertPayWayPayment{err})
		return "", err
	}

	record.ID = fmt.Sprintf("%v-%v", record.PayWay, record.ApiId)

	record.CreatedAt = now
	record.UpdatedAt = now

	result, err := mc.coll["paywayPayment"].InsertOne(ctx, record)

	if err != nil {
		mc.hl.Emit(ErrorInsertPayWayPayment{err})
		return "", err
	}

	mc.hl.Emit(InfoInsertPayWayPayment{result})

	mc.hl.Emit(InfoPayWay{
		CtxPayWay: record.PayWay,
		CtxName:   record.Name,
		CtxEvent:  "add",
	})

	return result.InsertedID.(string), nil
}

func (mc *MongoConnection) UpdatePayWayPayment(ctx context.Context, record PayWayPayment) error {
	//update := bson.M{"updated_at": time.Now()}

	//if record.ID == "" {
	//	err := errors.New("got empty id")
	//	mc.hl.Emit(ErrorUpdatePayWayPayment{err})
	//	return err
	//}
	//
	//if record.Name != "" {
	//	update["name"] = record.Name
	//}
	//
	//if record.PayWay != "" {
	//	update["payway"] = record.Name
	//}
	//
	//if record.Status != "" {
	//	update["status"] = record.Name
	//}
	record.UpdatedAt = time.Now()

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

	err := mc.coll["paywayPayment"].FindOneAndUpdate(ctx, bson.M{
		"_id": record.ID,
	}, bson.D{{"$set", record}}, opts).Decode(&PayWayPayment{})

	if err != nil {
		mc.hl.Emit(ErrorUpdatePayWayPayment{err})
		return err
	}

	//mc.hl.Emit(InfoInsertPayWayPayment{result})

	if record.Status != "" {
		//update["status"] = record.Name

		pw, _ := mc.GetPayWayPayment(ctx, record.ID)

		if pw.Status != record.Status {
			event := "stop"
			if record.Status == "active" {
				event = "start"
			}

			mc.hl.Emit(InfoPayWay{
				CtxPayWay: pw.PayWay,
				CtxName:   pw.Name,
				CtxEvent:  event,
			})
		}
	}
	return nil
}

func (mc *MongoConnection) GetPayWayPayment(ctx context.Context, id string) (*PayWayPayment, error) {
	filter := bson.M{"_id": id}

	var result PayWayPayment

	err := mc.coll["paywayPayment"].FindOne(ctx, filter).Decode(&result)

	if err == mongo.ErrNoDocuments {
		return nil, nil
	} else {
		if err != nil {
			mc.hl.Emit(ErrorGetPayWayPayment{err})
			return nil, err
		}
	}

	mc.hl.Emit(InfoGetPayWayPayment{result.ID})

	return &result, err
}

func (mc *MongoConnection) GetPayWayPaymentByPayWay(ctx context.Context, payWay string) ([]PayWayPayment, error) {
	filter := bson.M{"payWay": payWay}

	var results []PayWayPayment
	cursor, err := mc.coll["paywayPayment"].Find(ctx, filter)

	if err != nil {
		mc.hl.Emit(ErrorGetPayWayPayment{err})
		return results, nil
	}

	err = cursor.All(ctx, &results)

	if err != nil {
		mc.hl.Emit(ErrorGetPayWayPayment{err})
		return nil, nil
	}

	mc.hl.Emit(InfoGetPayWayPayment{fmt.Sprintf("by status %v", payWay)})

	return results, nil
}

func (mc *MongoConnection) DeletePayWayPayment(ctx context.Context, id string) error {
	filter := bson.M{"_id": id}

	result, err := mc.coll["paywayPayment"].DeleteOne(ctx, filter)

	if err != nil {
		mc.hl.Emit(ErrorDeletePayWayPayment{err})
		return err
	}

	mc.hl.Emit(InfoDeletePayWayPayment{result})

	return nil
}