linkkf 로직수정중

lib/plugin/__init__.py

@@ -1,5 +1,6 @@
 # 순서 바꾸지 말 것
-import os, sys, traceback, re, threading, time, queue
+import os, sys, traceback, re, threading, time, queue, json, shutil, yaml
+import requests
 from datetime import datetime, timedelta
 from flask import Blueprint, render_template, jsonify, redirect, request
 from sqlalchemy import desc, or_

lib/plugin/_ffmpeg_queue.py

@@ -94,8 +94,8 @@ class FfmpegQueue(object):
                 self.download_thread = threading.Thread(target=self.download_thread_function, args=())
                 self.download_thread.daemon = True  
                 self.download_thread.start()
-        except Exception as exception: 
-            self.P.logger.error('Exception:%s', exception)
+        except Exception as e: 
+            self.P.logger.error(f"Exception:{str(e)}")
             self.P.logger.error(traceback.format_exc())
 
 
@@ -107,8 +107,8 @@ class FfmpegQueue(object):
                         if self.current_ffmpeg_count < self.max_ffmpeg_count:
                             break
                         time.sleep(5)
-                    except Exception as exception: 
-                        self.P.logger.error('Exception:%s', exception)
+                    except Exception as e: 
+                        self.P.logger.error(f"Exception:{str(e)}")
                         self.P.logger.error(traceback.format_exc())
                         self.P.logger.error('current_ffmpeg_count : %s', self.current_ffmpeg_count)
                         self.P.logger.error('max_ffmpeg_count : %s', self.max_ffmpeg_count)
@@ -153,8 +153,8 @@ class FfmpegQueue(object):
                 f.start()
                 self.current_ffmpeg_count += 1
                 self.download_queue.task_done()    
-            except Exception as exception: 
-                self.P.logger.error('Exception:%s', exception)
+            except Exception as e: 
+                self.P.logger.error(f"Exception:{str(e)}")
                 self.P.logger.error(traceback.format_exc())
 
     def ffmpeg_listener(self, **arg):
@@ -203,8 +203,8 @@ class FfmpegQueue(object):
             self.entity_list.append(entity)
             self.download_queue.put(entity)
             return True
-        except Exception as exception:
-            self.P.logger.error('Exception:%s', exception)
+        except Exception as e:
+            self.P.logger.error(f"Exception:{str(e)}")
             self.P.logger.error(traceback.format_exc())
         return False
 
@@ -270,8 +270,8 @@ class FfmpegQueue(object):
                 self.entity_list = new_list
                 ret['ret'] = 'refresh'  
             return ret
-        except Exception as exception:
-            self.P.logger.error('Exception:%s', exception)
+        except Exception as e:
+            self.P.logger.error(f"Exception:{str(e)}")
             self.P.logger.error(traceback.format_exc())
 
 

lib/plugin/create_plugin.py

@@ -8,6 +8,8 @@ from support import SupportYaml
 from . import (Logic, default_route, default_route_single_module,
                get_model_setting)
 
+from loguru import logger as logger1
+
 
 class PluginBase(object):
     package_name = None
@@ -52,6 +54,7 @@ class PluginBase(object):
             self.home_module = setting.get('home_module')
             self.status = "init_success"
             self.config = {}
+            self.recent_menu_plugin_except_list = setting.get('recent_menu_plugin_except_list', [])
         except Exception as e: 
             self.logger.error(f'Exception:{str(e)}')
             self.logger.error(traceback.format_exc())
@@ -59,10 +62,16 @@ class PluginBase(object):
 
     def set_module_list(self, mod_list):
         try:
+            # self.module_list = []
             for mod in mod_list:
+                logger1.debug(mod)
                 mod_ins = mod(self)
+                # self.logger.debug(mod_ins)
+                logger1.debug(mod_ins)
                 self.module_list.append(mod_ins)
-            
+
+            if self.home_module == None:
+                self.home_module = self.module_list[0].name
         except Exception as e:
             F.logger.error(f'[{self.package_name}] Exception:{str(e)}')
             F.logger.error(traceback.format_exc())
