def del_module_info(user_key, module_index, file_exist_flag):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request create_qr", extra=logger_data)
log_request = "del_module_info"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
logger.info("Request set_user_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['module_index'] = module_index
input['file_exist_flag'] = file_exist_flag
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
input_list = [user_key, module_index, file_exist_flag]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "405"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 입력받은 사용자 키를 이용하여 사용자의 아이디, 권한 조회
send = get_user_info_from_key(user_key)
logger.info("Get user information", extra=logger_data)
# 접속해있는 사용자가 아닐 경우
if send['status'] == "201":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 접속 여부 확인 도중 DB 에러가 난 경우
elif send['status'] == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = send['data'][0]['error']
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 현재 접속 중인 사용자일 경우
elif send['status'] == "200":
# 수정을 요청한 사용자와 작성자가 동일한지 확인
# API 를 호출한 사용자 아이디
user_id = send['data'][0]['result_data_1']
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
# 인식모듈 상세정보 조회하는 포르시저 호출
try:
count_click = "N"
cursor.callproc('SP_KEYM_GET_MODULE_DETAILS_INFO',
[module_index, count_click])
column_names_list = [x[0] for x in cursor.description]
result_module_info = []
for row in cursor.fetchall():
result_module_info.append(dict(zip(column_names_list, row)))
# 인식모듈을 등록한 사용자 ID
user_id_module = result_module_info[0]['FK_KMMITN_MODULEINFO']
logger.info("Verify that the user and author match",
extra=logger_data)
# 작성자가 동일하지 않을 경우 권한 확인
if user_id != user_id_module:
logger.info("User and author do not match", extra=logger_data)
id_equal_flag = "N"
else:
logger.info("User and author match", extra=logger_data)
id_equal_flag = "Y"
user_auth_list = send['data'][0]['AUTH']
# 인식모듈 삭제 권한 'AUMOD0004'
request_auth = 'AUMOD0004'
auth_exist_flag = ""
logger.info("Check authority", extra=logger_data)
# 인식모듈 수정 권한 조회
for auth in user_auth_list:
if auth == request_auth:
logger.info("Authority exists", extra=logger_data)
auth_exist_flag = "Y"
break
else:
auth_exist_flag = "N"
# 작성자 동일 또는 권한 존재 중 하나라도 값이 Y 라면 인식모듈 삭제 가능
if id_equal_flag == "Y" or auth_exist_flag == "Y":
# 이전에 등록한 첨부파일명
file_name_del = result_module_info[0]['FILE_NAME']
# 이전에 등록한 첨부파일 경로
file_path_del = result_module_info[0]['FILE_PATH']
# 첨부파일이 존재하는 경우 서버에 저장된 파일 삭제
if file_exist_flag == "Y":
del_file_dir(file_path_del, file_name_del)
cursor.callproc('SP_KEYM_DEL_MODULE_INFO', [module_index])
data = []
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "del_module_info success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
else:
# 작성자가 아니거나 인식모듈 삭제 권한이 존재하지 않는 경우
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "You do not have permission"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "402"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "exception error"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '404'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
def get_key_list(user_key, user_name, address, user_id_search, date_start,
date_end, currentpage, countperpage):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request get_key_list", extra=logger_data)
log_request = "get_key_list"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
logger.info("Request set_user_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['user_name'] = user_name
input['address'] = address
input['user_id_search'] = user_id_search
input['date_start'] = date_start
input['date_end'] = date_end
input['currentpage'] = currentpage
input['countperpage'] = countperpage
log_request = "get_key_list"
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
# 입력값 리스트
input_list = [
user_key, user_name, address, user_id_search, date_start, date_end,
currentpage, countperpage
]
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
# check_text : 입력받은 문자열이 적합한지 판단
# check_text(문자열 타입, 문자열)
# 문자열 타입이 input_db 일 경우 db 에 입력할 수 있는지 판단(특수문자 여부)
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "403"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 검색 내용이 없을 경우(0으로 입력이 들어왔을 경우) None 으로 설정
if user_name == "0":
user_name = None
if address == "0":
address = None
if user_id_search == "0":
user_id_search = None
if date_start == "0":
date_start = None
if date_end == "0":
date_end = None
# 현재 페이지가 None 일 경우 1페이지로 설정되어 있음
if currentpage == "0":
currentpage = None
# 페이지 당 개수가 None 일 경우 저장되어 있는 모든 정보를 가져오도록 설정되어 있음
if countperpage == "0":
countperpage = None
# 입력받은 사용자 키를 이용하여 사용자의 아이디, 권한 조회
send = get_user_info_from_key(user_key)
logger.info("Get user information", extra=logger_data)
# 접속해있는 사용자가 아닐 경우
if send['status'] == "201":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 접속 여부 확인 도중 DB 에러가 난 경우
elif send['status'] == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "get_user_info_from_key DB error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 현재 접속 중인 사용자일 경우
elif send['status'] == "200":
# 인식키 조회 권한이 있는지 확인
user_auth_list = send['data'][0]['AUTH']
user_id = send['data'][0]['result_data_1']
# 인식키 조회 권한 'AUKEY0003'
request_auth = 'AUKEY0003'
logger.info("Check authority", extra=logger_data)
for auth in user_auth_list:
# 권한이 있을 경우 인식키 정보 조회
if auth == request_auth:
logger.info("Authority exists", extra=logger_data)
# 인식키 리스트를 가져오는 프로시저
cursor.callproc('SP_KEYM_GET_KEY_LIST', [
user_name, address, user_id_search, date_start,
date_end, currentpage, countperpage
])
column_names_list = [x[0] for x in cursor.description]
result_key_info = []
for row in cursor.fetchall():
result_key_info.append(
dict(zip(column_names_list, row)))
# 인식키 리스트 조회에 성공하였으나 결과값이 존재하지 않는 경우
if not result_key_info:
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "REQUEST"
output = ""
message = "Result is None"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "success"
status = "201"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 사용자 상태 한글로 변경
for key_info in result_key_info:
key_info['LOGIN'] = "******"
if key_info['DELETE_FLAG'] == "Y":
key_info['LOGIN'] = "******"
elif key_info['WITHDRAW_FLAG'] == "Y":
key_info['LOGIN'] = "******"
logger.info("change the state of a user",
extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "REQUEST"
output = result_key_info
message = "get_key_list success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
data = result_key_info
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
# 인식키 조회 권한이 존재하지 않을 경우
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "ERROR"
output = ""
message = "permission error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "404"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
data = []
status = '402'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = e
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
return send
finally:
connection.close()
def set_user_wih_del_flag(user_key, log_request):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request set_user_wih_del_flag", extra=logger_data)
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['log_request'] = log_request
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, "set_user_wih_del_flag")
input_list = [user_key, log_request]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "403"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 요청코드 종류 : 탈퇴, 사용자 삭제
# 탈퇴 'LGUSE0011'
if log_request == "LGUSE0011":
request_type = "withdraw"
# 사용자 정보 삭제 'LGUSE0006'
elif log_request == "LGUSE0006":
request_type = "del_user_info"
# 위 패턴으로 요청한 기능 판단
send = check_auth(user_key, request_type)
data = []
status = send['status']
# 접속해 있는 사용자가 아닌 경우
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 필요한 권한이 존재하지 않는 경우
elif status == "401":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "You don't have permission"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 필요한 권한이 존재하는 경우
elif status == "200":
# API 를 호출한 사용자의 ID
user_id = send['data'][0]['result_data_1']
withdraw_flag = 'N'
delete_flag = 'N'
if request_type == "withdraw":
withdraw_flag = 'Y'
elif request_type == "del_user_info":
delete_flag = 'Y'
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
cursor.callproc('SP_KEYM_SET_USR_WIH_DEL_FLAG',
[user_id, withdraw_flag, delete_flag])
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "set_user_wih_del_flag success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "exception error"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
result = "fail"
status = "402"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
def get_module_info(user_key, log_request, module_index):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request get_module_info", extra=logger_data)
request_log = "get_module_info"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, request_log)
logger.info("Request set_user_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['log_request'] = log_request
input['module_index'] = module_index
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
input_list = [user_key, log_request, module_index]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "404"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 입력받은 사용자 키를 이용하여 사용자의 아이디, 권한 조회
send = get_user_info_from_key(user_key)
logger.info("Get user information", extra=logger_data)
# 접속해있는 사용자가 아닐 경우
if send['status'] == "201":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 접속 여부 확인 도중 DB 에러가 난 경우
elif send['status'] == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = send['data'][0]['error']
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 현재 접속 중인 사용자일 경우
elif send['status'] == "200":
# 수정을 요청한 사용자와 작성자가 동일한지 확인
# API 를 호출한 사용자 아이디
user_id = send['data'][0]['result_data_1']
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
# 인식모듈 상세정보 조회하는 프로시저 호출
try:
# 작성자인지 판단하기 위해 조회하는 것 이므로 조회수 증가하지 않음
count_click = "N"
cursor.callproc('SP_KEYM_GET_MODULE_DETAILS_INFO', [module_index, count_click])
column_names_list = [x[0] for x in cursor.description]
result_module_info = []
for row in cursor.fetchall():
result_module_info.append(dict(zip(column_names_list, row)))
# 입력한 인덱스에 해당하는 인식모듈 정보가 존재하지 않을 경우(삭제된 인식모듈을 호출한 경우)
if not result_module_info:
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Module post does not exist"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message,
success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "405"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 초반에 None 으로 설정해뒀던 파일은 N 으로 바꾸어 출력
for module_info in result_module_info:
if module_info['FILE_EXIST_FLAG'] is None:
module_info['FILE_EXIST_FLAG'] = "N"
# 인식모듈을 등록한 사용자 ID
user_id_module = result_module_info[0]['FK_KMMITN_MODULEINFO']
logger.info("Verify that the user and author match", extra=logger_data)
# 작성자가 동일한지 확인
if user_id != user_id_module:
logger.info("User and author do not match", extra=logger_data)
id_equal_flag = "N"
else:
logger.info("User and author match", extra=logger_data)
id_equal_flag = "Y"
# 인식모듈을 조회하려는 사용자의 권한 리스트
user_auth_list = send['data'][0]['AUTH']
request_auth = ""
# 인식모듈 조회 'LGMOD0001'
if log_request == "LGMOD0001":
request_auth = 'AUMOD0001'
count_click = "Y"
# 인식모듈 수정 'LGMOD0003'
elif log_request == "LGMOD0003":
request_auth = 'AUMOD0003'
count_click = "N"
auth_exist_flag = ""
logger.info("Check authority", extra=logger_data)
# 인식모듈 조회 또는 수정 권한 조회
for auth in user_auth_list:
if auth == request_auth:
logger.info("Authority exists", extra=logger_data)
auth_exist_flag = "Y"
break
else:
auth_exist_flag = "N"
# 인식모듈 조회를 요청했을 경우 권한이 없으면 조회 불가
if log_request == "LGMOD0001":
if auth_exist_flag == "N":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "You do not have permission"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "402"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 자격이 있을 경우 조회수 증가
else:
# 조회수 증가 후 증가된 값을 호출
cursor.callproc('SP_KEYM_GET_MODULE_DETAILS_INFO', [module_index, count_click])
column_names_list = [x[0] for x in cursor.description]
result_module_info = []
for row in cursor.fetchall():
result_module_info.append(dict(zip(column_names_list, row)))
# 인식모듈 수정을 요청헀을 경우 작성자도 아니고 권한도 없을 경우 조회 불가(택1)
elif log_request == "LGMOD0003":
if id_equal_flag == "N" and auth_exist_flag == "N":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "You do not have permission"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "402"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
result_module_info[0]['id_equal_flag'] = id_equal_flag
data = result_module_info
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "get_module_info success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "exception error"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '403'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
def get_company_list(user_key, company_name, current_page, count_per_page):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request add_company", extra=logger_data)
log_request = "get_company_list"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
logger.info("Request set_user_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['company_name'] = company_name
input['current_page'] = current_page
input['count_per_page'] = count_per_page
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
input_list = [user_key, company_name, current_page, count_per_page]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
# 업체 정보 리스트 조회
cursor.callproc('SP_KEYM_GET_COM_LIST',
[company_name, current_page, count_per_page])
column_names_list = [x[0] for x in cursor.description]
result_company_info = []
for row in cursor.fetchall():
result_company_info.append(dict(zip(column_names_list, row)))
# 회원가입 화면에서 회사명 리스트를 불러올 경우
if current_page == '0' or count_per_page == '0':
URL = '/reg'
# 업체정보 조회 화면에서 회사명 리스트를 불러올 경우
else:
URL = '/업체명리스트조회페이지'
if result_company_info:
for company_info in result_company_info:
company_info['URL'] = URL
status = "200"
else:
result_company_info = []
status = "201"
data = result_company_info
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "get_company_list success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
# 사용자 key 를 이용해서 사용자 정보 조회
status_key = check_text('user_key', user_key)
user_info = {}
# 회원가입 시 업체 리스트를 표출하는 경우
if len(user_key) != 8 or type(user_key) != str or status_key == "400":
request_type = "regitser"
# 업체정보 조회 페이지에서 호출한 경우
else:
request_type = "search_company"
user_info = get_user_info_from_key(user_key)
# 사용자 정보 조회하는 중에 DB 에러가 난 경우
if user_info:
if user_info['status'] == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Error occurred while inquiring user information"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
user_id = user_info['data'][0]['result_data_1']
# 업체정보 조회 화면에서 조회한 경우에만 로그 저장
# 회원가입 전 업체명 리스트를 확인하는 과정에서는 로그인 전 단계이므로 로그를 저장할 수 없음
if request_type == "search_company":
# 로그 API 호출
# 상태코드 : 요청
# 요청코드 : 업체정보 조회
# log_status = 'LGSTA0001'
# log_request = 'LGPAT0001'
# log(user_id, log_status, log_request)
print("")
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "exception error"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
def upload_file(user_key, log_request, index, file, file_name, file_size):
# log_request = "set_user_info"
print("********** " + log_request + " **********")
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
# 파일이 실제로 존재하는 지 확인
if not file:
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
return send
# 입력받은 사용자 키를 이용하여 사용자의 아이디 조회
send = get_user_info_from_key(user_key)
user_id = send['data'][0]['result_data_1']
# 서버에 저장할 첨부파일명 변경(현재날짜 + 현재시간 + 등록한 사용자 ID)
if file_name:
file_name_split = file_name.split('.')
extension = file_name_split[1]
else:
extension = "zip"
file_name_ori = file_name
file_name = time.strftime('%Y%m%d%H%M%S', time.localtime(
time.time())) + user_id + "." + extension
# 각 요청에 따라 경로 설정 및 수정 프로시저 호출
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
# 인식모듈 등록 또는 수정을 요청헀을 경우
if log_request == 'LGMOD0005' or log_request == 'LGMOD0003':
file_path = module_path
# 인식모듈 수정을 요청하여 원래 게시글에 첨부파일이 존재했었을 경우(첨부파일 변경)
# 입력한 인덱스에 해당하는 게시글에 저장되어있던 첨부파일이 존재하는지 확인하기 위한 절차이므로 인식모듈 상세조회 코드 입력(기본권한, 작성자 중요X)
send = get_module_info(user_key, "LGMOD0001", index)
if send['data'][0]['FILE_EXIST_FLAG'] == "Y":
file_path_exist = send['data'][0]['FILE_PATH']
file_name_exist = send['data'][0]['FILE_NAME']
# 서버에 등록된 파일 삭제
del_file_dir(file_path_exist, file_name_exist)
file_exist_flag = "Y"
# 인식모듈 테이블에 파일 정보 저장
cursor.callproc('SP_KEYM_SET_MODULE_FILE_INFO', [
index, file_name_ori, file_name, file_path, file_size,
file_exist_flag
])
# 공지사항 등록 또는 수정을 요청했을 경우
else:
file_path = notice_path
# 공지사항 파일 테이블에 파일 정보 저장
# 해당 경로에 변경한 이름으로 파일 서버에 업로드
createFolder(file_path)
file.save(file_path + file_name)
# 로그 API 호출
# 상태코드 : 요청
# 요청코드 : 인식모듈 등록 또는 수정 또는 공지사항 등록 또는 수정
# log_status = 'LGSTA0001'
# log(user_id, log_status, log_request)
data = []
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# 로그 API 호출
# 상태코드 : 예외
# 요청코드 : 인식모듈 등록 또는 수정 또는 공지사항 등록 또는 수정
# log_status = 'LGSTA0005'
# log(user_id, log_status, log_request)
data = []
status = '401'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
return send
finally:
connection.close()
def del_file(user_key, log_request, index):
# log_request = "set_user_info"
print("********** " + log_request + " **********")
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
input_list = [user_key, log_request, index]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
data = []
result = "fail"
status = "402"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
return send
# 각 요청에 따라 경로 설정 및 수정 프로시저 호출
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
# 입력받은 사용자 키를 이용하여 사용자의 아이디 조회
send = get_user_info_from_key(user_key)
user_id = send['data'][0]['result_data_1']
file_path_exist = None
file_name_exist = None
try:
# 인식모듈 삭제 'LGMOD0004'
if log_request == 'LGMOD0004':
request_auth = 'AUMOD0004'
# 요청한 게시글에 실제 저장되어 있던 파일이 있는지 확인
# 입력한 인덱스에 해당하는 게시글에 저장되어있던 첨부파일이 존재하는지 확인하기 위한 절차이므로 인식모듈 상세조회 코드 입력(기본권한, 작성자 중요X)
send = get_module_info(user_key, "LGMOD0001", index)
# 파일이 존재하지 않았을 경우
if send['data'][0]['FILE_EXIST_FLAG'] == "N" or send['data'][0][
'FILE_EXIST_FLAG'] == None:
data = []
result = "fail"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
return send
file_path_exist = send['data'][0]['FILE_PATH']
file_name_exist = send['data'][0]['FILE_NAME']
file_name_ori = None
file_name = None
file_path = module_tmp_path
file_size = None
file_exist_flag = "N"
# 인식모듈 테이블에 파일 정보 저장
cursor.callproc('SP_KEYM_SET_MODULE_FILE_INFO', [
index, file_name_ori, file_name, file_path, file_size,
file_exist_flag
])
# 공지사항 삭제 'LGNOT0003'
elif log_request == 'LGNOT0003':
request_auth = 'AUNOT0003'
# 서버에 저장된 파일 삭제
del_file_dir(file_path_exist, file_name_exist)
# 로그 API 호출
# 상태코드 : 예외
# 요청코드 : 인식모듈 삭제 또는 공지사항 삭제
# log_status = 'LGSTA0005'
# log(user_id, log_status, log_request)
data = []
status = '200'
result = "success"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# 로그 API 호출
# 상태코드 : 예외
# 요청코드 : 인식모듈 삭제 또는 공지사항 삭제
# log_status = 'LGSTA0005'
# log(user_id, log_status, log_request)
data = []
status = '401'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
return send
finally:
connection.close()
def get_module_list(user_key, module_name, user_name, version, memo, date_reg_start, date_reg_end, currentpage,
countperpage):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request get_module_info", extra=logger_data)
log_request = "get_module_list"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
logger.info("Request set_user_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['module_name'] = module_name
input['user_name'] = user_name
input['version'] = version
input['memo'] = memo
input['date_reg_start'] = date_reg_start
input['date_reg_end'] = date_reg_end
input['currentpage'] = currentpage
input['countperpage'] = countperpage
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
input_list = [user_key, module_name, user_name, version, memo, date_reg_start, date_reg_end, currentpage, countperpage]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "404"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 검색 내용이 없을 경우 0을 입력 받음
# 0으로 받았을 경우 None 으로 설정
if module_name == "0":
module_name = None
if user_name == "0":
user_name = None
if version == "0":
version = None
if memo == "0":
memo = None
if date_reg_start == "0":
date_reg_start = None
if date_reg_end == "0":
date_reg_end = None
if currentpage == "0":
currentpage = None
if countperpage == "0":
countperpage = None
# 입력받은 사용자 키를 이용하여 사용자의 아이디, 권한 조회
send = get_user_info_from_key(user_key)
logger.info("Get user information", extra=logger_data)
# 접속해있는 사용자가 아닐 경우
if send['status'] == "201":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 접속 여부 확인 도중 DB 에러가 난 경우
elif send['status'] == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = send['data'][0]['error']
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 현재 접속 중인 사용자일 경우
elif send['status'] == "200":
# 인식모듈 조회 권한이 있는지 확인
user_auth_list = send['data'][0]['AUTH']
# 인식모듈 조회 권한 'AUMOD0001'
request_auth = 'AUMOD0001'
logger.info("Check authority", extra=logger_data)
for auth in user_auth_list:
user_id = send['data'][0]['result_data_1']
# 권한이 존재하는 경우
if auth == request_auth:
logger.info("Authority exists", extra=logger_data)
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
# 인식모듈 조회하는 포르시저 호출
try:
cursor.callproc('SP_KEYM_GET_MODULE_LIST', [module_name, user_name, version, memo,
date_reg_start, date_reg_end, currentpage,
countperpage])
column_names_list = [x[0] for x in cursor.description]
result_module_info = []
for row in cursor.fetchall():
result_module_info.append(dict(zip(column_names_list, row)))
for module_info in result_module_info:
if module_info['FILE_EXIST_FLAG'] == None:
module_info['FILE_EXIST_FLAG'] = "N"
if not result_module_info:
data = []
result = "success"
status = "201"
else:
data = result_module_info
result = "success"
status = "200"
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "get_module_list success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message,
success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "exception error"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '403'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
def add_company(user_key, com_name, com_address, phone_number, email, memo, day_max_count, max_count, date_max):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request add_company", extra=logger_data)
log_request = "add_company"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
logger.info("Request set_user_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['com_name'] = com_name
input['com_address'] = com_address
input['phone_number'] = phone_number
input['email'] = email
input['memo'] = memo
input['day_max_count'] = day_max_count
input['max_count'] = max_count
input['date_max'] = date_max
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
input_list = [user_key, com_name, com_address, phone_number, email, memo, day_max_count, max_count, date_max]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "416"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 업체를 등록한 사용자 ID
add_user_id = "admin01"
# DB 에서 조회한 사용자 정보
user_info = {}
status = check_text('user_key', user_key)
# 사용자의 키가 8자리 str, 0~9사이의 문자가 아니면 등록한 사용자 ID null 값으로 지정(회원가입 전 업체 자가 등록 요청)
if len(user_key) != 8 or type(user_key) != str or status == "400":
status = "200"
user_info['AUTH'] = "AUPAT0006"
requset_type = "add_company_user"
# 사용자의 키로 사용자 아이디 조회
else:
user_info = get_user_info_from_key(user_key)
logger.info("Get user information", extra=logger_data)
# 업체 정보를 등록하려는 사용자의 아이디
add_user_id = user_info['data'][0]['result_data_1']
requset_type = ""
# AUPAT0006(업체정보 자가 등록)만 있을 경우 키 발급 설정란은 null 값으로 지정(다른 값 타입, 크기 확인)
# AUPAT0005(업체정보 등록)만 있을 경우 키 발급 설정란은 null 값으로 지정(다른 값 타입, 크기 확인)
# AUPAT0006, AUPAT0005, AUPAT0004(업체정보 키 발급 설정)이 있을 경우 변경 X(다른 값 타입, 크기 확인)
for auth in user_info['data'][0]['AUTH']:
# 모든 사용자가 AUPAT0006 권한을 가진다는 전제
if auth == 'AUPAT0006':
if 'AUPAT0005' in user_info['data'][0]['AUTH']:
if 'AUPAT0004' in user_info['data'][0]['AUTH']:
requset_type = "add_company_admin_key"
else:
requset_type = "add_company_admin"
else:
requset_type = "add_company_user"
# 회원가입 시 업체정보 자가 등록을 요청했을 경우
if requset_type == "add_company_user":
day_max_count = None
max_count = None
date_max = None
add_user_id = None
# 관리자가 업체정보 등록을 요청했을 경우
elif requset_type == "add_company_admin":
day_max_count = None
max_count = None
date_max = None
# 관리자가 업체정보 등록 + 키 발급 설정을 요청했을 경우 설정하는 값 X
# 업체명 중복 확인
com_list = get_company_list(user_key, com_name, '0', '0')
logger.info("Check duplication of company name", extra=logger_data)
if com_list:
com_list = com_list['data']
else:
com_list['data'] = []
for com_info in com_list:
com_name_exist = com_info['COMPANY_NAME']
# 업체명이 중복될 경우
if com_name_exist == com_name:
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Company name duplicates"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 입력된 정보 타입, 크기 확인
# 업체명
if len(com_name) == 0 or len(com_name) > 100:
status = "401"
if type(com_name) != str:
status = "402"
# 주소
if len(com_address) > 100:
status = "403"
if type(com_address) != str:
status = "404"
# 전화번호
if len(phone_number) < 12 or len(phone_number) > 13:
status = "405"
if type(com_name) != str:
status = "406"
# 이메일
if len(email) > 100:
status = "407"
if type(email) != str:
status = "408"
# 메모
if len(memo) > 255:
status = "409"
if type(memo) != str:
status = "410"
# 하루 최대 발급 개수
if type(day_max_count) != int:
status = "411"
# 최대 발급 개수
if type(max_count) != int:
status = "412"
# 최대 발급 날짜
if type(date_max) != str:
status = "413"
# null 가능 값 중 입력하지 않은 값 null 설정
if not com_address or com_address == "":
com_address = None
if not phone_number or phone_number == "":
phone_number = None
if not email or email == "":
email = None
if not memo or memo == "":
memo = None
if not day_max_count or day_max_count == "":
day_max_count = None
if not max_count or max_count == "":
max_count = None
if date_max is not None:
convert_date = datetime.datetime.strptime(date_max, "%Y-%m-%d").date()
else:
convert_date = None
# 업체 저장
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
cursor.callproc('SP_KEYM_ADD_COM_INFO', [com_name, com_address, phone_number, email, memo, day_max_count,
max_count, convert_date, add_user_id])
logger.info("Save company information", extra=logger_data)
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "exception error"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '414'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
# 업체를 등록한 후 등록된 모든 업체 리스트를 불러옴
com_list = get_company_list(user_key, '', '0', '0')
logger.info("Get company information", extra=logger_data)
send = {}
# 업체 리스트 조회 시 에러가 났을 경우
if com_list['status'] == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "An error occurred while inquiring about the company"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
error = {}
error['error'] = message
data = []
data.append(error)
result = "fail"
status = "415"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
else:
status = "200"
com_list = com_list['data']
# 등록이 성공했을 경우 로그 저장
# 상태코드 : 요청
if status == "200":
log_status = 'LGSTA0001'
if requset_type == "add_company_user":
# 요청코드 : 업체정보 자가 등록
log_request = 'LGPAT0006'
elif requset_type == "add_company_admin":
# 요청코드 : 업체정보 등록
log_request = 'LGPAT0005'
else:
# 요청코드 : 업체정보 키 발급 설정
log_request = 'LGPAT0004'
# log(add_user_id, log_status, log_request)
data = com_list
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "add_company success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
def down_module(user_key, module_index):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request down_module", extra=logger_data)
log_request = "down_module"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
logger.info("Request set_user_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['module_index'] = module_index
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
input_list = [user_key, module_index]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "403"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 입력받은 사용자 키를 이용하여 사용자의 아이디, 권한 조회
send = get_user_info_from_key(user_key)
logger.info("Get user information", extra=logger_data)
# 접속해있는 사용자가 아닐 경우
if send['status'] == "201":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 접속 여부 확인 도중 DB 에러가 난 경우
elif send['status'] == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = send['data'][0]['error']
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 현재 접속 중인 사용자일 경우
elif send['status'] == "200":
# 인식모듈 조회 권한이 있는지 확인
user_auth_list = send['data'][0]['AUTH']
# 인식모듈 다운로드 권한 'AUMOD0002'
request_auth = 'AUMOD0002'
logger.info("Check authority", extra=logger_data)
for auth in user_auth_list:
user_id = send['data'][0]['result_data_1']
# 권한이 존재하는 경우
if auth == request_auth:
logger.info("Authority exists", extra=logger_data)
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
# 해당 모듈 게시글의 정보 조회
# 다운로드하기위해 인식모듈 게시글 정보를 조회하는 것 이므로 조회수 증가하지 않음
count_click = "N"
cursor.callproc('SP_KEYM_GET_MODULE_DETAILS_INFO', [module_index, count_click])
logger.info("get module post information", extra=logger_data)
column_names_list = [x[0] for x in cursor.description]
result_module_info = []
for row in cursor.fetchall():
result_module_info.append(dict(zip(column_names_list, row)))
# 조회한 첨부파일 정보 설정
file_path = result_module_info[0]['FILE_PATH']
file_name = result_module_info[0]['FILE_NAME']
file_name_ori = result_module_info[0]['FILE_NAME_ORI']
file_exist_flag = result_module_info[0]['FILE_EXIST_FLAG']
# 다운로드 요청한 게시글에 첨부파일이 존재하지 않을 경우
if file_exist_flag == "N":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Attachment does not exist"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message,
success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "402"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 해당 경로에 저장된 파일 찾아 변수에 저장
file = file_path + file_name
module_info = {}
module_info['FILE_PATH'] = file_path
module_info['FILE_NAME'] = file_name
module_info['FILE_NAME_ORI'] = file_name_ori
module_info['FILE'] = file
# 다운로드 수 1 증가
cursor.callproc('SP_KEYM_SET_MODULE_DOWM_INFO', [module_index])
logger.info("The number of downloads has increased", extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = module_info
message = "down_module success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
data = []
data.append(module_info)
status = '200'
result = "success"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "exception error"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '402'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
def add_module_info(user_key, module_name, version, memo):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request create_qr", extra=logger_data)
log_request = "add_module_info"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
logger.info("Request set_user_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['module_name'] = module_name
input['version'] = version
input['memo'] = memo
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
input_list = [user_key, module_name, version, memo]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "404"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 입력받은 사용자 키를 이용하여 사용자의 아이디, 권한 조회
send = get_user_info_from_key(user_key)
logger.info("Get user information", extra=logger_data)
# 접속해있는 사용자가 아닐 경우
if send['status'] == "201":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 접속 여부 확인 도중 DB 에러가 난 경우
elif send['status'] == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = send['data'][0]['error']
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 현재 접속 중인 사용자일 경우
elif send['status'] == "200":
# 인식모듈 등록 권한이 있는지 확인
user_auth_list = send['data'][0]['AUTH']
# 인식모듈 등록 권한 'AUMOD0005'
request_auth = 'AUMOD0005'
logger.info("Check authority", extra=logger_data)
for auth in user_auth_list:
# 권한이 존재하는 경우
if auth == request_auth:
logger.info("Authority exists", extra=logger_data)
# 인식모듈 게시글을 등록한 사용자 id
user_id = send['data'][0]['result_data_1']
# 첨부파일이 존재하지 않을 경우 첨부파일 관련 정보 None 으로 설정
file_name_ori = None
file_name = None
file_path = module_tmp_path
file_size = None
logger.info("You have not added an attachment to the post",
extra=logger_data)
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
# 인식모듈 게시글을 저장하는 포르시저 호출
try:
cursor.callproc('SP_KEYM_ADD_MODULE_INFO', [
user_id, module_name, file_name_ori, file_name,
file_path, file_size, version, memo
])
logger.info("save module post information",
extra=logger_data)
# 등록한 모듈의 인덱스값을 반환하기 위해 등록되어있는 모듈 게시글의 모든 정보를 가져옴
send = get_module_list(user_key, "0", "0", "0", "0", "0",
"0", "0", "0")
# 등록된 모듈 게시글의 인덱스값이 가장 큰 값(가장 최신값)을 저장
module_list = send['data']
module_index = module_list[0]['IX_KMMITN_MODULEINFO']
data = []
module_info = {}
module_info['index'] = module_index
data.append(module_info)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "add_module_info success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
status = "200"
result = "success"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "exception error"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '403'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
# 인식모듈 등록 권한이 존재하지 않는 경우
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "permission error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "402"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
def set_user_info(user_key, log_request, user_pw, user_name, company_name,
department, position, phone_number, email):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request set_user_info", extra=logger_data)
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['log_request'] = log_request
input['user_pw'] = user_pw
input['user_name'] = user_name
input['company_name'] = company_name
input['department'] = department
input['position'] = position
input['phone_number'] = phone_number
input['email'] = email
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
# log_request = "set_user_info"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, "set_user_info")
input_list = [
user_key, log_request, user_pw, user_name, company_name, department,
position, phone_number, email
]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "403"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 요청코드 종류 : 자기 정보 수정, 사용자 정보 수정
# 자기 정보 수정 'LGUSE0010'
# user_pw, company_name, department, position, phone_number, email 수정가능
if log_request == "LGUSE0010":
request_type = "set_my_info"
# 사용자 정보 수정 'LGUSE0005'
# user_name, company_name, department, position, phone_number, email 수정가능
elif log_request == "LGUSE0005":
request_type = "set_user_info"
# 위 패턴으로 요청한 기능 판단
send = check_auth(user_key, request_type)
data = []
status = send['status']
# 접속해 있는 사용자가 아닌 경우
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 필요한 권한이 존재하지 않는 경우
elif status == "401":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "You don't have permission"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 필요한 권한이 존재하는 경우
elif status == "200":
# API 를 호출한 사용자의 ID
user_id = send['data'][0]['result_data_1']
if request_type == "set_my_info":
user_name = None
# 비밀번호는 수정하지 않는 경우
if user_pw == '0':
user_pw = None
elif request_type == "set_user_info":
user_pw = None
# 사용자 정보 수정하는 프로시저 호출
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
cursor.callproc('SP_KEYM_SET_USR_INFO', [
user_id, user_pw, user_name, company_name, department,
position, phone_number, email
])
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "set_user_info success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "exception error"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
result = "fail"
status = "402"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
def get_user_info(user_key, user_id, log_request):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
# user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request get_user_info", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_id'] = user_id
input['user_ip'] = user_ip
input['log_request'] = log_request
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, "get_user_info")
input_list = [user_key, user_id, "get_user_info"]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "403"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 사용자 (상세)정보 조회(user_key)
if log_request == 'LGUSE0004':
request_type = "get_user_info"
# 사용자 정보 수정(user_key)
elif log_request == 'LGUSE0005':
request_type = "set_user_info"
# 자기 정보 수정(user_key)
elif log_request == 'LGUSE0010':
request_type = "set_my_info"
# ID 중복 확인(user_id)
else:
request_type = "login_before"
# 요청이 ID 중복 확인일 경우 user_id 로 사용자 정보 조회
if request_type == "login_before":
status = check_text('id', user_id)
# 입력받은 ID가 영어, 숫자 이외의 문자가 있는 경우
if status == '400':
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "The conditions of the input value are not correct"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
cursor.callproc('SP_KEYM_GET_USR_DETAILS_INFO', [user_id])
column_names_list = [x[0] for x in cursor.description]
result_user_info = []
for row in cursor.fetchall():
result_user_info.append(dict(zip(column_names_list, row)))
print(result_user_info)
# 입력한 ID에 해당하는 사용자 정보가 존재하지 않는 경우
if not result_user_info:
data = []
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "User information does not exist"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "201"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
# 입력한 ID에 해당하는 사용자 정보가 존재하는 경우
userinfo = result_user_info[0]
auth_list = userinfo['AUTH'].split(',')
userinfo['AUTH'] = auth_list
data = result_user_info
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "get_user_info success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = '200'
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "exception error"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '401'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
# 요청이 ID 중복 확인이 아닌 경우 user_key 로 권한 조회 후 사용자 정보 조회
else:
user_info = get_user_info_from_key(user_key)
user_auth_list = user_info['data'][0]['AUTH']
user_id = user_info['data'][0]['result_data_1']
request_auth = ""
# 요청이 사용자 (상세) 정보 조회인 경우
if request_type == "get_user_info":
request_auth = 'AUUSE0001'
# 요청이 사용자 정보 수정에서 조회한 경우
elif request_type == "set_user_info":
request_auth = 'AUUSE0002'
# 요청이 자기 정보 수정에서 조회한 경우
elif request_type == "set_my_info":
request_auth = 'AUUSE0007'
for auth in user_auth_list:
# 요청한 권한이 존재하는 경우
if auth == request_auth:
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
cursor.callproc('SP_KEYM_GET_USR_DETAILS_INFO', [user_id])
column_names_list = [x[0] for x in cursor.description]
result_user_info = []
for row in cursor.fetchall():
result_user_info.append(
dict(zip(column_names_list, row)))
# 입력한 ID에 해당하는 사용자 정보가 존재하지 않는 경우
if not result_user_info:
data = []
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "User information does not exist"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "201"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
# 입력한 ID에 해당하는 사용자 정보가 존재하는 경우
userinfo = result_user_info[0]
auth_list = userinfo['AUTH'].split(',')
userinfo['AUTH'] = auth_list
data = result_user_info
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "get_user_info success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = e
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '401'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
# 요청하는 권한이 존재하지 않는 경우
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "ERROR"
output = ""
message = "permission error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "402"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
def get_key_info(user_key, index):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request get_key_info", extra=logger_data)
log_request = "get_key_info"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
logger.info("Request set_user_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['index'] = index
input_list = [user_key, index]
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
# check_text : 입력받은 문자열이 적합한지 판단
# check_text(문자열 타입, 문자열)
# 문자열 타입이 input_db 일 경우 db 에 입력할 수 있는지 판단(특수문자 여부)
status = check_text("input_db", input_data)
# 문자열에 특수문자가 있는 경우
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "403"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 입력받은 사용자 키를 이용하여 사용자의 아이디, 권한 조회
send = get_user_info_from_key(user_key)
logger.info("Get user information", extra=logger_data)
# 접속해있는 사용자가 아닐 경우
if send['status'] == "201":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 접속 여부 확인 도중 DB 에러가 난 경우
elif send['status'] == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = send['data'][0]['error']
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 현재 접속 중인 사용자일 경우
elif send['status'] == "200":
# 인식키 조회 권한이 있는 확인
user_auth_list = send['data'][0]['AUTH']
# 인식키 조회 권한 'AUKEY0003'
request_auth = 'AUKEY0003'
logger.info("Check authority", extra=logger_data)
for auth in user_auth_list:
# 권한이 존재하는 경우
if auth == request_auth:
logger.info("Authority exists", extra=logger_data)
# 인식키 정보 조회
cursor.callproc('SP_KEYM_GET_KEY_DETAILS_INFO', [index])
column_names_list = [x[0] for x in cursor.description]
result_key_info = []
for row in cursor.fetchall():
result_key_info.append(
dict(zip(column_names_list, row)))
key_info = result_key_info[0]
# 인식키를 발급받은 사용자의 아이디
user_id = key_info['FK_KMKITN_KEYINFO']
# 사용자 정보 조회
user_info = get_user_info(user_key, user_id, '0')
user_info = user_info['data']
# 사용자 상태 한글로 변경
for info in user_info:
info['LOGIN'] = "******"
if info['DELETE_FLAG'] == "Y":
info['LOGIN'] = "******"
elif info['WITHDRAW_FLAG'] == "Y":
info['LOGIN'] = "******"
logger.info("change the state of a user",
extra=logger_data)
# 사용자 비밀번호가 속해있을 경우 삭제
key_list = user_info[0].keys()
# get_user_info 이용하여 가져온 정보 중 get_key_info 에서 필요없는 정보 제외
if "AUTH" in key_list:
del user_info[0]["AUTH"]
if "AUTH_GROUP_NAME" in key_list:
del user_info[0]["AUTH_GROUP_NAME"]
if "AUTH_GRUOP_ID" in key_list:
del user_info[0]["AUTH_GRUOP_ID"]
if "DATE_LAST" in key_list:
del user_info[0]["DATE_LAST"]
if "DATE_REG" in key_list:
del user_info[0]["DATE_REG"]
if "DELETE_FLAG" in key_list:
del user_info[0]["DELETE_FLAG"]
if "FK_KMUITN_USERINFO" in key_list:
del user_info[0]["FK_KMUITN_USERINFO"]
if "LOGIN_APPROVAL_FLAG" in key_list:
del user_info[0]["LOGIN_APPROVAL_FLAG"]
if "SESSION_ID" in key_list:
del user_info[0]["SESSION_ID"]
if "TIME_LAST" in key_list:
del user_info[0]["TIME_LAST"]
if "TIME_REG" in key_list:
del user_info[0]["TIME_REG"]
if "WITHDRAW_FLAG" in key_list:
del user_info[0]["WITHDRAW_FLAG"]
logger.info(
"Delete information that is not needed for the output",
extra=logger_data)
# 아이디가 총 두번 포함되므로 제외
if "result_data_1" in key_list:
del user_info[0]["result_data_1"]
# 비밀번호 제외
if "result_data_2" in key_list:
del user_info[0]["result_data_2"]
# 출력값에 인식키 정보와 사용자의 정보가 모두 필요하므로 인식키 정보와 사용자 정보를 가지는 딕셔너리를 합침
key_info.update(user_info[0])
data = []
data.append(key_info)
# 로그 저장
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "REQUEST"
output = data
message = "get_key_info success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
# 인식키 조회 권한이 존재하지 않을 경우
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "permission error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "404"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = e
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '402'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
def issue_key(user_key, index, user_ip, req_serial, version, memo):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
# user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request issue_key", extra=logger_data)
log_request = "issue_key"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
logger.info("Request set_user_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['index'] = index
input['req_serial'] = req_serial
input['version'] = version
if memo == "0":
memo = None
input['memo'] = memo
log_request = "issue_key"
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
# 입력받은 사용자 키를 이용하여 사용자의 아이디, 권한 조회
send = get_user_info_from_key(user_key)
logger.info("Get user information", extra=logger_data)
# 접속해있는 사용자가 아닐 경우
if send['status'] == "201":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 접속 여부 확인 도중 DB 에러가 난 경우
elif send['status'] == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = send['data'][0]['error']
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 현재 접속 중인 사용자일 경우
elif send['status'] == "200":
# 이미지가 실제로 존재하는 지 확인
'''
if not image:
data = []
result = "fail"
status = "402"
send = set_send(data, result, status)
return send
'''
# 인식키 발급 권한이 있는지 확인
user_auth_list = send['data'][0]['AUTH']
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
logger.info("Check authority", extra=logger_data)
try:
user_id = send['data'][0]['result_data_1']
# 사용자 정보 조회
cursor.callproc('SP_KEYM_GET_USR_DETAILS_INFO', [user_id])
column_names_list = [x[0] for x in cursor.description]
result_user_info = []
for row in cursor.fetchall():
result_user_info.append(dict(zip(column_names_list, row)))
company_id = result_user_info[0]['FK_KMUITN_USERINFO']
# phone_number = result_user_info[0]['PHONE_NUMBER']
# 전화번호가 하이픈(-)이 포함된 채로 저장되어 있었을 경우
'''
if '-' in phone_number:
print(phone_number)
number_list = phone_number.split('-')
phone_number = ""
for number_list in (0, len(number_list)-1):
print(number_list)
phone_number += number_list
print(phone_number)
'''
# 사용자가 속해있는 회사 정보 조회
cursor.callproc('SP_KEYM_GET_COM_DETAILS_INFO', [company_id])
column_names_list = [x[0] for x in cursor.description]
result_company_info = []
for row in cursor.fetchall():
result_company_info.append(dict(zip(column_names_list, row)))
user_code = result_company_info[0]['USER_CODE']
# user_code = "fa"
phone_number = "01027231797"
# 인식키 발급 권한 : 직원 발급 요청 'AUKEY0001', 파트너 발급 요청 'AUKEY0002'
if user_code == "fa":
request_auth = "AUKEY0001"
else:
request_auth = "AUKEY0002"
for auth in user_auth_list:
# 권한이 있을 경우 이미지 이름 변경 후 서버에 이미지 업로드
if auth == request_auth:
logger.info("Authority exists", extra=logger_data)
code_check_version = "version"
app_version = key_data['app_version']
# check_version API 호출 (GET)
url_check_version = key_url + user_code + "/" + phone_number + "/" + code_check_version + "/" + app_version + "/Keona"
response_check_version = requests.get(url_check_version)
logger.info("call check_version API", extra=logger_data)
data_check_version = json.loads(
response_check_version.text)
if data_check_version['Result'] == "ok":
logger.info("check_version API call succeeded",
extra=logger_data)
session_key = data_check_version['SessionKey']
# check_version API 호출 실패
else:
logger.info("check_version API call failed",
extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "REQUEST"
output = data_check_version
message = "check_version API error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "403"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# DB 저장
cursor.callproc('SP_KEYM_ADD_KEY_VERSION_INFO', [
index, company_id, user_code, user_id, phone_number,
app_version, session_key
])
logger.info("save check_version API information",
extra=logger_data)
column_names_list = [x[0] for x in cursor.description]
result_key_info = []
for row in cursor.fetchall():
result_key_info.append(
dict(zip(column_names_list, row)))
# key version 테이블에 저장한 index 로 변경하여 key_info 테이블에 해당 index 로 저장
index = result_key_info[0]['IN_INT_PK_KMKVTN_KEYVERSION']
code_create_key = "makekey"
# ip 이용하여 주소 정보 찾기
location_data = get_default_location(user_id)
logger.info("Find address information using ip",
extra=logger_data)
country = location_data['geoLocation']['country']
r1 = location_data['geoLocation']['r1']
r2 = location_data['geoLocation']['r2']
r3 = location_data['geoLocation']['r3']
address = r1 + " " + r2 + " " + r3
latitude = str(location_data['geoLocation']['lat'])
longitude = str(location_data['geoLocation']['long'])
logger.info("call create_key API", extra=logger_data)
# create_key API 호출 (POST)
url_create_key = key_url + user_code + "/" + session_key + "/" + code_create_key + "/" + version + "/Keona"
location = latitude + "," + longitude
post_data = {
"location": location,
"phonenumber": phone_number,
"req_serial": req_serial
}
response_create_key = requests.post(url_create_key,
data=post_data)
data_create_key = json.loads(response_create_key.text)
if data_create_key['Result'] != "ok":
logger.info("create_key API call failed",
extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "ERROR"
output = data_create_key
message = "create_key API error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "404"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
logger.info("create_key API call succeeded",
extra=logger_data)
data_create_key['qr_key'] = req_serial
issue_key = data_create_key['Key']
city = r1
state = r2
street = r3
user_name = result_user_info[0]['USER_NAME']
# DB 저장
cursor.callproc('SP_KEYM_ADD_KEY_INFO', [
index, company_id, user_code, user_id, user_name,
session_key, version, latitude, longitude,
phone_number, req_serial, issue_key, memo, address,
country, city, state, street
])
logger.info("save create_key API information",
extra=logger_data)
column_names_list = [x[0] for x in cursor.description]
result_key_info = []
for row in cursor.fetchall():
result_key_info.append(
dict(zip(column_names_list, row)))
data = []
data.append(data_create_key)
# 로그 저장
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "REQUEST"
output = data
message = "issue_key success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
# 인식키 발급 권한이 존재하지 않을 경우
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "ERROR"
output = ""
message = "permission error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "405"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# 회사 API 연결에 실패한 경우 랜덤값 출력하는 파일로 연결
print("10061" in str(e))
if "10061" in str(e):
# DB 에 저장할 check_version api 값 임의 설정
check_version_api_value = {}
check_version_api_value['index'] = index
check_version_api_value['company_id'] = company_id
check_version_api_value['user_code'] = user_code
check_version_api_value['user_id'] = user_id
check_version_api_value['phone_number'] = phone_number
check_version_api_value['app_version'] = app_version
check_version_api_value['session_key'] = "session_key_tmp"
# DB 에 저장할 create_key api 값 임의 설정
create_key_api_value = {}
create_key_api_value['index'] = index
create_key_api_value['company_id'] = company_id
create_key_api_value['user_code'] = user_code
create_key_api_value['user_id'] = user_id
create_key_api_value['user_name'] = result_user_info[0][
'USER_NAME']
create_key_api_value['session_key'] = "session_key_tmp"
create_key_api_value['version'] = version
# ip 이용하여 주소 정보 찾기
location_data = get_default_location(user_id)
country = location_data['geoLocation']['country']
r1 = location_data['geoLocation']['r1']
r2 = location_data['geoLocation']['r2']
r3 = location_data['geoLocation']['r3']
address = r1 + " " + r2 + " " + r3
latitude = str(location_data['geoLocation']['lat'])
longitude = str(location_data['geoLocation']['long'])
create_key_api_value['latitude'] = latitude
create_key_api_value['longitude'] = longitude
create_key_api_value['phone_number'] = phone_number
create_key_api_value['req_serial'] = req_serial
create_key_api_value['issue_key'] = None
create_key_api_value['memo'] = memo
create_key_api_value['address'] = address
create_key_api_value['country'] = country
city = r1
state = r2
street = r3
create_key_api_value['city'] = city
create_key_api_value['state'] = state
create_key_api_value['street'] = street
Key = issue_key_random_result(version, check_version_api_value,
create_key_api_value)
print("대체 함수 실행")
key_result = {}
key_result['Key'] = Key
key_result['Result'] = "success"
key_result['qr_key'] = req_serial
data = []
data.append(key_result)
status = "201"
result = "success"
send = set_send(data, result, status)
return send
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = ""
log_status = "EXCEPTION"
output = ""
message = e
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '480'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
