common/repository/account/account.go

package account

import (
	"context"
	"database/sql"
	"fmt"
	"github.com/google/uuid"
	"gitea.pena/SQuiz/common/dal/sqlcgen"
	"gitea.pena/SQuiz/common/model"
	"gitea.pena/SQuiz/common/pj_errors"
	"strconv"
)

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

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

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

// test +
func (r *AccountRepository) GetAccountByID(ctx context.Context, userID string) (model.Account, error) {
	accountRows, err := r.queries.GetAccountWithPrivileges(ctx, userID)
	if err != nil {
		return model.Account{}, err
	}

	var account model.Account
	privileges := make(map[string]model.ShortPrivilege)

	for _, row := range accountRows {
		if account.ID == "" {
			account.ID = row.ID.String()
			account.UserID = row.UserID
			account.CreatedAt = row.CreatedAt
			account.Deleted = row.Deleted
		}

		if row.PrivilegeID != 0 {
			privilege := model.ShortPrivilege{
				ID:            fmt.Sprintf("%d", row.PrivilegeID),
				PrivilegeID:   row.Privilegeid,
				PrivilegeName: row.PrivilegeName,
				Amount:        uint64(row.Amount),
				CreatedAt:     row.PrivilegeCreatedAt,
			}
			privileges[privilege.PrivilegeID] = privilege
		}
	}

	if account.ID == "" {
		return model.Account{}, sql.ErrNoRows
	}

	account.Privileges = privileges
	return account, nil
}

// test +
func (r *AccountRepository) GetPrivilegesByAccountID(ctx context.Context, userID string) ([]model.ShortPrivilege, error) {

	privilegeRows, err := r.queries.GetPrivilegesByAccountIDWC(ctx, userID)
	if err != nil {
		return nil, err
	}

	var privileges []model.ShortPrivilege

	for _, row := range privilegeRows {
		privilege := model.ShortPrivilege{
			ID:            fmt.Sprintf("%d", row.ID),
			PrivilegeID:   row.Privilegeid,
			PrivilegeName: row.PrivilegeName,
			Amount:        uint64(row.Amount),
			CreatedAt:     row.CreatedAt,
		}
		privileges = append(privileges, privilege)
	}

	return privileges, nil
}

// todo test
func (r *AccountRepository) CreateAccount(ctx context.Context, data *model.Account) (model.Account, error) {
	data.ID = uuid.NewString()
	row, err := r.queries.CreateAccount(ctx, sqlcgen.CreateAccountParams{
		ID:        uuid.MustParse(data.ID),
		UserID:    data.UserID,
		CreatedAt: data.CreatedAt,
		Deleted:   data.Deleted,
	})
	if err != nil {
		return model.Account{}, fmt.Errorf("failed to create account: %w", err)
	}

	createdAccount := model.Account{
		ID:     row.ID.String(),
		UserID: row.UserID,
	}

	for _, privilege := range data.Privileges {
		err := r.queries.InsertPrivilege(ctx, sqlcgen.InsertPrivilegeParams{
			Privilegeid:   privilege.PrivilegeID,
			AccountID:     uuid.MustParse(data.ID),
			PrivilegeName: privilege.PrivilegeName,
			Amount:        int32(privilege.Amount),
			CreatedAt:     privilege.CreatedAt,
		})

		if err != nil {
			return model.Account{}, fmt.Errorf("failed to insert privilege: %w", err)
		}
	}

	return createdAccount, nil
}

func (r *AccountRepository) DeleteAccount(ctx context.Context, accountID string) error {
	tx, err := r.pool.BeginTx(ctx, nil)
	if err != nil {
		return err
	}

	err = r.queries.DeleteAccountById(ctx, uuid.MustParse(accountID))
	if err != nil {
		tx.Rollback()
		return err
	}

	err = r.queries.DeletePrivilegeByAccID(ctx, uuid.MustParse(accountID))
	if err != nil {
		tx.Rollback()
		return err
	}

	return tx.Commit()
}

// test +
func (r *AccountRepository) GetAccounts(ctx context.Context, limit uint64, offset uint64) ([]model.Account, uint64, error) {
	rows, err := r.queries.AccountPagination(ctx, sqlcgen.AccountPaginationParams{
		Limit:  int32(limit),
		Offset: int32(offset),
	})
	if err != nil {
		return nil, 0, err
	}

	var accounts []model.Account

	for _, row := range rows {
		account := model.Account{
			ID:        row.ID.String(),
			UserID:    row.UserID,
			CreatedAt: row.CreatedAt,
			Deleted:   row.Deleted,
		}

		accounts = append(accounts, account)
	}

	return accounts, uint64(len(accounts)), nil
}