@@ -77,16 +86,31 @@ class PluginBase(object):
 
 
     def plugin_load(self):
-        self.logic.plugin_load()
+        if self.logic:
+            self.logic.plugin_load()
+    
+    def plugin_load_celery(self):
+        if self.logic:
+            self.logic.plugin_load_celery()
+
     
     def plugin_unload(self):
-        self.logic.plugin_unload()
+        if self.logic:
+            self.logic.plugin_unload()
 
     def get_first_manual_path(self):
         for __ in self.menu['list']:
             if __['uri'] == 'manual' and len(__['list']) > 0:
                 return __['list'][0]['uri']
 
+    def get_module(self, sub):
+        try:
+            for module in self.module_list:
+                if module.name == sub:
+                    return module
+        except Exception as e:
+            self.logger.error(f'Exception:{str(e)}')
+            #self.P.logger.error(traceback.format_exc())
 
 def create_plugin_instance(config):
     ins = PluginBase(config)

lib/plugin/logic.py

@@ -32,14 +32,39 @@ class Logic(object):
         if self.P.ModelSetting is not None:
             for module in self.P.module_list:
                 key = f'{module.name}_auto_start'
-                if self.P.ModelSetting.has_key(key) and self.P.ModelSetting.get_bool(key):
+                key2 = f'{module.name}_interval'
+                if self.P.ModelSetting.has_key(key) and self.P.ModelSetting.get_bool(key) and self.P.ModelSetting.has_key(key2):
                     self.scheduler_start(module.name)
+                
                 if module.page_list is not None:
                     for page_instance in module.page_list:
                         key = f'{module.name}_{page_instance.name}_auto_start'
                         if self.P.ModelSetting.has_key(key) and self.P.ModelSetting.get_bool(key):
                             self.scheduler_start_sub(module.name, page_instance.name)
 
+                key1 = f'{module.name}_db_auto_delete'
+                key2 = f'{module.name}_db_delete_day'
+                if self.P.ModelSetting.has_key(key1) and self.P.ModelSetting.has_key(key2) and self.P.ModelSetting.get_bool(key1):
+                    try: module.db_delete(self.P.ModelSetting.get_int(key2))
+                    except: pass
+                if module.page_list == None:
+                    continue
+                for page_instance in module.page_list:
+                    key1 = f'{module.name}_{page_instance.name}_db_auto_delete'
+                    key2 = f'{module.name}_{page_instance.name}_db_delete_day'
+                    if self.P.ModelSetting.has_key(key1) and self.P.ModelSetting.has_key(key2) and self.P.ModelSetting.get_bool(key1):
+                        try: page_instance.db_delete(self.P.ModelSetting.get_int(key2))
+                        except: pass
+
+    def plugin_load_celery(self):
+        self.P.logger.debug('%s plugin_load_celery', self.P.package_name)
+        for module in self.P.module_list:
+            module.plugin_load_celery()
+            if module.page_list is not None:
+                for page_instance in module.page_list:
+                    page_instance.plugin_load_celery()
+
+
 
     def db_init(self):
         try:
@@ -88,7 +113,7 @@ class Logic(object):
         try:
             job_id = '%s_%s' % (self.P.package_name, module_name)
             module = self.get_module(module_name)
-            job = Job(self.P.package_name, job_id, module.get_scheduler_interval(), self.scheduler_function, module.get_scheduler_desc(), args=module_name)
+            job = Job(self.P.package_name, job_id, module.get_scheduler_interval(), self.scheduler_function, module.get_scheduler_desc(), args=(module_name,))
             F.scheduler.add_job_instance(job)
         except Exception as e: 
             self.P.logger.error(f'Exception:{str(e)}')
@@ -112,15 +137,25 @@ class Logic(object):
             self.P.logger.error(f'Exception:{str(e)}')
             self.P.logger.error(traceback.format_exc())
 
-    def reset_db(self, module_name):
+   
+    def db_delete(self, module_name, page_name, day):
         try:
             module = self.get_module(module_name)
