cmdbox 0.5.2__py3-none-any.whl → 0.5.3__py3-none-any.whl

cmdbox/app/auth/signin.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from typing import Dict, Any, Tuple, List, Union
 import copy
 import logging
+import string
 
 
 class Signin(object):

cmdbox/app/features/cli/audit_base.py

@@ -8,7 +8,8 @@ import sqlite3
 
 
 class AuditBase(feature.ResultEdgeFeature):
-    
+    TBL_COLS = ['audit_type', 'clmsg_id', 'clmsg_date', 'clmsg_src', 'clmsg_title', 'clmsg_user', 'clmsg_body', 'clmsg_tag', 'svmsg_id', 'svmsg_date']
+    DT_FMT = ['%Y/%m/%d %H:%M', '%Y/%m/%d %H', '%Y/%m/%d', '%Y/%m', '%Y', '%m', '%u']
     def get_option(self):
         """
         この機能のオプションを返します
@@ -97,6 +98,7 @@ class AuditBase(feature.ResultEdgeFeature):
                             clmsg_id TEXT,
                             clmsg_date TIMESTAMP WITH TIME ZONE,
                             clmsg_src TEXT,
+                            clmsg_title TEXT,
                             clmsg_user TEXT,
                             clmsg_body JSON,
                             clmsg_tag JSON,
@@ -123,6 +125,7 @@ class AuditBase(feature.ResultEdgeFeature):
                             clmsg_id TEXT,
                             clmsg_date TEXT,
                             clmsg_src TEXT,
+                            clmsg_title TEXT,
                             clmsg_user TEXT,
                             clmsg_body JSON,
                             clmsg_tag JSON,

cmdbox/app/features/cli/cmdbox_audit_delete.py

@@ -41,7 +41,7 @@ class AuditDelete(audit_base.AuditBase):
         opt['discription_ja'] = "監査ログを削除します。"
         opt['discription_en'] = "Delete the audit log."
         opt['choice'] += [
-            dict(opt="delete_audit_type", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=Options.AUDITS,
+            dict(opt="delete_audit_type", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=['']+Options.AUDITS,
                  discription_ja="削除条件の監査の種類を指定します。",
                  discription_en="Specifies the type of audit for the delete condition."),
             dict(opt="delete_clmsg_id", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=None,
@@ -56,6 +56,9 @@ class AuditDelete(audit_base.AuditBase):
             dict(opt="delete_clmsg_src", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=None,
                  discription_ja="削除条件のクライアントのメッセージの発生源を指定します。LIKE検索を行います。",
                  discription_en="Specifies the source of the message for the client in the delete condition; performs a LIKE search."),
+            dict(opt="delete_clmsg_title", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=None,
+                 discription_ja="削除条件のクライアントのメッセージタイトルを指定します。LIKE検索を行います。",
+                 discription_en="Specifies the message title of the client for the deletion condition; a LIKE search is performed."),
             dict(opt="delete_clmsg_user", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=None,
                  discription_ja="削除条件のクライアントのメッセージの発生させたユーザーを指定します。LIKE検索を行います。",
                  discription_en="Specifies the user who generated the message for the client in the delete condition; performs a LIKE search."),
@@ -111,6 +114,7 @@ class AuditDelete(audit_base.AuditBase):
         delete_clmsg_edate = args.delete_clmsg_edate+common.get_tzoffset_str() if args.delete_clmsg_edate else None
         delete_clmsg_edate_b64 = convert.str2b64str(delete_clmsg_edate)
         delete_clmsg_src_b64 = convert.str2b64str(args.delete_clmsg_src)
+        delete_clmsg_title_b64 = convert.str2b64str(args.delete_clmsg_title) if args.delete_clmsg_title else None
         delete_clmsg_user_b64 = convert.str2b64str(args.delete_clmsg_user)
         delete_clmsg_body_str = json.dumps(args.delete_clmsg_body, default=common.default_json_enc, ensure_ascii=False) if args.delete_clmsg_body else '{}'
         delete_clmsg_body_b64 = convert.str2b64str(delete_clmsg_body_str)
@@ -129,8 +133,8 @@ class AuditDelete(audit_base.AuditBase):
         cl = client.Client(logger, redis_host=args.host, redis_port=args.port, redis_password=args.password, svname=args.svname)
         ret = cl.redis_cli.send_cmd(self.get_svcmd(),
                                     [delete_audit_type_b64, delete_clmsg_id_b64, delete_clmsg_sdate_b64, delete_clmsg_edate_b64,
-                                     delete_clmsg_src_b64, delete_clmsg_user_b64, delete_clmsg_body_b64, delete_clmsg_tag_b64, 
-                                     delete_svmsg_id_b64, delete_svmsg_sdate_b64, delete_svmsg_edate_b64,
+                                     delete_clmsg_src_b64, delete_clmsg_title_b64, delete_clmsg_user_b64, delete_clmsg_body_b64,
+                                     delete_clmsg_tag_b64, delete_svmsg_id_b64, delete_svmsg_sdate_b64, delete_svmsg_edate_b64,
                                      pg_enabled, pg_host_b64, pg_port, pg_user_b64, pg_password_b64, pg_dbname_b64],
                                     retry_count=args.retry_count, retry_interval=args.retry_interval, timeout=args.timeout)
         common.print_format(ret, args.format, tm, None, False, pf=pf)
@@ -180,21 +184,22 @@ class AuditDelete(audit_base.AuditBase):
         delete_clmsg_sdate = convert.b64str2str(msg[4])
         delete_clmsg_edate = convert.b64str2str(msg[5])
         delete_clmsg_src = convert.b64str2str(msg[6])
-        delete_clmsg_user = convert.b64str2str(msg[7])
-        body = json.loads(convert.b64str2str(msg[8]))
-        tags = json.loads(convert.b64str2str(msg[9]))
-        delete_svmsg_id = convert.b64str2str(msg[10])
-        delete_svmsg_sdate = convert.b64str2str(msg[11])
-        delete_svmsg_edate = convert.b64str2str(msg[12])
-        pg_enabled = True if msg[13]=='True' else False
-        pg_host = convert.b64str2str(msg[14])
-        pg_port = int(msg[15]) if msg[15]!='None' else None
-        pg_user = convert.b64str2str(msg[16])
-        pg_password = convert.b64str2str(msg[17])
-        pg_dbname = convert.b64str2str(msg[18])
+        delete_clmsg_title = convert.b64str2str(msg[7])
+        delete_clmsg_user = convert.b64str2str(msg[8])
+        body = json.loads(convert.b64str2str(msg[9]))
+        tags = json.loads(convert.b64str2str(msg[10]))
+        delete_svmsg_id = convert.b64str2str(msg[11])
+        delete_svmsg_sdate = convert.b64str2str(msg[12])
+        delete_svmsg_edate = convert.b64str2str(msg[13])
+        pg_enabled = True if msg[14]=='True' else False
+        pg_host = convert.b64str2str(msg[15])
+        pg_port = int(msg[16]) if msg[16]!='None' else None
+        pg_user = convert.b64str2str(msg[17])
+        pg_password = convert.b64str2str(msg[18])
+        pg_dbname = convert.b64str2str(msg[19])
         st = self.delete(msg[1],
                          delete_audit_type, delete_clmsg_id, delete_clmsg_sdate, delete_clmsg_edate,
-                         delete_clmsg_src, delete_clmsg_user, body, tags,
+                         delete_clmsg_src, delete_clmsg_title, delete_clmsg_user, body, tags,
                          delete_svmsg_id, delete_svmsg_sdate, delete_svmsg_edate,
                          pg_enabled, pg_host, pg_port, pg_user, pg_password, pg_dbname,
                          data_dir, logger, redis_cli)
@@ -202,8 +207,8 @@ class AuditDelete(audit_base.AuditBase):
 
     def delete(self, reskey:str,
                delete_audit_type:str, delete_clmsg_id:str, delete_clmsg_sdate:str, delete_clmsg_edate:str,
-               delete_clmsg_src:str, delete_clmsg_user:str, delete_clmsg_body:Dict[str, Any], delete_clmsg_tags:List[str],
-               delete_svmsg_id:str, delete_svmsg_sdate:str, delete_svmsg_edate:str,
+               delete_clmsg_src:str, delete_clmsg_title:str, delete_clmsg_user:str, delete_clmsg_body:Dict[str, Any],
+               delete_clmsg_tags:List[str], delete_svmsg_id:str, delete_svmsg_sdate:str, delete_svmsg_edate:str,
                pg_enabled:bool, pg_host:str, pg_port:int, pg_user:str, pg_password:str, pg_dbname:str,
                data_dir:Path, logger:logging.Logger, redis_cli:redis_client.RedisClient) -> int:
         """