// test +
func (r *AccountRepository) UpdatePrivilege(ctx context.Context, privilege *model.ShortPrivilege, accountID string) error {
	err := r.queries.UpdatePrivilege(ctx, sqlcgen.UpdatePrivilegeParams{
		Amount:      int32(privilege.Amount),
		CreatedAt:   privilege.CreatedAt,
		AccountID:   uuid.MustParse(accountID),
		Privilegeid: privilege.PrivilegeID,
	})

	if err != nil {
		return err
	}

	return nil
}

// test +
func (r *AccountRepository) InsertPrivilege(ctx context.Context, privilege *model.ShortPrivilege, accountID string) error {
	err := r.queries.InsertPrivilege(ctx, sqlcgen.InsertPrivilegeParams{
		Amount:        int32(privilege.Amount),
		CreatedAt:     privilege.CreatedAt,
		AccountID:     uuid.MustParse(accountID),
		Privilegeid:   privilege.PrivilegeID,
		PrivilegeName: privilege.PrivilegeName,
	})

	if err != nil {
		return err
	}

	return nil
}

// test +
func (r *AccountRepository) GetExpired(ctx context.Context, privilegeID string) ([]model.ExpiredPrivileges, error) {
	rows, err := r.queries.GetExpiredDayPrivilege(ctx, privilegeID)
	if err != nil {
		return nil, err
	}

	var expiredRecords []model.ExpiredPrivileges

	for _, row := range rows {
		privilege := model.ShortPrivilege{
			ID:            fmt.Sprintf("%d", row.ID),
			PrivilegeID:   row.Privilegeid,
			PrivilegeName: row.PrivilegeName,
			Amount:        uint64(row.Amount),
			CreatedAt:     row.CreatedAt,
		}
		expiredRecords = append(expiredRecords, model.ExpiredPrivileges{
			UserID:    row.UserID,
			Privilege: privilege,
		})

	}

	return expiredRecords, nil
}

func (r *AccountRepository) GetExpiredCount(ctx context.Context, privilegeID string) ([]model.ExpiredPrivileges, error) {
	rows, err := r.queries.GetExpiredCountPrivilege(ctx, privilegeID)
	if err != nil {
		return nil, err
	}

	var expiredRecords []model.ExpiredPrivileges

	for _, row := range rows {
		privilege := model.ShortPrivilege{
			ID:            fmt.Sprintf("%d", row.ID),
			PrivilegeID:   row.Privilegeid,
			PrivilegeName: row.PrivilegeName,
			Amount:        uint64(row.Amount),
			CreatedAt:     row.CreatedAt,
		}
		expiredRecords = append(expiredRecords, model.ExpiredPrivileges{
			UserID:    row.UserID,
			Privilege: privilege,
		})

	}

	return expiredRecords, nil
}

func (r *AccountRepository) CheckAndAddDefault(ctx context.Context, amount uint64, privilegeID string, zeroAmount uint64) error {
	err := r.queries.CheckAndAddDefault(ctx, sqlcgen.CheckAndAddDefaultParams{
		Amount:        int32(amount),
		PrivilegeName: privilegeID,
		Amount_2:      int32(zeroAmount),
	})

	if err != nil {
		return fmt.Errorf("error executing SQL query: %v", err)
	}

	return nil
}

// test +
func (r *AccountRepository) DeletePrivilegeByID(ctx context.Context, id string) error {
	intID, err := strconv.Atoi(id)
	if err != nil {
		return fmt.Errorf("failed to convert id to integer: %v", err)
	}

	return r.queries.DeletePrivilegeByID(ctx, int32(intID))
}

// test +
func (r *AccountRepository) UpdatePrivilegeAmount(ctx context.Context, ID string, newAmount uint64) error {
	intID, err := strconv.Atoi(ID)
	if err != nil {
		return fmt.Errorf("failed to convert id to integer: %v", err)
	}

	err = r.queries.UpdatePrivilegeAmount(ctx, sqlcgen.UpdatePrivilegeAmountParams{
		Amount: int32(newAmount),
		ID:     int32(intID),
	})

	if err != nil {
		return err
	}

	return nil
}

