WxPython跨平台开辟框架之用户选择和标签组件的设计

在系统的权限管理中，每每都会涉及到用户的选择处理，特别是基于脚色的访问控制中，许多情况下需要用到选择用户的处理。本篇随笔，基于WxPython跨平台开辟框架，采用原有开辟框架成熟的一套权限系统理念，对机构、用户、脚色、权限、菜单、日志、字典等内容进行管理的，因此也涉及到了用户选择的处理，在WxPython开辟中，为了方便，我们每每会构建一些自定义控件，以便重用处理，本篇设计了标签组件来简化一些处理操作，同时可以在许多地方进行重用。
1、权限内容的相关介绍

RBAC（Role-Based Access Control，基于脚色的访问控制）是一种常用的访问控制模型，在此模型中，系统中的每个用户被赋予一个或多个脚色，权限则与脚色相关联。脚色是一组权限的聚集，用户通过其所扮演的脚色来得到相应的权限，从而限制用户对系统资源的访问。
基本概念

• 脚色（Role）： 脚色是一个标识符，表示一组权限的聚集。每个脚色可以有不同的权限，比方 "管理员"、"普通用户"、"审计员" 等。
  
• 用户（User）： 用户是系统中的现实操作主体。每个用户可以分配一个或多个脚色，根据脚色来得到相应的权限。
  
• 权限（Permission）： 权限是指用户可以执行的操作或可以访问的资源。比方，"读取文件"、"修改文件"、"删除文件" 等。
  
• 会话（Session）： 会话是用户和系统之间交互的时间段，系统通过会话信息管理用户的脚色和权限。
  

RBAC的工作原理

RBAC模型的基本思想是：

• 用户通过其脚色得到访问权限。
  
• 系统将权限与脚色进行绑定，脚色分配给用户。
  
• 用户通过脚色来执行操作，而不是直接赋予权限。
  

RBAC的主要组成部分

• 脚色权限映射： 脚色和权限之间的映射关系是RBAC的核心。比方，"管理员"脚色拥有创建、删除、编辑用户的权限，而"普通用户"脚色只拥有读取数据的权限。
  
• 用户脚色映射： 用户通过脚色来得到权限。比方，某个用户被赋予"经理"脚色，那么该用户便得到了与"经理"脚色相关的所有权限。
  
• 访问控制： 系统根据用户当前脚色的权限来判定是否允许访问某个资源或执行某个操作。
  

RBAC的实现

• 定义脚色和权限： 在系统中定义不同的脚色，比方管理员、用户、访客等，并为每个脚色分配不同的权限。
  
• 用户分配脚色： 每个用户通过管理员或系统主动分配脚色，得到该脚色所拥有的权限。
  
• 控制访问： 系统根据用户的脚色判定是否允许其访问某些资源或执行某些操作。 
  

我曾经在《Winform开辟框架之权限管理系统改进的经验总结（2）-用户选择界面的设计》中介绍了选择用户的界面，

 可以在组织机构大概用户脚色管理中选择相关用户，我们在WxPython跨平台开辟框架同样也是采用这种管理概念。界面设计效果如下所示。

弹出的界面中，模拟了之前的用户界面，由于之前在添加每个用户的时间，采用的是添加自定义控件的方式呈现，在wxpython中做一些自定义控件的处理也黑白常方便的，我们先来看最终的界面效果，后面在分析如何实现用户标签的添加和移除等操作管理。

2、标签信息的自定义控件的处理

为了实现标签信息的处理，我们先来做一个简朴的标签组件的测试，在整合在界面中进行美满的处理。
简朴的例子代码如下所示。