@@ -216,6 +221,7 @@ class AuditDelete(audit_base.AuditBase):
             delete_clmsg_sdate (str): クライアントメッセージ発生日時(開始)
             delete_clmsg_edate (str): クライアントメッセージ発生日時(終了)
             delete_clmsg_src (str): クライアントメッセージの発生源
+            delete_clmsg_title (str): クライアントメッセージのタイトル
             delete_clmsg_user (str): クライアントメッセージの発生させたユーザー
             delete_clmsg_body (Dict[str, Any]): クライアントメッセージの本文
             delete_clmsg_tags (List[str]): クライアントメッセージのタグ
@@ -257,6 +263,9 @@ class AuditDelete(audit_base.AuditBase):
                     if delete_clmsg_src and delete_clmsg_src != 'None':
                         where.append(f'clmsg_src LIKE {"%s" if pg_enabled else "?"}')
                         params.append(delete_clmsg_src)
+                    if delete_clmsg_title and delete_clmsg_title != 'None':
+                        where.append(f'clmsg_title LIKE {"%s" if pg_enabled else "?"}')
+                        params.append(delete_clmsg_src)
                     if delete_clmsg_user and delete_clmsg_user != 'None':
                         where.append(f'clmsg_user LIKE {"%s" if pg_enabled else "?"}')
                         params.append(delete_clmsg_user)

cmdbox/app/features/cli/cmdbox_audit_search.py

