Merge pull request #2137 from openNAMU/dev

Dev

app.py

@@ -547,9 +547,8 @@ app.route('/revert/<int:num>/<everything:name>', methods = ['POST', 'GET'])(edit
 app.route('/move/<everything:name>', methods = ['POST', 'GET'])(edit_move)
 
 # Func-topic
-app.route('/recent_discuss', defaults = { 'tool' : 'normal' })(recent_discuss)
-app.route('/recent_discuss/close', defaults = { 'tool' : 'close' })(recent_discuss)
-app.route('/recent_discuss/open', defaults = { 'tool' : 'open' })(recent_discuss)
+app.route('/recent_discuss', defaults = { 'tool' : 'normal' })(list_recent_discuss)
+app.route('/recent_discuss/<tool>')(list_recent_discuss)
 
 app.route('/thread/<int:topic_num>', methods = ['POST', 'GET'])(topic)
 app.route('/thread/0/<everything:doc_name>', defaults = { 'topic_num' : '0' }, methods = ['POST', 'GET'])(topic)
@@ -703,19 +702,19 @@ app.route('/api/search_page/<int:num>/<everything:name>', defaults = { 'db_set'
 app.route('/api/search_data/<everything:name>', defaults = { 'search_type' : 'data', 'db_set' : db_set_str })(api_search)
 app.route('/api/search_data_page/<int:num>/<everything:name>', defaults = { 'search_type' : 'data', 'db_set' : db_set_str })(api_search)
 
-app.route('/api/recent_change', defaults = { 'db_set' : db_set_str })(api_recent_change)
-app.route('/api/recent_changes', defaults = { 'db_set' : db_set_str })(api_recent_change)
-app.route('/api/recent_change/<int:limit>', defaults = { 'db_set' : db_set_str })(api_recent_change)
-app.route('/api/recent_change/<int:limit>/<set_type>/<int:num>', defaults = { 'db_set' : db_set_str })(api_recent_change)
+app.route('/api/recent_change', defaults = { 'db_set' : db_set_str })(api_list_recent_change)
+app.route('/api/recent_changes', defaults = { 'db_set' : db_set_str })(api_list_recent_change)
+app.route('/api/recent_change/<int:limit>', defaults = { 'db_set' : db_set_str })(api_list_recent_change)
+app.route('/api/recent_change/<int:limit>/<set_type>/<int:num>', defaults = { 'db_set' : db_set_str })(api_list_recent_change)
 
-app.route('/api/recent_edit_request', defaults = { 'db_set' : db_set_str })(api_recent_edit_request)
-app.route('/api/recent_edit_request/<int:limit>/<set_type>/<int:num>', defaults = { 'db_set' : db_set_str })(api_recent_edit_request)
+app.route('/api/history_tool/<int(signed = True):rev>/<everything:name>', defaults = { 'db_set' : db_set_str })(api_list_history_tool)
 
-# 곧 개편 당할 곳
-app.route('/api/recent_discuss/<get_type>/<int:num>')(api_recent_discuss)
-app.route('/api/recent_discuss/<int:num>')(api_recent_discuss)
-app.route('/api/recent_discuss')(api_recent_discuss)
-##
+app.route('/api/recent_edit_request', defaults = { 'db_set' : db_set_str })(api_list_recent_edit_request)
+app.route('/api/recent_edit_request/<int:limit>/<set_type>/<int:num>', defaults = { 'db_set' : db_set_str })(api_list_recent_edit_request)
+
+app.route('/api/recent_discuss/<set_type>/<int:limit>', defaults = { 'db_set' : db_set_str })(api_list_recent_discuss)
+app.route('/api/recent_discuss/<int:limit>', defaults = { 'db_set' : db_set_str })(api_list_recent_discuss)
+app.route('/api/recent_discuss', defaults = { 'db_set' : db_set_str })(api_list_recent_discuss)
 
 app.route('/api/lang', methods = ['POST'], defaults = { 'db_set' : db_set_str })(api_func_language)
 app.route('/api/lang/<data>', defaults = { 'db_set' : db_set_str })(api_func_language)

route/__init__.py

@@ -1,5 +1,4 @@
 from route.api_image_view import api_image_view
-from route.api_recent_discuss import api_recent_discuss
 from route.api_setting import api_setting
 from route.api_skin_info import api_skin_info
 from route.api_user_info import api_user_info
@@ -167,6 +166,7 @@ from route.vote_list import vote_list
 from route.vote_select import vote_select
 
 from route.n_list_recent_change import list_recent_change
+from route.n_list_recent_discuss import list_recent_discuss
 
 from route.n_w_watch_list import w_watch_list
 
@@ -177,8 +177,10 @@ from route.go_api_func_ip import api_func_ip
 
 from route.go_api_search import api_search
 
-from route.go_api_recent_change import api_recent_change
-from route.go_api_recent_edit_request import api_recent_edit_request
+from route.go_api_list_history_tool import api_list_history_tool
+from route.go_api_list_recent_change import api_list_recent_change
+from route.go_api_list_recent_discuss import api_list_recent_discuss
+from route.go_api_list_recent_edit_request import api_list_recent_edit_request
 
 from route.go_api_bbs import api_bbs
 

route/api_recent_discuss.py

@@ -1,20 +0,0 @@
-from .tool.func import *
-
-def api_recent_discuss(num = 10, get_type = 'normal'):
-    with get_db_connect() as conn:
-        curs = conn.cursor()
-
-        num = 50 if (1 if not num > 0 else num) > 50 else num
-        data_list = []
-
-        if get_type == 'stop':
-            curs.execute(db_change("select title, sub, date, code, stop from rd where stop = 'O' order by date desc limit ?"), [num])
-        elif get_type == 'all':
-            curs.execute(db_change("select title, sub, date, code, stop from rd order by date desc limit ?"), [num])
-        else:
-            curs.execute(db_change("select title, sub, date, code, stop from rd where not stop = 'O' order by date desc limit ?"), [num])
-
-        for for_a in curs.fetchall():
-            data_list += [for_a]
-
-        return flask.jsonify(data_list if data_list else {}) 

route/go_api_bbs.py

@@ -1,24 +1,23 @@
 from .tool.func import *
 
 def api_bbs(db_set, bbs_num = "", page = 1):
-    with get_db_connect() as conn:
-        other_set = {}
-        other_set["bbs_num"] = str(bbs_num)
-        other_set["page"] = str(page)
-        other_set["ip"] = ip_check()
-        other_set = json.dumps(other_set)
+    other_set = {}
+    other_set["bbs_num"] = str(bbs_num)
+    other_set["page"] = str(page)
+    other_set["ip"] = ip_check()
+    other_set = json.dumps(other_set)
 
-        if platform.system() == 'Linux':
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    if platform.system() == 'Linux':
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
         else:
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    else:
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
 
-        data = data.decode('utf8')
+    data = data.decode('utf8')
 
-        return flask.Response(response = data, status = 200, mimetype = 'application/json')
+    return flask.Response(response = data, status = 200, mimetype = 'application/json')

route/go_api_func_ip.py

@@ -1,23 +1,22 @@
 from .tool.func import *
 
 def api_func_ip(db_set, data = 'Test'):
-    with get_db_connect() as conn:
-        other_set = {}
-        other_set["data"] = data
-        other_set["ip"] = ip_check()
-        other_set = json.dumps(other_set)
+    other_set = {}
+    other_set["data"] = data
+    other_set["ip"] = ip_check()
+    other_set = json.dumps(other_set)
 
-        if platform.system() == 'Linux':
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    if platform.system() == 'Linux':
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
         else:
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    else:
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
 
-        data = data.decode('utf8')
+    data = data.decode('utf8')
 
-        return flask.Response(response = data, status = 200, mimetype = 'application/json')
+    return flask.Response(response = data, status = 200, mimetype = 'application/json')

route/go_api_func_language.py

@@ -1,27 +1,26 @@
 from .tool.func import *
 
 def api_func_language(db_set, data = 'Test'):
-    with get_db_connect() as conn:
-        other_set = {}
-        if flask.request.method == 'POST':
-            other_set["data"] = flask.request.form.get('data', '')
-            other_set["data"] = other_set["data"].split(' ')
-        else:
-            other_set["data"] = [data]
-        
-        other_set = json.dumps(other_set)
+    other_set = {}
+    if flask.request.method == 'POST':
+        other_set["data"] = flask.request.form.get('data', '')
+        other_set["data"] = other_set["data"].split(' ')
+    else:
+        other_set["data"] = [data]
+    
+    other_set = json.dumps(other_set)
 
-        if platform.system() == 'Linux':
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    if platform.system() == 'Linux':
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    else:
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
         else:
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
 
-        data = data.decode('utf8')
+    data = data.decode('utf8')
 
-        return flask.Response(response = data, status = 200, mimetype = 'application/json')
+    return flask.Response(response = data, status = 200, mimetype = 'application/json')

route/go_api_func_llm.py

@@ -1,26 +1,25 @@
 from .tool.func import *
 
 def api_func_llm(db_set):
-    with get_db_connect() as conn:
-        if flask.request.method == 'POST':
-            other_set = {}
-            other_set["prompt"] = flask.request.form.get('prompt', '')
-            other_set["ip"] = ip_check()
-            other_set = json.dumps(other_set)
+    if flask.request.method == 'POST':
+        other_set = {}
+        other_set["prompt"] = flask.request.form.get('prompt', '')
+        other_set["ip"] = ip_check()
+        other_set = json.dumps(other_set)
 
-            if platform.system() == 'Linux':
-                if platform.machine() in ["AMD64", "x86_64"]:
-                    data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-                else:
-                    data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        if platform.system() == 'Linux':
+            if platform.machine() in ["AMD64", "x86_64"]:
+                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
             else:
-                if platform.machine() in ["AMD64", "x86_64"]:
-                    data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-                else:
-                    data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            if platform.machine() in ["AMD64", "x86_64"]:
+                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+            else:
+                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
 
-            data = data.decode('utf8')
+        data = data.decode('utf8')
 
-            return flask.Response(response = data, status = 200, mimetype = 'application/json')
-        else:
-            return flask.jsonify({})
+        return flask.Response(response = data, status = 200, mimetype = 'application/json')
+    else:
+        return flask.jsonify({})

route/go_api_func_sha224.py

@@ -1,18 +1,17 @@
 from .tool.func import *
 
 def api_func_sha224(data = 'Test'):
-    with get_db_connect() as conn:
-        if platform.system() == 'Linux':
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, data], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, data], stdout = subprocess.PIPE).communicate()[0]
+    if platform.system() == 'Linux':
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, data], stdout = subprocess.PIPE).communicate()[0]
         else:
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, data], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, data], stdout = subprocess.PIPE).communicate()[0]
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, data], stdout = subprocess.PIPE).communicate()[0]
+    else:
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, data], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, data], stdout = subprocess.PIPE).communicate()[0]
 