-            return module.reset_db()
+            if module == None:
+                return False
+            if page_name != None:
+                page = module.get_page(page_name)
+                if page != None:
+                    return page.db_delete(day)
+            else:
+                return module.db_delete(day)
         except Exception as e: 
             self.P.logger.error(f'Exception:{str(e)}')
             self.P.logger.error(traceback.format_exc())
 
 
+    
+
     def one_execute(self, module_name):
         self.P.logger.debug('one_execute :%s', module_name)
         try:
@@ -166,6 +201,7 @@ class Logic(object):
             self.P.logger.error(f'Exception:{str(e)}')
             self.P.logger.error(traceback.format_exc())
 
+    """
     def process_telegram_data(self, data, target=None):
         try:
             for module in self.P.module_list:
@@ -174,7 +210,7 @@ class Logic(object):
         except Exception as e:
             self.P.logger.error(f'Exception:{str(e)}')
             self.P.logger.error(traceback.format_exc())
-
+    """
 
 
 
@@ -303,12 +339,23 @@ class Logic(object):
 
 
     def arg_to_dict(self, arg):
+        """
         import urllib.parse
 
         tmp = urllib.parse.unquote(arg)
         tmps = tmp.split('&')
         ret = {}
         for tmp in tmps:
-            _ = tmp.split('=')
+            _ = tmp.split('=', 1)
             ret[_[0]] = _[1]
         return ret
+        """
+        import html
+        import urllib.parse
+        char = '||!||'
+        arg = arg.replace('&', char)
+        tmp = html.unescape(arg)
+        tmp = urllib.parse.unquote(tmp)
+        tmp = dict(urllib.parse.parse_qs(tmp, keep_blank_values=True))
+        ret = {k: v[0].replace(char, '&') for k, v in tmp.items()}
+        return ret

lib/plugin/logic_module_base.py

@@ -39,6 +39,8 @@ class PluginModuleBase(object):
     
     def get_page(self, page_name):
         try:
+            if self.page_list == None:
+                return
             for page in self.page_list:
                 if page_name == page.name:
                     return page
@@ -48,10 +50,22 @@ class PluginModuleBase(object):
 
 
     def process_menu(self, page, req):
-        if self.page_list is not None:
-            page_ins = self.get_page(page)
-            if page_ins != None:
-                return page_ins.process_menu(req)
+        from framework import F
+        
+        try:
+            if self.page_list is not None:
+                page_ins = self.get_page(page)
+                if page_ins != None:
+                    return page_ins.process_menu(req)
+
+            arg = self.P.ModelSetting.to_dict() if self.P.ModelSetting != None else {}
+            arg['path_data'] = F.config['path_data']
+            arg['is_include'] = F.scheduler.is_include(self.get_scheduler_name())
+            arg['is_running'] = F.scheduler.is_running(self.get_scheduler_name())
+            return render_template(f'{self.P.package_name}_{self.name}_{page}.html', arg=arg)
+        except Exception as e:
+            self.P.logger.error(f'Exception:{str(e)}')
+            self.P.logger.error(traceback.format_exc())
         return render_template('sample.html', title=f"PluginModuleBase-process_menu{self.P.package_name}/{self.name}/{page}")
 
     def process_ajax(self, sub, req):
@@ -69,12 +83,18 @@ class PluginModuleBase(object):
     def scheduler_function(self):
         pass
 
-    def reset_db(self):
-        pass
+    def db_delete(self, day):
+        if self.web_list_model != None:
+            return self.web_list_model.delete_all(day)
+
 
     def plugin_load(self):
         pass
     
+    def plugin_load_celery(self):
+        pass
+
+
     def plugin_unload(self):
         pass
     
@@ -115,12 +135,37 @@ class PluginModuleBase(object):
         pass
 
 
+    def arg_to_dict(self, arg):
+        return self.P.logic.arg_to_dict(arg)
+
+    def get_scheduler_name(self):
+        return f'{self.P.package_name}_{self.name}'
 
 
+    def process_discord_data(self, data):
+        pass
 