@@ -41,11 +41,14 @@ class AuditSearch(audit_base.AuditBase):
         opt['discription_ja'] = "監査ログを検索します。"
         opt['discription_en'] = "Search the audit log."
         opt['choice'] += [
-            dict(opt="select", type=Options.T_STR, default=None, required=False, multi=True, hide=False,
-                 choice=['', 'audit_type', 'clmsg_id', 'clmsg_date', 'clmsg_tag', 'clmsg_src', 'clmsg_body', 'svmsg_id', 'svmsg_date'],
+            dict(opt="select", type=Options.T_DICT, default=None, required=False, multi=True, hide=False,
+                 choice=dict(key=['']+self.TBL_COLS, val=['-','count','sum','avg','min','max']),
                  discription_ja="取得項目を指定します。指定しない場合は全ての項目を取得します。",
                  discription_en="Specify the items to be retrieved. If not specified, all items are acquired."),
-            dict(opt="filter_audit_type", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=Options.AUDITS,
+            dict(opt="select_date_format", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=['']+self.DT_FMT,
+                 discription_ja="取得項目の日時のフォーマットを指定します。",
+                 discription_en="Specifies the format of the date and time of the acquisition item."),
+            dict(opt="filter_audit_type", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=['']+Options.AUDITS,
                  discription_ja="フィルタ条件の監査の種類を指定します。",
                  discription_en="Specifies the type of audit for the filter condition."),
             dict(opt="filter_clmsg_id", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=None,
@@ -60,6 +63,9 @@ class AuditSearch(audit_base.AuditBase):
             dict(opt="filter_clmsg_src", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=None,
                  discription_ja="フィルタ条件のクライアントのメッセージの発生源を指定します。LIKE検索を行います。",
                  discription_en="Specifies the source of the message for the client in the filter condition; performs a LIKE search."),
+            dict(opt="filter_clmsg_title", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=None,
+                 discription_ja="フィルタ条件のクライアントのメッセージタイトルを指定します。LIKE検索を行います。",
+                 discription_en="Specifies the message title of the client for the filter condition; a LIKE search is performed."),
             dict(opt="filter_clmsg_user", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=None,
                  discription_ja="フィルタ条件のクライアントのメッセージの発生させたユーザーを指定します。LIKE検索を行います。",
                  discription_en="Specifies the user who generated the message for the client in the filter condition; performs a LIKE search."),
@@ -78,7 +84,13 @@ class AuditSearch(audit_base.AuditBase):
             dict(opt="filter_svmsg_edate", type=Options.T_DATETIME, default=None, required=False, multi=False, hide=False, choice=None,
                  discription_ja="フィルタ条件のサーバーのメッセージ発生日時(終了)を指定します。",
                  discription_en="Specify the date and time (end) when the message occurred for the server in the filter condition."),
-            dict(opt="sort", type=Options.T_DICT, default=None, required=False, multi=True, hide=False, choice=['', 'ASC', 'DICT'],
+            dict(opt="groupby", type=Options.T_STR, default=None, required=False, multi=True, hide=False, choice=['']+self.TBL_COLS,
+                 discription_ja="グループ化項目を指定します。",
+                 discription_en="Specify grouping items."),
+            dict(opt="groupby_date_format", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=['']+self.DT_FMT,
+                 discription_ja="グループ化項目の日時のフォーマットを指定します。",
+                 discription_en="Specifies the format of the date and time of the grouping item."),
+            dict(opt="sort", type=Options.T_DICT, default=None, required=False, multi=True, hide=False, choice=dict(key=['']+self.TBL_COLS, val=['', 'ASC', 'DESC']),
                  discription_ja="ソート項目を指定します。",
                  discription_en="Specify the sort item."),
             dict(opt="offset", type=Options.T_INT, default=0, required=False, multi=False, hide=False, choice=None,
@@ -117,43 +129,51 @@ class AuditSearch(audit_base.AuditBase):
             common.print_format(msg, args.format, tm, None, False, pf=pf)
             return 1, msg, None
 
-        select_str = json.dumps(args.select, default=common.default_json_enc, ensure_ascii=False) if args.select else '[]'
+        select_str = json.dumps(args.select, default=common.default_json_enc, ensure_ascii=False) if getattr(args, 'select', None) else '{}'
         select_b64 = convert.str2b64str(select_str)
-        sort_str = json.dumps(args.sort, default=common.default_json_enc, ensure_ascii=False) if args.sort else '{}'
+        select_date_format_b64 = convert.str2b64str(getattr(args, 'select_date_format', None))
+        groupby_str = json.dumps(args.groupby, default=common.default_json_enc, ensure_ascii=False) if getattr(args, 'groupby', None) else '[]'
+        groupby_b64 = convert.str2b64str(groupby_str)
+        groupby_date_format_b64 = convert.str2b64str(getattr(args, 'groupby_date_format', None))
+        args.sort = args.sort if getattr(args, 'sort', {}) else {}
+        args.sort = args.sort if isinstance(args.sort, dict) else {str(args.sort): 'DESC'}
+        sort_str = json.dumps(args.sort, default=common.default_json_enc, ensure_ascii=False)
         sort_b64 = convert.str2b64str(sort_str)
-        offset = args.offset
-        limit = args.limit
-        filter_audit_type_b64 = convert.str2b64str(args.filter_audit_type)
-        filter_clmsg_id_b64 = convert.str2b64str(args.filter_clmsg_id)
-        filter_clmsg_sdate = args.filter_clmsg_sdate+common.get_tzoffset_str() if args.filter_clmsg_sdate else None
+        offset = getattr(args, 'offset', None)
+        limit = getattr(args, 'limit', None)
+        filter_audit_type_b64 = convert.str2b64str(getattr(args, 'filter_audit_type', None))
+        filter_clmsg_id_b64 = convert.str2b64str(getattr(args, 'filter_clmsg_id', None))
+        filter_clmsg_sdate = args.filter_clmsg_sdate+common.get_tzoffset_str() if getattr(args, 'filter_clmsg_sdate', None) else None
         filter_clmsg_sdate_b64 = convert.str2b64str(filter_clmsg_sdate)
-        filter_clmsg_edate = args.filter_clmsg_edate+common.get_tzoffset_str() if args.filter_clmsg_edate else None
+        filter_clmsg_edate = args.filter_clmsg_edate+common.get_tzoffset_str() if getattr(args, 'filter_clmsg_edate', None) else None
         filter_clmsg_edate_b64 = convert.str2b64str(filter_clmsg_edate)
-        filter_clmsg_src_b64 = convert.str2b64str(args.filter_clmsg_src)
-        filter_clmsg_user_b64 = convert.str2b64str(args.filter_clmsg_user)
-        filter_clmsg_body_str = json.dumps(args.filter_clmsg_body, default=common.default_json_enc, ensure_ascii=False) if args.filter_clmsg_body else '{}'
+        filter_clmsg_src_b64 = convert.str2b64str(getattr(args, 'filter_clmsg_src', None))
+        filter_clmsg_title_b64 = convert.str2b64str(getattr(args, 'filter_clmsg_title', None))
+        filter_clmsg_user_b64 = convert.str2b64str(getattr(args, 'filter_clmsg_user', None))
+        filter_clmsg_body_str = json.dumps(args.filter_clmsg_body, default=common.default_json_enc, ensure_ascii=False) if getattr(args, 'filter_clmsg_body', None) else '{}'
         filter_clmsg_body_b64 = convert.str2b64str(filter_clmsg_body_str)
-        filter_clmsg_tag_str = json.dumps(args.filter_clmsg_tag, default=common.default_json_enc, ensure_ascii=False) if args.filter_clmsg_tag else '[]'
+        filter_clmsg_tag_str = json.dumps(args.filter_clmsg_tag, default=common.default_json_enc, ensure_ascii=False) if getattr(args, 'filter_clmsg_tag', None) else '[]'
         filter_clmsg_tag_b64 = convert.str2b64str(filter_clmsg_tag_str)
-        filter_svmsg_id_b64 = convert.str2b64str(args.filter_svmsg_id)
-        filter_svmsg_sdate_b64 = convert.str2b64str(args.filter_svmsg_sdate)
-        filter_svmsg_edate_b64 = convert.str2b64str(args.filter_svmsg_edate)
-        pg_enabled = args.pg_enabled
-        pg_host_b64 = convert.str2b64str(args.pg_host)
-        pg_port = args.pg_port if isinstance(args.pg_port, int) else None
-        pg_user_b64 = convert.str2b64str(args.pg_user)
-        pg_password_b64 = convert.str2b64str(args.pg_password)
-        pg_dbname_b64 = convert.str2b64str(args.pg_dbname)
+        filter_svmsg_id_b64 = convert.str2b64str(getattr(args, 'filter_svmsg_id', None))
+        filter_svmsg_sdate_b64 = convert.str2b64str(getattr(args, 'filter_svmsg_sdate', None))
+        filter_svmsg_edate_b64 = convert.str2b64str(getattr(args, 'filter_svmsg_edate', None))
+        pg_enabled = args.pg_enabled if getattr(args, 'pg_enabled', False) and isinstance(args.pg_enabled, bool) else False
+        pg_host_b64 = convert.str2b64str(getattr(args, 'pg_host', None))
+        pg_port = args.pg_port if getattr(args, 'pg_port', 5432) and isinstance(args.pg_port, int) else None
+        pg_user_b64 = convert.str2b64str(getattr(args, 'pg_user', None))
+        pg_password_b64 = convert.str2b64str(getattr(args, 'pg_password', None))
+        pg_dbname_b64 = convert.str2b64str(getattr(args, 'pg_dbname', None))
 
         cl = client.Client(logger, redis_host=args.host, redis_port=args.port, redis_password=args.password, svname=args.svname)
         ret = cl.redis_cli.send_cmd(self.get_svcmd(),
-                                    [select_b64, sort_b64, str(offset), str(limit),
+                                    [select_b64, select_date_format_b64, groupby_b64, groupby_date_format_b64,
+                                     sort_b64, str(offset), str(limit),
                                      filter_audit_type_b64, filter_clmsg_id_b64, filter_clmsg_sdate_b64, filter_clmsg_edate_b64,
-                                     filter_clmsg_src_b64, filter_clmsg_user_b64, filter_clmsg_body_b64, filter_clmsg_tag_b64, 
-                                     filter_svmsg_id_b64, filter_svmsg_sdate_b64, filter_svmsg_edate_b64,
+                                     filter_clmsg_src_b64, filter_clmsg_title_b64, filter_clmsg_user_b64, filter_clmsg_body_b64,
+                                     filter_clmsg_tag_b64, filter_svmsg_id_b64, filter_svmsg_sdate_b64, filter_svmsg_edate_b64,
                                      pg_enabled, pg_host_b64, pg_port, pg_user_b64, pg_password_b64, pg_dbname_b64],
                                     retry_count=args.retry_count, retry_interval=args.retry_interval, timeout=args.timeout)
-        common.print_format(ret, args.format, tm, None, False, pf=pf)
+        common.print_format(ret, getattr(args, 'format', False), tm, None, False, pf=pf)
 
         if 'success' not in ret:
             return 1, ret, cl
@@ -196,39 +216,44 @@ class AuditSearch(audit_base.AuditBase):
             int: 終了コード
         """
         select = json.loads(convert.b64str2str(msg[2]))
-        sort = json.loads(convert.b64str2str(msg[3]))
-        offset = int(msg[4]) if msg[4] else 0
-        limit = int(msg[5]) if msg[5] else 100
+        select_date_format = convert.b64str2str(msg[3])
+        groupby = json.loads(convert.b64str2str(msg[4]))
+        groupby_date_format = convert.b64str2str(msg[5])
+        sort = json.loads(convert.b64str2str(msg[6]))
+        offset = int(msg[7]) if msg[7] else 0
+        limit = int(msg[8]) if msg[8] else 100
         
-        filter_audit_type = convert.b64str2str(msg[6])
-        filter_clmsg_id = convert.b64str2str(msg[7])
-        filter_clmsg_sdate = convert.b64str2str(msg[8])
-        filter_clmsg_edate = convert.b64str2str(msg[9])
-        filter_clmsg_src = convert.b64str2str(msg[10])
-        filter_clmsg_user = convert.b64str2str(msg[11])
-        body = json.loads(convert.b64str2str(msg[12]))
-        tags = json.loads(convert.b64str2str(msg[13]))
-        filter_svmsg_id = convert.b64str2str(msg[14])
-        filter_svmsg_sdate = convert.b64str2str(msg[15])
-        filter_svmsg_edate = convert.b64str2str(msg[16])
-        pg_enabled = True if msg[17]=='True' else False
-        pg_host = convert.b64str2str(msg[18])
-        pg_port = int(msg[19]) if msg[19]!='None' else None
-        pg_user = convert.b64str2str(msg[20])
-        pg_password = convert.b64str2str(msg[21])
-        pg_dbname = convert.b64str2str(msg[22])
-        st = self.search(msg[1], select, sort, offset, limit,
+        filter_audit_type = convert.b64str2str(msg[9])
+        filter_clmsg_id = convert.b64str2str(msg[10])
+        filter_clmsg_sdate = convert.b64str2str(msg[11])
+        filter_clmsg_edate = convert.b64str2str(msg[12])
+        filter_clmsg_src = convert.b64str2str(msg[13])
+        filter_clmsg_title = convert.b64str2str(msg[14])
+        filter_clmsg_user = convert.b64str2str(msg[15])
+        body = json.loads(convert.b64str2str(msg[16]))
+        tags = json.loads(convert.b64str2str(msg[17]))
+        filter_svmsg_id = convert.b64str2str(msg[18])
+        filter_svmsg_sdate = convert.b64str2str(msg[19])
+        filter_svmsg_edate = convert.b64str2str(msg[20])
+        pg_enabled = True if msg[21]=='True' else False
+        pg_host = convert.b64str2str(msg[22])
+        pg_port = int(msg[23]) if msg[23]!='None' else None
+        pg_user = convert.b64str2str(msg[24])
+        pg_password = convert.b64str2str(msg[25])
+        pg_dbname = convert.b64str2str(msg[26])
+        st = self.search(msg[1], select, select_date_format, groupby, groupby_date_format,
+                         sort, offset, limit,
                          filter_audit_type, filter_clmsg_id, filter_clmsg_sdate, filter_clmsg_edate,
-                         filter_clmsg_src, filter_clmsg_user, body, tags,
+                         filter_clmsg_src, filter_clmsg_title, filter_clmsg_user, body, tags,
                          filter_svmsg_id, filter_svmsg_sdate, filter_svmsg_edate,
                          pg_enabled, pg_host, pg_port, pg_user, pg_password, pg_dbname,
                          data_dir, logger, redis_cli)
         return st
 
-    def search(self, reskey:str, select:List[str], sort:Dict[str, str], offset:int, limit:int,
+    def search(self, reskey:str, select:Dict[str, str], select_date_format:str, groupby:List[str], groupby_date_format:str, sort:Dict[str, str], offset:int, limit:int,
                filter_audit_type:str, filter_clmsg_id:str, filter_clmsg_sdate:str, filter_clmsg_edate:str,
-               filter_clmsg_src:str, filter_clmsg_user:str, filter_clmsg_body:Dict[str, Any], filter_clmsg_tags:List[str],
-               filter_svmsg_id:str, filter_svmsg_sdate:str, filter_svmsg_edate:str,
+               filter_clmsg_src:str, filter_clmsg_title:str, filter_clmsg_user:str, filter_clmsg_body:Dict[str, Any],
+               filter_clmsg_tags:List[str], filter_svmsg_id:str, filter_svmsg_sdate:str, filter_svmsg_edate:str,
                pg_enabled:bool, pg_host:str, pg_port:int, pg_user:str, pg_password:str, pg_dbname:str,
                data_dir:Path, logger:logging.Logger, redis_cli:redis_client.RedisClient) -> int:
         """
@@ -236,7 +261,10 @@ class AuditSearch(audit_base.AuditBase):
 
         Args:
             reskey (str): レスポンスキー
-            select (List[str]): 取得項目
+            select (Dict[str, str]): 取得項目
+            select_date_format (str): 取得項目の日時フォーマット
+            groupby (List[str]): グループ化項目
+            groupby_date_format (str): グループ化項目の日時フォーマット
             sort (Dict[str, str]): ソート条件
             offset (int): 取得する行の開始位置
             limit (int): 取得する行数
@@ -245,6 +273,7 @@ class AuditSearch(audit_base.AuditBase):
             filter_clmsg_sdate (str): クライアントメッセージ発生日時(開始)
             filter_clmsg_edate (str): クライアントメッセージ発生日時(終了)
             filter_clmsg_src (str): クライアントメッセージの発生源
+            filter_clmsg_title (str): クライアントメッセージのタイトル
             filter_clmsg_user (str): クライアントメッセージの発生させたユーザー
             filter_clmsg_body (Dict[str, Any]): クライアントメッセージの本文
             filter_clmsg_tags (List[str]): クライアントメッセージのタグ
@@ -264,6 +293,31 @@ class AuditSearch(audit_base.AuditBase):
         Returns:
             int: レスポンスコード
         """
+        def _date_format(pg_enabled, col, date_format):
+            if col not in ['clmsg_date', 'svmsg_date']:
+                return col
+            if pg_enabled:
+                if date_format == '%u':
+                    return f"to_char({col}, 'D')"
+                elif date_format == '%m':
+                    return f"to_char({col}, 'MM')"
+                elif date_format == '%Y':
+                    return f"to_char({col}, 'YYYY')"
+                elif date_format == '%Y/%m':
+                    return f"to_char({col}, 'YYYY/MM')"
+                elif date_format == '%Y/%m/%d':
+                    return f"to_char({col}, 'YYYY/MM/DD')"
+                elif date_format == '%Y/%m/%d %H':
+                    return f"to_char({col}, 'YYYY/MM/DD HH24')"
+                elif date_format == '%Y/%m/%d %H:%M':
+                    return f"to_char({col}, 'YYYY/MM/DD HH24:MI')"
+                else:
+                    return col
+            else:
+                if date_format is not None and date_format != '':
+                    return f"strftime('{date_format}', {col})"
+                else:
+                    return col
         try:
             with self.initdb(data_dir, logger, pg_enabled, pg_host, pg_port, pg_user, pg_password, pg_dbname) as conn:
                 def dict_factory(cursor, row):
@@ -271,17 +325,24 @@ class AuditSearch(audit_base.AuditBase):
                 conn.row_factory = dict_row if pg_enabled else dict_factory
                 cursor = conn.cursor()
                 try:
-                    select = select if select else ['audit_type', 'clmsg_id', 'clmsg_date', 'clmsg_src', 'clmsg_user', 'clmsg_body', 'clmsg_tag', 'svmsg_id', 'svmsg_date']
+                    select = {k:v for k,v in select.items() if k != ''} if select else None
+                    select = select if select and len(select)>0 else {k:'-' for k in self.TBL_COLS}
                     if pg_enabled:
                         toz = common.get_tzoffset_str()
-                        sel = []
-                        for s in select:
-                            if s in ['clmsg_date', 'svmsg_date']:
-                                sel.append(f"{s} AT TIME ZONE INTERVAL '{toz}' as {s}")
+                        sel = {}
+                        for k,v in select.items():
+                            if k in ['clmsg_date', 'svmsg_date']:
+                                sel[f"{k} AT TIME ZONE INTERVAL '{toz}' as {k}"] = v
                             else:
-                                sel.append(s)
+                                sel[k] = v
                         select = sel
-                    sql = f'SELECT {",".join(select)} FROM audit'
+                    sql = []
+                    for k,v in select.items():
+                        if v in ['count', 'sum', 'avg', 'min', 'max']:
+                            sql.append(f'{v}({_date_format(pg_enabled, k, select_date_format)}) AS {k}')
+                        else:
+                            sql.append(f'{_date_format(pg_enabled, k, select_date_format)} AS {k}')
+                    sql = f"SELECT {','.join(sql)} FROM audit"
                     params = []
                     where = []
                     if filter_audit_type and filter_audit_type != 'None':
@@ -299,6 +360,9 @@ class AuditSearch(audit_base.AuditBase):
                     if filter_clmsg_src and filter_clmsg_src != 'None':
                         where.append(f'clmsg_src LIKE {"%s" if pg_enabled else "?"}')
                         params.append(filter_clmsg_src)
+                    if filter_clmsg_title and filter_clmsg_title != 'None':
+                        where.append(f'clmsg_title LIKE {"%s" if pg_enabled else "?"}')
+                        params.append(filter_clmsg_title)
                     if filter_clmsg_user and filter_clmsg_user != 'None':
                         where.append(f'clmsg_user LIKE {"%s" if pg_enabled else "?"}')
                         params.append(filter_clmsg_user)
@@ -322,6 +386,8 @@ class AuditSearch(audit_base.AuditBase):
                         where.append(f'svmsg_date<={"%s" if pg_enabled else "?"}')
                         params.append(filter_svmsg_edate)
                     sql += ' WHERE ' + ' AND '.join(where) if len(where)>0 else ''
+                    if groupby and len(groupby) > 0:
+                        sql += ' GROUP BY ' + ', '.join([f"{_date_format(pg_enabled, g, groupby_date_format)}" for g in groupby])
                     if sort and len(sort) > 0:
                         sql += ' ORDER BY ' + ', '.join([f"{k} {v}" for k, v in sort.items()])
                     else:

cmdbox/app/features/cli/cmdbox_audit_write.py

@@ -53,6 +53,9 @@ class AuditWrite(audit_base.AuditBase):
             dict(opt="clmsg_src", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=None,
                  discription_ja="クライアントのメッセージの発生源を指定します。通常 `cmdbox.app.feature.Feature` を継承したクラス名を指定します。",
                  discription_en="Specifies the source of client messages. Usually specifies the name of a class that extends `cmdbox.app.feature.Feature` ."),
+            dict(opt="clmsg_title", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=None,
+                 discription_ja="クライアントのメッセージタイトルを指定します。通常コマンドタイトルを指定します。",
+                 discription_en="Specifies the client message title. Usually specifies the command title."),
             dict(opt="clmsg_user", type=Options.T_STR, default=None, required=False, multi=False, hide=False, choice=None,
                  discription_ja="クライアントのメッセージを発生させたユーザーを指定します。",
                  discription_en="SpecSpecifies the user who generated the client message."),
@@ -107,6 +110,7 @@ class AuditWrite(audit_base.AuditBase):
         clmsg_id_b64 = convert.str2b64str(args.clmsg_id)
         clmsg_date_b64 = convert.str2b64str(args.clmsg_date)
         clmsg_src_b64 = convert.str2b64str(args.clmsg_src) if args.clmsg_src is not None else ''
+        clmsg_title_b64 = convert.str2b64str(args.clmsg_title) if args.clmsg_title is not None else ''
         clmsg_user_b64 = convert.str2b64str(args.clmsg_user) if args.clmsg_user is not None else ''
         clmsg_body_str = json.dumps(args.clmsg_body, default=common.default_json_enc, ensure_ascii=False) if args.clmsg_body is not None else '{}'
         clmsg_body_b64 = convert.str2b64str(clmsg_body_str)
@@ -121,7 +125,7 @@ class AuditWrite(audit_base.AuditBase):
 
         cl = client.Client(logger, redis_host=args.host, redis_port=args.port, redis_password=args.password, svname=args.svname)
         cl.redis_cli.send_cmd(self.get_svcmd(),
-                              [audit_type_b64, clmsg_id_b64, clmsg_date_b64, clmsg_src_b64, clmsg_user_b64, clmsg_body_b64, clmsg_tag_b64,
+                              [audit_type_b64, clmsg_id_b64, clmsg_date_b64, clmsg_src_b64, clmsg_title_b64, clmsg_user_b64, clmsg_body_b64, clmsg_tag_b64,
                                pg_enabled, pg_host_b64, pg_port, pg_user_b64, pg_password_b64, pg_dbname_b64,
                                args.retention_period_days],
                               retry_count=args.retry_count, retry_interval=args.retry_interval, timeout=args.timeout, nowait=True)
@@ -157,24 +161,26 @@ class AuditWrite(audit_base.AuditBase):
         clmsg_id = convert.b64str2str(msg[3])
         clmsg_date = convert.b64str2str(msg[4])
         clmsg_src = convert.b64str2str(msg[5])
-        clmsg_user = convert.b64str2str(msg[6])
-        clmsg_body = convert.b64str2str(msg[7])
-        clmsg_tags = convert.b64str2str(msg[8])
-        pg_enabled = True if msg[9]=='True' else False
-        pg_host = convert.b64str2str(msg[10])
-        pg_port = int(msg[11]) if msg[11]!='None' else None
-        pg_user = convert.b64str2str(msg[12])
-        pg_password = convert.b64str2str(msg[13])
-        pg_dbname = convert.b64str2str(msg[14])
-        retention_period_days = int(msg[15]) if msg[15] != 'None' else None
+        clmsg_title = convert.b64str2str(msg[6])
+        clmsg_user = convert.b64str2str(msg[7])
+        clmsg_body = convert.b64str2str(msg[8])
+        clmsg_tags = convert.b64str2str(msg[9])
+        pg_enabled = True if msg[10]=='True' else False
+        pg_host = convert.b64str2str(msg[11])
+        pg_port = int(msg[12]) if msg[12]!='None' else None
+        pg_user = convert.b64str2str(msg[13])
+        pg_password = convert.b64str2str(msg[14])
+        pg_dbname = convert.b64str2str(msg[15])
+        retention_period_days = int(msg[16]) if msg[16] != 'None' else None
         svmsg_id = str(uuid.uuid4())
-        st = self.write(msg[1], audit_type, clmsg_id, clmsg_date, clmsg_src, clmsg_user, clmsg_body, clmsg_tags, svmsg_id,
+        st = self.write(msg[1], audit_type, clmsg_id, clmsg_date, clmsg_src, clmsg_title, clmsg_user, clmsg_body, clmsg_tags, svmsg_id,
                         pg_enabled, pg_host, pg_port, pg_user, pg_password, pg_dbname,
                         retention_period_days,
                         data_dir, logger, redis_cli)
         return st
 
-    def write(self, reskey:str, audit_type:str, clmsg_id:str, clmsg_date:str, clmsg_src:str, clmsg_user:str, clmsg_body:str, clmsg_tags:str, svmsg_id:str,
+    def write(self, reskey:str, audit_type:str, clmsg_id:str, clmsg_date:str, clmsg_src:str, clmsg_title:str,
+              clmsg_user:str, clmsg_body:str, clmsg_tags:str, svmsg_id:str,
               pg_enabled:bool, pg_host:str, pg_port:int, pg_user:str, pg_password:str, pg_dbname:str,
               retention_period_days:int,
               data_dir:Path, logger:logging.Logger, redis_cli:redis_client.RedisClient) -> int:
@@ -187,6 +193,7 @@ class AuditWrite(audit_base.AuditBase):
             clmsg_id (str): クライアントメッセージID
             clmsg_date (str): クライアントメッセージ発生日時
             clmsg_src (str): クライアントメッセージの発生源
+            clmsg_title (str): クライアントメッセージのタイトル
             clmsg_user (str): クライアントメッセージの発生させたユーザー
             clmsg_body (str): クライアントメッセージの本文
             clmsg_tags (str): クライアントメッセージのタグ
@@ -209,22 +216,22 @@ class AuditWrite(audit_base.AuditBase):
             with self.initdb(data_dir, logger, pg_enabled, pg_host, pg_port, pg_user, pg_password, pg_dbname) as conn:
                 cursor = conn.cursor()
                 try:
-                    clmsg_tags = json.dumps(clmsg_tags)
+                    svmsg_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S') + common.get_tzoffset_str()
                     if not pg_enabled:
                         cursor.execute('''
-                            INSERT INTO audit (audit_type, clmsg_id, clmsg_date, clmsg_src, clmsg_user, clmsg_body, clmsg_tag, 
+                            INSERT INTO audit (audit_type, clmsg_id, clmsg_date, clmsg_src, clmsg_title, clmsg_user, clmsg_body, clmsg_tag, 
                                             svmsg_id, svmsg_date)
-                            VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
-                        ''', (audit_type, clmsg_id, clmsg_date, clmsg_src, clmsg_user, clmsg_body, clmsg_tags, svmsg_id))
+                            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                        ''', (audit_type, clmsg_id, clmsg_date, clmsg_src, clmsg_title, clmsg_user, clmsg_body, clmsg_tags, svmsg_id, svmsg_date))
                         if retention_period_days is not None and retention_period_days > 0:
                             cursor.execute('DELETE FROM audit WHERE svmsg_date < datetime(CURRENT_TIMESTAMP, ?)',
                                            (f'-{retention_period_days} days',))
                     else:
                         cursor.execute('''
-                            INSERT INTO audit (audit_type, clmsg_id, clmsg_date, clmsg_src, clmsg_user, clmsg_body, clmsg_tag, 
+                            INSERT INTO audit (audit_type, clmsg_id, clmsg_date, clmsg_src, clmsg_title, clmsg_user, clmsg_body, clmsg_tag, 
                                             svmsg_id, svmsg_date)
-                            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, CURRENT_TIMESTAMP)
-                        ''', (audit_type, clmsg_id, clmsg_date, clmsg_src, clmsg_user, clmsg_body, clmsg_tags, svmsg_id))
+                            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+                        ''', (audit_type, clmsg_id, clmsg_date, clmsg_src, clmsg_title, clmsg_user, clmsg_body, clmsg_tags, svmsg_id, svmsg_date))
                         if retention_period_days is not None and retention_period_days > 0:
                             cursor.execute("DELETE FROM audit WHERE svmsg_date < CURRENT_TIMESTAMP + %s ",
                                            (f'-{retention_period_days} day',))

cmdbox/app/features/web/cmdbox_web_audit.py

@@ -0,0 +1,81 @@
+from cmdbox.app import common, feature
+from cmdbox.app.web import Web
+from fastapi import FastAPI, Request, Response
+from fastapi.responses import HTMLResponse
+from typing import Dict, Any
+import argparse
+import time
+
+
+class Audit(feature.WebFeature):
+
+    def route(self, web:Web, app:FastAPI) -> None:
+        """
+        webモードのルーティングを設定します
+
+        Args:
+            web (Web): Webオブジェクト
+            app (FastAPI): FastAPIオブジェクト
+        """
+        if web.audit_html is not None:
+            if not web.audit_html.is_file():
+                raise FileNotFoundError(f'audit_html is not found. ({web.audit_html})')
+            with open(web.audit_html, 'r', encoding='utf-8') as f:
+                web.audit_html_data = f.read()
+
+        @app.get('/audit', response_class=HTMLResponse)
+        @app.post('/audit', response_class=HTMLResponse)
+        async def audit(req:Request, res:Response):
+            signin = web.signin.check_signin(req, res)
+            if signin is not None:
+                return signin
+            res.headers['Access-Control-Allow-Origin'] = '*'
+            web.options.audit_exec(req, res, web)
+            return web.audit_html_data
+
+        @app.post('/audit/rawlog')
+        async def audit_rawlog(req:Request, res:Response):
+            signin = web.signin.check_signin(req, res)
+            if signin is not None:
+                return signin
+            if web.signin.get_data() is None:
+                return dict(error='signin_file_data is None.')
+            if not hasattr(web.options, 'audit_search') or web.options.audit_search is None:
+                raise dict(error='audit search feature is not found.')
+            opt = await req.json()
+            opt = {**opt, **web.options.audit_search_args.copy()}
+            args = argparse.Namespace(**{k:common.chopdq(v) for k,v in opt.items()})
+            status, ret_main, _ = web.options.audit_search.apprun(web.logger, args, time.perf_counter(), [])
+            if status != 0:
+                return dict(error=ret_main)
+            return ret_main
+
+        @app.get('/audit/mode_cmd')
+        async def audit_mode_cmd(req:Request, res:Response):
+            signin = web.signin.check_signin(req, res)
+            if signin is not None:
+                return signin
+            return dict(success=web.options.audit_search_args)
+
+    def toolmenu(self, web:Web) -> Dict[str, Any]:
+        """
+        ツールメニューの情報を返します
+
+        Args:
+            web (Web): Webオブジェクト
+        
+        Returns:
+            Dict[str, Any]: ツールメニュー情報
+        
+        Sample:
+            {
+                'filer': {
+                    'html': 'Filer',
+                    'href': 'filer',
+                    'target': '_blank',
+                    'css_class': 'dropdown-item'
+                    'onclick': 'alert("filer")'
+                }
+            }
+        """
+        return dict(audit=dict(html='Audit', href='audit', target='_blank', css_class='dropdown-item'))