1. import wx
2. import random
5. class Tag(wx.Panel):
6.     def __init__(self, parent, label, on_close):
7.         """标签控件初始化
8.         :param parent: 父控件
9.         :param label: 标签文本
10.         :param on_close: 关闭事件回调函数
11.         """
12.         super().__init__(parent, style=wx.BORDER_SIMPLE)
14.         self.on_close = on_close  # 回调函数，用于处理关闭事件
15.         self.label = label
17.         # 设置背景颜色，方便区分标签
18.         # self.SetBackgroundColour(wx.Colour(240, 240, 240))
19.         r = random.randint(128, 255)
20.         g = random.randint(128, 255)
21.         b = random.randint(128, 255)
22.         self.SetBackgroundColour(wx.Colour(r,g,b))
24.         # 创建控件
25.         self.text = wx.StaticText(self, label=label)
26.         self.close_btn = wx.Button(self, label="x", size=(20, 20))
28.         # 布局
29.         sizer = wx.BoxSizer(wx.HORIZONTAL)
30.         sizer.Add(self.text, 0, wx.ALIGN_CENTER | wx.RIGHT, 5)
31.         sizer.AddSpacer(2)
32.         sizer.Add(self.close_btn, 0, wx.ALIGN_CENTER)
34.         self.SetSizer(sizer)
35.         sizer.Fit(self)
37.         # 绑定事件
38.         self.close_btn.Bind(wx.EVT_BUTTON, self._on_close)
40.     def _on_close(self, event):
41.         """处理关闭事件"""
42.         if self.on_close:
43.             self.on_close(self)
46. class TagPanel(wx.Panel):
47.     def __init__(self, parent):
48.         """标签面板控件初始化
49.         :param parent: 父控件
50.         """
51.         super().__init__(parent)
53.         self.sizer = wx.WrapSizer(wx.HORIZONTAL, wx.WRAPSIZER_DEFAULT_FLAGS)
54.         self.SetSizer(self.sizer)
56.         # 测试用标签
57.         for i in range(5):
58.             self.add_tag(f"张三发 {i+1}")
60.     def add_tag(self, label):
61.         """添加一个新标签"""
62.         tag = Tag(self, label, self.remove_tag)
63.         self.sizer.Add(tag, 0, wx.ALL, 5)
64.         self.Layout()
66.     def remove_tag(self, tag):
67.         """移除一个标签"""
68.         self.sizer.Detach(tag)
69.         tag.Destroy()
70.         self.Layout()
73. class MyFrame(wx.Frame):
74.     def __init__(self):
75.         super().__init__(None, title="标签测试案例", size=(400, 300))
77.         panel = wx.Panel(self)
78.         main_sizer = wx.BoxSizer(wx.VERTICAL)
80.         self.tag_panel = TagPanel(panel)
81.         main_sizer.Add(self.tag_panel, 1, wx.EXPAND | wx.ALL, 10)
83.         # 添加标签的按钮
84.         add_button = wx.Button(panel, label="添加新标签")
85.         add_button.Bind(wx.EVT_BUTTON, self.on_add_tag)
86.         main_sizer.Add(add_button, 0, wx.ALIGN_CENTER | wx.ALL, 10)
88.         panel.SetSizer(main_sizer)
90.     def on_add_tag(self, event):
91.         """添加新标签"""
92.         self.tag_panel.add_tag(f"标签 {len(self.tag_panel.sizer.GetChildren()) + 1}")
94. if __name__ == "__main__":
95.     app = wx.App()
96.     frame = MyFrame()
97.     frame.Show()
98.     app.MainLoop()

复制代码

实现的效果如下所示。

大概就是如许的效果，我们在添加用户的界面中整合它，并美满一些操作，如可以记载选中的相关信息，清空记载，可以更新选中的记载数等信息。
起首，我们增加一个通用的对象类，来承载显示内容和值信息的（text,value键值对)，如下定义所示。

1. class CListItem(BaseModel):
2.     """框架用来记录字典键值的类，用于Comobox等控件对象的值传递"""
4.     def __init__(self, text: str, value: Any, **data: Any):
5.         super().__init__(**data)
6.         self.text = text
7.         self.value = value
9.     text: str = None
10.     value: Any = None
12.     def __repr__(self):
13.         return f"CListItem(text={self.text}, value={self.value})"

