You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
318 lines
8.9 KiB
318 lines
8.9 KiB
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 |
|
}
|
|
|