-
-
-
+    
+    def start_celery(self, func, on_message=None, *args, page=None):
+        from framework import F
+        if F.config['use_celery']:
+            result = func.apply_async(args)
+            try:
+                if on_message != None:
+                    ret = result.get(on_message=on_message, propagate=True)
+                else:
+                    ret = result.get()
+            except:
+                ret = result.get()
+        else:
+            if on_message == None:
+                ret = func(*args)
+            else:
+                if page == None:
+                    ret = func(self, *args)
+                else:
+                    ret = func(page, *args)
+        return ret
 
 
 
@@ -153,7 +198,8 @@ class PluginPageBase(object):
                 arg = self.P.ModelSetting.to_dict()
             return render_template(f'{self.P.package_name}_{self.parent.name}_{self.name}.html', arg=arg)
         except Exception as e:
-            pass
+            self.P.logger.error(f'Exception:{str(e)}')
+            self.P.logger.error(traceback.format_exc())
             
         return render_template('sample.html', title=f"PluginPageBase-process_menu --- {self.P.package_name}/{self.parent.name}/{self.name}")
 
@@ -176,6 +222,9 @@ class PluginPageBase(object):
     def plugin_load(self):
         pass
     
+    def plugin_load_celery(self):
+        pass
+    
     # logic
     def plugin_unload(self):
         pass
@@ -207,3 +256,41 @@ class PluginPageBase(object):
         pass
 
 
+    def arg_to_dict(self, arg):
+        return self.P.logic.arg_to_dict(arg)
+
+
+    def get_page(self, page_name):
+        return self.parent.get_page(page_name)
+
+
+    def get_module(self, module_name):
+        return self.parent.get_module(module_name)
+
+    def process_discord_data(self, data):
+        pass
+    
+    def db_delete(self, day):
+        if self.web_list_model != None:
+            return self.web_list_model.delete_all(day)
+    
+
+    def start_celery(self, func, on_message, *args):
+        return self.parent.start_celery(func, on_message, *args, page=self)
+    
+    """
+    def start_celery(self, func, on_message=None, *args):
+        from framework import F
+        if F.config['use_celery']:
+            result = func.apply_async(args)
+            try:
+                if on_message != None:
+                    ret = result.get(on_message=on_message, propagate=True)
+                else:
+                    ret = result.get()
+            except:
+                ret = result.get()
+        else:
+            ret = func(*args)
+        return ret
+    """

lib/plugin/model_base.py

@@ -1,3 +1,4 @@
+import sqlite3
 import traceback
 from datetime import datetime, timedelta
 
@@ -45,7 +46,7 @@ class ModelBase(F.db.Model):
                 paging['next_page'] = False
             paging['current_page'] = current_page
             paging['count'] = count
-            F.logger.debug('paging : c:%s %s %s %s %s %s', count, paging['total_page'], paging['prev_page'], paging['next_page'] , paging['start_page'], paging['last_page'])
+            #F.logger.debug('paging : c:%s %s %s %s %s %s', count, paging['total_page'], paging['prev_page'], paging['next_page'] , paging['start_page'], paging['last_page'])
             return paging
         except Exception as e:
             cls.P.logger.error(f'Exception:{str(e)}')
@@ -89,24 +90,30 @@ class ModelBase(F.db.Model):
         return False
 
     @classmethod
-    def delete_all(cls, days=None):
+    def delete_all(cls, day=None):
+        count = -1
         try:
             with F.app.app_context():
-                if days == None:
-                    F.db.session.query(cls).delete()
-                    F.db.session.commit()
+                if day == None or day in [0, '0']:
+                    count = F.db.session.query(cls).delete()
                 else:
                     now = datetime.now()
-                    ago = now - timedelta(days=int(days))
+                    ago = now - timedelta(days=int(day))
                     #ago.hour = 0
                     #ago.minute = 0
-                    count = F.db.session.query(cls).filter(cls.created_time > ago).delete()
-                    cls.P.logger.info(f"delete_all {days=} {count=}")
-                return True
+                    count = F.db.session.query(cls).filter(cls.created_time < ago).delete()
+                    cls.P.logger.info(f"delete_all {day=} {count=}")
+                F.db.session.commit()
+               
+                db_file = F.app.config['SQLALCHEMY_BINDS'][cls.P.package_name].replace('sqlite:///', '').split('?')[0]
+                connection = sqlite3.connect(db_file)
+                cursor = connection.cursor()
+                cursor.execute('VACUUM;')
+                connection.close()
         except Exception as e:
             cls.P.logger.error(f'Exception:{str(e)}')
             cls.P.logger.error(traceback.format_exc())