复制代码

因此Tag的类初始化，改用该对象来来处理，如下代码所示

1. class MyTag(wx.Panel):
2.     """自定义标签, 带有关闭按钮"""
4.     item: CListItem = None  # 标签数据
6.     def __init__(self, parent, <strong>item: CListItem,</strong> on_close):
7.         """初始化
9.         :param parent: 父容器
10.         :param label: 标签文本
11.         :param on_close: 关闭事件回调函数
12.         """
13.         super().__init__(parent, style=wx.BORDER_SIMPLE)
15.         self.on_close = on_close  # 回调函数，用于处理关闭事件
16.         self.item = item
18.         # 设置背景颜色，方便区分标签
19.         # self.SetBackgroundColour(wx.Colour(240, 240, 240))
20.         r = random.randint(128, 255)
21.         g = random.randint(128, 255)
22.         b = random.randint(128, 255)
23.         self.SetBackgroundColour(wx.Colour(r, g, b))
25.         # 创建控件
26.         self.text = wx.StaticText(self, <strong>label=</strong><strong>item.text</strong>)
27.         self.close_btn = wx.Button(self, label="x", size=(20, 20))
29.         # 布局
30.         sizer = wx.BoxSizer(wx.HORIZONTAL)
31.         sizer.Add(self.text, 0, wx.ALIGN_CENTER | wx.RIGHT, 5)
32.         sizer.AddSpacer(2)
33.         sizer.Add(self.close_btn, 0, wx.ALIGN_CENTER)
35.         self.SetSizer(sizer)
36.         sizer.Fit(self)
38.         # 绑定事件
39.         self.close_btn.Bind(wx.EVT_BUTTON, self._on_close)
41.     def _on_close(self, event):
42.         """处理关闭事件"""
43.         if self.on_close:
44.             self.on_close(self)

复制代码

标签面板的内容中，我们也改用 wx.WrapSizer 这个可折叠的面板Sizer来做标签控件的展示，如许可以在一个位置上堆叠，并且可以换行处理等，比力常规的Panel会好一些。
同时，标签面板增加一个更新的处理函数给外部定义，并且在添加的时间，对重复添加的进行判定，如许我们在标签的添加、删除等操作都进行外部事件的调用就完美了。完整的代码如下所示。

1. class MyTagPanel(wx.Panel):
2.     def __init__(
3.         self,
4.         parent,
5.         id=wx.ID_ANY,
6.         pos=wx.DefaultPosition,
7.         size=wx.DefaultSize,
8.         on_tag_updated=None,
9.         *args,
10.         **kwargs,
11.     ):
12.         super().__init__(parent, id, pos, size, *args, **kwargs)
14.         self.sizer = wx.WrapSizer(wx.HORIZONTAL, wx.WRAPSIZER_DEFAULT_FLAGS)
15.         self.SetSizer(self.sizer)
17.         self.list = []  # 标签数据列表
18.         self.on_tag_updated = on_tag_updated  # 回调函数，用于处理标签变化事件
20.     def _find_tag(self, item: CListItem):
21.         """查找标签"""
22.         # for child in self.list:
23.         #     if item.value == child.value:
24.         #         return item
25.         # return None
27.         # next 函数：用于从迭代器中获取第一个匹配的元素。如果找不到匹配项，可以指定默认值（这里为 None）。
28.         return next((child for child in self.list if item.value == child.value), None)
30.     def add_tag(self, item: CListItem):
31.         """添加一个新标签"""
32.         <strong>if self._find_tag(item):
33.             </strong>return  # 标签已存在，不再添加
34.         self.list.append(item)
36.         tag = MyTag(self, item, self.remove_tag)
37.         self.sizer.Add(tag, 0, wx.ALL, 5)
38.         self.Layout()
40.         self.update_tag()
42.     def update_tag(self):
43.         # 触发回调函数
44.         if self.on_tag_updated:
45.             self.on_tag_updated()
47.     def remove_tag(self, tag: MyTag):
48.         """移除一个标签"""
50.         self.list.remove(tag.item)  # 从列表中移除标签数据
52.         self.sizer.Detach(tag)
53.         tag.Destroy()
54.         self.Layout()
56.         self.update_tag()
58.     def get_items(self):
59.         """获取标签列表"""
60.         items = []
61.         for child in self.sizer.GetChildren():
62.             tag = child.GetWindow()
63.             tag: MyTag  # 限定类型
64.             items.append(tag.item)
65.         return items
67.     def clear_items(self):
68.         """清空标签列表"""
69.         for child in self.sizer.GetChildren():
70.             tag = child.GetWindow()
71.             tag: MyTag  # 限定类型
72.             self.remove_tag(tag)
74.         self.update_tag()

