xps-server-go/repositories/account_repo.go

package repositories

import (
	"fmt"
	"time"
	"xorm.io/xorm"
	"xps/datamodels"
	"xps/viewmodels"
)

type AccountRepo struct {
	engine *xorm.Engine
}

func NewAccountRepo(engine *xorm.Engine) *AccountRepo {
	return &AccountRepo{
		engine: engine,
	}
}

func (d *AccountRepo) GetAccountByName(accountName string)(*viewmodels.AccountInfo, error) {
	sqlSelect := ` SELECT   A.oc_id,
                            B.oc_type_id,
                            B.oc_name,
                            A.account_id,
                            A.account_name,
                            A.account_real_name,
                            A.password,
                            A.account_type,
                            A.account_staff_no,
                            A.account_phone,
                            A.account_last_ip,
                            A.account_loc,
                            A.status,
                            A.account_avatar,
                            A.account_photo,
                            A.account_real_name,
                            A.account_intro,
                            A.wx_id,
                            A.is_fixed `
	sqlFrom   := `  FROM      account AS A
                    LEFT JOIN oc      AS B ON (A.oc_id = B.oc_id ) `
	sqlWhere  := `  WHERE A.deleted_flag = 0  `

	if accountName != "" {
		sqlWhere += ` AND  A.account_name like ` + "'%" + accountName + "%'"
	}

	data := &viewmodels.AccountInfo{}
	ok, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Get(data)
	if !ok && err != nil {
		return nil, err
	} else {
		return data, nil
	}
}

func (d *AccountRepo) GetAccountByCode(code string) (*viewmodels.AccountInfo, error) {
	sqlSelect := ` SELECT   A.oc_id,
							B.oc_type_id,
							B.oc_name,
							A.account_id,
							A.account_name,
							A.account_real_name,
							A.password,
							A.account_type,
							A.account_staff_no,
							A.account_phone,
							A.account_last_ip,
							A.account_loc,
							A.status,
							A.account_avatar,
							A.account_photo,
							A.account_real_name,
							A.account_intro,
							A.wx_id,
							A.is_fixed `
	sqlFrom  := ` FROM      account AS A
                  LEFT JOIN oc      AS B ON (A.oc_id = B.oc_id ) `
	sqlWhere := ` WHERE A.deleted_flag = 0  `
	sqlWhere += ` AND  (A.account_name = ` + "'" + code + "'"
	sqlWhere += ` OR    A.account_phone = ` + "'" + code + "'"
	sqlWhere += ` OR    A.account_mail = ` + "'" + code + "'"
	sqlWhere += ` OR    A.account_staff_no = ` + "'" + code + "')"
	
	data := &viewmodels.AccountInfo{}
	ok, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Get(data)
	if !ok && err != nil {
		return nil, err
	}
	return data, nil
}

func (d *AccountRepo) GetById(ocId int64, accountId int64)(*viewmodels.AccountInfo, error){
	sqlSelect := ` SELECT   A.oc_id,
                            B.oc_type_id,
                            B.oc_name,
                            A.account_id,
                            A.account_name,
                            A.account_real_name,
                            A.password,
                            A.account_type,
                            A.account_staff_no,
                            A.account_phone,
                            A.account_last_ip,
                            A.account_loc,
                            A.status,
                            A.account_avatar,
                            A.account_photo,
                            A.account_real_name,
                            A.account_intro,
                            A.wx_id,
                            A.is_fixed `
	sqlFrom := `  FROM      account AS A
                  LEFT JOIN oc      AS B ON (A.oc_id = B.oc_id ) `
	sqlWhere := ` WHERE A.deleted_flag = 0  AND A.oc_id = ` + fmt.Sprintf("%d", ocId)
	sqlWhere += ` AND   A.account_id = ` + fmt.Sprintf("%d", accountId)
	
	user := &viewmodels.AccountInfo{}
	has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Get(user)
	if !has || err != nil {
		return nil, err
	} else {
		return user, nil
	}
}

func (d *AccountRepo) GetList(m map[string]interface{}) ([]viewmodels.AccountInfo, error) {
	sqlSelect := ` SELECT   A.oc_id,
                            B.oc_type_id,
                            B.oc_name,
                            A.account_id,
                            A.account_name,
                            A.account_real_name,
                            A.password,
                            A.account_type,
                            A.account_staff_no,
                            A.account_phone,
                            A.account_last_ip,
                            A.account_loc,
                            A.status,
                            A.account_avatar,
                            A.account_photo,
                            A.account_real_name,
                            A.account_intro,
                            A.wx_id,
                            A.is_fixed `
	sqlFrom  := ` FROM      account AS A
                  LEFT JOIN oc      AS B ON (A.oc_id = B.oc_id ) `
	sqlWhere := ` WHERE A.deleted_flag = 0  `
	
	if ocId, ok := m["ocId"]; ok {
		sqlWhere += " AND A.oc_id = " + fmt.Sprintf("%d", ocId)
	}
	
	datalist := make([]viewmodels.AccountInfo, 0)
	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Asc("account_id").Find(&datalist)
	if err != nil {
		return nil, err
	} else {
		return datalist, nil
	}
}

func (d *AccountRepo) Create(data *datamodels.Account) error {
	_, err := d.engine.Insert(data)
	return err
}

func (d *AccountRepo) Update(ocId, accountId int64, data *datamodels.Account) error {
	_, err := d.engine.
		Where("oc_id = ?", ocId).
		Where("account_id = ?", accountId).
		Update(data)
	return err
}

func (d *AccountRepo) Delete(m map[string]interface{}) error {
	ocId      := m["ocId"].(int64)
	accountId := m["accountId"].(int64)
	deletedBy := m["deletedBy"].(int64)
	data := &datamodels.Account{
		OcId: ocId,
		AccountId: accountId,
		DeletedFlag: 1,
		DeletedBy: deletedBy,
		DeletedAt: time.Now(),
	}
	_, err := d.engine.
		Where("oc_id = ?", ocId).
		Where("account_id = ?", accountId).
		Update(data)
	return err
}

func (d *AccountRepo) IsUserNameExist(ocId int64, accountName string) (bool, error) {
	count, err := d.engine.
		Where("oc_id = ?", ocId).
		Where("deleted_flag = 0").
		Where("account_name = ?", accountName).
		Count(new(datamodels.Account))
	if err != nil {
		return false, err
	}
	return count > 0, nil
}

func (d *AccountRepo) IsUserPhoneExist(ocId int64, accountPhone string)(bool, error){
	count, err := d.engine.
		Where("oc_id = ?", ocId).
		Where("deleted_flag = 0").
		Where("account_phone = ?", accountPhone).
		Count(new(datamodels.Account))
	if err != nil {
		return true, err
	}
	return count > 0, nil
}


func (d *AccountRepo) IsStaffNoExist(ocId int64, staffNo string)(bool, error){
	count, err := d.engine.
		Where("oc_id = ?", ocId).
		Where("deleted_flag = 0").
		Where("account_staff_no = ?", staffNo).
		Count(new(datamodels.Account))
	if err != nil {
		return true, err
	}
	return count > 0, nil
}

func (d *AccountRepo) IsEmailExist(ocId int64, email string)(bool, error) {
	count, err := d.engine.
		Where("oc_id = ?", ocId).
		Where("deleted_flag = 0").
		Where("account_email = ?", email).
		Count(new(datamodels.Account))
	if err != nil {
		return true, err
	}
	return count > 0, nil
}