-        return False
+        return count
     
 
     @classmethod
@@ -135,12 +142,12 @@ class ModelBase(F.db.Model):
                 if cls.P.ModelSetting is not None and cls.__tablename__ is not None:
                     cls.P.ModelSetting.set(f'{cls.__tablename__}_last_list_option', f'{order}|{page}|{search}|{option1}|{option2}')
             except Exception as e:
-                F.logger.error('Exception:%s', e)
+                F.logger.error(f"Exception:{str(e)}")
                 F.logger.error(traceback.format_exc())
                 F.logger.error(f'{cls.__tablename__}_last_list_option ERROR!' )
             return ret
         except Exception as e:
-            cls.P.logger.error('Exception:%s', e)
+            cls.P.logger.error(f"Exception:{str(e)}")
             cls.P.logger.error(traceback.format_exc())
 
 
@@ -149,6 +156,10 @@ class ModelBase(F.db.Model):
     def make_query(cls, req, order='desc', search='', option1='all', option2='all'):
         with F.app.app_context():
             query = F.db.session.query(cls)
+            if order == 'desc':
+                query = query.order_by(desc(cls.id))
+            else:
+                query = query.order_by(cls.id)
             return query 
         
     
@@ -171,3 +182,16 @@ class ModelBase(F.db.Model):
                 query = query.filter(field.like('%'+search+'%'))
             #query = query1.union(query2)
         return query
+
+
+    @classmethod
+    def get_list_by_status(cls, status):
+        try:
+            with F.app.app_context():
+                query = F.db.session.query(cls).filter(
+                    cls.status == status,
+                )
+                query = query.order_by(cls.id)
+                return query.all()
+        except:
+            pass

lib/plugin/model_setting.py

@@ -107,6 +107,8 @@ def get_model_setting(package_name, logger, table_name=None):
                     if ModelSetting.get(key) != value:
                         change_list.append(key)
                         entity = F.db.session.query(ModelSetting).filter_by(key=key).with_for_update().first()
+                        if entity == None:
+                            logger.warning(f"NOT exist setting key: {key}")
                         entity.value = value
                 F.db.session.commit()
                 return True, change_list 
@@ -117,7 +119,8 @@ def get_model_setting(package_name, logger, table_name=None):
                 return False, []
 
         @staticmethod
-        def get_list(key, delimeter='\n', comment=' #'):
+        def get_list(key, delimeter='\n', comment='#'):
+            value = None
             try:
                 value = ModelSetting.get(key).replace('\n', delimeter)
                 if comment is None:

lib/plugin/route.py

@@ -27,7 +27,12 @@ def default_route(P):
     def first_menu(sub):
         try:
             if P.ModelSetting is not None and (P.package_name == 'system' and sub != 'home'):
-                P.ModelSetting.set('recent_menu_plugin', '{}'.format(sub))
+                current_menu = sub
+                for except_menu in P.recent_menu_plugin_except_list:
+                    if current_menu.startswith(except_menu) or current_menu == except_menu:
+                        break
+                else:
+                    P.ModelSetting.set('recent_menu_plugin', current_menu)
             for module in P.module_list:
                 if sub == module.name:
                     first_menu =  module.get_first_menu()
@@ -45,8 +50,8 @@ def default_route(P):
                     return redirect(f"/{P.package_name}/manual/{P.get_first_manual_path()}")
                     
             return render_template('sample.html', title='%s - %s' % (P.package_name, sub))
-        except Exception as exception:
-            P.logger.error('Exception:%s', exception)
+        except Exception as e:
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())
     
     @P.blueprint.route('/manual/<path:path>', methods=['GET', 'POST'])
