def __init__(self):
# Log
self.__logger = OrcLog("view.driver.web.service.window_def")
self.__resource_widget_def = OrcHttpNewResource("WidgetDef")
self.__resource_widow_def = OrcHttpNewResource("WindowDef")
class ReportDetService:
def __init__(self):
self.__resource_report = OrcHttpNewResource("Report")
def get_report_path(self, p_path):
self.__resource_report.set_path(p_path["path"])
return self.__resource_report.get()
def __init__(self):
self.__config = get_config()
self.__resource_batch_def = OrcHttpNewResource("BatchDef")
self.__resource_case_def = OrcHttpNewResource("CaseDef")
self.__list = RunCore()
self.__home = self.__list.get_home()
if not os.path.exists(self.__home):
os.mkdir(self.__home)
class StepService(object):
def __init__(self):
object.__init__(self)
self.__resource_step_def = OrcHttpNewResource("StepDef")
def view_get_step_type(self, p_step_id):
self.__resource_step_def.set_path(p_step_id)
return self.__resource_step_def.get()["step_type"]
def get_lib_dict_text(p_flag, p_value):
"""
获取操作文字
:param p_value:
:param p_flag:
:return:
"""
resource_dict = OrcHttpNewResource("Dict")
dict_data = resource_dict.get(
dict(dict_flag=p_flag, dict_value=p_value))
return None if not dict_data else dict_data[0]["dict_text"]
def get_page_def_flag(p_id):
"""
获取页面标识
:param p_id:
:return:
"""
resource_page_def = OrcHttpNewResource("PageDef")
resource_page_def.set_path(p_id)
page_def_data = resource_page_def.get()
return None if not page_def_data else page_def_data["page_flag"]
def get_widget_def_path(p_id):
"""
获取控件路径
:param p_id:
:return:
"""
resource_widget_def = OrcHttpNewResource("WidgetDef")
resource_widget_def.set_path(p_id)
widget_def_data = resource_widget_def.get()
return None if not resource_widget_def else widget_def_data[
"widget_path"]
def test_http_res_01(self):
"""
test get dict
:return:
"""
OrcTest.test_print_begin()
_obj = OrcHttpNewResource('BatchDef')
_res = _obj.get()
OrcTest.test_print_result(_res)
OrcTest.test_print_end()
def test_get_data(self):
OrcTest.test_print_begin()
test = OrcHttpNewResource("Data")
result = test.get({
"src_type": "CASE",
"data_flag": "3300000019",
"src_id": "2000000003"
})
OrcTest.test_print_result(result)
OrcTest.test_print_end()
class BatchDefService(object):
def __init__(self):
object.__init__(self)
self.__resource_batch_def = OrcHttpNewResource("BatchDef")
self.__resource_run_def = OrcHttpNewResource("RunDef")
def usr_add(self, p_data):
"""
增加
:param p_data:
:return:
"""
node = self.__resource_batch_def.post(p_data)
return dict(id=node["id"])
def usr_delete(self, p_list):
"""
删除
:param p_list:
:return:
"""
return self.__resource_batch_def.delete(p_list)
def usr_update(self, p_data):
"""
更新
:param p_data:
:return:
"""
self.__resource_batch_def.set_path(p_data["id"])
return self.__resource_batch_def.put(p_data)
def usr_search(self, p_cond):
"""
查询
:param p_cond:
:return:
"""
cond = dict(type="all")
cond.update(p_cond)
return self.__resource_batch_def.get(cond)
def add_to_run(self, p_id):
cond = dict(id=p_id, run_def_type="BATCH")
self.__resource_run_def.set_path(p_id)
self.__resource_run_def.post(cond)
def test_list_search(self):
"""
Test get root
:return:
"""
OrcTest.test_print_begin()
run_time = OrcHttpNewResource("RunTime")
result = run_time.get()
OrcTest.test_print_result(result)
OrcTest.test_print_end()
class RunDetService():
def __init__(self):
self.__resource_run_det = OrcHttpNewResource("RunDet")
self.__resource_run = OrcHttpNewResource("Run")
def usr_search(self, p_path):
res = self.__resource_run_det.get(p_path)
return res
def usr_run(self, p_path):
self.__resource_run.put(p_path)
def test_delete(self):
"""
Test get root
:return:
"""
OrcTest.test_print_begin()
run_time = OrcHttpNewResource("RunTime")
run_time.set_path(1)
result = run_time.delete()
OrcTest.test_print_result(result)
OrcTest.test_print_end()
def test_update(self):
"""
Test get root
:return:
"""
OrcTest.test_print_begin()
run_time = OrcHttpNewResource("RunTime")
run_time.set_path(2)
result = run_time.put(dict(data_value=10))
OrcTest.test_print_result(result)
OrcTest.test_print_end()
def test_list_delete(self):
"""
Test get root
:return:
"""
OrcTest.test_print_begin()
run_time = OrcHttpNewResource("RunTime")
data = [1]
result = run_time.delete(data)
OrcTest.test_print_result(result)
OrcTest.test_print_end()
class BatchDetService(object):
def __init__(self):
object.__init__(self)
self.__resource_batch_det = OrcHttpNewResource("BatchDet")
self.__resource_case_def = OrcHttpNewResource("CaseDef")
def usr_add(self, p_data):
"""
增加,将多条记录转换为单条
:param p_data:
:return:
"""
batch_id = p_data["batch_id"]
for _case_id in p_data["case"]:
self.__resource_batch_det.post(
dict(batch_id=batch_id, case_id=_case_id))
return dict(batch_id=batch_id)
def usr_delete(self, p_list):
"""
删除
:param p_list:
:return:
"""
return self.__resource_batch_det.delete(p_list)
def usr_update(self, p_data):
"""
更新
:param p_data:
:return:
"""
self.__resource_batch_det.set_path(p_data["id"])
return self.__resource_batch_det.put(p_data)
def usr_search(self, p_cond):
"""
查询,查询batch及case并连接数据
:param p_cond:
:return:
"""
# 查询 batch_det 列表
batch_det_list = self.__resource_batch_det.get(p_cond)
# case_det id 列表
case_def_id_list = [
batch_det["case_id"] for batch_det in batch_det_list
]
# case_def 列表
case_def_list = self.__resource_case_def.get(dict(id=case_def_id_list))
# 连接 list 并返回
return connect_list(batch_det_list, case_def_list, "case_id")
def __init__(self):
# Log
self.__logger = OrcLog("view.driver.web.service.web_main")
self.__resource_page_def = OrcHttpNewResource("PageDef")
self.__resource_page_det = OrcHttpNewResource("PageDet")
self.__resource_widget_def = OrcHttpNewResource("WidgetDef")
self.__resource_widget_det = OrcHttpNewResource("WidgetDet")
def test_list_add(self):
"""
Test get root
:return:
"""
OrcTest.test_print_begin()
run_time = OrcHttpNewResource("RunTime")
data = dict(data_flag="env",
data_index=1,
data_value="3")
result = run_time.post(data)
OrcTest.test_print_result(result)
OrcTest.test_print_end()
class CaseDefService(object):
def __init__(self):
object.__init__(self)
self.__resource_case_def = OrcHttpNewResource("CaseDef")
self.__resource_run_def = OrcHttpNewResource("RunDef")
def usr_add(self, p_data):
"""
新增
:param p_data:
:return:
"""
case_def_data = self.__resource_case_def.post(p_data)
return dict(id=case_def_data["id"])
def usr_delete(self, p_list):
"""
删除
:param p_list:
:return:
"""
return self.__resource_case_def.delete(p_list)
def usr_update(self, p_data):
"""
更新
:param p_data:
:return:
"""
self.__resource_case_def.set_path(p_data["id"])
return self.__resource_case_def.put(p_data)
def usr_search(self, p_cond):
"""
查询
:param p_cond:
:return:
"""
cond = dict(type="all")
cond.update(p_cond)
return self.__resource_case_def.get(cond)
def add_to_run(self, p_id):
"""
加入运行
:param p_id:
:return:
"""
cond = dict(id=p_id, run_def_type="CASE")
self.__resource_run_def.post(cond)
def __init__(self):
# Log
self.__logger = OrcLog("api.driver.service")
self.__resource_page_def = OrcHttpNewResource("PageDef")
self.__resource_page_det = OrcHttpNewResource("PageDet")
self.__resource_widget_def = OrcHttpNewResource("WidgetDef")
self.__resource_widget_det = OrcHttpNewResource("WidgetDet")
class PageDefService:
def __init__(self):
# Log
self.__logger = OrcLog("view.driver.web.service.page_def")
self.__resource_page_def = OrcHttpNewResource("PageDef")
def usr_add(self, p_data):
"""
新增
:param p_data:
:return:
"""
page_data = self.__resource_page_def.post(p_data)
return dict(id=page_data["id"])
def usr_delete(self, p_list):
"""
删除
:param p_list:
:return:
"""
return self.__resource_page_def.delete(p_list)
def usr_update(self, p_data):
"""
修改
:param p_data:
:return:
"""
self.__resource_case_def.set_path(p_data["id"])
return self.__resource_page_def.put(p_data)
def usr_search(self, p_cond):
"""
查询
:param p_cond:
:return:
"""
return self.__resource_page_def.get(p_cond)
def __init__(self):
object.__init__(self)
self.__resource_case_def = OrcHttpNewResource("CaseDef")
self.__resource_step_det = OrcHttpNewResource("StepDet")
self.__resource_item = OrcHttpNewResource("Item")
class RunDefService:
def __init__(self):
self.__res_run_def = OrcHttpNewResource("RunDef")
self.__res_run = OrcHttpNewResource("Run")
def usr_add(self, p_cond):
"""
:param p_cond: {id, run_def_type, result}
:return:
"""
if "pid" not in p_cond:
return dict()
cond = dict(id=p_cond["pid"],
run_def_type=p_cond["run_def_type"],
result=True)
self.__res_run_def.post(cond)
return dict()
def usr_search(self, p_cond):
"""
查询
:param p_cond:
:return:
"""
return self.__res_run_def.get(p_cond)
def usr_delete(self, p_list):
"""
删除
:param p_list:
:return:
"""
self.__res_run_def.delete(p_list)
def usr_run(self, p_pid, p_id):
"""
执行
:param p_pid:
:param p_id:
:return:
"""
self.__res_run.put(dict(pid=p_pid, id=p_id))
class WebDriverService:
def __init__(self):
# Log
self.__logger = OrcLog("api.driver.service")
self.__resource_page_def = OrcHttpNewResource("PageDef")
self.__resource_page_det = OrcHttpNewResource("PageDet")
self.__resource_widget_def = OrcHttpNewResource("WidgetDef")
self.__resource_widget_det = OrcHttpNewResource("WidgetDet")
def page_get_url(self, p_env, p_id):
"""
获取页面 url
:param p_env:
:param p_id: page id
:return: url/None
"""
page_det_datas = self.__resource_page_det.get(dict(page_id=p_id, page_env=p_env))
return None if not page_det_datas else page_det_datas[0]["page_url"]
def widget_get_definition(self, p_id):
"""
获取单个控件定义
:param p_id:
:return: definition list or None
"""
self.__resource_widget_def.set_path(p_id)
widget_def_data = self.__resource_widget_def.get()
return None if not widget_def_data else WebWidgetDef(widget_def_data)
def widget_get_definition_path(self, p_id):
"""
获取控件定义树
:param p_id:
:return: definition list or None
"""
widget_def_datas = self.__resource_widget_def.get(dict(type="path", id=p_id))
return None if not widget_def_datas else [WebWidgetDef(item) for item in widget_def_datas]
def widget_get_detail(self, p_id):
"""
获取定义细节
:param p_id: widget definition id (not detail id)
:return:
"""
widget_det_data = self.__resource_widget_det.get(dict(widget_id=p_id))
return None if not widget_det_data else [WebWidgetDet(_item) for _item in widget_det_data]
class DataService:
def __init__(self):
self.__resource_data = OrcHttpNewResource("Data")
def usr_add(self, p_data):
"""
新增
:param p_data:
:return:
"""
data_data = self.__resource_data.post(p_data)
return dict(id=data_data["id"])
def usr_delete(self, p_cond):
"""
删除
:param p_cond:
:return:
"""
self.__resource_data.delete(p_cond)
def usr_update(self, p_data):
"""
更新
:param p_cond:
:return:
"""
self.__resource_data.set_path(p_data["id"])
self.__resource_data.put(p_data)
def usr_search(self, p_cond):
"""
查询
:param p_cond:
:return:
"""
return self.__resource_data.get(p_cond)
class WidgetDefService:
def __init__(self):
# Log
self.__logger = OrcLog("view.driver.web.service.widget_def")
self.__resource_widget_def = OrcHttpNewResource("WidgetDef")
def usr_add(self, p_data):
"""
新增
:param p_data:
:return:
"""
widget_data = self.__resource_widget_def.post(p_data)
return dict(id=widget_data["id"])
def usr_delete(self, p_list):
"""
删除
:param p_list:
:return:
"""
return self.__resource_widget_def.delete(p_list)
def usr_update(self, p_data):
"""
修改
:param p_data:
:return:
"""
self.__resource_widget_def.set_path(p_data["id"])
return self.__resource_widget_def.put(p_data)
def usr_search(self, p_cond):
"""
查询
:param p_cond:
:return:
"""
cond = dict(type="all")
cond.update(p_cond)
return self.__resource_widget_def.get(cond)
class ItemService(object):
def __init__(self):
object.__init__(self)
self.__resource_case_def = OrcHttpNewResource("CaseDef")
self.__resource_step_det = OrcHttpNewResource("StepDet")
self.__resource_item = OrcHttpNewResource("Item")
def usr_add(self, p_data):
"""
增加
:param p_data:
:return:
"""
step_type = p_data["type"]
step_id = p_data["step_id"]
step_data = p_data["data"]
if "ITEM" == step_type:
# 增加 item
item = self.__resource_item.post(step_data)
# 增加 step det
step_id = step_id
item_id = item["id"]
step_det_data = dict(step_id=step_id, item_id=item_id)
self.__resource_step_det.post(step_det_data)
elif "FUNC" == step_type:
# 增加 step det
step_id = step_id
func_id = step_data
step_det_data = dict(step_id=step_id, item_id=func_id)
self.__resource_step_det.post(step_det_data)
return dict(step_id=step_id)
def usr_delete(self, p_list):
"""
删除
:param p_list:
:return:
"""
return self.__resource_step_det.delete(p_list)
def usr_update(self, p_data):
"""
更新
:param p_data:
:return:
"""
# 获取 item id
self.__resource_step_det.set_path(p_data["id"])
item_id = self.__resource_step_det.get()["item_id"]
# 更新数据
data = p_data.copy()
data["id"] = item_id
self.__resource_item.set_path(item_id)
return self.__resource_item.put(p_data)
def usr_search(self, p_cond):
"""
删除
:param p_cond:
:return:
"""
# 查询 step det 列表
step_det_list = self.__resource_step_det.get(p_cond)
# 查询 item id 列表
item_id_list = [step_det["item_id"] for step_det in step_det_list]
# 查询 item 列表
item_list = self.__resource_item.get(dict(id=item_id_list))
# 查询 func
case_list = self.__resource_case_def.get(dict(id=item_id_list))
# func 转成 item 结构
func_list = [
dict(id=case["id"],
item_no=case["case_no"],
item_mode="",
item_type="",
item_operate=case["case_path"],
item_desc=case["case_desc"],
comment=case["comment"],
create_time=case["create_time"],
modify_time=case["modify_time"]) for case in case_list
]
# 连接 list
print func_list
item_list.extend(func_list)
print item_list
# 连接数据
return connect_list(step_det_list, item_list, "item_id")
def __init__(self):
object.__init__(self)
self.__resource_step_def = OrcHttpNewResource("StepDef")
def __init__(self):
self.__resource_report = OrcHttpNewResource("Report")
class WebMainService:
"""
"""
def __init__(self):
# Log
self.__logger = OrcLog("view.driver.web.service.web_main")
self.__resource_page_def = OrcHttpNewResource("PageDef")
self.__resource_page_det = OrcHttpNewResource("PageDet")
self.__resource_widget_def = OrcHttpNewResource("WidgetDef")
self.__resource_widget_det = OrcHttpNewResource("WidgetDet")
def get_page_key(self, p_id):
"""
获取界面显示页面标识
:param p_id:
:type p_id: str
:return:
:rtype: str
"""
_page_det = self.get_page_det(p_id)
_page_def = self.get_page_def(_page_det.page_id)
return _page_def.id, _page_def.page_flag, _page_det.page_env
def get_widget_key(self, p_id):
"""
获取界面显示控件标识
:param p_id:
:type p_id: str
:return:
:rtype: str
"""
_widget_def = self.get_widget_def(p_id)
return _widget_def.widget_path
def get_widget_type(self, p_id):
"""
获取控件类型
:param p_id:
:return:
"""
_type_value = self.get_widget_def(p_id).widget_type
return _type_value
def get_page_def(self, p_id):
"""
获取页面定义
:param p_id:
:return:
:rtype: WebPageDef
"""
from OrcLib.LibDatabase import WebPageDef
self.__resource_page_def.set_path(p_id)
page_def_data = self.__resource_page_def.get()
if page_def_data:
return WebPageDef(page_def_data)
else:
return None
def get_page_det(self, p_id):
"""
获取页面定义
:param p_id:
:return:
:rtype: WebPageDet
"""
from OrcLib.LibDatabase import WebPageDet
self.__resource_page_det.set_path(p_id)
page_det_data = self.__resource_page_det.get()
if page_det_data:
return WebPageDet(page_det_data)
else:
return None
def get_widget_def(self, p_id):
"""
获取控件定义
:param p_id:
:return:
:rtype: WebWidgetDef
"""
from OrcLib.LibDatabase import WebWidgetDef
self.__resource_widget_def.set_path(p_id)
widget_def_data = self.__resource_widget_def.get()
if widget_def_data:
return WebWidgetDef(widget_def_data)
else:
return None
def get_widget_det(self, p_id):
"""
获取控件细节
:param p_id:
:return: WebWidgetDet
"""
from OrcLib.LibDatabase import WebWidgetDet
self.__resource_widget_det.set_path(p_id)
widget_det_data = self.__resource_widget_det.get()
if widget_det_data:
return WebWidgetDet(widget_det_data)
else:
return None
