class ViewDataAdd(ViewAdd):
"""
View of table
"""
sig_data_flag = OrcSignal()
def __init__(self):
"""
:return:
"""
ViewAdd.__init__(self, def_view_data)
self.__service = DataService()
self.__id = None
self.sig_submit.connect(self.__save)
def set_type(self, p_type):
self.set_data("src_type", p_type)
self.set_enable("src_type", False)
def set_path(self, p_path):
self.set_data("src_id", p_path)
self.set_enable("src_id", False)
def set_id(self, p_id):
self.__id = p_id
def __save(self, p_data):
p_data["src_id"] = self.__id
self.__service.usr_add(p_data)
class ViewWidgetSelect(QWidget):
sig_selected = OrcSignal(dict)
def __init__(self):
QWidget.__init__(self)
# Model
self.__model = WidgetSelectModel()
self.__model.usr_set_definition(def_view_widget_def)
self.__model.usr_chk_able()
# Control
_control = WidgetSelectControl(def_view_widget_def)
# Search condition widget
self.__wid_search_cond = ViewSearch(def_view_widget_def)
self.__wid_search_cond.set_col_num(2)
self.__wid_search_cond.create()
# Data result display widget
_wid_display = ViewTree()
_wid_display.set_model(self.__model)
_wid_display.set_control(_control)
# Buttons widget
_wid_buttons = ViewButtons([dict(id="search", name=u"查询")])
# Layout
_layout = QVBoxLayout()
_layout.addWidget(self.__wid_search_cond)
_layout.addWidget(_wid_display)
_layout.addWidget(_wid_buttons)
self.setLayout(_layout)
# Connection
_wid_buttons.sig_clicked.connect(self.__operate)
_wid_display.doubleClicked.connect(self.select)
def search(self):
_cond = self.__wid_search_cond.get_cond()
self.__model.usr_search(_cond)
def select(self, p_index):
_node = self.__model.usr_get_node(p_index).content
_id = _node["id"]
_path = _node["widget_path"]
_type = _node["widget_type"]
self.sig_selected.emit(dict(id=str(_id), flag=_path, type=_type))
self.close()
def __operate(self, p_flag):
if "search" == p_flag:
self.search()
else:
pass
class ViewTable(QTableView):
"""
View of table
"""
sig_context = OrcSignal(str)
def __init__(self):
QTableView.__init__(self)
self.__configer = get_config()
# 拉申最后一列
self.horizontalHeader().setStretchLastSection(True)
# ...
self.resizeColumnToContents(True)
# 不显示格间距
self.setShowGrid(False)
self.alternatingRowColors()
self.setStyleSheet(get_theme("TableView"))
def create_context_menu(self, p_def):
"""
右键菜单
:param p_def:
:return:
"""
_context_menu = ViewContextMenu(p_def)
self.setContextMenuPolicy(Qt.CustomContextMenu)
# connection
self.customContextMenuRequested.connect(_context_menu.show_menu)
_context_menu.sig_clicked.connect(self.sig_context.emit)
def set_model(self, p_model):
"""
设置模型
:param p_model:
:return:
"""
self.setModel(p_model)
def set_control(self, p_control):
"""
:param p_control:
:return:
"""
self.setItemDelegate(p_control)
class PageContainer(QWidget):
sig_selected = OrcSignal(str)
def __init__(self):
QWidget.__init__(self)
self.title = u"页面"
# Search condition widget
self.__wid_search_cond = ViewSearch(def_view_page_def)
self.__wid_search_cond.set_col_num(2)
self.__wid_search_cond.create()
# Column widget
self.__wid_page_def = ViewPageDefMag()
self.__wid_page_det = ViewPageDetMag()
# Bottom layout
_layout_bottom = QHBoxLayout()
_layout_bottom.addWidget(self.__wid_page_def)
_layout_bottom.addWidget(self.__wid_page_det)
# Main layout
_layout_main = QVBoxLayout()
_layout_main.addWidget(self.__wid_search_cond)
_layout_main.addLayout(_layout_bottom)
_layout_main.setContentsMargins(0, 0, 0, 0)
_layout_main.setSpacing(0)
self.setLayout(_layout_main)
self.__wid_page_def.sig_selected.connect(
self.__wid_page_det.set_page_id)
self.__wid_page_def.sig_search.connect(self.search_definition)
self.__wid_page_def.sig_delete.connect(self.__wid_page_det.clean)
self.__wid_page_det.sig_selected[str].connect(self.sig_selected.emit)
def search_definition(self):
_cond = self.__wid_search_cond.get_cond()
self.__wid_page_def.search(_cond)
self.__wid_page_det.clean()
class OrcLineEdit(QLineEdit):
"""
单行输入框
"""
clicked = OrcSignal()
def __init__(self):
QLineEdit.__init__(self)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
def get_data(self):
return self.text()
def set_data(self, p_data):
return self.setText(p_data)
def mousePressEvent(self, *args, **kwargs):
self.clicked.emit()
class ViewTree(QTreeView):
"""
Base tree view
"""
sig_context = OrcSignal(str)
def __init__(self):
QTreeView.__init__(self)
# MVC
self.dragEnabled()
self.acceptDrops()
self.showDropIndicator()
self.setDragDropMode(QAbstractItemView.InternalMove)
self.header().setStretchLastSection(True)
self.setFocusPolicy(Qt.NoFocus)
self.setStyleSheet(get_theme("TreeView"))
def create_context_menu(self, p_def):
"""
右键菜单
:param p_def:
:return:
"""
_context_menu = ViewContextMenu(p_def)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(_context_menu.show_menu)
_context_menu.sig_clicked.connect(self.sig_context.emit)
def set_model(self, p_model):
self.setModel(p_model)
def set_control(self, p_control):
self.setItemDelegate(p_control)
class StatusReceiver(QThread):
sig_status = OrcSignal(str)
def __init__(self):
QThread.__init__(self)
self.__config = get_config("network")
self.__logger = OrcLog("view")
def run(self, *args, **kwargs):
_ip = self.__config.get_option("VIEW", "ip")
_port = int(self.__config.get_option("VIEW", "port"))
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind((_ip, _port))
sock.listen(1)
while True:
connection, address = sock.accept()
try:
connection.settimeout(5)
_cmd = connection.recv(1024)
self.sig_status.emit(_cmd)
connection.send(_cmd)
except socket.timeout:
self.__logger.error("time out")
except Exception, err:
self.__logger.error(err)
connection.close()
class OrcOperate(QLineEdit):
sig_operate = OrcSignal()
def __init__(self, parent):
QLineEdit.__init__(self, parent)
self.__data = None
self.setReadOnly(True)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
def get_data(self):
return self.__data
def set_data(self, p_data):
self.__data = p_data
_text = operate_to_str(p_data)
return self.setText(_text)
def mousePressEvent(self, *args, **kwargs):
self.sig_operate.emit()
class ViewContextMenu(QMenu):
sig_clicked = OrcSignal(str)
def __init__(self, p_def):
"""
:param p_def: [{NAME:..., STR:...}, ...]
:return:
"""
QMenu.__init__(self)
for _def in p_def:
_act = QAction(_def["NAME"], self)
_act.triggered.connect(partial(self.menu_emit, _def["STR"]))
self.addAction(_act)
def show_menu(self):
self.popup(QCursor.pos())
self.show()
def menu_emit(self, p_str):
self.sig_clicked.emit(p_str)
class ViewPageDetMag(QWidget):
"""
"""
sig_selected = OrcSignal(str)
def __init__(self):
QWidget.__init__(self)
# Current page id
self.__page_id = None
# Model
self.__model = PageDetModel()
self.__model.usr_set_definition(def_view_page_det)
# Control
_control = PageDetControl(def_view_page_det)
# Data result display widget
_wid_display = ViewTable()
_wid_display.set_model(self.__model)
_wid_display.set_control(_control)
# Buttons widget
_wid_buttons = ViewButtons([
dict(id="add", name=u"增加"),
dict(id="delete", name=u"删除"),
dict(id="update", name=u"修改", type="CHECK")
])
# win_add
self.__win_add = ViewAdd(def_view_page_det)
# Layout
_layout = QVBoxLayout()
_layout.addWidget(_wid_display)
_layout.addWidget(_wid_buttons)
_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(_layout)
# Connection
_wid_buttons.sig_clicked.connect(self.__operate)
_wid_display.clicked[QModelIndex].connect(self.__page_select)
self.__win_add.sig_submit[dict].connect(self.add)
def __operate(self, p_flag):
if "add" == p_flag:
self.__win_add.show()
elif "delete" == p_flag:
self.__model.usr_delete()
elif "update" == p_flag:
self.__model.usr_editable()
else:
pass
def __page_select(self, p_index):
page_det_id = self.__model.usr_get_data(p_index.row())["id"]
self.sig_selected.emit(page_det_id)
def add_show(self):
if self.__page_id is not None:
self.__win_add.show()
def add(self, p_data):
_data = p_data
_data["page_id"] = self.__page_id
self.__model.usr_add(_data)
def set_page_id(self, p_page_id):
self.__page_id = p_page_id
self.__model.usr_search({"page_id": self.__page_id})
def clean(self):
self.__model.usr_clean()
class ViewRunDef(QWidget):
sig_search = OrcSignal()
sig_selected = OrcSignal(str)
sig_run = OrcSignal()
def __init__(self):
QWidget.__init__(self)
self.title = u"执行列表"
self.__service = RunDefService()
self.__threads = []
# Model
self.__model = RunDefModel()
self.__model.usr_set_definition(def_view_run_def)
# Control
_control = RunDefControl(def_view_run_def)
# Data result display widget
_wid_display = ViewTree()
_wid_display.set_model(self.__model)
_wid_display.set_control(_control)
# Buttons window
_wid_buttons = ViewButtons([
dict(id="add", name=u'增加'),
dict(id="delete", name=u"删除"),
dict(id="search", name=u'查询'),
dict(id="run", name=u"执行")
])
# Layout
_layout = QVBoxLayout()
_layout.addWidget(_wid_display)
_layout.addWidget(_wid_buttons)
self.setLayout(_layout)
_layout.setContentsMargins(0, 0, 0, 0)
_wid_display.clicked.connect(self.__model.usr_set_current_data)
_wid_buttons.sig_clicked.connect(self.__operate)
_wid_display.clicked.connect(self.select)
def select(self, p_index):
_node = self.__model.usr_get_node(p_index)
_node_content = _node.content
_node_flag = _node_content["run_flag"]
_node_pid = _node_content["pid"]
if _node_pid is None:
return None
_parent_content = _node.parent.content
_parent_type = _parent_content["run_def_type"]
_parent_id = _parent_content["id"]
_file = "%s_%s/%s" % (_parent_type, _parent_id, _node_flag)
self.sig_selected.emit(_file)
def search(self, p_cond):
self.__model.usr_search(p_cond)
def __operate(self, p_flg):
if "add" == p_flg:
# {id, run_def_type, result}
data = self.__model.usr_get_current_data()
if data is None:
return
self.__model.usr_add(
dict(run_def_type=data.content["run_def_type"]))
elif "delete" == p_flg:
self.__model.usr_delete()
elif "search" == p_flg:
self.sig_search.emit()
elif "run" == p_flg:
self.sig_run.emit()
item_data = self.__model.usr_get_current_data()
if item_data is not None:
_id = item_data.content["id"]
_pid = item_data.content["pid"]
if _pid is None:
return
_thread_run = RunThread()
_thread_run.setup(_pid, _id)
_thread_run.start()
self.__threads.append(_thread_run)
else:
pass
class ViewCaseDefMag(QWidget):
sig_case_det = OrcSignal(dict)
def __init__(self):
QWidget.__init__(self)
self.title = u"用例管理"
self.__service = CaseDefService()
# Model
self.__model = CaseDefModel()
self.__model.usr_set_definition(def_view_case_def)
# Control
_control = CaseDefControl(def_view_case_def)
# Search condition widget
self.__wid_search_cond = ViewSearch(def_view_case_def)
self.__wid_search_cond.set_col_num(2)
self.__wid_search_cond.create()
# Data result display widget
_wid_display = ViewTree()
_wid_display.set_model(self.__model)
_wid_display.set_control(_control)
# Context menu
_wid_display.create_context_menu([
dict(NAME=u"增加", STR="sig_add"),
dict(NAME=u"删除", STR="sig_del"),
dict(NAME=u"增加数据", STR="sig_data"),
dict(NAME=u"添加至运行", STR="sig_run")
])
# Buttons widget
_wid_buttons = ViewButtons([
dict(id="add", name=u"增加"),
dict(id="delete", name=u"删除"),
dict(id="update", name=u"修改", type="CHECK"),
dict(id="search", name=u"查询")
])
# win add case
self.__win_add = ViewAdd(def_view_case_def)
# 选择控件
self.__win_widget_select = ViewWidgetSelect()
# win add data
self.__win_data = ViewDataAdd()
# Layout
_layout = QVBoxLayout()
_layout.addWidget(self.__wid_search_cond)
_layout.addWidget(_wid_display)
_layout.addWidget(_wid_buttons)
self.setLayout(_layout)
# Connection
_wid_buttons.sig_clicked.connect(self.__operate)
self.__win_add.sig_submit[dict].connect(self.add) # 增加用例
_wid_display.doubleClicked[QModelIndex].connect(
self.__case_detail) # 打开用例详情窗
_wid_display.sig_context.connect(self.__context) # 右键菜单
_wid_display.clicked.connect(self.__model.usr_set_current_data)
self.__win_data.widgets["data_flag"]["WIDGET"].clicked.connect(
self.__win_widget_select.show)
self.__win_widget_select.sig_selected.connect(self.set_widget)
def set_widget(self, p_data):
self.__win_data.set_data("data_flag", p_data["id"])
def search(self):
"""
查询
:return:
"""
self.__model.usr_search(self.__wid_search_cond.get_cond())
def add(self, p_data):
"""
增加用例
:param p_data:
:return:
"""
self.__model.usr_add(p_data)
def __operate(self, p_flag):
if "add" == p_flag:
self.__win_add.show()
elif "delete" == p_flag:
self.__model.usr_delete()
elif "update" == p_flag:
self.__model.usr_editable()
elif "search" == p_flag:
self.search()
else:
pass
def __case_detail(self, p_index):
if not self.__model.usr_get_editable():
_id = self.__model.usr_get_node(p_index).content["id"]
_no = self.__model.usr_get_node(p_index).content["case_no"]
_data = {"id": _id, "no": _no}
self.sig_case_det[dict].emit(_data)
def __context(self, p_flag):
if "sig_data" == p_flag:
_path = self.__model.usr_get_current_data().content["case_path"]
_id = self.__model.usr_get_current_data().content["id"]
self.__win_data.show()
self.__win_data.set_type("CASE")
self.__win_data.set_path(_path)
self.__win_data.set_id(_id)
# self.__win_data.set_enable("data_flag", False)
elif "sig_run" == p_flag:
case_id = self.__model.usr_get_current_data().content["id"]
self.__service.add_to_run(case_id)
class ViewBatchDefMag(QWidget):
sig_batch_det = OrcSignal(dict)
def __init__(self):
QWidget.__init__(self)
self.title = u"计划管理"
self.__service = BatchDefService()
# Model
self.__model = BatchDefModel()
self.__model.usr_set_definition(def_view_batch_def)
# Control
_control = BatchDefControl(def_view_batch_def)
# Search condition widget
self.__wid_search_cond = ViewSearch(def_view_batch_def)
self.__wid_search_cond.create()
# Data result display widget
_wid_display = ViewTree()
_wid_display.set_model(self.__model)
_wid_display.set_control(_control)
# Context menu
_wid_display.create_context_menu([
dict(NAME=u"增加", STR="sig_add"),
dict(NAME=u"删除", STR="sig_del"),
dict(NAME=u"增加数据", STR="sig_data"),
dict(NAME=u"添加至运行", STR="sig_run")
])
# Buttons widget
_wid_buttons = ViewButtons([
dict(id="add", name=u"增加"),
dict(id="delete", name=u"删除"),
dict(id="update", name=u"修改", type="CHECK"),
dict(id="search", name=u"查询")
])
# win_add
self.__win_add = ViewAdd(def_view_batch_def)
# win add data
self.__win_data = ViewDataAdd()
# Layout
_layout = QVBoxLayout()
_layout.addWidget(self.__wid_search_cond)
_layout.addWidget(_wid_display)
_layout.addWidget(_wid_buttons)
self.setLayout(_layout)
# Connection
_wid_buttons.sig_clicked.connect(self.__operate)
self.__win_add.sig_submit[dict].connect(self.add)
_wid_display.doubleClicked[QModelIndex].connect(self.__batch_detail)
_wid_display.sig_context.connect(self.__context) # 右键菜单
_wid_display.clicked.connect(self.__model.usr_set_current_data)
def search(self):
self.__model.usr_search(self.__wid_search_cond.get_cond())
def add(self, p_data):
self.__model.usr_add(p_data)
def __operate(self, p_flag):
if "add" == p_flag:
self.__win_add.show()
elif "delete" == p_flag:
self.__model.usr_delete()
elif "update" == p_flag:
self.__model.usr_editable()
elif "search" == p_flag:
self.search()
else:
pass
def __batch_detail(self, p_index):
if not self.__model.usr_get_editable():
_id = self.__model.usr_get_node(p_index).content["id"]
_no = self.__model.usr_get_node(p_index).content["batch_no"]
_data = dict(id=_id, no=_no)
self.sig_batch_det[dict].emit(_data)
def __context(self, p_flag):
if "sig_data" == p_flag:
_data = self.__model.usr_get_current_data()
_path = _data.content["batch_no"]
_id = _data.content["id"]
self.__win_data.show()
self.__win_data.set_type("BATCH")
self.__win_data.set_path(_path)
self.__win_data.set_id(_id)
elif "sig_run" == p_flag:
batch_id = self.__model.usr_get_current_data().content["id"]
self.__service.add_to_run(batch_id)
class ViewOperate(QWidget):
"""
"""
sig_submit = OrcSignal(dict)
def __init__(self):
QWidget.__init__(self)
self.__view_page_select = ViewPageSelectMag()
self.__view_widget_select = ViewWidgetSelect()
self.__widget_data = dict()
# 主 layout
_layout = QGridLayout()
self.setLayout(_layout)
# 控件类型
_type_label = QLabel(u"对象类型")
self.__type_select = OrcSelect("operate_object_type")
# 控件信息输入
_widget_label = QLabel(u"控件")
self.__widget_input = OrcLineEdit()
self.__widget_input.setReadOnly(True)
# 操作信息输入 layout
_operate_label = QLabel(u"操作")
self.__operate_select = SelectWidgetOperation()
# 按钮
_button_submit = QPushButton(u"确定")
_button_cancel = QPushButton(u"取消")
# 按钮 layout
_layout_button = QHBoxLayout()
_layout_button.addStretch()
_layout_button.addWidget(_button_submit)
_layout_button.addWidget(_button_cancel)
_layout.addWidget(_type_label, 0, 0)
_layout.addWidget(self.__type_select, 0, 1)
_layout.addWidget(_widget_label, 1, 0)
_layout.addWidget(self.__widget_input, 1, 1)
_layout.addWidget(_operate_label, 2, 0)
_layout.addWidget(self.__operate_select, 2, 1)
_layout.addLayout(_layout_button, 3, 1)
self.__change_type("PAGE")
# connection
_button_cancel.clicked.connect(self.close)
_button_submit.clicked.connect(self.__submit)
self.__widget_input.clicked.connect(self.__show_select)
self.__view_widget_select.sig_selected[dict].connect(self.__set_widget)
self.__view_page_select.sig_selected[dict].connect(self.__set_widget)
self.__type_select.currentIndexChanged.connect(self.__change_type)
def __submit(self):
_data = dict(TYPE=self.__type_select.get_data(),
OBJECT=self.__widget_data["id"])
if self.__operate_select.get_data() is not None:
_data["OPERATION"] = self.__operate_select.get_data()
if "INPUT" == _data["OPERATION"]:
_data["DATA"] = ""
self.sig_submit[dict].emit(_data)
self.close()
def __set_widget(self, p_data):
"""
:param p_data: {'flag': u'dddd', 'type': u'WINDOW', 'id': '3300000002'}
:return:
"""
self.__widget_data = p_data
self.__widget_input.set_data(p_data["flag"])
# 设置操作方式
if "type" in p_data:
self.__operate_select.set_type(p_data["type"])
def __change_type(self, p_data):
_type = self.__type_select.get_data()
print "--->", _type
self.__widget_input.clear()
if "WIDGET" == _type:
self.__operate_select.set_type(_type)
elif "PAGE" == _type:
self.__operate_select.set_type("PAGE")
else:
self.__operate_select.set_type("")
def __show_select(self):
"""
Show a select widget according to type
:return:
"""
_type = self.__type_select.get_data()
if "WIDGET" == _type:
self.__view_widget_select.show()
else:
self.__view_page_select.show()
class ViewWidgetDef(QWidget):
sig_selected = OrcSignal(str)
sig_search = OrcSignal()
sig_delete = OrcSignal()
def __init__(self, p_type=None):
"""
支持选择类型,选择时按钮/查询条件/查询方式都有不同
:param p_type:
:return:
"""
QWidget.__init__(self)
self.__type = p_type
# Model
self.__model = WidgetDefModel()
self.__model.usr_set_definition(def_view_widget_def)
# Control
_control = WidgetDefControl(def_view_widget_def)
# Search
if self.__type is not None:
self.__wid_search_cond = ViewSearch(def_view_widget_def)
self.__wid_search_cond.set_col_num(2)
self.__wid_search_cond.create()
else:
self.__wid_search_cond = None
# Data result display widget
_wid_display = ViewTree()
_wid_display.set_model(self.__model)
_wid_display.set_control(_control)
# Buttons window
btn_definition = []
if self.__type is None:
btn_definition.append(dict(id="add", name=u'增加')),
btn_definition.append(dict(id="delete", name=u"删除"))
btn_definition.append(dict(id="update", name=u"修改", type="CHECK"))
btn_definition.append(dict(id="search", name=u"查询"))
_wid_buttons = ViewButtons(btn_definition)
_wid_buttons.align_back()
# win_add
self.__win_add = ViewAdd(def_view_widget_def)
# Layout
_layout = QVBoxLayout()
if self.__type is not None:
_layout.addWidget(self.__wid_search_cond)
_layout.addWidget(_wid_display)
_layout.addWidget(_wid_buttons)
_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(_layout)
# connection
self.__win_add.sig_submit[dict].connect(self.add)
_wid_buttons.sig_clicked.connect(self.__operate)
if self.__type is None:
_wid_display.clicked[QModelIndex].connect(self.__widget_detail)
else:
_wid_display.doubleClicked[QModelIndex].connect(
self.__widget_detail)
def __operate(self, p_flg):
if "add" == p_flg:
self.__win_add.show()
elif "delete" == p_flg:
self.__model.usr_delete()
self.sig_delete.emit()
elif "update" == p_flg:
self.__model.usr_editable()
elif "search" == p_flg:
if self.__type is None:
self.sig_search.emit()
else:
_cond = self.__wid_search_cond.get_cond()
self.search(_cond)
else:
pass
def search(self, p_cond):
self.__model.usr_search(p_cond)
def add(self, p_data):
self.__model.usr_add(p_data)
def __widget_detail(self, p_index):
_widget_id = self.__model.usr_get_node(p_index).content["id"]
self.sig_selected[str].emit(str(_widget_id))
class ViewAdd(QWidget):
"""
新增弹出框
"""
sig_submit = OrcSignal([dict])
sig_operate = OrcSignal()
def __init__(self, p_def):
QWidget.__init__(self)
self.__fields = p_def # 控件定义
self.widgets = dict() # 控件
_lay_inputs = QGridLayout()
for _index in range(len(self.__fields)):
if not self.__fields[_index]["ADD"]:
continue
_id = self.__fields[_index]["ID"]
_type = self.__fields[_index]["TYPE"]
_name = self.__fields[_index]["NAME"]
_ess = self.__fields[_index]["ESSENTIAL"]
_widget = create_editor(self,
dict(TYPE=_type, SOURCE="ADD", FLAG=_id))
self.widgets[_id] = dict(TYPE=_type,
NAME=_name,
WIDGET=_widget,
ESSENTIAL=_ess)
if "OPERATE" == _type:
_widget.sig_operate.connect(self.sig_operate.emit)
_label = QLabel(("*" if _ess else " ") + _name + ":")
_lay_inputs.addWidget(_label, _index, 0)
_lay_inputs.addWidget(self.widgets[_id]["WIDGET"], _index, 1)
buttuns = ViewButtons(
[dict(id="submit", name=u"提交"),
dict(id="cancel", name=u"取消")])
lay_main = QVBoxLayout()
lay_main.addLayout(_lay_inputs)
lay_main.addWidget(buttuns)
self.setLayout(lay_main)
buttuns.sig_clicked.connect(self.__operate)
self.setStyleSheet(get_theme("Input"))
def set_data(self, p_id, p_data):
"""
设置数据
:param p_id:
:param p_data:
:return:
"""
self.widgets[p_id]["WIDGET"].set_data(p_data)
def get_data(self, p_id):
"""
获取数据
:param p_id:
:return:
"""
return self.widgets[p_id]["WIDGET"].get_data()
def set_enable(self, p_id, p_status):
"""
设置控件可用/不可用
:param p_id:
:param p_status:
:return:
"""
self.widgets[p_id]["WIDGET"].setEnabled(p_status)
def __operate(self, p_flag):
if "submit" == p_flag:
self.__submit()
elif "cancel" == p_flag:
self.close()
else:
pass
def __submit(self):
_res = dict()
for t_id in self.widgets:
_res[t_id] = self.get_data(t_id)
# Guarantee input is not null
if self.widgets[t_id]["ESSENTIAL"] and is_null(_res[t_id]):
_message = u"%s不可以为空" % self.widgets[t_id]["NAME"]
_msg_box = QMessageBox(QMessageBox.Warning, "Alert", _message)
_msg_box.setStyleSheet(get_theme("Buttons"))
_msg_box.exec_()
return
self.sig_submit[dict].emit(_res)
self.close()
class ViewCaseSelMag(QWidget):
sig_selected = OrcSignal([dict])
def __init__(self):
QWidget.__init__(self)
self.title = u"选择用例"
# Model
self.__model = CaseSelModel()
self.__model.usr_set_definition(def_view_case_def)
# Control
_control = CaseSelControl(def_view_case_def)
# Search condition widget
self.__wid_search_cond = ViewSearch(def_view_case_def)
self.__wid_search_cond.set_col_num(2)
self.__wid_search_cond.create()
# Data result display widget
_wid_display = ViewTree()
_wid_display.set_model(self.__model)
_wid_display.set_control(_control)
# Buttons widget
_wid_buttons = ViewButtons([
dict(id="select", name=u"选择"),
dict(id="search", name=u"查询"),
dict(id="cancel", name=u"取消")
])
# win_add
self.__win_add = ViewAdd(def_view_case_def)
# Layout
_layout = QVBoxLayout()
_layout.addWidget(self.__wid_search_cond)
_layout.addWidget(_wid_display)
_layout.addWidget(_wid_buttons)
self.setLayout(_layout)
# Connection
_wid_buttons.sig_clicked.connect(self.__operate)
def __operate(self, p_flag):
if "select" == p_flag:
self.__select()
elif "search" == p_flag:
self.__search()
elif "cancel" == p_flag:
self.close()
else:
pass
def __search(self):
self.__model.usr_search(self.__wid_search_cond.get_cond())
def __select(self):
_res = self.__model.usr_get_checked()
self.sig_selected[dict].emit(_res)
self.close()
class ViewPageSelectMag(QWidget):
sig_selected = OrcSignal(dict)
def __init__(self):
QWidget.__init__(self)
self.title = u"用例管理"
# Model
self.__model = PageSelectModel()
self.__model.usr_set_definition(def_view_page_def)
# Control
_control = PageSelectControl(def_view_page_def)
# Search condition widget
self.__wid_search_cond = ViewSearch(def_view_page_def)
self.__wid_search_cond.set_col_num(2)
self.__wid_search_cond.create()
# Data result display widget
_wid_display = ViewTable()
_wid_display.set_model(self.__model)
_wid_display.set_control(_control)
# Buttons widget
_wid_buttons = ViewButtons([dict(id="search", name=u"查询")])
# win_add
self.__win_add = ViewAdd(def_view_page_def)
# Layout
_layout = QVBoxLayout()
_layout.addWidget(self.__wid_search_cond)
_layout.addWidget(_wid_display)
_layout.addWidget(_wid_buttons)
self.setLayout(_layout)
# Connection
_wid_buttons.sig_clicked.connect(self.__operate)
_wid_display.doubleClicked.connect(self.select)
def __operate(self, p_flag):
if "search" == p_flag:
self.search()
else:
pass
def search(self):
_cond = self.__wid_search_cond.get_cond()
self.__model.usr_search(_cond)
def select(self, p_index):
_node = self.__model.usr_get_data(p_index.row())
_id = _node["id"]
_flag = _node["page_flag"]
self.sig_selected.emit(dict(id=str(_id), flag=_flag))
self.close()
class WidgetTest(QWidget):
sig_exec = OrcSignal()
def __init__(self):
QWidget.__init__(self)
self.__dict = LibDict()
self.__service = WebMainService()
self.id = None
self.type = None
self.operation = None
self.data = None
self.env = None
# 输入框
_layout_top = QGridLayout()
self.__edit_type = OrcSelect() # 类型,页面或者控件
self.__edit_flag = OrcLineEdit() # 标识符
self.__widget_type = SelectWidgetType(True) # 控件类型
self.__widget_ope = SelectWidgetOperation(True) # 控件操作类型
self.__widget_data = OrcLineEdit()
self.__edit_type.set_empty()
self.__edit_type.set_flag("operate_object_type")
self.__edit_type.setEnabled(False)
self.__edit_flag.setEnabled(False)
self.__widget_type.setEnabled(False)
self.__widget_data.setEnabled(False)
_layout_top.addWidget(QLabel(u"类型:"), 0, 0)
_layout_top.addWidget(self.__edit_type, 0, 1)
_layout_top.addWidget(QLabel(u"标识:"), 1, 0)
_layout_top.addWidget(self.__edit_flag, 1, 1)
_layout_top.addWidget(QLabel(u"控件:"), 2, 0)
_layout_top.addWidget(self.__widget_type, 2, 1)
_layout_top.addWidget(QLabel(u"操作:"), 3, 0)
_layout_top.addWidget(self.__widget_ope, 3, 1)
_layout_top.addWidget(QLabel(u"数据:"), 4, 0)
_layout_top.addWidget(self.__widget_data, 4, 1)
self.__edit_status = OrcTextArea(self)
self.__edit_status.setReadOnly(True)
# 按钮
_layout_button = QHBoxLayout()
self.__btn_exec = QPushButton(u"执行")
self.__btn_exec.setStyleSheet(get_theme("Buttons"))
_layout_button.addStretch()
_layout_button.addWidget(self.__btn_exec)
# 主界面
_layout = QVBoxLayout()
_layout.addLayout(_layout_top)
_layout.addWidget(self.__edit_status)
_layout.addLayout(_layout_button)
self.setLayout(_layout)
self.__widget_ope.currentIndexChanged.connect(self.__set_operation)
self.__widget_data.textChanged.connect(self.__set_data)
self.__btn_exec.clicked.connect(self.sig_exec.emit)
def __set_operation(self):
_ope = self.__widget_ope.get_data()
if not _ope:
self.operation = None
else:
self.operation = _ope
def __set_data(self):
self.data = self.__widget_data.get_data()
def set_type(self, p_type, p_id):
# 设置对象类型
_type_text = self.__dict.get_dict("operate_object_type",
p_type)[0].dict_text
self.__edit_type.set_data(_type_text)
self.id = p_id
self.type = p_type
if "PAGE" == p_type:
_page_id, _page_flg, _page_env = self.__service.get_page_key(p_id)
_page_key = "%s[%s]" % (_page_flg, _page_env)
self.id = _page_id
self.env = _page_env
# 设置页面标识
self.__edit_flag.set_data(_page_key)
# 禁用控件类型
self.__widget_type.set_data("")
# 页面操作项
self.__widget_ope.set_type("PAGE")
# self.__widget_ope.setEnabled(False)
# 禁止输入数据
self.__widget_data.clear()
self.__widget_data.setEnabled(False)
elif "WIDGET" == p_type:
_widget_key = self.__service.get_widget_key(p_id)
_widget_type = self.__service.get_widget_type(p_id)
# 设置控件标识
self.__edit_flag.set_data(_widget_key)
# 设置控件类型
self.__widget_type.set_data(_widget_type)
# 重置控件操作项
self.__widget_ope.set_type(_widget_type)
# self.__widget_ope.setEnabled(True)
# 数据输入框可用
self.__widget_data.setEnabled(True)
else:
pass
def set_env(self, p_env):
self.env = p_env
def set_status(self, p_status):
if p_status:
self.__edit_status.setText("Success")
else:
self.__edit_status.setText("Fail")
class ViewWebMain(QWidget):
"""
"""
sig_page_selected = OrcSignal(str)
def __init__(self):
QWidget.__init__(self)
self.title = u"Web对象管理"
# Page
_page = PageContainer()
# Window
_window = ViewWindow()
# Widget
_widget = WidgetContainer()
# 页面 tab
_tab = QTabWidget()
_tab.addTab(_page, _page.title)
_tab.addTab(_window, _window.title)
_tab.addTab(_widget, _widget.title)
_tab.setTabPosition(QTabWidget.West)
_tab.setStyleSheet(get_theme("TabViewWeb"))
# 测试区
self.__test = WidgetTest()
self.__test.setStyleSheet(get_theme("TestWidget"))
# 主layout
_layout = QHBoxLayout()
_layout.addWidget(_tab)
_layout.addWidget(self.__test)
_layout.setStretch(0, 5)
_layout.setStretch(1, 1)
_layout.setContentsMargins(0, 0, 0, 0)
_layout.setSpacing(0)
self.setLayout(_layout)
# 信号
_page.sig_selected.connect(self.set_page)
_widget.sig_selected.connect(self.set_widget)
self.__test.sig_exec.connect(self.send)
def set_page(self, p_id):
self.__test.set_type("PAGE", p_id)
def set_widget(self, p_id):
self.__test.set_type("WIDGET", p_id)
def send(self):
# Todo 接口调用方式
_data = dict(OBJECT=self.__test.id,
TYPE=self.__test.type,
ENV=self.__test.env,
OPERATION=self.__test.operation,
DATA=self.__test.data)
from OrcLib.LibNet import OrcSocketResource
_resource = OrcSocketResource("DriverWeb")
_result = _resource.get(_data)
self.__test.set_status(_result)
class ViewPageDefMag(QWidget):
sig_selected = OrcSignal(str)
sig_search = OrcSignal()
sig_delete = OrcSignal()
def __init__(self):
QWidget.__init__(self)
self.title = u"用例管理"
# Model
self.__model = PageDefModel()
self.__model.usr_set_definition(def_view_page_def)
# Control
_control = PageDefControl(def_view_page_def)
# Data result display widget
_wid_display = ViewTable()
_wid_display.set_model(self.__model)
_wid_display.set_control(_control)
# Buttons widget
_wid_buttons = ViewButtons([
dict(id="add", name=u"增加"),
dict(id="delete", name=u"删除"),
dict(id="update", name=u"修改", type="CHECK"),
dict(id="search", name=u"查询")
])
# win_add
self.__win_add = ViewAdd(def_view_page_def)
# Layout
_layout = QVBoxLayout()
_layout.addWidget(_wid_display)
_layout.addWidget(_wid_buttons)
_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(_layout)
# Connection
_wid_buttons.sig_clicked.connect(self.__operate)
self.__win_add.sig_submit[dict].connect(self.add)
_wid_display.clicked[QModelIndex].connect(self.__page_detail)
def search(self, p_cond):
self.__model.usr_search(p_cond)
def add(self, p_data):
self.__model.usr_add(p_data)
def __operate(self, p_flag):
if "add" == p_flag:
self.__win_add.show()
elif "delete" == p_flag:
self.__model.usr_delete()
self.sig_delete.emit()
elif "update" == p_flag:
self.__model.usr_editable()
elif "search" == p_flag:
self.sig_search.emit()
else:
pass
def __page_detail(self, p_index):
_page_id = self.__model.usr_get_data(p_index.row())["id"]
self.sig_selected[str].emit(str(_page_id))
class ViewCaseDetMag(QWidget):
sig_select = OrcSignal(str)
sig_search = OrcSignal()
sig_delete = OrcSignal()
def __init__(self, p_id):
QWidget.__init__(self)
self.__case_id = p_id
# Model
self.__model = CaseDetModel()
self.__model.usr_set_definition(def_view_case_det)
self.__model.usr_search({"case_id": self.__case_id})
# Control
_control = CaseDetControl(def_view_case_det)
# Data result display widget
_wid_display = ViewTable()
_wid_display.set_model(self.__model)
_wid_display.set_control(_control)
# 界面列宽自适应
# _wid_display.resizeColumnsToContents()
# Context menu
_menu_def = [
dict(NAME=u"增加", STR="sig_add"),
dict(NAME=u"删除", STR="sig_del"),
dict(NAME=u"增加数据", STR="sig_data")
]
_wid_display.create_context_menu(_menu_def)
# Buttons widget
_wid_buttons = ViewButtons([
dict(id="add", name=u"增加"),
dict(id="delete", name=u"删除"),
dict(id="update", name=u"修改", type="CHECK")
], "VER")
# win_add
self.__win_add = ViewAdd(def_view_case_det)
# win add data
self.__win_data = ViewDataAdd()
# Layout
_layout = QHBoxLayout()
_layout.addWidget(_wid_display)
_layout.addWidget(_wid_buttons)
_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(_layout)
# Connection
_wid_buttons.sig_clicked.connect(self.__operate)
_wid_display.clicked.connect(self.__selected)
self.__win_add.sig_submit.connect(self.add)
_wid_display.sig_context.connect(self.__context) # 右键菜单
_wid_display.clicked.connect(self.__model.usr_set_current_data)
def add(self, p_data):
_data = dict(case_det={"case_id": self.__case_id}, step=p_data)
self.__model.usr_add(_data)
def __operate(self, p_flag):
if "add" == p_flag:
self.__win_add.show()
elif "delete" == p_flag:
self.__model.usr_delete()
self.sig_delete.emit()
elif "update" == p_flag:
self.__model.usr_editable()
else:
pass
def __selected(self, p_index):
_index = p_index.row()
_step_id = self.__model.usr_get_data(_index)["step_id"]
self.sig_select.emit(str(_step_id))
def __context(self, p_flag):
if "sig_data" == p_flag:
_path = self.__model.usr_get_current_data()["step_no"]
self.__win_data.show()
self.__win_data.set_type("STEP")
self.__win_data.set_id(_path)
class ViewButtons(QWidget):
sig_clicked = OrcSignal(str)
def __init__(self, p_def, p_direction="HOR"):
"""
生成一个按钮组
:param p_def: [{id, name, type=None}]
:return: None
"""
QWidget.__init__(self)
# 定义
self.__definition = p_def
# 按钮字典
self.__buttons = dict()
# 设置方向
if "HOR" == p_direction:
self.__layout = QHBoxLayout()
else:
self.__layout = QVBoxLayout()
# 设置 layout
self.setLayout(self.__layout)
# 添加按钮
for t_def in self.__definition:
_id = t_def["id"]
_name = t_def["name"]
_type = None if "type" not in t_def else t_def["type"]
_button = QPushButton(_name)
# Toggle button
if _type is not None and "CHECK" == _type:
_button.setCheckable(True)
_button.clicked.connect(partial(self.sig_clicked.emit, _id))
self.__buttons["id"] = _button
self.__layout.addWidget(_button)
# 默认向右对齐
self.align_back()
# 设置样式
self.setStyleSheet(get_theme("Buttons"))
def align_back(self):
"""
向下/向右对齐
:return:
"""
self.__layout.insertStretch(0)
def align_front(self):
"""
向下/向左对齐
:return:
"""
self.__layout.addStretch()
def set_disable(self, p_id):
"""
设置按钮不可用
:param p_id:
:return:
"""
if p_id in self.__buttons:
self.__buttons[p_id].setEnabled(False)
def set_enable(self, p_id):
"""
设置按钮可用
:param p_id:
:return:
"""
if p_id in self.__buttons:
self.__buttons[p_id].setEnabled(True)
class ViewCaseSelMag(QWidget):
sig_selected = OrcSignal([dict])
def __init__(self, p_type=None):
QWidget.__init__(self)
self.title = u"选择用例"
self.__type = "MULTI" if p_type is None else p_type
# Model
self.__model = CaseSelModel()
self.__model.usr_set_definition(def_view_case_def)
if "SINGLE" == self.__type:
self.__model.usr_chk_able()
# Control
_control = CaseSelControl(def_view_case_def)
# Search condition widget
self.__wid_search_cond = ViewSearch(def_view_case_def)
self.__wid_search_cond.set_col_num(2)
self.__wid_search_cond.create()
# Data result display widget
_wid_display = ViewTree()
_wid_display.set_model(self.__model)
_wid_display.set_control(_control)
# Buttons widget
if "SINGLE" == self.__type:
button_def = []
else:
button_def = [dict(id="select", name=u"选择")]
button_def.extend([
dict(id="search", name=u"查询"),
dict(id="cancel", name=u"取消")])
_wid_buttons = ViewButtons(button_def)
# win_add
self.__win_add = ViewAdd(def_view_case_def)
# Layout
_layout = QVBoxLayout()
_layout.addWidget(self.__wid_search_cond)
_layout.addWidget(_wid_display)
_layout.addWidget(_wid_buttons)
self.setLayout(_layout)
# Connection
_wid_buttons.sig_clicked.connect(self.__operate)
_wid_display.clicked.connect(self.__model.usr_set_current_data)
_wid_display.doubleClicked.connect(self.__select_one)
def __operate(self, p_flag):
if "select" == p_flag:
self.__select()
elif "search" == p_flag:
self.__search()
elif "cancel" == p_flag:
self.close()
else:
pass
def __search(self):
self.__model.usr_search(self.__wid_search_cond.get_cond())
def __select(self):
_res = self.__model.usr_get_checked()
self.sig_selected[dict].emit(_res)
self.close()
def __select_one(self):
_res = self.__model.usr_get_current_data().content["id"]
self.sig_selected[dict].emit([_res])
self.close()