@@ -57,16 +62,43 @@ def default_route(P):
             filepath = os.path.join(plugin_root,  *path.split('/'))
             from support import SupportFile
             data = SupportFile.read_file(filepath)
+            if filepath.endswith('.mdf'):
+                try:
+                    from support import SupportSC
+                    data = SupportSC.decode(data)
+                except:
+                    pass
             return render_template('manual.html', data=data)
-        except Exception as exception:
-            P.logger.error('Exception:%s', exception)
+        except Exception as e:
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())
+    
+    @P.blueprint.route('/<module_name>/manual/<path:path>', methods=['GET', 'POST'])
+    @login_required
+    def module_manual(module_name, path):
+        try:
+            plugin_root = os.path.dirname(P.blueprint.template_folder)
+            filepath = os.path.join(plugin_root,  *path.split('/'))
+            from support import SupportFile
+            data = SupportFile.read_file(filepath)
+            return render_template('manual.html', data=data)
+        except Exception as e:
+            P.logger.error(f"Exception:{str(e)}")
+            P.logger.error(traceback.format_exc())
+
 
     @P.blueprint.route('/<sub>/<sub2>', methods=['GET', 'POST'])
     @login_required
     def second_menu(sub, sub2):
+        if sub2 == 'null':
+            return
         if P.ModelSetting is not None:
-            P.ModelSetting.set('recent_menu_plugin', '{}|{}'.format(sub, sub2))
+            current_menu = f"{sub}|{sub2}"
+            for except_menu in P.recent_menu_plugin_except_list:
+                if current_menu.startswith(except_menu) or current_menu == except_menu:
+                    break
+            else:
+                P.ModelSetting.set('recent_menu_plugin', current_menu)
         try:
             for module in P.module_list:
                 if sub == module.name:
@@ -74,8 +106,8 @@ def default_route(P):
             if sub == 'log':
                 return render_template('log.html', package=P.package_name)
             return render_template('sample.html', title='%s - %s' % (P.package_name, sub))
-        except Exception as exception:
-            P.logger.error('Exception:%s', exception)
+        except Exception as e:
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())
 
     #########################################################
@@ -84,7 +116,7 @@ def default_route(P):
     @P.blueprint.route('/ajax/<sub>', methods=['GET', 'POST'])
     @login_required
     def ajax(sub):
-        P.logger.debug('AJAX %s %s', P.package_name, sub)
+        #P.logger.debug('AJAX %s %s', P.package_name, sub)
         try:
             # global
             if sub == 'setting_save':
@@ -93,8 +125,8 @@ def default_route(P):
                     module.setting_save_after(change_list)
                 return jsonify(ret)
             
-        except Exception as exception: 
-            P.logger.error('Exception:%s', exception)
+        except Exception as e: 
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())  
 
     @P.blueprint.route('/ajax/<module_name>/<cmd>', methods=['GET', 'POST'])
@@ -109,8 +141,9 @@ def default_route(P):
                     else:
                         P.logic.scheduler_stop(module_name)
                     return jsonify(go)
-                elif cmd == 'reset_db':
-                    ret = P.logic.reset_db(module_name)
+                elif cmd == 'db_delete':
+                    day = request.form['day']
+                    ret = P.logic.db_delete(module_name, None, day)
                     return jsonify(ret)
                 elif cmd == 'one_execute':
                     ret = P.logic.one_execute(module_name)
@@ -118,18 +151,25 @@ def default_route(P):
                 elif cmd == 'immediately_execute':
                     ret = P.logic.immediately_execute(module_name)
                     return jsonify(ret)
-                elif cmd == 'web_list':
-                    model = P.logic.get_module(module_name).web_list_model
-                    if model != None:
-                        return jsonify(model.web_list(request))
+                
                     
                 if module_name == module.name:
                     if cmd == 'command':
                         return module.process_command(request.form['command'], request.form.get('arg1'), request.form.get('arg2'), request.form.get('arg3'), request)
+                    elif cmd == 'web_list':
+                        model = P.logic.get_module(module_name).web_list_model
+                        if model != None:
+                            return jsonify(model.web_list(request))
+                    elif cmd == 'db_delete_item':
+                        db_id = request.form['db_id']
+                        ret = False
+                        if module.web_list_model != None:
+                            ret = module.web_list_model.delete_by_id(db_id)
+                        return jsonify(ret)
                     else:
                         return module.process_ajax(cmd, request)
