319 lines
8.9 KiB
Go
319 lines
8.9 KiB
Go
package dao
|
||
|
||
import (
|
||
"database/sql"
|
||
"fmt"
|
||
"strconv"
|
||
|
||
"go-common/app/admin/ep/merlin/model"
|
||
"go-common/library/ecode"
|
||
|
||
pkgerr "github.com/pkg/errors"
|
||
)
|
||
|
||
// FindMobileMachineBySerial Find Device FarmBy Serial.
|
||
func (d *Dao) FindMobileMachineBySerial(serial string) (mobileMachine *model.MobileMachine, err error) {
|
||
mobileMachine = &model.MobileMachine{}
|
||
if err = d.db.Where("serial = ?", serial).Find(mobileMachine).Error; err == ecode.NothingFound {
|
||
err = nil
|
||
}
|
||
return
|
||
}
|
||
|
||
// DeleteMobileMachineByUUID Delete Mobile Machine By UUID.
|
||
func (d *Dao) DeleteMobileMachineByUUID(UUID string) (delCnt int, err error) {
|
||
err = pkgerr.WithStack(d.db.Model(&model.MobileMachine{}).Where("uuid <> ? and action <>?", UUID, model.MBHostDel).Count(&delCnt).Update("action", model.MBOffline).Error)
|
||
return
|
||
}
|
||
|
||
// DeleteMobileMachineNotInHost Delete Mobile Machine Not In Host.
|
||
func (d *Dao) DeleteMobileMachineNotInHost(hostList []string) (delCnt int, err error) {
|
||
err = pkgerr.WithStack(d.db.Model(&model.MobileMachine{}).Where("host not in (?)", hostList).Count(&delCnt).Update("action", model.MBHostDel).Error)
|
||
return
|
||
}
|
||
|
||
// FindMobileMachineByID Find Mobile Machine By Id.
|
||
func (d *Dao) FindMobileMachineByID(deviceID int64) (mobileMachine *model.MobileMachine, err error) {
|
||
mobileMachine = &model.MobileMachine{}
|
||
err = pkgerr.WithStack(d.db.Where("id = ?", deviceID).Find(mobileMachine).Error)
|
||
return
|
||
}
|
||
|
||
// InsertMobileMachine Insert Device Farm.
|
||
func (d *Dao) InsertMobileMachine(mobileMachine *model.MobileMachine) (err error) {
|
||
return pkgerr.WithStack(d.db.Create(&mobileMachine).Error)
|
||
}
|
||
|
||
// UpdateMobileMachineWsurlAndState Update Mobile Machine Wsurl And State.
|
||
func (d *Dao) UpdateMobileMachineWsurlAndState(mobileMachine *model.MobileMachine) (err error) {
|
||
return pkgerr.WithStack(d.db.Model(&model.MobileMachine{}).Where("serial=?", mobileMachine.Serial).Updates(map[string]interface{}{"wsurl": mobileMachine.WsURL, "state": mobileMachine.State, "upload_url": mobileMachine.UploadURL}).Error)
|
||
}
|
||
|
||
// UpdateMobileMachine Update Mobile Machine.
|
||
func (d *Dao) UpdateMobileMachine(mobileMachine *model.MobileMachine) (err error) {
|
||
return pkgerr.WithStack(d.db.Model(&model.MobileMachine{}).Where("serial=?", mobileMachine.Serial).Updates(mobileMachine).Error)
|
||
}
|
||
|
||
// UpdateMobileMachineByRelease Update Mobile Machine By Release.
|
||
func (d *Dao) UpdateMobileMachineByRelease(mobileMachine *model.MobileMachine) (err error) {
|
||
return pkgerr.WithStack(d.db.Model(&model.MobileMachine{}).Where("serial=?", mobileMachine.Serial).Updates(map[string]interface{}{"username": mobileMachine.Username, "end_time": mobileMachine.EndTime}).Error)
|
||
}
|
||
|
||
//FindMobileMachines Find Mobile Machines.
|
||
func (d *Dao) FindMobileMachines(queryRequest *model.QueryMobileDeviceRequest) (total int64, mobileMachines []*model.MobileMachine, err error) {
|
||
gDB := d.db.Model(&model.MobileMachine{}).Where("action> ? ", model.MBHostDel)
|
||
|
||
if queryRequest.MobileID > 0 {
|
||
gDB = gDB.Where("id=?", queryRequest.MobileID)
|
||
}
|
||
if queryRequest.Serial != "" {
|
||
gDB = gDB.Where("serial=?", queryRequest.Serial)
|
||
}
|
||
if queryRequest.Name != "" {
|
||
gDB = gDB.Where("name=?", queryRequest.Name)
|
||
}
|
||
if queryRequest.Username != "" {
|
||
gDB = gDB.Where("username=?", queryRequest.Username)
|
||
}
|
||
if queryRequest.OwnerName != "" {
|
||
gDB = gDB.Where("owner_name=?", queryRequest.OwnerName)
|
||
}
|
||
if queryRequest.CPU != "" {
|
||
gDB = gDB.Where("cpu=?", queryRequest.CPU)
|
||
}
|
||
if queryRequest.Version != "" {
|
||
gDB = gDB.Where("version=?", queryRequest.Version)
|
||
}
|
||
if queryRequest.Mode != "" {
|
||
gDB = gDB.Where("mode=?", queryRequest.Mode)
|
||
}
|
||
if queryRequest.Type > -1 {
|
||
gDB = gDB.Where("type=?", queryRequest.Type)
|
||
}
|
||
if queryRequest.State != "" {
|
||
gDB = gDB.Where("state=?", queryRequest.State)
|
||
}
|
||
if queryRequest.Online {
|
||
gDB = gDB.Where("action=?", model.MBOnline)
|
||
}
|
||
if queryRequest.Usage == model.MBFree {
|
||
gDB = gDB.Where("username='' and action=?", model.MBOnline)
|
||
}
|
||
if queryRequest.Usage == model.MBInUse {
|
||
gDB = gDB.Where("username<>'' and action=?", model.MBOnline)
|
||
}
|
||
if queryRequest.Usage == model.MBNoConnect {
|
||
gDB = gDB.Where("action=?", model.MBOffline)
|
||
}
|
||
if err = pkgerr.WithStack(gDB.Count(&total).Error); err != nil {
|
||
return
|
||
}
|
||
|
||
//先出action>0的，未连接的排在后面
|
||
err = pkgerr.WithStack(gDB.Order("action desc,id desc").Offset((queryRequest.PageNum - 1) * queryRequest.PageSize).Limit(queryRequest.PageSize).Find(&mobileMachines).Error)
|
||
|
||
return
|
||
}
|
||
|
||
// FindMobileMachineCategory Find Mobile Machine Category.
|
||
func (d *Dao) FindMobileMachineCategory(isShowOffline bool) (mobileCategory *model.MobileCategory, err error) {
|
||
var (
|
||
rows *sql.Rows
|
||
cpus []string
|
||
versions []string
|
||
modes []string
|
||
states []string
|
||
types []int
|
||
usages []int
|
||
|
||
sqlGroupTpl string
|
||
|
||
inUseCnt int
|
||
freeCnt int
|
||
noConCnt int
|
||
)
|
||
|
||
if isShowOffline {
|
||
sqlGroupTpl = "select %s from mobile_machines where action> " + strconv.Itoa(model.MBHostDel) + " group by %s"
|
||
} else {
|
||
sqlGroupTpl = "select %s from mobile_machines where action>-1 group by %s"
|
||
}
|
||
|
||
tx := d.db.Begin()
|
||
if err = tx.Error; err != nil {
|
||
return
|
||
}
|
||
|
||
//cpu
|
||
if rows, err = tx.Raw(fmt.Sprintf(sqlGroupTpl, "cpu", "cpu")).Rows(); err != nil {
|
||
return
|
||
}
|
||
for rows.Next() {
|
||
var cpu string
|
||
if err = rows.Scan(&cpu); err != nil {
|
||
return
|
||
}
|
||
cpus = append(cpus, cpu)
|
||
}
|
||
|
||
//version
|
||
if rows, err = tx.Raw(fmt.Sprintf(sqlGroupTpl, "version", "version")).Rows(); err != nil {
|
||
return
|
||
}
|
||
for rows.Next() {
|
||
var version string
|
||
if err = rows.Scan(&version); err != nil {
|
||
return
|
||
}
|
||
versions = append(versions, version)
|
||
}
|
||
|
||
//mode
|
||
if rows, err = tx.Raw(fmt.Sprintf(sqlGroupTpl, "mode", "mode")).Rows(); err != nil {
|
||
return
|
||
}
|
||
for rows.Next() {
|
||
var mode string
|
||
if err = rows.Scan(&mode); err != nil {
|
||
return
|
||
}
|
||
modes = append(modes, mode)
|
||
}
|
||
|
||
//state
|
||
if rows, err = tx.Raw(fmt.Sprintf(sqlGroupTpl, "state", "state")).Rows(); err != nil {
|
||
return
|
||
}
|
||
for rows.Next() {
|
||
var state string
|
||
if err = rows.Scan(&state); err != nil {
|
||
return
|
||
}
|
||
states = append(states, state)
|
||
}
|
||
|
||
//type
|
||
if rows, err = tx.Raw(fmt.Sprintf(sqlGroupTpl, "type", "type")).Rows(); err != nil {
|
||
return
|
||
}
|
||
for rows.Next() {
|
||
var stype int
|
||
if err = rows.Scan(&stype); err != nil {
|
||
return
|
||
}
|
||
types = append(types, stype)
|
||
}
|
||
|
||
//usage
|
||
if err = tx.Model(&model.MobileMachine{}).Where("username<>'' and action>0").Count(&inUseCnt).Error; err != nil {
|
||
return
|
||
}
|
||
if err = tx.Model(&model.MobileMachine{}).Where("username='' and action>0").Count(&freeCnt).Error; err != nil {
|
||
return
|
||
}
|
||
|
||
if err = tx.Model(&model.MobileMachine{}).Where("action<0").Count(&noConCnt).Error; err != nil {
|
||
return
|
||
}
|
||
|
||
if inUseCnt > 0 {
|
||
usages = append(usages, model.MBInUse)
|
||
}
|
||
|
||
if freeCnt > 0 {
|
||
usages = append(usages, model.MBFree)
|
||
}
|
||
|
||
if noConCnt > 0 {
|
||
usages = append(usages, model.MBNoConnect)
|
||
}
|
||
|
||
mobileCategory = &model.MobileCategory{}
|
||
mobileCategory.CPUs = cpus
|
||
mobileCategory.Versions = versions
|
||
mobileCategory.Modes = modes
|
||
mobileCategory.States = states
|
||
mobileCategory.Types = types
|
||
mobileCategory.Usages = usages
|
||
|
||
if err = tx.Commit().Error; err != nil {
|
||
tx.Rollback()
|
||
}
|
||
return
|
||
}
|
||
|
||
// FindAllMobileImages Find All Mobile Images.
|
||
func (d *Dao) FindAllMobileImages() (mobileImages []*model.MobileImage, err error) {
|
||
err = pkgerr.WithStack(d.db.Model(&model.MobileImage{}).Find(&mobileImages).Error)
|
||
return
|
||
}
|
||
|
||
// FindMobileImageByMode Find Mobile Image By Mode.
|
||
func (d *Dao) FindMobileImageByMode(mode string) (mobileImage *model.MobileImage, err error) {
|
||
mobileImage = &model.MobileImage{}
|
||
if err = d.db.Where("mode=?", mode).First(mobileImage).Error; err == ecode.NothingFound {
|
||
err = nil
|
||
}
|
||
return
|
||
}
|
||
|
||
// LendOutMobileMachine Lend Out Mobile.
|
||
func (d *Dao) LendOutMobileMachine(deviceID int64, serial, username string) (err error) {
|
||
tx := d.db.Begin()
|
||
|
||
if err = tx.Error; err != nil {
|
||
return
|
||
}
|
||
|
||
mobileMachineLog := &model.MobileMachineLog{
|
||
OperateType: model.MBLendOutLog,
|
||
Username: username,
|
||
MachineID: deviceID,
|
||
OperateResult: model.OperationSuccessForMachineLog,
|
||
}
|
||
if err = tx.Create(mobileMachineLog).Error; err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
if err = tx.Model(&model.MobileMachine{}).Where("serial=?", serial).Update("is_lendout", model.MBLendOut).Error; err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
if err = tx.Commit().Error; err != nil {
|
||
tx.Rollback()
|
||
}
|
||
return
|
||
}
|
||
|
||
// ReturnMobileMachine return Mobile.
|
||
func (d *Dao) ReturnMobileMachine(deviceID int64, serial, username string) (err error) {
|
||
tx := d.db.Begin()
|
||
|
||
if err = tx.Error; err != nil {
|
||
return
|
||
}
|
||
|
||
mobileMachineLog := &model.MobileMachineLog{
|
||
OperateType: model.MBReturnLog,
|
||
Username: username,
|
||
MachineID: deviceID,
|
||
OperateResult: model.OperationSuccessForMachineLog,
|
||
}
|
||
if err = tx.Create(mobileMachineLog).Error; err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
if err = tx.Model(&model.MobileMachine{}).Where("serial=?", serial).Update("is_lendout", model.MBOnSite).Error; err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
|
||
if err = tx.Commit().Error; err != nil {
|
||
tx.Rollback()
|
||
}
|
||
return
|
||
}
|