def init_all_data():
SystemConfig().logger.info(
'==================================================================')
SystemConfig().logger.info('init database: %s' %
SystemConfig().get_section_map(
SECTION.MONGODB_SETTINGS)[MONGO_CONFIG.DB])
collections = [Organization(), Province(), Severity(), Category()]
for c in collections:
c.init_data()
def __init__(self):
super(PytempAuthorization, self).__init__()
self.config = SystemConfig()
self.key = self.config.get_section_map(
AUTH_CONFIG.JWT)[AUTH_CONFIG.SECRET_KEY]
self.algorithm = self.config.get_section_map(
AUTH_CONFIG.JWT)[AUTH_CONFIG.ALGORITHM]
self.module = self.config.get_section_map(
AUTH_CONFIG.JWT)[AUTH_CONFIG.MODULE]
self.ADMIN = 'admin'
def __init__(self, *args): # real signature unknown
# *args is used to get a list of the parameters passed in
param = None
array = [a for a in args]
try:
param = request.args.get('lang')
if len(array) > 0:
array[0].encode('utf-8')
self.params = array
except Exception as ex:
print("my_except/BaseMoError.__init__", ex)
self.params = array[1:]
if (param is None) or (param and param not in (LANG_VI, LANG_EN)):
param = LANG_VI
self.lang = LangConfig().lang_map(param)
self.message_name_default = LANG.VALIDATE_ERROR
self.sys_conf = SystemConfig()
def init_data(self, file_name=None):
if file_name:
file_path = "{path}{name}.json".format(path=COLLECTION_PATH,
name=file_name)
else:
file_path = "{path}{name}.json".format(
path=COLLECTION_PATH, name=self.__class__.__name__)
with open(file_path, 'r', encoding='UTF-8') as f:
SystemConfig().logger.info('init collection from file: %s' %
file_path)
data = json.load(f)
for obj in data:
self.__init__(**obj) # json as input
self.save()
import os
from functools import wraps
from src import PROJECT_NAME
os.environ[PROJECT_NAME + "_HOME"], _ = os.path.split(
os.path.abspath(__file__))
from src.common.my_except import BaseMoError
from src.common.system_config import SystemConfig
from src.libs.thread_pool import ThreadPool
logger = SystemConfig().logger
pool = ThreadPool(num_workers=8, logger=logger)
def __function(param1, param2, param3):
print(param1 + param2 + param3)
raise BaseMoError('error')
@pool.thread
def thread_function_error(param1, param2, param3):
print(param1 + param2 + param3)
raise BaseMoError('error')
thread_function_error(1, 2, 3)
pool.add_task(__function, 1, 2, 3)
# đợi cho đến khi tất cả nhiệm vụ được hoàn thành
class PytempAuthorization(ProjectAuthorization):
def __init__(self):
super(PytempAuthorization, self).__init__()
self.config = SystemConfig()
self.key = self.config.get_section_map(
AUTH_CONFIG.JWT)[AUTH_CONFIG.SECRET_KEY]
self.algorithm = self.config.get_section_map(
AUTH_CONFIG.JWT)[AUTH_CONFIG.ALGORITHM]
self.module = self.config.get_section_map(
AUTH_CONFIG.JWT)[AUTH_CONFIG.MODULE]
self.ADMIN = 'admin'
def get(self, token, field_name):
"""
lấy thông tin theo tên trường từ Json Web Token
:param token:
:param field_name:
:return:
"""
body = self.decode(token)
if body is None:
return None
return body.get(field_name, None)
@staticmethod
def _get_requests(url, api_key=None):
if api_key is None:
result = requests.get(url)
else:
result = requests.get(
url=url, headers={'Authorization': 'Basic %s' % api_key})
if result.status_code == 200:
return json.loads(result.text)
else:
return None
def is_permitted(self, jwt_token, typically, method):
"""
hàm kiểm tra method có được phân quyền hay không
:param jwt_token:
:param typically:
:param method:
:return:
"""
return True
def verify_token(self, jwt_token, typically):
"""
nếu là module có chức năng au then thì kiem tra trong redis
nếu là module khác thì gọi moddule authen để verify token
:param typically:
:param jwt_token:
:return: trả về token nếu hợp lệ
"""
try:
if typically == TYPICALLY.BEARER or typically == TYPICALLY.DIGEST:
return jwt_token
elif typically == TYPICALLY.BASIC: # and self.module == self.ADMIN:
return jwt_token
return None
except Exception as e:
print(e)
BaseMoError(LANG.INTERNAL_SERVER_ERROR).get_message()
return None
from src.common.lang_config import LANG
from src.common.my_except import BaseMoError, ParamInvalidError, InputNotFoundError, LogicSystemError
from src.common.pytemp_authorization import PytempAuthorization
from src.common.system_config import SystemConfig
from src.libs.caching import LruCache, STORE_TYPE
from src.libs.http_jwt_auth import HttpJwtAuth, TYPICALLY
from src.libs.subscribe import SubscribeAssigner
# from src.models.bot_config_repository import BotConfigRepository
# from src.models import PERMITTED_STRUCTURE
from src.common import ADMIN, SECTION, LOGGING_MODE, PROJECT_CONFIG_FILE_PATH
from functools import wraps
from src.performers.test_performer import TestPerformer
SubscribeAssigner().set_logger(SystemConfig().logger)
SubscribeAssigner().add_performer(TestPerformer())
class HTTP_METHOD:
DELETE = 'delete'
PATCH = 'patch'
PUT = 'put'
POST = 'post'
GET = 'get'
class API_URI:
BOT_REGISTER = 'bot_register'
BOT_DELETE = 'bot_delete'
BOT_UPDATE = 'bot_update'
def job_process():
fac = SchedulerFactory()
fac.set_logger(SystemConfig().logger)
fac.add(TestScheduler())
fac.run()
def tear_down():
db.connection.drop_database(SystemConfig().get_section_map(SECTION.MONGODB_SETTINGS)[MONGO_CONFIG.DB])
class BaseMoError(Exception):
""" Attribute not found. """
def __init__(self, *args): # real signature unknown
# *args is used to get a list of the parameters passed in
param = None
array = [a for a in args]
try:
param = request.args.get('lang')
if len(array) > 0:
array[0].encode('utf-8')
self.params = array
except Exception as ex:
print("my_except/BaseMoError.__init__", ex)
self.params = array[1:]
if (param is None) or (param and param not in (LANG_VI, LANG_EN)):
param = LANG_VI
self.lang = LangConfig().lang_map(param)
self.message_name_default = LANG.VALIDATE_ERROR
self.sys_conf = SystemConfig()
def get_message(self):
try:
return self._get_message()
except Exception as ex:
print("my_except/BaseMoError.get_message", ex)
self.sys_conf.logger.exception(
'%s :: %s exception occurred' %
(str(datetime.datetime.now()), self.get_class_name()))
code = self.lang[LANG.INTERNAL_SERVER_ERROR][LANG_STRUCTURE.CODE]
message = self.lang[LANG.INTERNAL_SERVER_ERROR][
LANG_STRUCTURE.MESSAGE]
return BaseMoError.build_message_error(code, message)
def _get_message(self):
log_mod = self.sys_conf.get_section_map(SECTION.LOGGING_MODE)
len_arg = len(self.params)
message_name = self.message_name_default
if len_arg > 0:
message_name = self.params[0]
log_message = None
if message_name not in self.lang:
log_message = "arg[0] là [%s] không được định nghĩa trong file Lang" % message_name
message_name = self.message_name_default
code = self.lang[message_name][LANG_STRUCTURE.CODE]
message = self.lang[message_name][LANG_STRUCTURE.MESSAGE]
is_custom_except = message_name != LANG.INTERNAL_SERVER_ERROR and message_name != LANG.MESSAGE_SUCCESS
mod1 = int(log_mod[LOGGING_MODE.LOG_FOR_ALL_CUSTOMIZE_EXCEPTION]
) == 1 and is_custom_except
mod2 = int(
log_mod[LOGGING_MODE.WRITE_TRACEBACK_FOR_ALL_CUSTOMIZE_EXCEPTION]
) == 1 and is_custom_except
mod3 = int(
log_mod[LOGGING_MODE.WRITE_TRACEBACK_FOR_GLOBAL_EXCEPTION]) == 1
mod3 = mod3 and message_name == LANG.INTERNAL_SERVER_ERROR
mod4 = int(log_mod[LOGGING_MODE.LOG_FOR_GLOBAL_EXCEPTION]) == 1
mod4 = mod4 and message_name == LANG.INTERNAL_SERVER_ERROR
mod5 = int(log_mod[LOGGING_MODE.LOG_FOR_REQUEST_SUCCESS]) == 1
mod5 = mod5 and message_name == LANG.MESSAGE_SUCCESS
if mod1 or mod2 or mod3 or mod4 or mod5:
self.sys_conf.logger.debug(
'=================================================================='
)
self.sys_conf.logger.debug(str(datetime.datetime.now()))
if log_message:
self.sys_conf.logger.debug(log_message)
errors = None
if len_arg > 1:
errors = self.params[1]
try:
if mod1 or mod4 or mod5:
body = str(request.data, 'utf-8')
if body is None or body == '' or body == b'':
body = str(request.form)
self.sys_conf.logger.debug(
'request_id: {request_id} \n HTTP/1.1 {method} {url}\n{headers}\n\nbody: {body}'
.format(request_id=get_request_id(),
method=request.method,
url=request.url,
headers='\n'.join(
'{}: {}'.format(k, v)
for k, v in request.headers.items()),
body=body))
except Exception as ex:
print("my_except/BaseMoError._get_message", ex)
pass
if mod2 or mod3:
self.sys_conf.logger.exception('%s exception occurred' %
self.get_class_name())
if message and str(message).find('%s') >= 0:
params = list(self.params[1:])
message = message % tuple(params)
return BaseMoError.build_message_error(code, message)
else:
return BaseMoError.build_message_error(code, message, errors)
@staticmethod
def build_message_error(code, message, errors=None):
if errors:
return {
LANG_STRUCTURE.CODE: code,
LANG_STRUCTURE.MESSAGE: message,
'errors': errors
}
return {LANG_STRUCTURE.CODE: code, LANG_STRUCTURE.MESSAGE: message}
@staticmethod
def get_track_back(limit=2, chain=True):
res = ""
_, value, tb = sys.exc_info()
for line in TracebackException(type(value), value, tb,
limit=limit).format(chain=chain):
res = res + line + "\n"
return res
def get_class_name(self):
return self.__class__.__name__