-        except Exception as exception: 
-            P.logger.error('Exception:%s', exception)
+        except Exception as e: 
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())
 
     @P.blueprint.route('/ajax/<module_name>/<page_name>/<command>', methods=['GET', 'POST'])
@@ -148,10 +188,10 @@ def default_route(P):
                     else:
                         P.logic.scheduler_stop_sub(module_name, page_name)
                     return jsonify(go)
-                #elif command == 'reset_db':
-                #    sub = request.form['sub']
-                #    ret = P.logic.reset_db(sub)
-                #    return jsonify(ret)
+                elif command == 'db_delete':
+                    day = request.form['day']
+                    ret = P.logic.db_delete(module_name, page_name, day)
+                    return jsonify(ret)
                 elif command == 'one_execute':
                     ret = P.logic.one_execute_sub(module_name, page_name)
                     return jsonify(ret)
@@ -160,25 +200,30 @@ def default_route(P):
                     return jsonify(ret)
                 elif command == 'command':
                     return ins_page.process_command(request.form['command'], request.form.get('arg1'), request.form.get('arg2'), request.form.get('arg3'), request)
+                elif command == 'db_delete_item':
+                    db_id = request.form['db_id']
+                    ret = False
+                    if ins_page.web_list_model != None:
+                        ret = ins_page.web_list_model.delete_by_id(db_id)
+                    return jsonify(ret)
                 else:
                     return ins_page.process_ajax(command, request)
             P.logger.error(f"not process ajax : {P.package_name} {module_name} {page_name} {command}")
-        except Exception as exception: 
-            P.logger.error('Exception:%s', exception)
+        except Exception as e: 
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())
 
     #########################################################
     # API - 외부
     #########################################################
     # 단일 모듈인 경우 모듈이름을 붙이기 불편하여 추가.
-    @P.blueprint.route('/api/<sub2>', methods=['GET', 'POST'])
+    @P.blueprint.route('/api/<sub>', methods=['GET', 'POST'])
     @F.check_api
-    def api_first(sub2):
+    def api_first(sub):
         try:
-            for module in P.module_list:
-                return module.process_api(sub2, request)
-        except Exception as exception: 
-            P.logger.error('Exception:%s', exception)
+            return P.module_list[0].process_api(sub, request)
+        except Exception as e: 
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())
 
     @P.blueprint.route('/api/<sub>/<sub2>', methods=['GET', 'POST'])
@@ -188,8 +233,16 @@ def default_route(P):
             for module in P.module_list:
                 if sub == module.name:
                     return module.process_api(sub2, request)
-        except Exception as exception: 
-            P.logger.error('Exception:%s', exception)
+        except Exception as e: 
+            P.logger.error(f"Exception:{str(e)}")
+            P.logger.error(traceback.format_exc())
+
+    @P.blueprint.route('/normal/<sub>', methods=['GET', 'POST'])
+    def normal_first(sub):
+        try:
+            return P.module_list[0].process_normal(sub, request)
+        except Exception as e: 
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())
 
     @P.blueprint.route('/normal/<sub>/<sub2>', methods=['GET', 'POST'])
@@ -198,13 +251,13 @@ def default_route(P):
             for module in P.module_list:
                 if sub == module.name:
                     return module.process_normal(sub2, request)
-        except Exception as exception: 
-            P.logger.error('Exception:%s', exception)
+        except Exception as e: 
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())
 
 
 
-
+    # default_route 끝
 
 
 
@@ -266,18 +319,14 @@ def default_route_single_module(P):
                 else:
                     P.logic.scheduler_stop(sub)
                 return jsonify(go)
-            elif sub == 'reset_db':
-                sub = request.form['sub']
-                ret = P.logic.reset_db(sub)
-                return jsonify(ret)
             elif sub == 'one_execute':
                 sub = request.form['sub']
                 ret = P.logic.one_execute(sub)
                 return jsonify(ret)
             else:
                 return P.module_list[0].process_ajax(sub, request)
