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 login(user_id, user_pw):
# 로그를 남기기 위한 값
# 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 login", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_id'] = user_id
input['user_pw'] = user_pw
log_request = "login"
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
input_list = [user_id, user_pw]
# 입력값에서 디비 또는 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 = "412"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# ID, PW 조건 확인
# 상태코드 리턴
status_id = check_text('id', user_id)
status_pw = check_text('pw', user_pw)
# ID에 영어, 숫자 이외의 문자가 존재할 경우
if status_id == "400":
userinfo = {}
data = []
data.append(userinfo)
# 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)
result = "fail"
status = status_id
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# PW에 영어, 숫자 이외의 문자가 존재할 경우
elif status_pw == "400":
userinfo = {}
data = []
data.append(userinfo)
# 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)
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()
# 접속 테이블에서 동일 아이피 존재 확인
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
status = ""
try:
cursor.callproc('SP_KEYM_GET_USR_INFO_IP', [user_ip])
column_names_list = [x[0] for x in cursor.description]
result_user_access_info = []
for row in cursor.fetchall():
result_user_access_info.append(dict(zip(column_names_list, row)))
# 접속 테이블에 동일한 ip가 존재할 경우 로그아웃
if result_user_access_info:
# 로그아웃 API 호출
send = logout(user_ip)
# IP가 입력이 제대로 되지 않은 경우
if send['status'] == "400":
send['status'] = "402"
# 동일한 IP로 접속한 사용자가 없을 경우
elif send['status'] == "401":
send['status'] = "403"
# DB 조회 시 에러가 난 경우
elif send['status'] == "402":
send['status'] = "404"
elif send['status'] == "403":
send['status'] = "412"
# 동일한 IP로 접속한 사용자가 존재하여 접속해 있던 사용자는 로그아웃 되는 경우
elif send['status'] == "200":
send['result'] = "success"
send['status'] = "201"
if send['status'] != "201":
data = []
# 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)
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
else:
status = "201"
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 = "406"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
# 사용자 테이블에서 사용자 정보 조회
userinfo = {}
try:
cursor.callproc('SP_KEYM_GET_USR_INFO_ID_PW', [user_id, user_pw])
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와 PW를 가지는 사용자가 존재할 경우 로그인 성공
if result_user_info:
userinfo = result_user_info[0]
# 탈퇴한 사용자인 경우
if userinfo['WITHDRAW_FLAG'] == 'Y':
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 = "You have withdrawn"
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 = "410"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 관리자에의해 삭제된 사용자인 경우
if userinfo['DELETE_FLAG'] == 'Y':
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 = "Deleted user"
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 = "410"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
auth_list = userinfo['AUTH'].split(',')
userinfo['AUTH'] = auth_list
# 접속 API 호출
# 사용자 key 반환
access_info = access(user_id, user_ip)
# 접속 테이블에 저장하는 도중 DB 에러가 난 경우
if access_info['status'] == "400":
access_info['status'] = "407"
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = None
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.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
send = access_info
logger.error(send, extra=logger_data)
return send
# 접속 테이블에 저장이 된 경우
userinfo["USER_KEY"] = access_info['data'][0]['result_data_3']
# URL 추가
if userinfo['MAIN_AUTH'] == 'MVIEW0001':
userinfo['URL'] = '/notice'
else:
userinfo['URL'] = '/notadd'
data = []
data.append(userinfo)
result = 'success'
# 동일한 IP로 접속한 사용자가 없어 로그아웃이 되지 않은 경우
if status != "201":
status = "200"
message = "login success"
else:
status = "201"
message = "Logged out because there is a user with the same IP connection"
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
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
# 해당 ID와 PW를 가지는 사용자가 존재하지 않을 경우
else:
data = []
data.append(userinfo)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User information corresponding to the input value 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)
result = "fail"
status = "408"
# 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 = []
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "exception 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)
result = "fail"
status = "409"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
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 get_user_auth(user_key):
# 로그를 남기기 위한 값
# 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_user_info", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
log_request = "get_user_auth"
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
input_list = [user_key]
# 입력값에서 디비 또는 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 = "402"
# 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_ACCESS_INFO', [user_key])
column_names_list = [x[0] for x in cursor.description]
result_dicts = []
for row in cursor.fetchall():
result_dicts.append(dict(zip(column_names_list, row)))
# 입력받은 user_key 에 해당하는 정보가 없는 경우
if not result_dicts:
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User information 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 = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 입력한 key 와 현재 사용자가 접속해 있는 IP 에 해당하는 key 와 일치하는지 확인
for userinfo in result_dicts:
# 추출한 사용자의 key 와 입력한 key 가 정확히 일치하지 않은 경우 = 존재하지 않는 경우
if userinfo['PK_KMAUTN_ACCESSUSER'] != user_key:
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User information 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 = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
userinfo = result_dicts[0]
auth_list = userinfo['AUTH'].split(',')
userinfo['AUTH'] = auth_list
user_auth = {}
user_auth['AUTH'] = userinfo['AUTH']
result_dicts = []
result_dicts.append(user_auth)
data = []
data.append(user_auth)
# 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_auth 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 = []
result = "fail"
status = "401"
# 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 logout(user_ip):
# 로그를 남기기 위한 값
# 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 logout", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_ip'] = user_ip
log_request = "logout"
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
input_list = [user_ip]
# 입력값에서 디비 또는 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_info = {}
user_info['user_ip'] = user_ip
data = []
data.append(user_info)
# IP가 입력이 제대로 되지 않은 경우
if user_ip == '' or user_ip == None:
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User's IP is not extracted"
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"
status = "400"
# 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:
# 현재 접속해있는 사용자 중 동일한 IP를 가지는 사용자의 정보 조회
cursor.callproc('SP_KEYM_GET_USR_INFO_IP', [user_ip])
column_names_list = [x[0] for x in cursor.description]
result_user_access_info = []
for row in cursor.fetchall():
result_user_access_info.append(dict(zip(column_names_list, row)))
# 동일한 IP로 접속한 사용자가 없을 경우
if not result_user_access_info or result_user_access_info == "":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "No user connected with the IP entered"
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"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 로그아웃 실행
cursor.callproc('SP_KEYM_DEL_USR_ACCESS_INFO', [user_ip])
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "logout 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)
reuslt = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, reuslt, 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)
send['status'] = '402'
send['result'] = "fail"
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 add_user_info(user_id, 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 add_user_info", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_id'] = user_id
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
log_request = "add_user_info"
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
status = "200"
# 입력된 정보 타입, 크기 확인
status_id = check_type_len('user_id', user_id)
status_pw = check_type_len('user_pw', user_pw)
status_name = check_type_len('user_name', user_name)
status_company = check_type_len('company', company_name)
status_department = check_type_len('department', department)
status_position = check_type_len('position', position)
status_phone_number = check_type_len('phone_number', phone_number)
status_email = check_type_len('email', email)
logger.info("Check the type and size of the input value",
extra=logger_data)
if status_id == "400":
status = "400"
elif status_id == "401":
status = "401"
if status_pw == "400":
status = "402"
elif status_pw == "401":
status = "403"
if status_name == "400":
status = "404"
elif status_name == "401":
status = "405"
if status_company == "400":
status = "406"
elif status_company == "401":
status = "407"
if status_department == "400":
status = "408"
elif status_department == "401":
status = "409"
if status_position == "400":
status = "410"
elif status_position == "401":
status = "411"
if status_phone_number == "400":
status = "412"
elif status_phone_number == "401":
if phone_number != '0':
status = "413"
else:
status = "200"
if status_email == "400":
status = "414"
elif status_email == "401":
status = "415"
# 입력값 중 하나라도 조건에 맞지 않으면 리턴
if status != "200":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "The type and size of the input value are not appropriate"
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
# 조건이 있는 값 적합성 확인
status_id = check_text('id', user_id)
status_pw = check_text('pw', user_pw)
status_name = check_text('name', user_name)
status_company = check_text('company', company_name)
status_department = check_text('department', department)
logger.info("Check the conditions of the input values", extra=logger_data)
# 조건에 맞지 않은 값이 존재하는 경우
if status_id != "200":
status = "416"
if status_pw != "200":
status = "417"
if status_name != "200":
status = "418"
if status_company != "200":
status = "419"
if status_department != "200":
status = "420"
if status != "200":
# 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
# 입력된 값이 없는 것 중 null 가능 값은 None 으로 변환
if not department or department == "" or department == '0':
department = None
if not position or position == "" or position == '0':
position = None
if not phone_number or phone_number == "" or phone_number == '0':
phone_number = None
if not email or email == "" or email == '0':
email = None
# 아이디 중복 확인
user_list = get_user_info("0", user_id, "login_before")
status = user_list['status']
# ID 에 영어, 숫자 이외의 문자가 있는 경우
if status == "400":
status = "416"
message = "The ID does not meet the conditions"
# 동일한 ID 조회 과정에서 DB 에러가 난 경우
elif status == "401":
status = "421"
message = "DB error occurred while inquiring the same ID"
# 동일한 ID 가 존재하는 경우
elif status == "200":
status = "422"
message = "The same ID exists"
# 동일한 ID 가 존재하지 않는 경우
else:
status = "200"
if status != "200":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
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
# 회사명 존재 확인
company_list = get_company_list('0', company_name, '0', '0')
status = company_list['status']
data = company_list['data']
logger.info("Check that the selected company name exists",
extra=logger_data)
# 동일한 회사명 조회 과정에서 DB 에러가 난 경우
if status == "400":
status = "423"
message = "DB error occurred while inquiring the same company name"
# 동일한 회사명이 존재하지 않는 경우
elif status == "201":
status = "424"
message = "The same company name does not exist"
# 동일한 회사명이 존재하는 경우
else:
for company in data:
company_name_exist = company['COMPANY_NAME']
if company_name == company_name_exist:
status = "200"
# 사용자가 선택한 회사명의 회사 ID
company_id_exist = company['PK_KMPTTN_PARTNER']
break
# 입력한 회사명이 포함되는 회사명이 존재하나 완벽하게 일치하지는 않는 경우 동일한 회사명이 존재하지 않는 경우로 설정
else:
status = "424"
message = "The same company name does not exist"
if status != "200":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
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_ADD_USR_INFO', [
user_id, user_pw, user_name, company_id_exist, department,
position, phone_number, email
])
logger.info("Store the user's 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 = []
result = "fail"
status = "425"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
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 = "add_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
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 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 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 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 get_access_info(user_key):
# 로그를 남기기 위한 값
# 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_access_info", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
log_request = "get_access_info"
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
input_list = [user_key]
# 입력값에서 디비 또는 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
data = []
result = "fail"
status = ""
# 입력이 되었는지 확인
if not user_key:
status = "400"
message = "User key not entered"
if not user_ip:
status = "401"
message = "User's IP is not extracted"
if status == "400" or status == "401":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = None
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)
# 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_INFO_IP', [user_ip])
column_names_list = [x[0] for x in cursor.description]
result_user_access_info = []
for row in cursor.fetchall():
result_user_access_info.append(dict(zip(column_names_list, row)))
for access_info in result_user_access_info:
if access_info['PK_KMAUTN_ACCESSUSER'] != user_key:
# 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 is not connecting"
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 = "201"
result = "success"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
# 접속한 사용자가 있을 경우 리턴
if result_user_access_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_access_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)
data = result_user_access_info
result = "success"
status = "200"
# 접속한 사용자가 없을 경우 리턴
else:
# 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 is not connecting"
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
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)
status = "402"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