-        data = data.decode('utf8')
+    data = data.decode('utf8')
 
-        return flask.Response(response = data, status = 200, mimetype = 'application/json')
+    return flask.Response(response = data, status = 200, mimetype = 'application/json')

route/go_api_list_history_tool.py

@@ -0,0 +1,23 @@
+from .tool.func import *
+
+def api_list_history_tool(db_set, rev = 1, name = 'Test'):
+    other_set = {}
+    other_set["doc_name"] = name
+    other_set["rev"] = str(rev)
+    other_set["ip"] = ip_check()
+    other_set = json.dumps(other_set)
+
+    if platform.system() == 'Linux':
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    else:
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+
+    data = data.decode('utf8')
+
+    return flask.Response(response = data, status = 200, mimetype = 'application/json')

route/go_api_list_recent_change.py

@@ -0,0 +1,24 @@
+from .tool.func import *
+
+def api_list_recent_change(db_set, num = 1, set_type = 'normal', limit = 10):
+    other_set = {}
+    other_set["num"] = str(num)
+    other_set["limit"] = str(limit)
+    other_set["set_type"] = set_type
+    other_set["ip"] = ip_check()
+    other_set = json.dumps(other_set)
+
+    if platform.system() == 'Linux':
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    else:
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+
+    data = data.decode('utf8')
+
+    return flask.Response(response = data, status = 200, mimetype = 'application/json')

route/go_api_list_recent_discuss.py

@@ -0,0 +1,23 @@
+from .tool.func import *
+
+def api_list_recent_discuss(db_set, set_type = 'normal', limit = 10):
+    other_set = {}
+    other_set["limit"] = str(limit)
+    other_set["set_type"] = set_type
+    other_set["ip"] = ip_check()
+    other_set = json.dumps(other_set)
+
+    if platform.system() == 'Linux':
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    else:
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+
+    data = data.decode('utf8')
+
+    return flask.Response(response = data, status = 200, mimetype = 'application/json')

route/go_api_list_recent_edit_request.py

@@ -0,0 +1,24 @@
+from .tool.func import *
+
+def api_list_recent_edit_request(db_set, num = 1, set_type = 'normal', limit = 50):
+    other_set = {}
+    other_set["num"] = str(num)
+    other_set["limit"] = str(limit)
+    other_set["set_type"] = set_type
+    other_set["ip"] = ip_check()
+    other_set = json.dumps(other_set)
+
+    if platform.system() == 'Linux':
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    else:
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+
+    data = data.decode('utf8')
+
+    return flask.Response(response = data, status = 200, mimetype = 'application/json')

route/go_api_recent_change.py

@@ -1,25 +0,0 @@
-from .tool.func import *
-
-def api_recent_change(db_set, num = 1, set_type = 'normal', limit = 10):
-    with get_db_connect() as conn:
-        other_set = {}
-        other_set["num"] = str(num)
-        other_set["limit"] = str(limit)
-        other_set["set_type"] = set_type
-        other_set["ip"] = ip_check()
-        other_set = json.dumps(other_set)
-
-        if platform.system() == 'Linux':
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-        else:
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-
-        data = data.decode('utf8')
-
-        return flask.Response(response = data, status = 200, mimetype = 'application/json')

route/go_api_recent_edit_request.py

@@ -1,25 +0,0 @@
-from .tool.func import *
-
-def api_recent_edit_request(db_set, num = 1, set_type = 'normal', limit = 50):
-    with get_db_connect() as conn:
-        other_set = {}
-        other_set["num"] = str(num)
-        other_set["limit"] = str(limit)
-        other_set["set_type"] = set_type
-        other_set["ip"] = ip_check()
-        other_set = json.dumps(other_set)
-
-        if platform.system() == 'Linux':
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-        else:
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-
-        data = data.decode('utf8')
-
-        return flask.Response(response = data, status = 200, mimetype = 'application/json')

route/go_api_search.py

@@ -1,24 +1,23 @@
 from .tool.func import *
 
 def api_search(db_set, name = 'Test', search_type = 'title', num = 1):
-    with get_db_connect() as conn:
-        other_set = {}
-        other_set["name"] = name
-        other_set["search_type"] = search_type
-        other_set["num"] = str(num)
-        other_set = json.dumps(other_set)
+    other_set = {}
+    other_set["name"] = name
+    other_set["search_type"] = search_type
+    other_set["num"] = str(num)
+    other_set = json.dumps(other_set)
 
-        if platform.system() == 'Linux':
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    if platform.system() == 'Linux':
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
         else:
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    else:
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
 
-        data = data.decode('utf8')
+    data = data.decode('utf8')
 
-        return flask.Response(response = data, status = 200, mimetype = 'application/json')
+    return flask.Response(response = data, status = 200, mimetype = 'application/json')

route/go_api_w_random.py

@@ -1,18 +1,17 @@
 from .tool.func import *
 
 def api_w_random(db_set):
-    with get_db_connect() as conn:
-        if platform.system() == 'Linux':
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set], stdout = subprocess.PIPE).communicate()[0]
+    if platform.system() == 'Linux':
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set], stdout = subprocess.PIPE).communicate()[0]
         else:
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set], stdout = subprocess.PIPE).communicate()[0]
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set], stdout = subprocess.PIPE).communicate()[0]
+    else:
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set], stdout = subprocess.PIPE).communicate()[0]
 
-        data = data.decode('utf8')
+    data = data.decode('utf8')
 
-        return flask.Response(response = data, status = 200, mimetype = 'application/json')
+    return flask.Response(response = data, status = 200, mimetype = 'application/json')

route/go_api_w_watch_list.py

@@ -1,25 +1,24 @@
 from .tool.func import *
 
 def api_w_watch_list(db_set, name = 'Test', do_type = 'watch_list', num = 1):
-    with get_db_connect() as conn:
-        other_set = {}
-        other_set["name"] = name
-        other_set["do_type"] = do_type
-        other_set["ip"] = ip_check()
-        other_set["num"] = str(num)
-        other_set = json.dumps(other_set)
+    other_set = {}
+    other_set["name"] = name
+    other_set["do_type"] = do_type
+    other_set["ip"] = ip_check()
+    other_set["num"] = str(num)
+    other_set = json.dumps(other_set)
 
-        if platform.system() == 'Linux':
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    if platform.system() == 'Linux':
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
         else:
-            if platform.machine() in ["AMD64", "x86_64"]:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
-            else:
-                data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.bin"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+    else:
+        if platform.machine() in ["AMD64", "x86_64"]:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.amd64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
+        else:
+            data = subprocess.Popen([os.path.join(".", "route_go", "bin", "main.arm64.exe"), sys._getframe().f_code.co_name, db_set, other_set], stdout = subprocess.PIPE).communicate()[0]
 
-        data = data.decode('utf8')
+    data = data.decode('utf8')
 
-        return flask.Response(response = data, status = 200, mimetype = 'application/json')
+    return flask.Response(response = data, status = 200, mimetype = 'application/json')

route/n_list_recent_discuss.py

@@ -1,13 +1,22 @@
 from .tool.func import *
 
-def list_recent_discuss():
+def list_recent_discuss(tool = 'normal'):
     with get_db_connect() as conn:
+        m_sub = 0
+        if tool == 'normal':
+            pass
+        elif tool == 'close':
+            m_sub = '(' + get_lang(conn, 'closed') + ')'
+        else:
+            tool = 'open'
+            m_sub = '(' + get_lang(conn, 'open_discussion_list') + ')'
+
         return easy_minify(conn, flask.render_template(skin_check(conn),
-            imp = [get_lang(conn, 'recent_discuss'), wiki_set(conn), wiki_custom(conn), wiki_css([0, 0])],
+            imp = [get_lang(conn, 'recent_discussion'), wiki_set(conn), wiki_custom(conn), wiki_css([m_sub, 0])],
             data = '' + \
                 '<div id="opennamu_list_recent_discuss"></div>' + \
                 '<script src="/views/main_css/js/route/list_recent_discuss.js' + cache_v() + '"></script>' + \
-                '<script>opennamu_list_recent_discuss();</script>' + \
+                '<script>opennamu_list_recent_discuss("' + tool + '");</script>' + \
             '',
             menu = [['other', get_lang(conn, 'return')]]
         ))

route/recent_edit_request.py

@@ -2,7 +2,7 @@ from .tool.func import *
 
 from .recent_change import recent_change_send_render
 
-from .go_api_recent_edit_request import api_recent_edit_request
+from .go_api_list_recent_edit_request import api_list_recent_edit_request
 
 def recent_edit_request(db_set):
     with get_db_connect() as conn:
@@ -17,7 +17,7 @@ def recent_edit_request(db_set):
                     </tr>
         '''
 
-        all_list = json.loads(api_recent_edit_request(db_set).data)
+        all_list = json.loads(api_list_recent_edit_request(db_set).data)
         for data in all_list:
             if re.search(r"\+", data[5]):
                 leng = '<span style="color:green;">(' + data[5] + ')</span>'

route/tool/func.py

@@ -1043,7 +1043,7 @@ def skin_check(conn, set_n = 0):
         return skin
     
 def cache_v():
-    return '.cache_v221'
+    return '.cache_v227'
 
 def wiki_css(data):
     global global_wiki_set

route_go/main.go

@@ -22,9 +22,9 @@ func main() {
 		route.Api_thread(call_arg[1:])
 	} else if call_arg[0] == "api_func_ip" {
 		route.Api_func_ip(call_arg[1:])
-	} else if call_arg[0] == "api_recent_change" {
+	} else if call_arg[0] == "api_list_recent_change" {
 		route.Api_list_recent_change(call_arg[1:])
-	} else if call_arg[0] == "api_recent_edit_request" {
+	} else if call_arg[0] == "api_list_recent_edit_request" {
 		route.Api_list_recent_edit_request(call_arg[1:])
 	} else if call_arg[0] == "api_bbs" {
 		route.Api_bbs(call_arg[1:])
@@ -40,5 +40,9 @@ func main() {
 		route.Api_func_llm(call_arg[1:])
 	} else if call_arg[0] == "api_func_language" {
 		route.Api_func_language(call_arg[1:])
+	} else if call_arg[0] == "api_list_history_tool" {
+		route.Api_list_history_tool(call_arg[1:])
+	} else if call_arg[0] == "api_list_recent_discuss" {
+		route.Api_list_recent_discuss(call_arg[1:])
 	}
 }

route_go/route/api_bbs.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"log"
 	"opennamu/route/tool"
 	"strconv"
 )
@@ -27,7 +28,7 @@ func Api_bbs(call_arg []string) {
 
 		rows, err = db.Query(tool.DB_change(db_set, "select set_code, set_id from bbs_data where set_name = 'date' order by set_data desc limit 50"))
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 	} else {
 		page, _ := strconv.Atoi(other_set["page"])
@@ -38,13 +39,13 @@ func Api_bbs(call_arg []string) {
 
 		stmt, err := db.Prepare(tool.DB_change(db_set, "select set_code, set_id from bbs_data where set_name = 'title' and set_id like ? order by set_code + 0 desc limit ?, 50"))
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
 		rows, err = stmt.Query(other_set["bbs_num"], num)
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 	}
 	defer rows.Close()
@@ -59,7 +60,7 @@ func Api_bbs(call_arg []string) {
 
 		err := rows.Scan(&set_code, &set_id)
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 
 		temp_data["set_code"] = set_code
@@ -67,13 +68,13 @@ func Api_bbs(call_arg []string) {
 
 		stmt, err := db.Prepare(tool.DB_change(db_set, "select set_name, set_data, set_code, set_id from bbs_data where set_code = ? and set_id = ?"))
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
 		rows, err := stmt.Query(set_code, set_id)
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer rows.Close()
 
@@ -83,7 +84,7 @@ func Api_bbs(call_arg []string) {
 
 			err := rows.Scan(&set_name, &set_data, &set_code, &set_id)
 			if err != nil {
-				return
+				log.Fatal(err)
 			}
 
 			temp_data[set_name] = set_data

route_go/route/api_func_llm.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"log"
 	"opennamu/route/tool"
 
 	"github.com/google/generative-ai-go/genai"
@@ -28,7 +29,7 @@ func Api_func_llm(call_arg []string) {
 
 	stmt, err := db.Prepare(tool.DB_change(db_set, "select data from user_set where name = 'llm_api_key' and id = ?"))
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer stmt.Close()
 
@@ -37,7 +38,7 @@ func Api_func_llm(call_arg []string) {
 		if err == sql.ErrNoRows {
 			api_key = ""
 		} else {
-			return
+			log.Fatal(err)
 		}
 	}
 
@@ -45,14 +46,14 @@ func Api_func_llm(call_arg []string) {
 
 	client, err := genai.NewClient(ctx, option.WithAPIKey(api_key))
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer client.Close()
 
 	model := client.GenerativeModel("gemini-pro")
 	resp, err := model.GenerateContent(ctx, genai.Text(other_set["prompt"]))
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 
 	text := resp.Candidates[0].Content.Parts[0]

route_go/route/api_list_history_tool.go

@@ -0,0 +1,108 @@
+package route
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"opennamu/route/tool"
+	"strconv"
+)
+
+func Api_list_history_tool(call_arg []string) {
+	db_set := map[string]string{}
+	json.Unmarshal([]byte(call_arg[0]), &db_set)
+
+	other_set := map[string]string{}
+	json.Unmarshal([]byte(call_arg[1]), &other_set)
+
+	db := tool.DB_connect(db_set)
+	if db == nil {
+		return
+	}
+	defer db.Close()
+
+	main_dict := [][]string{}
+
+	main_dict = append(
+		main_dict,
+		[]string{
+			"/raw_rev/" + other_set["rev"] + "/" + tool.Url_parser(other_set["doc_name"]),
+			tool.Get_language(db, db_set, "raw", false),
+		},
+	)
+	main_dict = append(
+		main_dict,
+		[]string{
+			"/revert/" + other_set["rev"] + "/" + tool.Url_parser(other_set["doc_name"]),
+			tool.Get_language(db, db_set, "revert", false) + " (r" + other_set["rev"] + ")",
+		},
+	)
+
+	rev_int, err := strconv.Atoi(other_set["rev"])
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if rev_int > 1 {
+		rev_str := strconv.Itoa(rev_int - 1)
+
+		main_dict = append(
+			main_dict,
+			[]string{
+				"/revert/" + rev_str + "/" + tool.Url_parser(other_set["doc_name"]),
+				tool.Get_language(db, db_set, "revert", false) + " (r" + rev_str + ")",
+			},
+		)
+		main_dict = append(
+			main_dict,
+			[]string{
+				"/diff/" + rev_str + "/" + other_set["rev"] + "/" + tool.Url_parser(other_set["doc_name"]),
+				tool.Get_language(db, db_set, "compare", false),
+			},
+		)
+	}
+
+	main_dict = append(
+		main_dict,
+		[]string{
+			"/history/" + tool.Url_parser(other_set["doc_name"]),
+			tool.Get_language(db, db_set, "history", false),
+		},
+	)
+
+	auth_name := tool.Get_user_auth(db, db_set, other_set["ip"])
+	auth_info := tool.Get_auth_group_info(db, db_set, auth_name)
+
+	_, ok := auth_info["hidel"]
+	_, ok2 := auth_info["owner"]
+
+	if ok || ok2 {
+		main_dict = append(
+			main_dict,
+			[]string{
+				"/history_hidden/" + other_set["rev"] + "/" + tool.Url_parser(other_set["doc_name"]),
+				tool.Get_language(db, db_set, "hide", false),
+			},
+		)
+	}
+
+	if ok2 {
+		main_dict = append(
+			main_dict,
+			[]string{
+				"/history_delete/" + other_set["rev"] + "/" + tool.Url_parser(other_set["doc_name"]),
+				tool.Get_language(db, db_set, "history_delete", false),
+			},
+		)
+		main_dict = append(
+			main_dict,
+			[]string{
+				"/history_send/" + other_set["rev"] + "/" + tool.Url_parser(other_set["doc_name"]),
+				tool.Get_language(db, db_set, "send_edit", false),
+			},
+		)
+	}
+
+	json_data, _ := json.Marshal(main_dict)
+	fmt.Print(string(json_data))
+}

route_go/route/api_list_recent_change.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"log"
 	"opennamu/route/tool"
 	"strconv"
 )
@@ -28,7 +29,7 @@ func Api_list_recent_change(call_arg []string) {
 
 	limit_int, err := strconv.Atoi(other_set["limit"])
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 
 	if limit_int > 50 || limit_int < 0 {
@@ -37,18 +38,19 @@ func Api_list_recent_change(call_arg []string) {
 
 	stmt, err := db.Prepare(tool.DB_change(db_set, "select id, title from rc where type = ? order by date desc limit ?"))
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer stmt.Close()
 
 	rows, err := stmt.Query(set_type, limit_int)
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer rows.Close()
 
 	var data_list [][]string
-	admin_auth := tool.Get_admin_auth(db, db_set, other_set["ip"])
+	admin_auth := tool.Get_user_auth(db, db_set, other_set["ip"])
+	ip_parser_temp := map[string][]string{}
 
 	for rows.Next() {
 		var id string
@@ -56,7 +58,7 @@ func Api_list_recent_change(call_arg []string) {
 
 		err := rows.Scan(&id, &title)
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 
 		var date string
@@ -68,7 +70,7 @@ func Api_list_recent_change(call_arg []string) {
 
 		stmt, err := db.Prepare(tool.DB_change(db_set, "select date, ip, send, leng, hide, type from history where id = ? and title = ?"))
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
@@ -82,20 +84,33 @@ func Api_list_recent_change(call_arg []string) {
 				hide = ""
 				type_data = ""
 			} else {
-				return
+				log.Fatal(err)
 			}
 		}
 
+		var ip_pre string
+		var ip_render string
+
+		if _, ok := ip_parser_temp[ip]; ok {
+			ip_pre = ip_parser_temp[ip][0]
+			ip_render = ip_parser_temp[ip][1]
+		} else {
+			ip_pre = tool.IP_preprocess(db, db_set, ip, other_set["ip"])[0]
+			ip_render = tool.IP_parser(db, db_set, ip, other_set["ip"])
+
+			ip_parser_temp[ip] = []string{ip_pre, ip_render}
+		}
+
 		if hide == "" || admin_auth != "" {
 			data_list = append(data_list, []string{
 				id,
 				title,
 				date,
-				tool.IP_preprocess(db, db_set, ip, other_set["ip"])[0],
+				ip_pre,
 				send,
 				leng,
 				hide,
-				tool.IP_parser(db, db_set, ip, other_set["ip"]),
+				ip_render,
 				type_data,
 			})
 		} else {

route_go/route/api_list_recent_discuss.go

@@ -3,6 +3,8 @@ package route
 import (
 	"database/sql"
 	"encoding/json"
+	"fmt"
+	"log"
 	"opennamu/route/tool"
 	"strconv"
 )
@@ -22,7 +24,7 @@ func Api_list_recent_discuss(call_arg []string) {
 
 	limit_int, err := strconv.Atoi(other_set["limit"])
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 
 	if limit_int > 50 || limit_int < 0 {
@@ -33,41 +35,42 @@ func Api_list_recent_discuss(call_arg []string) {
 
 	set_type := other_set["set_type"]
 	if set_type == "normal" {
-		stmt, err = db.Prepare(tool.DB_change(db_set, "select title, sub, date, code from rd where not stop = 'O' order by date desc limit ?"))
+		stmt, err = db.Prepare(tool.DB_change(db_set, "select title, sub, date, code, stop from rd order by date desc limit ?"))
 	} else if set_type == "close" {
-		stmt, err = db.Prepare(tool.DB_change(db_set, "select title, sub, date, code from rd where stop = 'O' order by date desc limit ?"))
+		stmt, err = db.Prepare(tool.DB_change(db_set, "select title, sub, date, code, stop from rd where stop = 'O' order by date desc limit ?"))
 	} else {
-		stmt, err = db.Prepare(tool.DB_change(db_set, "select title, sub, date, code from rd where stop != 'O' order by date asc limit ?"))
+		stmt, err = db.Prepare(tool.DB_change(db_set, "select title, sub, date, code, stop from rd where stop != 'O' order by date asc limit ?"))
 	}
 
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer stmt.Close()
 
 	rows, err := stmt.Query(limit_int)
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer rows.Close()
 
-	// var data_list [][]string
-	// admin_auth := tool.Get_admin_auth(db, db_set, other_set["ip"])
+	var data_list [][]string
+	ip_parser_temp := map[string][]string{}
 
 	for rows.Next() {
 		var title string
 		var sub string
 		var date string
 		var code string
+		var stop string
 
-		err := rows.Scan(&title, &sub, &date, &code)
+		err := rows.Scan(&title, &sub, &date, &code, &stop)
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 
 		stmt, err := db.Prepare(tool.DB_change(db_set, "select ip from topic where code = ? order by id + 0 desc limit 1"))
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
@@ -78,8 +81,38 @@ func Api_list_recent_discuss(call_arg []string) {
 			if err == sql.ErrNoRows {
 				ip = ""
 			} else {
-				return
+				log.Fatal(err)
 			}
 		}
+
+		var ip_pre string
+		var ip_render string
+
+		if _, ok := ip_parser_temp[ip]; ok {
+			ip_pre = ip_parser_temp[ip][0]
+			ip_render = ip_parser_temp[ip][1]
+		} else {
+			ip_pre = tool.IP_preprocess(db, db_set, ip, other_set["ip"])[0]
+			ip_render = tool.IP_parser(db, db_set, ip, other_set["ip"])
+
+			ip_parser_temp[ip] = []string{ip_pre, ip_render}
+		}
+
+		data_list = append(data_list, []string{
+			title,
+			sub,
+			date,
+			code,
+			stop,
+			ip_pre,
+			ip_render,
+		})
+	}
+
+	if len(data_list) == 0 {
+		fmt.Print("{}")
+	} else {
+		json_data, _ := json.Marshal(data_list)
+		fmt.Print(string(json_data))
 	}
 }

route_go/route/api_list_recent_edit_request.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"log"
 	"opennamu/route/tool"
 	"strconv"
 )
@@ -23,7 +24,7 @@ func Api_list_recent_edit_request(call_arg []string) {
 
 	limit_int, err := strconv.Atoi(other_set["limit"])
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 
 	if limit_int > 50 || limit_int < 0 {
@@ -32,13 +33,13 @@ func Api_list_recent_edit_request(call_arg []string) {
 
 	stmt, err := db.Prepare(tool.DB_change(db_set, "select doc_name, doc_rev, set_data from data_set where set_name = 'edit_request_doing' order by set_data desc limit ?"))
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer stmt.Close()
 
 	rows, err := stmt.Query(limit_int)
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer rows.Close()
 
@@ -50,7 +51,7 @@ func Api_list_recent_edit_request(call_arg []string) {
 	for rows.Next() {
 		err := rows.Scan(&doc_name, &doc_rev, &date)
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 
 		var ip string
@@ -59,7 +60,7 @@ func Api_list_recent_edit_request(call_arg []string) {
 
 		stmt, err := db.Prepare(tool.DB_change(db_set, "select set_data from data_set where set_name = 'edit_request_user' and doc_rev = ? and doc_name = ?"))
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
@@ -68,13 +69,13 @@ func Api_list_recent_edit_request(call_arg []string) {
 			if err == sql.ErrNoRows {
 				ip = ""
 			} else {
-				return
+				log.Fatal(err)
 			}
 		}
 
 		stmt, err = db.Prepare(tool.DB_change(db_set, "select set_data from data_set where set_name = 'edit_request_send' and doc_rev = ? and doc_name = ?"))
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
@@ -83,13 +84,13 @@ func Api_list_recent_edit_request(call_arg []string) {
 			if err == sql.ErrNoRows {
 				send = ""
 			} else {
-				return
+				log.Fatal(err)
 			}
 		}
 
 		stmt, err = db.Prepare(tool.DB_change(db_set, "select set_data from data_set where set_name = 'edit_request_leng' and doc_rev = ? and doc_name = ?"))
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
@@ -98,7 +99,7 @@ func Api_list_recent_edit_request(call_arg []string) {
 			if err == sql.ErrNoRows {
 				leng = ""
 			} else {
-				return
+				log.Fatal(err)
 			}
 		}
 

route_go/route/api_search.go

@@ -3,6 +3,7 @@ package route
 import (
 	"encoding/json"
 	"fmt"
+	"log"
 	"strconv"
 
 	"opennamu/route/tool"
@@ -30,7 +31,7 @@ func Api_search(call_arg []string) {
 	if other_set["search_type"] == "title" {
 		stmt, err := db.Prepare(tool.DB_change(db_set, "select title from data where title collate nocase like ? order by title limit ?, 50"))
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
@@ -39,14 +40,14 @@ func Api_search(call_arg []string) {
 
 		rows, err := stmt.Query("%"+other_set["name"]+"%", num)
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer rows.Close()
 
 		for rows.Next() {
 			err := rows.Scan(&title)
 			if err != nil {
-				return
+				log.Fatal(err)
 			}
 
 			title_list = append(title_list, title)
@@ -61,7 +62,7 @@ func Api_search(call_arg []string) {
 	} else {
 		stmt, err := db.Prepare(tool.DB_change(db_set, "select title from data where data collate nocase like ? order by title limit ?, 50"))
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
@@ -70,14 +71,14 @@ func Api_search(call_arg []string) {
 
 		rows, err := stmt.Query("%"+other_set["name"]+"%", num)
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer rows.Close()
 
 		for rows.Next() {
 			err := rows.Scan(&title)
 			if err != nil {
-				return
+				log.Fatal(err)
 			}
 
 			title_list = append(title_list, title)

route_go/route/api_thread.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"log"
 
 	"opennamu/route/tool"
 )
@@ -24,7 +25,7 @@ func Api_thread(call_arg []string) {
 	if other_set["tool"] == "length" {
 		stmt, err := db.Prepare(tool.DB_change(db_set, "select id from topic where code = ? order by id + 0 desc limit 1"))
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
@@ -34,7 +35,7 @@ func Api_thread(call_arg []string) {
 			if err == sql.ErrNoRows {
 				length = "0"
 			} else {
-				return
+				log.Fatal(err)
 			}
 		}
 
@@ -49,36 +50,36 @@ func Api_thread(call_arg []string) {
 		if other_set["tool"] == "top" {
 			stmt, err := db.Prepare(tool.DB_change(db_set, "select id, data, date, ip, block, top from topic where code = ? and top = 'O' order by id + 0 asc"))
 			if err != nil {
-				return
+				log.Fatal(err)
 			}
 			defer stmt.Close()
 
 			rows, err = stmt.Query(other_set["topic_num"])
 			if err != nil {
-				return
+				log.Fatal(err)
 			}
 		} else {
 			if other_set["s_num"] != "" && other_set["e_num"] != "" {
 				stmt, err := db.Prepare(tool.DB_change(db_set, "select id, data, date, ip, block, top from topic where code = ? and ? + 0 <= id + 0 and id + 0 <= ? + 0 order by id + 0 asc"))
 				if err != nil {
-					return
+					log.Fatal(err)
 				}
 				defer stmt.Close()
 
 				rows, err = stmt.Query(other_set["topic_num"], other_set["s_num"], other_set["e_num"])
 				if err != nil {
-					return
+					log.Fatal(err)
 				}
 			} else {
 				stmt, err := db.Prepare(tool.DB_change(db_set, "select id, data, date, ip, block, top from topic where code = ? order by id + 0 asc"))
 				if err != nil {
-					return
+					log.Fatal(err)
 				}
 				defer stmt.Close()
 
 				rows, err = stmt.Query(other_set["topic_num"])
 				if err != nil {
-					return
+					log.Fatal(err)
 				}
 			}
 		}
@@ -90,7 +91,7 @@ func Api_thread(call_arg []string) {
 		for rows.Next() {
 			err := rows.Scan(&id, &data, &date, &ip, &block, &top)
 			if err != nil {
-				return
+				log.Fatal(err)
 			}
 
 			data_list = append(data_list, []string{id, data, date, ip, block, top})
@@ -100,7 +101,7 @@ func Api_thread(call_arg []string) {
 		new_data["data"] = []map[string]string{}
 		data_slice := []map[string]string{}
 
-		admin_auth := tool.Get_admin_auth(db, db_set, other_set["ip"])
+		admin_auth := tool.Get_user_auth(db, db_set, other_set["ip"])
 
 		for for_a := 0; for_a < len(data_list); for_a++ {
 			data := ""

route_go/route/api_user_watch_list.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"log"
 	"opennamu/route/tool"
 	"strconv"
 )
@@ -29,7 +30,7 @@ func Api_user_watch_list(call_arg []string) {
 
 	ip := other_set["ip"]
 	name := other_set["name"]
-	if ip != name && tool.Get_admin_auth(db, db_set, ip) == "" {
+	if ip != name && tool.Get_user_auth(db, db_set, ip) == "" {
 		fmt.Print("{}")
 		return
 	}
@@ -42,13 +43,13 @@ func Api_user_watch_list(call_arg []string) {
 		stmt, err = db.Prepare(tool.DB_change(db_set, "select data from user_set where name = 'watchlist' and id = ? limit ?, 50"))
 	}
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer stmt.Close()
 
 	rows, err := stmt.Query(name, num)
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer rows.Close()
 
@@ -59,7 +60,7 @@ func Api_user_watch_list(call_arg []string) {
 
 		err := rows.Scan(&title_data)
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 
 		data_list = append(data_list, title_data)

route_go/route/api_w_random.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"log"
 
 	"opennamu/route/tool"
 )
@@ -25,7 +26,7 @@ func Api_w_random(call_arg []string) {
 		if err == sql.ErrNoRows {
 			title = ""
 		} else {
-			return
+			log.Fatal(err)
 		}
 	}
 

route_go/route/api_w_raw.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"log"
 
 	"opennamu/route/tool"
 )
@@ -24,7 +25,7 @@ func Api_w_raw(call_arg []string) {
 	if other_set["exist_check"] != "" {
 		stmt, err := db.Prepare(tool.DB_change(db_set, "select title from data where title = ?"))
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
@@ -35,7 +36,7 @@ func Api_w_raw(call_arg []string) {
 		if err != nil {
 			if err == sql.ErrNoRows {
 			} else {
-				return
+				log.Fatal(err)
 			}
 		} else {
 			new_data["exist"] = "1"
@@ -50,7 +51,7 @@ func Api_w_raw(call_arg []string) {
 		if other_set["rev"] != "" {
 			stmt, err := db.Prepare(tool.DB_change(db_set, "select data from history where title = ? and id = ?"))
 			if err != nil {
-				return
+				log.Fatal(err)
 			}
 			defer stmt.Close()
 
@@ -58,7 +59,7 @@ func Api_w_raw(call_arg []string) {
 			if err != nil {
 				if err == sql.ErrNoRows {
 				} else {
-					return
+					log.Fatal(err)
 				}
 			} else {
 				new_data["title"] = other_set["name"]
@@ -70,7 +71,7 @@ func Api_w_raw(call_arg []string) {
 		} else {
 			stmt, err := db.Prepare(tool.DB_change(db_set, "select data from data where title = ?"))
 			if err != nil {
-				return
+				log.Fatal(err)
 			}
 			defer stmt.Close()
 
@@ -78,7 +79,7 @@ func Api_w_raw(call_arg []string) {
 			if err != nil {
 				if err == sql.ErrNoRows {
 				} else {
-					return
+					log.Fatal(err)
 				}
 			} else {
 				new_data["title"] = other_set["name"]

route_go/route/api_w_watch_list.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"log"
 	"opennamu/route/tool"
 	"strconv"
 )
@@ -28,7 +29,7 @@ func Api_w_watch_list(call_arg []string) {
 	defer db.Close()
 
 	ip := other_set["ip"]
-	if tool.Get_admin_auth(db, db_set, ip) == "" {
+	if tool.Get_user_auth(db, db_set, ip) == "" {
 		fmt.Print("{}")
 		return
 	}
@@ -41,13 +42,13 @@ func Api_w_watch_list(call_arg []string) {
 		stmt, err = db.Prepare(tool.DB_change(db_set, "select id from user_set where name = 'watchlist' and data = ? limit ?, 50"))
 	}
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer stmt.Close()
 
 	rows, err := stmt.Query(other_set["name"], num)
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer rows.Close()
 
@@ -58,7 +59,7 @@ func Api_w_watch_list(call_arg []string) {
 
 		err := rows.Scan(&user_name)
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 
 		data_list = append(data_list, user_name)

route_go/route/api_w_xref.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"log"
 	"opennamu/route/tool"
 	"strconv"
 )
@@ -34,7 +35,7 @@ func Api_w_xref(call_arg []string) {
 		if err == sql.ErrNoRows {
 			link_case_insensitive = ""
 		} else {
-			return
+			log.Fatal(err)
 		}
 	}
 
@@ -50,13 +51,13 @@ func Api_w_xref(call_arg []string) {
 	}
 
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer stmt.Close()
 
 	rows, err := stmt.Query(other_set["name"], num)
 	if err != nil {
-		return
+		log.Fatal(err)
 	}
 	defer rows.Close()
 
@@ -68,7 +69,7 @@ func Api_w_xref(call_arg []string) {
 	for rows.Next() {
 		err := rows.Scan(&name, &type_data)
 		if err != nil {
-			return
+			log.Fatal(err)
 		}
 
 		data_list = append(data_list, []string{name, type_data})

route_go/route/tool/db_connect.go

@@ -2,6 +2,7 @@ package tool
 
 import (
 	"database/sql"
+	"log"
 	"strings"
 
 	_ "github.com/go-sql-driver/mysql"
@@ -12,14 +13,14 @@ func DB_connect(db_set map[string]string) *sql.DB {
 	if db_set["type"] == "sqlite" {
 		db, err := sql.Open("sqlite", db_set["name"]+".db")
 		if err != nil {
-			return nil
+			log.Fatal(err)
 		}
 
 		return db
 	} else {
 		db, err := sql.Open("mysql", db_set["mysql_user"]+":"+db_set["mysql_pw"]+"@tcp("+db_set["mysql_host"]+":"+db_set["mysql_port"]+")/"+db_set["name"])
 		if err != nil {
-			return nil
+			log.Fatal(err)
 		}
 
 		return db

route_go/route/tool/ip_parser.go

@@ -2,6 +2,7 @@ package tool
 
 import (
 	"database/sql"
+	"log"
 	"regexp"
 	"strconv"
 )
@@ -22,7 +23,7 @@ func Get_level(db *sql.DB, db_set map[string]string, ip string) []string {
 
 	stmt, err := db.Prepare(DB_change(db_set, "select data from user_set where id = ? and name = 'level'"))
 	if err != nil {
-		return []string{"", "", ""}
+		log.Fatal(err)
 	}
 	defer stmt.Close()
 
@@ -31,13 +32,13 @@ func Get_level(db *sql.DB, db_set map[string]string, ip string) []string {
 		if err == sql.ErrNoRows {
 			level = "0"
 		} else {
-			return []string{"", "", ""}
+			log.Fatal(err)
 		}
 	}
 
 	stmt, err = db.Prepare(DB_change(db_set, "select data from user_set where id = ? and name = 'experience'"))
 	if err != nil {
-		return []string{"", "", ""}
+		log.Fatal(err)
 	}
 	defer stmt.Close()
 
@@ -46,7 +47,7 @@ func Get_level(db *sql.DB, db_set map[string]string, ip string) []string {
 		if err == sql.ErrNoRows {
 			exp = "0"
 		} else {
-			return []string{"", "", ""}
+			log.Fatal(err)
 		}
 	}
 
@@ -56,13 +57,13 @@ func Get_level(db *sql.DB, db_set map[string]string, ip string) []string {
 	return []string{level, exp, max_exp}
 }
 
-func Get_admin_auth(db *sql.DB, db_set map[string]string, ip string) string {
+func Get_user_auth(db *sql.DB, db_set map[string]string, ip string) string {
 	if !IP_or_user(ip) {
 		var auth string
 
 		stmt, err := db.Prepare(DB_change(db_set, "select data from user_set where id = ? and name = 'acl'"))
 		if err != nil {
-			return ""
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
@@ -71,7 +72,7 @@ func Get_admin_auth(db *sql.DB, db_set map[string]string, ip string) string {
 			if err == sql.ErrNoRows {
 				auth = "user"
 			} else {
-				return ""
+				log.Fatal(err)
 			}
 		}
 
@@ -85,6 +86,35 @@ func Get_admin_auth(db *sql.DB, db_set map[string]string, ip string) string {
 	return ""
 }
 
+func Get_auth_group_info(db *sql.DB, db_set map[string]string, auth string) map[string]bool {
+	stmt, err := db.Prepare(DB_change(db_set, "select name from alist where name = ?"))
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+
+	rows, err := stmt.Query(auth)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer rows.Close()
+
+	data_list := map[string]bool{}
+
+	for rows.Next() {
+		var name string
+
+		err := rows.Scan(&name)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		data_list[name] = true
+	}
+
+	return data_list
+}
+
 func IP_preprocess(db *sql.DB, db_set map[string]string, ip string, my_ip string) []string {
 	var ip_view string
 	var user_name_view string
@@ -94,7 +124,7 @@ func IP_preprocess(db *sql.DB, db_set map[string]string, ip string, my_ip string
 		if err == sql.ErrNoRows {
 			ip_view = ""
 		} else {
-			return []string{"", ""}
+			log.Fatal(err)
 		}
 	}
 
@@ -103,11 +133,11 @@ func IP_preprocess(db *sql.DB, db_set map[string]string, ip string, my_ip string
 		if err == sql.ErrNoRows {
 			user_name_view = ""
 		} else {
-			return []string{"", ""}
+			log.Fatal(err)
 		}
 	}
 
-	if Get_admin_auth(db, db_set, my_ip) != "" {
+	if Get_user_auth(db, db_set, my_ip) != "" {
 		ip_view = ""
 		user_name_view = ""
 	}
@@ -125,7 +155,7 @@ func IP_preprocess(db *sql.DB, db_set map[string]string, ip string, my_ip string
 
 			stmt, err := db.Prepare(DB_change(db_set, "select data from user_set where id = ? and name = 'sub_user_name'"))
 			if err != nil {
-				return []string{"", ""}
+				log.Fatal(err)
 			}
 			defer stmt.Close()
 
@@ -134,7 +164,7 @@ func IP_preprocess(db *sql.DB, db_set map[string]string, ip string, my_ip string
 				if err == sql.ErrNoRows {
 					sub_user_name = Get_language(db, db_set, "member", false)
 				} else {
-					return []string{"", ""}
+					log.Fatal(err)
 				}
 			}
 
@@ -149,7 +179,7 @@ func IP_preprocess(db *sql.DB, db_set map[string]string, ip string, my_ip string
 
 			stmt, err := db.Prepare(DB_change(db_set, "select data from user_set where name = 'user_name' and id = ?"))
 			if err != nil {
-				return []string{"", ""}
+				log.Fatal(err)
 			}
 			defer stmt.Close()
 
@@ -158,7 +188,7 @@ func IP_preprocess(db *sql.DB, db_set map[string]string, ip string, my_ip string
 				if err == sql.ErrNoRows {
 					user_name = ip
 				} else {
-					return []string{"", ""}
+					log.Fatal(err)
 				}
 			}
 
@@ -194,7 +224,7 @@ func IP_parser(db *sql.DB, db_set map[string]string, ip string, my_ip string) st
 				if err == sql.ErrNoRows {
 					user_name_level = ""
 				} else {
-					return ""
+					log.Fatal(err)
 				}
 			}
 
@@ -207,7 +237,7 @@ func IP_parser(db *sql.DB, db_set map[string]string, ip string, my_ip string) st
 
 			stmt, err := db.Prepare(DB_change(db_set, "select data from user_set where name = 'user_title' and id = ?"))
 			if err != nil {
-				return ""
+				log.Fatal(err)
 			}
 			defer stmt.Close()
 
@@ -216,11 +246,11 @@ func IP_parser(db *sql.DB, db_set map[string]string, ip string, my_ip string) st
 				if err == sql.ErrNoRows {
 					user_title = ""
 				} else {
-					return ""
+					log.Fatal(err)
 				}
 			}
 
-			if Get_admin_auth(db, db_set, ip) != "" {
+			if Get_user_auth(db, db_set, ip) != "" {
 				ip = "<b>" + ip + "</b>"
 			}
 

route_go/route/tool/language.go

@@ -3,7 +3,7 @@ package tool
 import (
 	"database/sql"
 	"encoding/json"
-	"fmt"
+	"log"
 	"os"
 )
 
@@ -15,14 +15,13 @@ func Get_language(db *sql.DB, db_set map[string]string, data string, safe bool)
 		if err == sql.ErrNoRows {
 			language = "ko-KR"
 		} else {
-			return ""
+			log.Fatal(err)
 		}
 	}
 
 	file, err := os.Open("./lang/" + language + ".json")
 	if err != nil {
-		fmt.Print(err)
-		return ""
+		log.Fatal(err)
 	}
 	defer file.Close()
 

route_go/route/tool/markdown.go

@@ -3,6 +3,7 @@ package tool
 import (
 	"bytes"
 	"database/sql"
+	"log"
 	"net/url"
 	"regexp"
 	"strconv"
@@ -113,13 +114,17 @@ func Markdown(db *sql.DB, db_set map[string]string, data map[string]string) map[
 
 			stmt, err := db.Prepare(DB_change(db_set, "select title from data where title = ?"))
 			if err != nil {
-				exist = ""
+				log.Fatal(err)
 			}
 			defer stmt.Close()
 
 			err = stmt.QueryRow(link).Scan(&exist)
 			if err != nil {
-				exist = ""
+				if err == sql.ErrNoRows {
+					exist = ""
+				} else {
+					log.Fatal(err)
+				}
 			}
 
 			backlink[link][""] = ""

route_go/route/tool/render.go

@@ -2,6 +2,7 @@ package tool
 
 import (
 	"database/sql"
+	"log"
 	"strconv"
 	"time"
 )
@@ -12,7 +13,7 @@ func Get_render(db *sql.DB, db_set map[string]string, doc_name string, data stri
 	if render_type == "api_view" || render_type == "api_from" || render_type == "api_include" || render_type == "backlink" {
 		stmt, err := db.Prepare(DB_change(db_set, "select set_data from data_set where doc_name = ? and set_name = 'document_markup'"))
 		if err != nil {
-			return map[string]string{}
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
@@ -21,7 +22,7 @@ func Get_render(db *sql.DB, db_set map[string]string, doc_name string, data stri
 			if err == sql.ErrNoRows {
 				markup = ""
 			} else {
-				return map[string]string{}
+				log.Fatal(err)
 			}
 		}
 	}
@@ -32,7 +33,7 @@ func Get_render(db *sql.DB, db_set map[string]string, doc_name string, data stri
 			if err == sql.ErrNoRows {
 				markup = ""
 			} else {
-				return map[string]string{}
+				log.Fatal(err)
 			}
 		}
 	}
@@ -88,82 +89,82 @@ func Get_render_direct(db *sql.DB, db_set map[string]string, doc_name string, da
 	if backlink == "1" {
 		stmt, err := db.Prepare(DB_change(db_set, "delete from back where link = ?"))
 		if err != nil {
-			return map[string]string{}
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
 		_, err = stmt.Exec(doc_name)
 		if err != nil {
-			return map[string]string{}
+			log.Fatal(err)
 		}
 
 		stmt, err = db.Prepare(DB_change(db_set, "delete from back where title = ? and type = 'no'"))
 		if err != nil {
-			return map[string]string{}
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
 		_, err = stmt.Exec(doc_name)
 		if err != nil {
-			return map[string]string{}
+			log.Fatal(err)
 		}
 
 		stmt, err = db.Prepare(DB_change(db_set, "delete from data_set where doc_name = ? and set_name = 'link_count'"))
 		if err != nil {
-			return map[string]string{}
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
 		_, err = stmt.Exec(doc_name)
 		if err != nil {
-			return map[string]string{}
+			log.Fatal(err)
 		}
 
 		stmt, err = db.Prepare(DB_change(db_set, "delete from data_set where doc_name = ? and set_name = 'doc_type'"))
 		if err != nil {
-			return map[string]string{}
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
 		_, err = stmt.Exec(doc_name)
 		if err != nil {
-			return map[string]string{}
+			log.Fatal(err)
 		}
 
 		end_backlink := render_data["backlink"].([][]string)
 		for for_a := 0; for_a < len(end_backlink); for_a++ {
 			stmt, err := db.Prepare(DB_change(db_set, "insert into back (link, title, type, data) values (?, ?, ?, ?)"))
 			if err != nil {
-				return map[string]string{}
+				log.Fatal(err)
 			}
 			defer stmt.Close()
 
 			_, err = stmt.Exec(end_backlink[0], end_backlink[1], end_backlink[2])
 			if err != nil {
-				return map[string]string{}
+				log.Fatal(err)
 			}
 		}
 
 		stmt, err = db.Prepare(DB_change(db_set, "insert into data_set (doc_name, doc_rev, set_name, set_data) values (?, '', 'link_count', ?)"))
 		if err != nil {
-			return map[string]string{}
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
 		_, err = stmt.Exec(doc_name, render_data["link_count"].(int))
 		if err != nil {
-			return map[string]string{}
+			log.Fatal(err)
 		}
 
 		stmt, err = db.Prepare(DB_change(db_set, "insert into data_set (doc_name, doc_rev, set_name, set_data) values (?, '', 'doc_type', ?)"))
 		if err != nil {
-			return map[string]string{}
+			log.Fatal(err)
 		}
 		defer stmt.Close()
 
 		_, err = stmt.Exec(doc_name, "")
 		if err != nil {
-			return map[string]string{}
+			log.Fatal(err)
 		}
 	}
 

version.json

@@ -1,6 +1,6 @@
 {
     "beta" : {
-        "r_ver" : "v3.5.0-dev65",
+        "r_ver" : "v3.5.0-dev71",
         "c_ver" : "3500376",
         "s_ver" : "3500113"
     }

views/main_css/css/main.css

@@ -263,10 +263,11 @@ code, pre {
 
     padding: 10px;
 
-    background-color: #efefef;
+    background-color: white;
     color: initial;
     
     border: 1px solid #cecece;
+    border-radius: 5px;
 
     font-size: small;
     font-weight: initial;
@@ -416,6 +417,14 @@ s:hover, strike:hover, del:hover {
     margin-top: 10px;
 }
 
+.opennamu_recent_change {
+    padding: 10px;
+
+    border: 1px solid gainsboro;
+    
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
 /* 이 부분 이하로는 레거시 */
 #topic_color {
     background: #bbeabb;

views/main_css/js/route/list_recent_change.js

@@ -15,20 +15,6 @@ function opennamu_list_recent_change() {
         fetch('/api/recent_change/50').then(function(res) {
             return res.json();
         }).then(function(data) {
-            /*
-                data_list = append(data_list, []string{
-                    id,
-                    title,
-                    date,
-                    tool.IP_preprocess(db, db_set, ip, other_set["ip"])[0],
-                    send,
-                    leng,
-                    hide,
-                    tool.IP_parser(db, db_set, ip, other_set["ip"]),
-                    type_data,
-                })
-            */
-
             let data_html = '';
 
             let option_list = [
@@ -47,39 +33,88 @@ function opennamu_list_recent_change() {
 
             data_html += '<hr class="main_hr">'
 
-            data_html += '<ul class="opennamu_ul">';
             for(let for_a = 0; for_a < data.length; for_a++) {
+                if(data[for_a][6] !== "" && data[for_a][1] === "") {
+                    data_html += '<div class="opennamu_recent_change">----</div>';
+                    data_html += '<hr class="main_hr">';
+
+                    continue;
+                }
+
                 let doc_name = opennamu_do_url_encode(data[for_a][1]);
 
-                data_html += '<li>';
-                data_html += '<a href="/w/' + doc_name + '">' + data[for_a][1] + '</a> ';
+                data_html += '<div class="opennamu_recent_change">';
+                data_html += '<a href="/w/' + doc_name + '">' + opennamu_xss_filter(data[for_a][1]) + '</a> ';
+
+                data_html += '<div style="float: right;">';
+
+                data_html += '<span id="opennamu_list_recent_change_' + String(for_a) + '_over">';
+                data_html += '<a id="opennamu_list_recent_change_' + String(for_a) + '" href="javascript:void(0);">';
+                data_html += '⚒️'
+                data_html += '</a>';
+                data_html += '<span class="opennamu_popup_footnote" id="opennamu_list_recent_change_' + String(for_a) + '_load" style="display: none;"></span>';
+                data_html += '</span>';
+                data_html += ' | '
 
-                let rev = Number(data[for_a][0]);
-                if(rev <= 1) {
-                    data_html += '<a href="/history/' + doc_name + '">(r' + data[for_a][0] + ')</a> ';
+                if(data[for_a][6] !== "") {
+                    data_html += '<span style="color: red;">(r' + data[for_a][0] + ')</span> ';
                 } else {
-                    data_html += '<a href="/diff/' + String(rev - 1) + '/' + data[for_a][0] + '/' + doc_name + '">(r' + data[for_a][0] + ')</a> ';
+                    data_html += '(r' + data[for_a][0] + ') ';
                 }
                 
                 if(data[for_a][5] === '0') {
-                    data_html += '<span style="color: gray;">(' + data[for_a][5] + ')</span> ';
+                    data_html += '<span style="color: gray;">(' + data[for_a][5] + ')</span>';
                 } else if(data[for_a][5].match(/\+/)) {
-                    data_html += '<span style="color: green;">(' + data[for_a][5] + ')</span> ';
+                    data_html += '<span style="color: green;">(' + data[for_a][5] + ')</span>';
                 } else {
-                    data_html += '<span style="color: red;">(' + data[for_a][5] + ')</span> ';
+                    data_html += '<span style="color: red;">(' + data[for_a][5] + ')</span>';
                 }
+                data_html += ' | ';
                 
-                data_html += '<a href="/history_tool/' + data[for_a][0] + '/' + doc_name + '">(' + lang[0] + ')</a> | ';
                 data_html += data[for_a][7] + ' | ';
                 data_html += data[for_a][2];
-                data_html += '<br>'
-                data_html += data[for_a][4];
-                data_html += '</li>';
-            }
+                
+                data_html += '<span style="display: none;" id="opennamu_history_tool_' + String(for_a) + '"></span>';
+                
+                data_html += '</div>'
+                data_html += '<div style="clear: both;"></div>';
 
-            data_html += '</ul>';
+                if(data[for_a][4] !== "") {
+                    data_html += '<hr>'
+                    data_html += opennamu_xss_filter(data[for_a][4]);
+                }
+
+                data_html += '</div>';
+                data_html += '<hr class="main_hr">';
+            }
 
             document.getElementById('opennamu_list_recent_change').innerHTML = data_html;
+
+            for(let for_a = 0; for_a < data.length; for_a++) {
+                if(data[for_a][6] !== "" && data[for_a][1] === "") {
+                    data_html += '<li>----</li>';
+
+                    continue;
+                }
+
+                let doc_name = opennamu_do_url_encode(data[for_a][1]);
+
+                fetch('/api/history_tool/' + data[for_a][0] + '/' + doc_name).then(function(res) {
+                    return res.json();
+                }).then(function(tool_list) {
+                    let tool_html = '';
+                    for(let for_b = 0; for_b < tool_list.length; for_b++) {
+                        tool_html += '<a href="' + tool_list[for_b][0] + '">' + tool_list[for_b][1] + '</a> | ';
+                    }
+
+                    tool_html = tool_html.replace(/ \| $/, '');
+                    
+                    document.getElementById('opennamu_history_tool_' + String(for_a)).innerHTML = tool_html;
+                    
+                    document.getElementById('opennamu_list_recent_change_' + String(for_a) + "_over").addEventListener("mouseenter", function() { opennamu_do_footnote_popover('opennamu_list_recent_change_' + String(for_a), '', 'opennamu_history_tool_' + String(for_a)); });
+                    document.getElementById('opennamu_list_recent_change_' + String(for_a) + "_over").addEventListener("mouseleave", function() { opennamu_do_footnote_popover('opennamu_list_recent_change_' + String(for_a), '', 'opennamu_history_tool_' + String(for_a)); });
+                });
+            }
         });
     });
 }

views/main_css/js/route/list_recent_discuss.js

@@ -0,0 +1,52 @@
+"use strict";
+
+function opennamu_list_recent_discuss(tool = 'normal') {
+    let lang_data = new FormData();
+    lang_data.append('data', 'tool normal close_discussion open_discussion_list')
+
+    fetch('/api/lang', {
+        method : 'post',
+        body : lang_data,
+    }).then(function(res) {
+        return res.json();
+    }).then(function(lang) {
+        lang = lang["data"];
+
+        fetch('/api/recent_discuss/' + tool + '/50').then(function(res) {
+            return res.json();
+        }).then(function(data) {
+            let data_html = '';
+
+            let option_list = [
+                ['normal', lang[1]],
+                ['close', lang[2]],
+                ['open', lang[3]]
+            ];
+            for(let for_a = 0; for_a < option_list.length; for_a++) {
+                data_html += '<a href="/recent_discuss/' + option_list[for_a][0] + '">(' + option_list[for_a][1] + ')</a> ';
+            }
+
+            data_html += '<hr class="main_hr">'
+
+            for(let for_a = 0; for_a < data.length; for_a++) {
+                let doc_name = opennamu_do_url_encode(data[for_a][0]);
+
+                data_html += '<div class="opennamu_recent_change">';
+                data_html += '<a href="/thread/' + data[for_a][3] + '">' + opennamu_xss_filter(data[for_a][1]) + '</a> ';
+                data_html += '<a href="/w/' + doc_name + '">(' + opennamu_xss_filter(data[for_a][0]) + ')</a> ';
+
+                data_html += '<div style="float: right;">';
+
+                data_html += data[for_a][6];
+
+                data_html += '</div>';
+                data_html += '<div style="clear: both;"></div>';
+
+                data_html += '</div>';
+                data_html += '<hr class="main_hr">';
+            }
+
+            document.getElementById('opennamu_list_recent_discuss').innerHTML = data_html;
+        });
+    });
+}

views/main_css/js/route/render.js

@@ -209,10 +209,14 @@ function opennamu_do_footnote_spread(set_name, load_name) {
     }
 }
 
-function opennamu_do_footnote_popover(set_name, load_name) {
+function opennamu_do_footnote_popover(set_name, load_name, sub_obj = undefined) {
     if(document.getElementById(set_name + '_load').style.display === 'none') {
-        document.getElementById(set_name).title = '';
-        document.getElementById(set_name + '_load').innerHTML = '<a href="#' + load_name + '">(Go)</a> ' + document.getElementById(load_name + '_title').innerHTML;
+        if(sub_obj !== undefined) {
+            document.getElementById(set_name + '_load').innerHTML = document.getElementById(sub_obj).innerHTML; 
+        } else {
+            document.getElementById(set_name).title = '';
+            document.getElementById(set_name + '_load').innerHTML = '<a href="#' + load_name + '">(Go)</a> ' + document.getElementById(load_name + '_title').innerHTML;   
+        }
         document.getElementById(set_name + '_load').style.display = "inline-block";
 
         let width = document.getElementById(set_name + '_load').clientWidth;
@@ -246,7 +250,7 @@ function opennamu_do_category_spread() {
     if(document.getElementsByClassName('opennamu_render_complete')) {
         document.getElementsByClassName('opennamu_render_complete')[0].innerHTML = '' +
             '<style>.opennamu_category_button { display: none; } .opennamu_category { white-space: pre-wrap; overflow-x: unset; text-overflow: unset; }</style>' +
-        '' + document.getElementsByClassName('opennamu_render_complete')[0].innerHTML
+        '' + document.getElementsByClassName('opennamu_render_complete')[0].innerHTML;
     }
 }
 

views/ringo/index.html

@@ -11,7 +11,7 @@
         <link href="https://cdn.jsdelivr.net/gh/sun-typeface/SUIT/fonts/static/woff2/SUIT.css" rel="stylesheet">
         <script src="https://code.iconify.design/1/1.0.3/iconify.min.js"></script>
         <script src="/views/ringo/js/main.js.cache_v2"></script>
-        <script src="/views/ringo/js/sidebar.js.cache_v2"></script>
+        <script src="/views/ringo/js/sidebar.js.cache_v3"></script>
         <script src="/views/ringo/js/skin_set.js.cache_v5"></script>
         <link rel="stylesheet" href="/views/ringo/css/main.css.cache_v8">
         {% if request.cookies.get('main_css_darkmode', '') == '1' %}

views/ringo/js/sidebar.js

@@ -47,7 +47,7 @@ function ringo_do_side_button_2() {
             let data = '';
             for(let for_a = 0; for_a < text.length; for_a++) {
                 data += '<a href="/thread/' + ringo_do_url_encode(text[for_a][3]) + '">' + ringo_do_xss_encode(text[for_a][1]) + '</a><br>';
-                data += text[for_a][2] + '<br>';
+                data += text[for_a][2] + ' | ' + text[for_a][5] +'<br>';
             }
 
             document.getElementById('side_content').innerHTML = data;