复制代码

3、在用户选择界面中使用标签控件和标签面板

我们来看看在选择用户的界面中添加标签面板和相关处理的按钮，如下界面效果所示。

 添加标签面板我们用一个函数来处理，如下所示。

1.     def create_tag_panel_buttons(self, parent, style=wx.BORDER_SIMPLE):
2.         """创建标签面板和操作按钮"""
3.         dlg_sizer: wx.BoxSizer = self.GetSizer()
5.         # 添加选择区标签面板
6.         self.tag_panel = ctrl.MyTagPanel(
7.             parent, size=(-1, 100), style=style, on_tag_updated=self.OnTagsUpdated
8.         )
9.         dlg_sizer.Add(self.tag_panel, 0, wx.EXPAND | wx.ALL, 10)
11.         # 添加按钮区
12.         btn_sizer = self.CreateCustomButtons(self)
13.         dlg_sizer.Add(
14.             btn_sizer, 0, wx.EXPAND | wx.BOTTOM | wx.RIGHT, self.GetDialogBorder()
15.         )

复制代码

我们在标签的厘革处理事件OnTagsUpdated实现通知外部标签显示的处理，如下代码所示。

1.     def OnTagsUpdated(self):
2.         """更新选择的用户信息"""
3.         items = self.tag_panel.get_items()
4.         self.lbl_selected_text.SetLabel(f"已选择【{len(items)}】个项目")

复制代码

我们在表格的双击事件大概按钮事件中添加对应的用户到面板中，我们得到记载的id和用户姓名添加到标签面板即可。

1.             # 获取该行的主键值和值
2.             entity_id = self.table.GetPrimaryKeyValue(row)
3.             fullname = self.table.GetValueByKey(row, "fullname")
4.             if entity_id and fullname:
5.                 self.tag_panel.<strong>add_tag</strong>(CListItem(fullname, entity_id))
6.             else:
7.                 MessageUtil.show_info(self, "该行无主键值 或 真实姓名")

复制代码

假如我们需要再外部清空，也是调用标签面板的清空函数，假如需要得到选中的记载，也照旧调用标签面板的选择记载聚集即可。
如确认选择的处理事件中，代码如下所示。

1.     async def OnConfirmSelect(self, event):
2.         """确认选择"""
3.         items = self.tag_panel.<strong>get_items</strong>()
4.         if len(items) == 0:
5.             MessageUtil.show_warning(self, "请先选择项目")
6.             return
8.         self.selected_items = items  # 保存选择的记录
9.         self.CloseModel(wx.ID_OK)

复制代码

因此简朴的封装一下，就可以实现了标签记载的相关处理，非常方便，当前其他一样平常的功能实现，也是云云简化即可。
当然，对于选择用户的整个界面窗体，我们也是可以把它当做一个公用组件来实现的，因此在机构和脚色中都需要对用户进行关联，因此它们公用一个界面处理。
以上就是对于常规界面中常用到的一些功能，进行了相关的封装，然后在系统中整合使用的整个过程。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。