// test +
func (r *AccountRepository) GetAccAndPrivilegeByEmail(ctx context.Context, email string) (model.Account, []model.ShortPrivilege, error) {
	var account model.Account
	var privileges []model.ShortPrivilege

	row, err := r.queries.GetAccAndPrivilegeByEmail(ctx, email)
	if err != nil {
		return account, privileges, err
	}

	account.ID = row.ID.String()
	account.UserID = row.UserID
	account.CreatedAt = row.CreatedAt

	if row.ID_2 != 0 {
		privilege := model.ShortPrivilege{
			ID:          fmt.Sprint(row.ID_2),
			PrivilegeID: row.Privilegeid,
			Amount:      uint64(row.Amount),
			CreatedAt:   row.CreatedAt_2,
		}
		privileges = append(privileges, privilege)
	}

	return account, privileges, nil
}

func (r *AccountRepository) GetQidOwner(ctx context.Context, qId string) (string, error) {
	qUUID, err := uuid.Parse(qId)
	if err != nil {
		return "", err
	}

	qNullUUID := uuid.NullUUID{UUID: qUUID, Valid: true}

	userID, err := r.queries.GetQidOwner(ctx, qNullUUID)
	if err != nil {
		return "", err
	}

	return userID, nil
}

func (r *AccountRepository) ManualDone(ctx context.Context, userID string) error {
	_, err := r.queries.DecrementManual(ctx, sqlcgen.DecrementManualParams{
		UserID:      userID,
		Privilegeid: "quizManual",
	})

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

	return nil
}

func (r *AccountRepository) PostLeadTarget(ctx context.Context, req model.LeadTarget) (model.LeadTarget, error) {
	row, err := r.queries.CreateLeadTarget(ctx, sqlcgen.CreateLeadTargetParams{
		Accountid:  req.AccountID,
		Type:       req.Type,
		Quizid:     req.QuizID,
		Target:     req.Target,
		Invitelink: req.InviteLink,
	})
	if err != nil {
		return model.LeadTarget{}, err
	}

	var targetType model.LeadTargetType
	v := string(row.Type.([]byte))
	targetType = model.LeadTargetType(v)

	return model.LeadTarget{
		ID:         row.ID,
		AccountID:  row.Accountid,
		Type:       targetType,
		QuizID:     row.Quizid,
		Target:     row.Target,
		Deleted:    row.Deleted,
		CreatedAt:  row.Createdat,
		InviteLink: row.Invitelink,
	}, nil
}

func (r *AccountRepository) DeleteLeadTarget(ctx context.Context, id int64) error {
	err := r.queries.DeleteLeadTarget(ctx, id)
	if err != nil {
		return err
	}
	return nil
}

func (r *AccountRepository) GetLeadTarget(ctx context.Context, accountID string, quizID int32) ([]model.LeadTarget, error) {
	rows, err := r.queries.GetLeadTarget(ctx, sqlcgen.GetLeadTargetParams{
		Accountid: accountID,
		Quizid:    quizID,
	})
	if err != nil {
		if err == sql.ErrNoRows {
			return []model.LeadTarget{}, pj_errors.ErrNotFound
		}
		return []model.LeadTarget{}, err
	}
	var leadTargets []model.LeadTarget
	for _, row := range rows {
		var targetType model.LeadTargetType
		v := string(row.Type.([]byte))
		targetType = model.LeadTargetType(v)

		leadTargets = append(leadTargets, model.LeadTarget{
			ID:         row.ID,
			AccountID:  row.Accountid,
			Type:       targetType,
			QuizID:     row.Quizid,
			Target:     row.Target,
			Deleted:    row.Deleted,
			CreatedAt:  row.Createdat,
			InviteLink: row.Invitelink,
		})
	}

	return leadTargets, nil
}

func (r *AccountRepository) UpdateLeadTarget(ctx context.Context, req model.LeadTarget) (model.LeadTarget, error) {
	row, err := r.queries.UpdateLeadTarget(ctx, sqlcgen.UpdateLeadTargetParams{
		Invitelink: req.InviteLink,
		Target:     req.Target,
		ID:         req.ID,
	})
	if err != nil {
		if err == sql.ErrNoRows {
			return model.LeadTarget{}, pj_errors.ErrNotFound
		}
		return model.LeadTarget{}, err
	}

	var targetType model.LeadTargetType
	v := string(row.Type.([]byte))
	targetType = model.LeadTargetType(v)

	return model.LeadTarget{
		ID:         row.ID,
		AccountID:  row.Accountid,
		Type:       targetType,
		QuizID:     row.Quizid,
		Target:     row.Target,
		Deleted:    row.Deleted,
		CreatedAt:  row.Createdat,
		InviteLink: row.Invitelink,
	}, nil
}