def create(cls, tag, project_id, description):
try:
creator = g.userid if g.userid else None
ret = Tag.query.filter(Tag.tag == tag).first()
if ret:
if ret.status == Tag.DISABLE:
with db.auto_commit():
ret.status = Tag.ACTIVE
ret.creator = creator
db.session.add(ret)
return 0
else:
raise SaveObjectException('存在相同名称的标签')
else:
task = Tag(
tag=tag,
project_id=project_id,
description=description,
creator=creator
)
db.session.add(task)
db.session.commit()
return 0
except Exception as e:
current_app.logger.error(str(e))
raise SaveObjectException
def create_by_one2one(send_id, rec_ids, content, message_type, group):
"""
创建一条私密消息，用于少量用户的流程通知
:param send_id: 发送者
:param rec_ids: 接收者
:param content: 内容
:param message_type: 类型
:param group: 用户组
:return: code
"""
rec_ids = list(set(rec_ids))
if not message_type:
message_type = Content.PRIVATE
if not group:
group = 'public'
if send_id is not None and content:
with db.auto_commit():
content = Content(send_id=send_id,
content=content,
type=message_type,
group=group)
db.session.add(content)
db.session.flush()
content_id = content.id
if content_id:
with db.auto_commit():
for i in rec_ids:
db.session.add(
Message(rec_id=int(i),
content_id=content_id,
status=Message.UNREAD))
# for i in rec_ids:
# push2redis(i)
return 0
raise SaveObjectException()
def auto_commit(self):
try:
yield
self.session.commit()
except Exception:
self.session.rollback()
raise SaveObjectException()
def update(cls, id, end_time, process, jenkins_url, status, app_version, begin_time, report_url, run_time,
actual_run_time, download_app_status):
try:
monkey = Monkey.query.get(id)
check_list = {
'id': id,
'end_time': end_time,
'jenkins_url': jenkins_url,
'process': process,
'status': status,
'app_version': app_version,
'begin_time': begin_time,
'report_url': report_url,
'run_time': run_time,
'actual_run_time': actual_run_time,
'download_app_status': download_app_status
}
for key in check_list.keys():
if check_list.get(key) is not None:
setattr(monkey, key, check_list.get(key))
db.session.add(monkey)
db.session.commit()
return 0, None
except Exception as e:
current_app.logger.error(e)
current_app.logger.error(traceback.format_exc())
raise SaveObjectException()
def update_process(cls, id, process):
try:
monkey = MonkeyDeviceStatus.query.get(id)
monkey.process = process
db.session.add(monkey)
db.session.commit()
return 0, None
except Exception as e:
current_app.logger.error(e)
current_app.logger.error(traceback.format_exc())
raise SaveObjectException()
def start_jenkins_job(cls, parameters):
try:
jenkins_server_url = current_app.config['CI_AUTO_MAN_JENKINS_URL']
jenkins_server_username = current_app.config['CI_AUTO_MAN_JENKINS_AUTH']
job_name = current_app.config['CI_AUTO_MAN_JENKINS_MONKEY_JOB']
jenkins_server = jenkins.Jenkins(jenkins_server_url, username=jenkins_server_username.get('username'),
password=jenkins_server_username.get('password'))
jenkins_server.build_job(job_name, parameters)
return 'Success'
except Exception as e:
current_app.logger.error(e)
current_app.logger.error(traceback.format_exc())
raise SaveObjectException()
def update_jenkins_url(cls, id, jenkins_url):
try:
monkey = Monkey.query.get(id)
monkey.jenkins_url = jenkins_url
db.session.add(monkey)
db.session.commit()
return 0, None
except Exception as e:
current_app.logger.error(e)
current_app.logger.error(traceback.format_exc())
raise SaveObjectException()
def update(cls, tag_id, tag_name, description):
tag = Tag.query.get(tag_id)
if not tag:
raise CannotFindObjectException
ret = Tag.query.filter(Tag.tag == tag_name, Tag.project_id == g.projectid, Tag.id != tag_id).first()
if ret:
raise SaveObjectException('存在相同名称的标签')
tag.tag = tag_name
tag.description = description
tag.modifier = g.userid
with db.auto_commit():
db.session.add(tag)
return 0
def change_status(user, message_ids=None, isall=None):
if message_ids:
with db.auto_commit():
query = f"UPDATE message SET status={Message.READ} WHERE rec_id={user} and id in ({message_ids})"
db.engine.execute(query)
# push2redis(user)
return 0, ''
elif isall:
with db.auto_commit():
query = f"UPDATE message SET status={Message.READ} WHERE rec_id={user}"
db.engine.execute(query)
# push2redis(user)
return 0, ''
else:
raise SaveObjectException()
def update(cls, monkey_report_id, monkey_id=None, task_id=None, report_type=None, report_url=None):
try:
monkey_report = MonkeyReport.query.get(monkey_report_id)
monkey_report.monkey_id = monkey_id or monkey_report.monkey_id
monkey_report.task_id = task_id or monkey_report.task_id
monkey_report.report_type = report_type or monkey_report.report_type
monkey_report.report_url = report_url or monkey_report.report_url
db.session.add(monkey_report)
db.session.commit()
return 0, None
except Exception as e:
current_app.logger.error(e)
current_app.logger.error(traceback.format_exc())
raise SaveObjectException()
def module_create(cls, name, project_id, description, parent_id=None):
ret = Module.query.filter_by(name=name,
project_id=project_id,
status=Case.ACTIVE).first()
if ret:
raise SaveObjectException('存在相同名称的模块')
m = Module(
name=name,
project_id=project_id,
description=description,
parent_id=parent_id,
)
db.session.add(m)
db.session.commit()
return 0, None
def create(cls, name, package_name, oss_url, picture, version, default_activity, user_id, size):
try:
monkey_package = MonkeyPackage(
name=name,
package_name=package_name,
oss_url=oss_url,
picture=picture,
version=version,
default_activity=default_activity,
user_id=user_id,
size=size
)
db.session.add(monkey_package)
db.session.commit()
return 0, None
except Exception as e:
current_app.logger.error(e)
current_app.logger.error(traceback.format_exc())
raise SaveObjectException()
def delete_status(user, message_ids=None, isall=None):
"""
修改通知的状态，已读改为1，删除改为2
:return: 修改成功
"""
if message_ids:
with db.auto_commit():
query = f"UPDATE message SET status={Message.DISABLE} WHERE rec_id={user} and id in ({message_ids})"
db.engine.execute(query)
# push2redis(user)
return 0, ''
elif isall:
with db.auto_commit():
query = f"UPDATE message SET status={Message.DISABLE} WHERE rec_id={user}"
db.engine.execute(query)
# push2redis(user)
return 0, ''
else:
raise SaveObjectException()
def release_device(cls, serial):
try:
devices = MonkeyDeviceUsing.query.filter(MonkeyDeviceUsing.serial == serial).all()
if len(devices) == 0:
device = MonkeyDeviceUsing(
serial=serial,
using=MonkeyDeviceUsing.DISABLE
)
db.session.add(device)
db.session.commit()
else:
device = devices[0]
device.using = MonkeyDeviceUsing.DISABLE
db.session.add(device)
db.session.commit()
return 0, None
except Exception as e:
current_app.logger.error(e)
current_app.logger.error(traceback.format_exc())
raise SaveObjectException()
def create(cls, monkey_id, mobile_id, mobile_model, mobile_version, mobile_serial, mobile_resolution, run_time):
try:
monkey_device_status = MonkeyDeviceStatus(
monkey_id=monkey_id,
mobile_id=mobile_id,
mobile_version=mobile_version,
mobile_model=mobile_model,
mobile_serial=mobile_serial,
mobile_resolution=mobile_resolution,
run_time=run_time,
begin_time=None,
end_time=None,
activity_all='',
activity_tested='',
process=0,
activity_count=0,
activity_tested_count=0,
anr_count=0,
crash_count=0,
exception_count=0,
exception_run_time=0,
device_connect_status=0,
screen_lock_status=0,
setup_install_app_status=0,
start_app_status=0,
running_status=0,
setup_uninstall_app_status=0,
login_app_status=0,
teardown_uninstall_app_status=0,
)
db.session.add(monkey_device_status)
db.session.flush()
return monkey_device_status.id
except Exception as e:
current_app.logger.error(e)
current_app.logger.error(traceback.format_exc())
raise SaveObjectException()
def update(cls, id, process, activity_count, activity_tested_count, activity_all, activity_tested, anr_count,
crash_count, exception_count, exception_run_time, setup_install_app_status,
start_app_status, begin_time, setup_uninstall_app_status, login_app_status, running_status,
teardown_uninstall_app_status, end_time, run_time, device_connect_status, screen_lock_status,
current_stage, running_error_reason, mobile_resolution):
try:
monkey_device_status = MonkeyDeviceStatus.query.get(id)
monkey_device_status.process = process or monkey_device_status.process
monkey_device_status.activity_count = activity_count or monkey_device_status.activity_count
monkey_device_status.activity_tested_count = (
activity_tested_count or monkey_device_status.activity_tested_count)
monkey_device_status.activity_all = activity_all or monkey_device_status.activity_all
monkey_device_status.activity_tested = activity_tested or monkey_device_status.activity_tested
monkey_device_status.anr_count = anr_count or monkey_device_status.anr_count
monkey_device_status.crash_count = crash_count or monkey_device_status.crash_count
monkey_device_status.exception_count = exception_count or monkey_device_status.exception_count
monkey_device_status.exception_run_time = exception_run_time or monkey_device_status.exception_run_time
monkey_device_status.end_time = end_time or monkey_device_status.end_time
monkey_device_status.run_time = run_time or monkey_device_status.run_time
monkey_device_status.begin_time = begin_time or monkey_device_status.begin_time
monkey_device_status.current_stage = current_stage or monkey_device_status.current_stage
monkey_device_status.running_error_reason = running_error_reason or monkey_device_status.running_error_reason
monkey_device_status.mobile_resolution = mobile_resolution or monkey_device_status.mobile_resolution
if device_connect_status is not None:
monkey_device_status.device_connect_status = device_connect_status
monkey_device_status.current_stage = 0
if setup_uninstall_app_status is not None:
monkey_device_status.setup_uninstall_app_status = setup_uninstall_app_status
monkey_device_status.current_stage = 1
if setup_install_app_status is not None:
monkey_device_status.setup_install_app_status = setup_install_app_status
monkey_device_status.current_stage = 2
if screen_lock_status is not None:
monkey_device_status.screen_lock_status = screen_lock_status
monkey_device_status.current_stage = 3
if start_app_status is not None:
monkey_device_status.start_app_status = start_app_status
monkey_device_status.current_stage = 4
if login_app_status is not None:
monkey_device_status.login_app_status = login_app_status
monkey_device_status.current_stage = 5
if running_status is not None:
monkey_device_status.running_status = running_status
monkey_device_status.current_stage = 6
if teardown_uninstall_app_status is not None:
monkey_device_status.teardown_uninstall_app_status = teardown_uninstall_app_status
if monkey_device_status.setup_install_app_status == 2:
monkey_device_status.current_stage = 101
elif monkey_device_status.screen_lock_status == 2:
monkey_device_status.current_stage = 102
elif monkey_device_status.start_app_status == 2:
monkey_device_status.current_stage = 103
elif monkey_device_status.login_app_status == 2:
monkey_device_status.current_stage = 104
elif monkey_device_status.running_status == 2:
monkey_device_status.current_stage = 105
else:
monkey_device_status.current_stage = current_stage or monkey_device_status.current_stage
db.session.add(monkey_device_status)
db.session.commit()
return 0, None
except Exception as e:
current_app.logger.error(e)
current_app.logger.error(traceback.format_exc())
raise SaveObjectException()
def start_monkey(cls, user_id, mobile_infos, type_id, run_time, system_device, login_required, login_username,
login_password, app_id, parameters, app_install_required):
try:
if not isinstance(mobile_infos, list):
return 102, 'mobile_ids 参数格式不对，应为 List 格式'
mobile_ids = []
mobile_models = {}
mobile_versions = {}
mobile_resolutions = {}
for info in mobile_infos:
id = info.get('mobile_id')
mobile_ids.append(id)
mobile_models[id] = info.get('mobile_model')
mobile_versions[id] = info.get('mobile_version')
mobile_resolutions[id] = info.get('mobile_resolution')
try:
parameters = json.loads(parameters)
except Exception as e:
current_app.logger.warning('error when json the parameters: {}'.format(parameters))
if not isinstance(parameters, dict):
return 102, 'parameters 参数格式不对，应为 dict 格式'
app_info = MonkeyPackage.query.get(app_id)
# 创建 Monkey 示例
monkey = Monkey(
app_name=app_info.name,
app_id=app_id,
package_name=app_info.package_name,
begin_time=datetime.now(),
user_id=user_id,
report_url='',
mobile_ids=','.join(mobile_ids),
parameters=str(parameters),
process=0,
type_id=type_id,
run_time=run_time,
system_device=system_device,
login_required=login_required,
login_username=login_username,
login_password=login_password,
app_install_required=app_install_required,
)
db.session.add(monkey)
db.session.flush()
# 创建 MonkeyDeviceStatus
device_serial_list = []
task_id_list = []
devices_info = TcDevicesnInfo.query.all()
for mobile_id in mobile_ids:
current_app.logger.info(mobile_id)
device_serial_list.append(mobile_id)
for device in devices_info:
if device.serial == mobile_id:
task = MonkeyDeviceStatusBusiness.create(monkey.id, device.id, mobile_models.get(mobile_id),
mobile_versions.get(mobile_id), device.serial,
mobile_resolutions.get(mobile_id), run_time)
task_id_list.append(str(task))
break
db.session.commit()
jenkins_parameters = {
'PackageName': app_info.package_name,
'DeviceName': ','.join(device_serial_list),
'RunMode': type_id,
'RunTime': run_time,
'AppDownloadUrl': app_info.oss_url,
'DefaultAppActivity': app_info.default_activity,
'SystemDevice': system_device,
'LoginRequired': login_required,
'LoginUsername': login_username,
'LoginPassword': login_password,
'TaskId': ','.join(task_id_list),
'MonkeyId': monkey.id,
'InstallAppRequired': monkey.app_install_required
}
msg = cls.start_jenkins_job(jenkins_parameters)
if msg == "Success":
current_app.logger.info('build jenkins job success')
return 0, None
except Exception as e:
current_app.logger.error(e)
current_app.logger.error(traceback.format_exc())
raise SaveObjectException()
