718 lines
19 KiB
Go
718 lines
19 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
"go-common/app/admin/ep/merlin/model"
|
|
"go-common/library/ecode"
|
|
"go-common/library/log"
|
|
|
|
"github.com/satori/go.uuid"
|
|
)
|
|
|
|
//SyncMobileDeviceList Sync Device Farm List .
|
|
func (s *Service) SyncMobileDeviceList(c context.Context) (uid string, err error) {
|
|
uid = uuid.NewV4().String()
|
|
s.deviceChan.Do(c, func(c context.Context) {
|
|
var (
|
|
startCnt int
|
|
status int
|
|
totalCnt int
|
|
addCnt int
|
|
updateCnt int
|
|
delCnt int
|
|
err error
|
|
)
|
|
|
|
if startCnt, err = s.dao.FindMobileSyncLogStartStatus(); err != nil {
|
|
return
|
|
}
|
|
|
|
if startCnt > 0 {
|
|
return
|
|
}
|
|
|
|
mobileSyncLog := &model.MobileSyncLog{
|
|
UUID: uid,
|
|
}
|
|
s.dao.InsertMobileSyncLog(mobileSyncLog)
|
|
|
|
if totalCnt, addCnt, updateCnt, delCnt, err = s.SyncMobileDeviceListInChan(uid); err != nil {
|
|
status = -1
|
|
} else {
|
|
status = 1
|
|
}
|
|
|
|
mobileSyncLog = &model.MobileSyncLog{
|
|
UUID: uid,
|
|
TotalCnt: totalCnt,
|
|
AddCnt: addCnt,
|
|
UpdateCnt: updateCnt,
|
|
DeleteCnt: delCnt,
|
|
Status: status,
|
|
}
|
|
s.dao.UpdateMobileSyncLog(mobileSyncLog)
|
|
|
|
})
|
|
return
|
|
}
|
|
|
|
// SyncMobileDeviceListInChan Sync Mobile Device List In Chan.
|
|
func (s *Service) SyncMobileDeviceListInChan(uuid string) (totalCnt, addCnt, updateCnt, delCnt int, err error) {
|
|
var (
|
|
resTotal map[string][]*model.Device
|
|
)
|
|
|
|
if resTotal, err = s.dao.MobileDeviceList(context.Background()); err != nil {
|
|
log.Error("SyncMobileDeviceListInChan httpClient err(%+v)", err)
|
|
err = nil
|
|
}
|
|
|
|
if len(resTotal) == 0 {
|
|
return
|
|
}
|
|
|
|
for host, devices := range resTotal {
|
|
totalCnt = totalCnt + len(devices)
|
|
for _, device := range devices {
|
|
var deviceType int
|
|
var tmpMobileMachine *model.MobileMachine
|
|
|
|
if device.IsSimulator {
|
|
deviceType = model.MBSimulator
|
|
}
|
|
|
|
if tmpMobileMachine, err = s.dao.FindMobileMachineBySerial(device.Serial); err != nil {
|
|
log.Error("d.SyncMobileDeviceList FindMobileMachineBySerial err(%+v)", err)
|
|
continue
|
|
}
|
|
mobileMachine := &model.MobileMachine{
|
|
Serial: device.Serial,
|
|
Name: device.Name,
|
|
CPU: device.CPU,
|
|
Version: device.Version,
|
|
Mode: device.Mode,
|
|
State: device.State,
|
|
Host: host,
|
|
Type: deviceType,
|
|
Action: model.MBOnline,
|
|
UUID: uuid,
|
|
}
|
|
|
|
if tmpMobileMachine.ID == 0 {
|
|
if err = s.dao.InsertMobileMachine(mobileMachine); err != nil {
|
|
log.Error("d.SyncMobileDeviceList InsertMobileMachine err(%+v)", err)
|
|
} else {
|
|
addCnt = addCnt + 1
|
|
}
|
|
|
|
} else {
|
|
if err = s.dao.UpdateMobileMachine(mobileMachine); err != nil {
|
|
log.Error("d.SyncMobileDeviceList UpdateMobileMachine err(%+v)", err)
|
|
} else {
|
|
updateCnt = updateCnt + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
s.dao.DeleteMobileMachineNotInHost(s.c.DeviceFarm.HostList)
|
|
|
|
delCnt, err = s.dao.DeleteMobileMachineByUUID(uuid)
|
|
|
|
return
|
|
}
|
|
|
|
// QueryMobileDeviceList Query Mobile Device List.
|
|
func (s *Service) QueryMobileDeviceList(c context.Context, queryRequest *model.QueryMobileDeviceRequest) (p *model.PaginateMobileMachines, err error) {
|
|
var (
|
|
total int64
|
|
mobileMachines []*model.MobileMachine
|
|
mobileMachinesResponse []*model.MobileMachineResponse
|
|
)
|
|
if total, mobileMachines, err = s.dao.FindMobileMachines(queryRequest); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, mobileMachine := range mobileMachines {
|
|
var mobileMachineResponse model.MobileMachineResponse
|
|
mobileMachineResponse.MobileMachine = mobileMachine
|
|
mobileMachinesResponse = append(mobileMachinesResponse, &mobileMachineResponse)
|
|
}
|
|
|
|
if err = s.getMobileImages(mobileMachinesResponse); err != nil {
|
|
return
|
|
}
|
|
|
|
p = &model.PaginateMobileMachines{
|
|
PageNum: queryRequest.PageNum,
|
|
PageSize: queryRequest.PageSize,
|
|
Total: total,
|
|
MobileMachines: mobileMachinesResponse,
|
|
}
|
|
return
|
|
}
|
|
|
|
// RefreshMobileDeviceDetail Refresh Mobile Device Detail.
|
|
func (s *Service) RefreshMobileDeviceDetail(c context.Context, deviceID int64) (mobileMachineResponse *model.MobileMachineResponse, err error) {
|
|
var (
|
|
device *model.Device
|
|
mobileMachine *model.MobileMachine
|
|
)
|
|
|
|
if mobileMachine, err = s.dao.FindMobileMachineByID(deviceID); err != nil {
|
|
return
|
|
}
|
|
|
|
if device, err = s.dao.MobileDeviceDetail(c, mobileMachine.Host, mobileMachine.Serial); err != nil {
|
|
return
|
|
}
|
|
|
|
//update db
|
|
mobileMachine.State = device.State
|
|
mobileMachine.Action = 1
|
|
if err = s.dao.UpdateMobileMachine(mobileMachine); err != nil {
|
|
log.Error("d.RefreshMobileDeviceDetail err(%+v)", err)
|
|
return
|
|
}
|
|
|
|
mobileMachineResponse = &model.MobileMachineResponse{}
|
|
mobileMachineResponse.MobileMachine = mobileMachine
|
|
if err = s.getMobileImage(mobileMachineResponse); err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// MobileMachineCategory Mobile Machine Category.
|
|
func (s *Service) MobileMachineCategory(c context.Context, isShowOffline bool) (categoryList []*model.MobileDeviceCategoryResponse, err error) {
|
|
var mobileCategory *model.MobileCategory
|
|
if mobileCategory, err = s.dao.FindMobileMachineCategory(isShowOffline); err != nil {
|
|
return
|
|
}
|
|
|
|
interfaceCPU := make([]interface{}, len(mobileCategory.CPUs))
|
|
for i, v := range mobileCategory.CPUs {
|
|
interfaceCPU[i] = v
|
|
}
|
|
categoryCPU := &model.MobileDeviceCategoryResponse{
|
|
Name: "cpu",
|
|
Label: "CPU",
|
|
Values: interfaceCPU,
|
|
}
|
|
|
|
interfaceVersion := make([]interface{}, len(mobileCategory.Versions))
|
|
for i, v := range mobileCategory.Versions {
|
|
interfaceVersion[i] = v
|
|
}
|
|
categoryVersion := &model.MobileDeviceCategoryResponse{
|
|
Name: "version",
|
|
Label: "版本",
|
|
Values: interfaceVersion,
|
|
}
|
|
|
|
interfaceMode := make([]interface{}, len(mobileCategory.Modes))
|
|
for i, v := range mobileCategory.Modes {
|
|
interfaceMode[i] = v
|
|
}
|
|
categoryMode := &model.MobileDeviceCategoryResponse{
|
|
Name: "mode",
|
|
Label: "型号",
|
|
Values: interfaceMode,
|
|
}
|
|
|
|
interfaceType := make([]interface{}, len(mobileCategory.Types))
|
|
for i, v := range mobileCategory.Types {
|
|
interfaceType[i] = v
|
|
}
|
|
categoryType := &model.MobileDeviceCategoryResponse{
|
|
Name: "type",
|
|
Label: "是否真机",
|
|
Values: interfaceType,
|
|
}
|
|
|
|
interfaceState := make([]interface{}, len(mobileCategory.States))
|
|
for i, v := range mobileCategory.States {
|
|
interfaceState[i] = v
|
|
}
|
|
categoryState := &model.MobileDeviceCategoryResponse{
|
|
Name: "state",
|
|
Label: "状态",
|
|
Values: interfaceState,
|
|
}
|
|
|
|
interfaceUsage := make([]interface{}, len(mobileCategory.Usages))
|
|
for i, v := range mobileCategory.Usages {
|
|
interfaceUsage[i] = v
|
|
}
|
|
categoryUsage := &model.MobileDeviceCategoryResponse{
|
|
Name: "usage",
|
|
Label: "使用情况",
|
|
Values: interfaceUsage,
|
|
}
|
|
|
|
categoryList = append(categoryList, categoryCPU)
|
|
categoryList = append(categoryList, categoryVersion)
|
|
categoryList = append(categoryList, categoryMode)
|
|
categoryList = append(categoryList, categoryType)
|
|
categoryList = append(categoryList, categoryState)
|
|
categoryList = append(categoryList, categoryUsage)
|
|
return
|
|
}
|
|
|
|
// BindMobileDevice Bind Mobile Device.
|
|
func (s *Service) BindMobileDevice(c context.Context, deviceID int64, username string) (status int, err error) {
|
|
var mobileMachine *model.MobileMachine
|
|
|
|
status = -1
|
|
if mobileMachine, err = s.dao.FindMobileMachineByID(deviceID); err != nil {
|
|
return
|
|
}
|
|
|
|
if mobileMachine.Action < model.MBOnline {
|
|
err = ecode.MerlinDeviceFarmMachineStatusErr
|
|
return
|
|
}
|
|
|
|
//真机借出状态， 无法操作
|
|
if mobileMachine.Type == model.MBReal && mobileMachine.IsLendOut == model.MBLendOut {
|
|
err = ecode.MerlinDeviceIsLendOut
|
|
return
|
|
}
|
|
|
|
if mobileMachine.Username != "" {
|
|
return
|
|
}
|
|
|
|
mobileMachine.Username = username
|
|
mobileMachine.EndTime = time.Now().AddDate(0, s.c.DeviceFarm.ApplyMonthTime, 0)
|
|
mobileMachine.LastBindTime = time.Now()
|
|
if err = s.dao.UpdateMobileMachine(mobileMachine); err != nil {
|
|
return
|
|
}
|
|
|
|
if err = s.addMobileDeviceLog(deviceID, username, model.MBBindLog); err != nil {
|
|
return
|
|
}
|
|
|
|
status = 0
|
|
return
|
|
|
|
}
|
|
|
|
// ReleaseMobileDevice Release Mobile Device.
|
|
func (s *Service) ReleaseMobileDevice(c context.Context, deviceID int64, username string) (status int, err error) {
|
|
var mobileMachine *model.MobileMachine
|
|
|
|
status = -1
|
|
if mobileMachine, err = s.isAccessToMobileDevice(deviceID, username); err != nil {
|
|
return
|
|
}
|
|
|
|
mobileMachine.Username = ""
|
|
if mobileMachine.EndTime, err = time.ParseInLocation(model.TimeFormat, "1990-01-01 01:01:01", time.Local); err != nil {
|
|
return
|
|
}
|
|
|
|
if err = s.dao.UpdateMobileMachineByRelease(mobileMachine); err != nil {
|
|
return
|
|
}
|
|
|
|
if err = s.addMobileDeviceLog(deviceID, username, model.MBReleaseLog); err != nil {
|
|
return
|
|
}
|
|
|
|
status = 0
|
|
return
|
|
|
|
}
|
|
|
|
// LendOutMobileDevice Pull Out Mobile Device.
|
|
func (s *Service) LendOutMobileDevice(c context.Context, deviceID int64, username string) (status int, err error) {
|
|
var (
|
|
mobileMachine *model.MobileMachine
|
|
)
|
|
|
|
status = -1
|
|
|
|
if mobileMachine, err = s.isAccessToMobileDevice(deviceID, username); err != nil {
|
|
return
|
|
}
|
|
|
|
//只有真机支持借出 真机type=0
|
|
if mobileMachine.Type != model.MBReal {
|
|
err = ecode.MerlinDeviceIsNotRealMachineErr
|
|
return
|
|
}
|
|
|
|
if err = s.dao.LendOutMobileMachine(deviceID, mobileMachine.Serial, username); err != nil {
|
|
return
|
|
}
|
|
status = 0
|
|
return
|
|
}
|
|
|
|
// ReturnMobileDevice Return Mobile Device.
|
|
func (s *Service) ReturnMobileDevice(c context.Context, deviceID int64, username string) (status int, err error) {
|
|
var (
|
|
mobileMachine *model.MobileMachine
|
|
isSuperOwner = false
|
|
)
|
|
|
|
status = -1
|
|
|
|
for _, superOwner := range s.c.DeviceFarm.SuperOwner {
|
|
if username == superOwner {
|
|
isSuperOwner = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if !isSuperOwner {
|
|
err = ecode.MerlinDeviceNoRight
|
|
return
|
|
}
|
|
|
|
if mobileMachine, err = s.dao.FindMobileMachineByID(deviceID); err != nil {
|
|
return
|
|
}
|
|
|
|
if mobileMachine.IsLendOut == model.MBOnSite {
|
|
err = ecode.MerlinDeviceFarmErr
|
|
return
|
|
}
|
|
|
|
if err = s.dao.ReturnMobileMachine(deviceID, mobileMachine.Serial, username); err != nil {
|
|
return
|
|
}
|
|
|
|
status = 0
|
|
return
|
|
}
|
|
|
|
// StartMobileDevice Start Mobile Device.
|
|
func (s *Service) StartMobileDevice(c context.Context, deviceID int64, username string) (deviceBootData *model.DeviceBootData, err error) {
|
|
var (
|
|
mobileMachine *model.MobileMachine
|
|
device *model.Device
|
|
)
|
|
|
|
if mobileMachine, err = s.isAccessToMobileDevice(deviceID, username); err != nil {
|
|
return
|
|
}
|
|
|
|
if deviceBootData, err = s.dao.BootMobileDevice(c, mobileMachine.Host, mobileMachine.Serial); err != nil {
|
|
return
|
|
}
|
|
|
|
if device, err = s.dao.MobileDeviceDetail(c, mobileMachine.Host, mobileMachine.Serial); err != nil {
|
|
return
|
|
}
|
|
|
|
mobileMachine.State = device.State
|
|
mobileMachine.WsURL = deviceBootData.WSRUL
|
|
mobileMachine.UploadURL = deviceBootData.UploadURL
|
|
if err = s.dao.UpdateMobileMachineWsurlAndState(mobileMachine); err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.addMobileDeviceLog(deviceID, username, model.MBStartLog)
|
|
return
|
|
|
|
}
|
|
|
|
// ShutdownMobileDevice Shutdown Mobile Device.
|
|
func (s *Service) ShutdownMobileDevice(c context.Context, deviceID int64, username string) (status int, err error) {
|
|
var (
|
|
mobileMachine *model.MobileMachine
|
|
device *model.Device
|
|
)
|
|
status = -1
|
|
if mobileMachine, err = s.isAccessToMobileDevice(deviceID, username); err != nil {
|
|
return
|
|
}
|
|
|
|
if err = s.dao.ShutdownMobileDevice(c, mobileMachine.Host, mobileMachine.Serial); err != nil {
|
|
return
|
|
}
|
|
|
|
if device, err = s.dao.MobileDeviceDetail(c, mobileMachine.Host, mobileMachine.Serial); err != nil {
|
|
return
|
|
}
|
|
|
|
mobileMachine.State = device.State
|
|
mobileMachine.WsURL = ""
|
|
mobileMachine.UploadURL = ""
|
|
if err = s.dao.UpdateMobileMachineWsurlAndState(mobileMachine); err != nil {
|
|
return
|
|
}
|
|
|
|
if err = s.addMobileDeviceLog(deviceID, username, model.MBShutDownLog); err != nil {
|
|
return
|
|
}
|
|
status = 0
|
|
return
|
|
}
|
|
|
|
func (s *Service) isAccessToMobileDevice(deviceID int64, username string) (mobileMachine *model.MobileMachine, err error) {
|
|
if mobileMachine, err = s.dao.FindMobileMachineByID(deviceID); err != nil {
|
|
return
|
|
}
|
|
|
|
if mobileMachine.Action < model.MBOnline {
|
|
err = ecode.MerlinDeviceFarmMachineStatusErr
|
|
return
|
|
}
|
|
|
|
//真机借出状态， 无法操作
|
|
if mobileMachine.Type == model.MBReal && mobileMachine.IsLendOut == model.MBLendOut {
|
|
err = ecode.MerlinDeviceIsLendOut
|
|
return
|
|
}
|
|
|
|
for _, superOwner := range s.c.DeviceFarm.SuperOwner {
|
|
if username == superOwner {
|
|
return
|
|
}
|
|
}
|
|
|
|
if mobileMachine.Username != username {
|
|
err = ecode.MerlinDeviceNotBind
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) addMobileDeviceLog(deviceID int64, username, operateType string) (err error) {
|
|
machineLog := &model.MobileMachineLog{
|
|
OperateType: operateType,
|
|
Username: username,
|
|
MachineID: deviceID,
|
|
OperateResult: model.OperationSuccessForMachineLog,
|
|
}
|
|
return s.dao.InsertMobileMachineLog(machineLog)
|
|
}
|
|
|
|
func (s *Service) getMobileImages(mobileMachinesResponse []*model.MobileMachineResponse) (err error) {
|
|
var mobileImages []*model.MobileImage
|
|
if mobileImages, err = s.dao.FindAllMobileImages(); err != nil {
|
|
return
|
|
}
|
|
for _, mobileMachineResponse := range mobileMachinesResponse {
|
|
for _, mobileImage := range mobileImages {
|
|
if mobileImage.Mode == mobileMachineResponse.Mode {
|
|
mobileMachineResponse.ImageSrc = mobileImage.ImageSrc
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) getMobileImage(mobileMachinesResponse *model.MobileMachineResponse) (err error) {
|
|
var mobileImage *model.MobileImage
|
|
if mobileImage, err = s.dao.FindMobileImageByMode(mobileMachinesResponse.Mode); err != nil {
|
|
return
|
|
}
|
|
mobileMachinesResponse.ImageSrc = mobileImage.ImageSrc
|
|
return
|
|
}
|
|
|
|
// QueryMobileMachineLogs Query Mobile Machine Logs.
|
|
func (s *Service) QueryMobileMachineLogs(c context.Context, queryRequest *model.QueryMobileMachineLogRequest) (p *model.PaginateMobileMachineLog, err error) {
|
|
var (
|
|
total int64
|
|
machineLogs []*model.AboundMobileMachineLog
|
|
)
|
|
if total, machineLogs, err = s.dao.FindMobileMachineLogs(queryRequest); err != nil {
|
|
return
|
|
}
|
|
p = &model.PaginateMobileMachineLog{
|
|
PageNum: queryRequest.PageNum,
|
|
PageSize: queryRequest.PageSize,
|
|
Total: total,
|
|
MachineLogs: machineLogs,
|
|
}
|
|
return
|
|
}
|
|
|
|
// QueryMobileMachineLendOutLogs Query Mobile Machine Lend Out Logs.
|
|
func (s *Service) QueryMobileMachineLendOutLogs(c context.Context, username string, queryRequest *model.QueryMobileMachineLogRequest) (p *model.PaginateMobileMachineLendOutLog, err error) {
|
|
var (
|
|
total int64
|
|
machineLogs []*model.AboundMobileMachineLog
|
|
machineLendOutRecords []*model.MachineLendOutRecord
|
|
mobileMachine *model.MobileMachine
|
|
existMachineIDs []int64
|
|
isSuperUser bool
|
|
)
|
|
isSuperUser = s.isSuperUser(username)
|
|
|
|
queryRequest.OperateType = model.MBLendOutLog
|
|
|
|
if total, machineLogs, err = s.dao.FindMobileMachineLogs(queryRequest); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, machineLog := range machineLogs {
|
|
|
|
var (
|
|
enableReturn bool
|
|
isExistLendRecord bool
|
|
)
|
|
|
|
if mobileMachine, err = s.dao.FindMobileMachineByID(machineLog.MachineID); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, existMachineID := range existMachineIDs {
|
|
if existMachineID == machineLog.MachineID {
|
|
isExistLendRecord = true
|
|
break
|
|
}
|
|
}
|
|
|
|
//移动设备借出状态 且 用户是超级用户 才有资格归还手机 只有最新一条记录 才能点击返还
|
|
if isExistLendRecord {
|
|
|
|
machineLendOutRecord := &model.MachineLendOutRecord{
|
|
MachineID: machineLog.MachineID,
|
|
Lender: machineLog.Username,
|
|
LendTime: machineLog.OperateTime,
|
|
EnableReturn: false,
|
|
Status: model.MBOnSite,
|
|
}
|
|
machineLendOutRecords = append(machineLendOutRecords, machineLendOutRecord)
|
|
|
|
} else {
|
|
|
|
if isSuperUser && (mobileMachine.IsLendOut == model.MBLendOut) {
|
|
enableReturn = true
|
|
}
|
|
|
|
machineLendOutRecord := &model.MachineLendOutRecord{
|
|
MachineID: machineLog.MachineID,
|
|
Lender: machineLog.Username,
|
|
LendTime: machineLog.OperateTime,
|
|
EnableReturn: enableReturn,
|
|
Status: mobileMachine.IsLendOut,
|
|
}
|
|
machineLendOutRecords = append(machineLendOutRecords, machineLendOutRecord)
|
|
existMachineIDs = append(existMachineIDs, machineLog.MachineID)
|
|
}
|
|
|
|
}
|
|
|
|
p = &model.PaginateMobileMachineLendOutLog{
|
|
PageNum: queryRequest.PageNum,
|
|
PageSize: queryRequest.PageSize,
|
|
Total: total,
|
|
MachineLendOutRecords: machineLendOutRecords,
|
|
}
|
|
return
|
|
}
|
|
|
|
// QueryMobileMachineErrorLogs Query Mobile Machine Error Logs.
|
|
func (s *Service) QueryMobileMachineErrorLogs(c context.Context, queryRequest *model.QueryMobileMachineErrorLogRequest) (p *model.PaginateMobileMachineErrorLog, err error) {
|
|
var (
|
|
total int64
|
|
machineLogs []*model.MobileMachineErrorLog
|
|
)
|
|
if total, machineLogs, err = s.dao.FindMobileMachineErrorLog(queryRequest); err != nil {
|
|
return
|
|
}
|
|
p = &model.PaginateMobileMachineErrorLog{
|
|
PageNum: queryRequest.PageNum,
|
|
PageSize: queryRequest.PageSize,
|
|
Total: total,
|
|
MachineLogs: machineLogs,
|
|
}
|
|
return
|
|
}
|
|
|
|
// CallBackMobileDeviceError Call Back Mobile Device Error.
|
|
func (s *Service) CallBackMobileDeviceError(c context.Context, serialName, errMsg string, errCode int) (err error) {
|
|
var mobileMachine *model.MobileMachine
|
|
|
|
if mobileMachine, err = s.dao.FindMobileMachineBySerial(serialName); err != nil {
|
|
return
|
|
}
|
|
|
|
mobileMachineErrorLog := &model.MobileMachineErrorLog{
|
|
MachineID: mobileMachine.ID,
|
|
SerialName: serialName,
|
|
ErrorMessage: errMsg,
|
|
ErrorCode: errCode,
|
|
}
|
|
|
|
err = s.dao.InsertMobileMachineErrorLog(mobileMachineErrorLog)
|
|
return
|
|
}
|
|
|
|
// ReportMobileDeviceError Report Mobile Device Error.
|
|
func (s *Service) ReportMobileDeviceError(c context.Context, serialName, errMsg string, errCode int) (err error) {
|
|
var mobileMachine *model.MobileMachine
|
|
|
|
if mobileMachine, err = s.dao.FindMobileMachineBySerial(serialName); err != nil {
|
|
return
|
|
}
|
|
|
|
if mobileMachine.ID == 0 {
|
|
err = ecode.NothingFound
|
|
return
|
|
}
|
|
|
|
content := fmt.Sprintf("通知\n设备ID: %d\n系列号: %s\n型号: %s\n系统版本: %s\n使用者: %s\n错误信息: %s\n错误码: %d", mobileMachine.ID, serialName, mobileMachine.Mode, mobileMachine.Version, mobileMachine.Username, errMsg, errCode)
|
|
msgSendReq := &model.MsgSendReq{
|
|
Chatid: s.c.WeChat.WeChatDeviceFarm.ChatID,
|
|
Msgtype: s.c.WeChat.WeChatDeviceFarm.MsgType,
|
|
Text: model.MsgSendReqText{Content: content},
|
|
Safe: s.c.WeChat.WeChatDeviceFarm.Safe,
|
|
}
|
|
if _, err = s.dao.WeChatSendMessage(c, msgSendReq); err != nil {
|
|
return
|
|
}
|
|
|
|
mobileMachineErrorLog := &model.MobileMachineErrorLog{
|
|
MachineID: mobileMachine.ID,
|
|
SerialName: serialName,
|
|
ErrorMessage: errMsg,
|
|
ErrorCode: errCode,
|
|
}
|
|
|
|
err = s.dao.InsertMobileMachineErrorLog(mobileMachineErrorLog)
|
|
return
|
|
}
|
|
|
|
// DeviceFarmSuperUser Device Farm Super User.
|
|
func (s *Service) DeviceFarmSuperUser() (responseMap map[string]interface{}) {
|
|
responseMap = make(map[string]interface{})
|
|
responseMap["superuser_list"] = s.c.DeviceFarm.SuperOwner
|
|
return
|
|
}
|
|
|
|
// IsBindMobileDeviceByTheUser Is Bind Mobile Device By The User.
|
|
func (s *Service) IsBindMobileDeviceByTheUser(c context.Context, deviceID int64, username string) (isBind bool, err error) {
|
|
var mobileMachine *model.MobileMachine
|
|
|
|
if mobileMachine, err = s.dao.FindMobileMachineByID(deviceID); err != nil {
|
|
return
|
|
}
|
|
|
|
if mobileMachine.Username == username {
|
|
isBind = true
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) isSuperUser(username string) bool {
|
|
for _, superOwner := range s.c.DeviceFarm.SuperOwner {
|
|
if username == superOwner {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|