certmanager/internal/logic/account.go

package logic

import (
	"context"
	"fmt"
	"time"

	"certmanager/internal/descriptor"
	"certmanager/pkg/auxid"
	"certmanager/pkg/cmctl"
)

func (lg *Logic) SeedAccount(ctx context.Context) (int64, error) {
	var err error
	var userID int64

	accountDescrs, err := lg.db.ListAccounts(ctx)
	if err != nil {
		return userID, err
	}
	if len(accountDescrs) == 0 {
		now := time.Now().Format(time.RFC3339)
		accountDescr := &descriptor.Account{
			ID:        auxid.GenID(),
			Username:  "certman",
			Password:  "certman",
			Disabled:  false,
			CreatedAt: now,
			UpdatedAt: now,
		}
		err = lg.db.InsertAccount(ctx, accountDescr)
		if err != nil {
			return userID, err
		}
		userID = accountDescr.ID
	}
	return userID, err
}

func (lg *Logic) ValidateAcount(ctx context.Context, username, password string) (bool, int64, error) {
	var err error
	var userID int64
	var valid bool

	accountExists, accountDescr, err := lg.db.GetAccountByUsername(ctx, username)
	if !accountExists {
		err := fmt.Errorf("Account not exists")
		return valid, userID, err
	}
	if password != accountDescr.Password {
		err := fmt.Errorf("Login data mismatch")
		return valid, userID, err
	}
	valid = true
	userID = accountDescr.ID
	return valid, userID, err

}

func (lg *Logic) CreateAccount(ctx context.Context, userID int64, params *cmctl.CreateAccountParams) (*cmctl.CreateAccountResult, error) {
	var err error
	res := &cmctl.CreateAccountResult{}

	accountExists, _, err := lg.db.GetAccountByUsername(ctx, params.Username)
	if err != nil {
		return res, err
	}
	if accountExists {
		err := fmt.Errorf("Account with thist name already exists")
		return res, err
	}
	now := time.Now().Format(time.RFC3339)
	accountDescr := &descriptor.Account{
		ID:        auxid.GenID(),
		Username:  params.Username,
		Password:  params.Password,
		Disabled:  false,
		CreatedAt: now,
		UpdatedAt: now,
	}
	err = lg.db.InsertAccount(ctx, accountDescr)
	if err != nil {
		return res, err
	}
	res.AccountID = accountDescr.ID
	return res, err
}

func (lg *Logic) UpdateAccount(ctx context.Context, userID int64, params *cmctl.UpdateAccountParams) (*cmctl.UpdateAccountResult, error) {
	var err error
	res := &cmctl.UpdateAccountResult{}

	var accountDescr *descriptor.Account
	var accountExists bool
	switch {
	case params.AccountID != 0:
		accountExists, accountDescr, err = lg.db.GetAccountByID(ctx, params.AccountID)
		if err != nil {
			return res, err
		}
	case params.Username != "":
		accountExists, accountDescr, err = lg.db.GetAccountByUsername(ctx, params.Username)
		if err != nil {
			return res, err
		}
	}
	if !accountExists {
		err := fmt.Errorf("Account with this is or name dont exists")
		return res, err
	}
	now := time.Now().Format(time.RFC3339)
	if params.NewUsername != "" {
		accountDescr.UpdatedAt = now
		accountDescr.Username = params.NewUsername
	}
	if params.NewPassword != "" {
		accountDescr.UpdatedAt = now
		accountDescr.Password = params.NewPassword
	}
	if params.Disabled != accountDescr.Disabled {
		accountDescr.UpdatedAt = now
		accountDescr.Disabled = params.Disabled
	}

	err = lg.db.UpdateAccountByID(ctx, accountDescr.ID, accountDescr)
	if err != nil {
		return res, err
	}
	return res, err
}

func (lg *Logic) DeleteAccount(ctx context.Context, userID int64, params *cmctl.DeleteAccountParams) (*cmctl.DeleteAccountResult, error) {
	var err error
	res := &cmctl.DeleteAccountResult{}

	var accountDescr *descriptor.Account
	var accountExists bool
	switch {
	case params.AccountID != 0:
		accountExists, accountDescr, err = lg.db.GetAccountByID(ctx, params.AccountID)
		if err != nil {
			return res, err
		}
	case params.Username != "":
		accountExists, accountDescr, err = lg.db.GetAccountByUsername(ctx, params.Username)
		if err != nil {
			return res, err
		}
	}
	if !accountExists {
		err := fmt.Errorf("Account with this is or name dont exists")
		return res, err
	}

	err = lg.db.DeleteAccountByID(ctx, accountDescr.ID)
	if err != nil {
		return res, err
	}
	return res, err
}

func (lg *Logic) ListAccounts(ctx context.Context, userID int64, params *cmctl.ListAccountsParams) (*cmctl.ListAccountsResult, error) {
	var err error
	res := &cmctl.ListAccountsResult{
		Accounts: make([]*cmctl.AccountShortDescr, 0),
	}
	accountDescrs, err := lg.db.ListAccounts(ctx)
	if err != nil {
		return res, err
	}
	for _, accountDescr := range accountDescrs {
		shortDescr := &cmctl.AccountShortDescr{
			Username:  accountDescr.Username,
			Disabled:  accountDescr.Disabled,
			CreatedAt: accountDescr.CreatedAt,
			UpdatedAt: accountDescr.UpdatedAt,
		}
		res.Accounts = append(res.Accounts, shortDescr)
	}
	return res, err
}