-        except Exception as exception: 
-            P.logger.error('Exception:%s', exception)
+        except Exception as e: 
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())  
 
     @P.blueprint.route('/api/<sub>', methods=['GET', 'POST'])
@@ -285,16 +334,16 @@ def default_route_single_module(P):
     def api(sub):
         try:
             return P.module_list[0].process_api(sub, request)
-        except Exception as exception: 
-            P.logger.error('Exception:%s', exception)
+        except Exception as e: 
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())
 
     @P.blueprint.route('/normal/<sub>', methods=['GET', 'POST'])
     def normal(sub):
         try:
             return P.module_list[0].process_normal(sub, request)
-        except Exception as exception: 
-            P.logger.error('Exception:%s', exception)
+        except Exception as e: 
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())    
 
 
@@ -330,14 +379,15 @@ def default_route_socketio_module(module, attach=''):
         module.socketio_list = []
 
     @F.socketio.on('connect', namespace=f'/{P.package_name}/{module.name}{attach}')
+    @F.login_required
     def connect():
         try:
             P.logger.debug(f'socket_connect : {P.package_name} - {module.name}{attach}')
             module.socketio_list.append(request.sid)
             socketio_callback('start', '')
             module.socketio_connect()
-        except Exception as exception: 
-            P.logger.error('Exception:%s', exception)
+        except Exception as e: 
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())
 
 
@@ -347,8 +397,8 @@ def default_route_socketio_module(module, attach=''):
             P.logger.debug(f'socket_disconnect : {P.package_name} - {module.name}{attach}')
             module.socketio_list.remove(request.sid)
             module.socketio_disconnect()
-        except Exception as exception: 
-            P.logger.error('Exception:%s', exception)
+        except Exception as e: 
+            P.logger.error(f"Exception:{str(e)}")
             P.logger.error(traceback.format_exc())
 
 
@@ -357,7 +407,7 @@ def default_route_socketio_module(module, attach=''):
             if encoding:
                 data = json.dumps(data, cls=AlchemyEncoder)
                 data = json.loads(data)
-            F.socketio.emit(cmd, data, namespace=f'/{P.package_name}/{module.name}{attach}', broadcast=True)
+            F.socketio.emit(cmd, data, namespace=f'/{P.package_name}/{module.name}{attach}')
 
     module.socketio_callback = socketio_callback
 
@@ -392,9 +442,10 @@ def default_route_socketio_page(page):
         page.socketio_list = []
 
     @F.socketio.on('connect', namespace=f'/{P.package_name}/{module.name}/{page.name}')
+    @F.login_required
     def page_socketio_connect():
         try:
-            P.logger.debug(f'socket_connect : {P.package_name}/{module.name}/{page.name}')
+            #P.logger.debug(f'socket_connect : {P.package_name}/{module.name}/{page.name}')
             page.socketio_list.append(request.sid)
             page_socketio_socketio_callback('start', '')
         except Exception as e: 
@@ -405,7 +456,7 @@ def default_route_socketio_page(page):
     @F.socketio.on('disconnect', namespace=f'/{P.package_name}/{module.name}/{page.name}')
     def page_socketio_disconnect():
         try:
-            P.logger.debug(f'socket_disconnect : {P.package_name}/{module.name}/{page.name}')
+            #P.logger.debug(f'socket_disconnect : {P.package_name}/{module.name}/{page.name}')
             page.socketio_list.remove(request.sid)
         except Exception as e: 
             P.logger.error(f'Exception:{str(e)}')
@@ -417,6 +468,6 @@ def default_route_socketio_page(page):
             if encoding:
                 data = json.dumps(data, cls=AlchemyEncoder)
                 data = json.loads(data)
-            F.socketio.emit(cmd, data, namespace=f'/{P.package_name}/{module.name}/{page.name}', broadcast=True)
+            F.socketio.emit(cmd, data, namespace=f'/{P.package_name}/{module.name}/{page.name}')
 
     page.socketio_callback = page_socketio_socketio_callback