def check_auth(user_key, request_type):
data = []
result = "fail"
# 사용자 정보 조회
user_info = get_user_info_from_key(user_key)
# 접속 정보가 없는 경우
if not user_info['data']:
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
return send
# 동일한 key 에 대한 정보는 하나밖에 존재하지 않음
data = user_info['data']
user_auth_list = data[0]['AUTH']
# 자기 정보 수정 'AUUSE0007'
if request_type == "set_my_info":
request_auth = "AUUSE0007"
# 사용자 정보 수정 'AUUSE0002'
elif request_type == "set_user_info":
request_auth = "AUUSE0002"
# 탈퇴 'AUUSE0008'
elif request_type == "withdraw":
request_auth = "AUUSE0008"
# 사용자 정보 삭제 'AUUSE0003'
elif request_type == "del_user_info":
request_auth = "AUUSE0003"
# 위 패턴으로 각 요청마다 필요한 권한 지정
# 권한 확인
for user_auth in user_auth_list:
# API 를 호출한 사용자가 필요한 권한을 가지고 있는 경우
if user_auth == request_auth:
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
return send
# API 를 호출한 사용자가 필요한 권한을 가지고 있지 않은 경우
result = "fail"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
return send
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 crop_qr(user_id, image, image_name, image_path):
log_request = "crop_qr"
# 로그를 남기기 위한 값
# 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 crop_qr", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_id'] = user_id
input['image'] = image
input['image_name'] = image_name
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
try:
# QR 코드의 가장자리에 있는 3개(또는 그 이상)의 겹쳐진 네모 이미지를 찾음(인식 코드라 표기)
# 이미지의 컨투어 박스를 구하고 QR 코드의 인식 코드의 특징을 이용하여 조건에 맞는 컨투어 박스를 인식 코드라 판단
# 인식 코드를 기준으로 QR 코드를 크롭하고, QR 코드의 색상 히스토그램을 이용하여 적절한 임계값을 찾아 흑백 변환을 뚜렷하게 함
# 뚜렷하게 보정한 QR 코드를 다시 인식
# 아래 코드에서 사용할 대부분의 함수가 cv2 에서 이미지 호출한 결과의 타입(numpy array)에 적합
# 폼으로 받아온 원본 이미지를 서버에 업로드 하고 해당 경로와 이름을 이용하여 다시 호출
# imread : 해당 경로에 저장되어 있는 이미지를 numpy array 형식으로 불러오기 (cv2.imread(경로 + 이름))
image = cv2.imread(image_path + "/" + image_name)
logger.info("Image read", extra=logger_data)
# 입력한 이미지의 높이, 너비, 채널
# shape : 이미지의 높이, 너비, 채널의 값을 추출하는 함수
height, width, channel = image.shape
# cvtColor : 경계값을 추출하기 위해 흑백 변환
# COLOR_RGB2GRAY : RGB 에서 GRAY 로 변환
# cv2.cvtColor(변환할 이미지, 변환할 방식)
image_gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
logger.info("Image convert to gray", extra=logger_data)
# 이미지 너비에 따라 적합한 block 의 크기를 구하는 함수
block_size = get_block_size(width)
# 경계값 추출
# adaptiveThreshold : 필터의 크기를 설정해 이미지의 (0,0) 에서 (x,y) 까지 이동하면서 해당 구역만큼의 값을 구하여 적용
# 일반 threshold 는 전체 이미지의 임계값을 설정해 해당 임계값을 넘기면 설정해둔 값(보통 흰색 또는 검정)으로 적용되기때문에
# 어두운 이미지거나 밝은 이미지의 경우 정확한 경계값을 찾기 어려움
# adaptiveThreshold 를 이용하면 일부 영역의 값들을 비교하여 적절한 값을 찾기 때문에 더욱 세밀한 경계값을 추출할 수 있음
# cv2.adaptiveThreshold(입력 이미지, 임계값을 넘길 경우 적용될 값, 경계값을 추출할 방법, 경계값을 추출한 후 이미지 표현 방법, 필터 크기, 필터를 씌운 후 결과값에서 뺄 값)
# ADAPTIVE_THRESH_GAUSSIAN_C : 가우시안 방법을 이용하여 필터 중심점에 결과값 적용
# THRESH_BINARY : 선명한 흑백 대비로 이미지 표현
image_adapthresh = cv2.adaptiveThreshold(
image_gray,
maxValue=255.0,
adaptiveMethod=cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
thresholdType=cv2.THRESH_BINARY,
blockSize=block_size,
C=9)
logger.info("The boundary value of the image was obtained",
extra=logger_data)
# 추출한 경계값에서 덩어리를 이루고 있는 묶음들의 경계선 표시(같은 색상을 가지는 묶음을 하나의 객체로 인식하기 위해 하는 과정)
# 컨투어(contour) : 같은 레벨(색상 등)을 가지는 하나의 덩어리
# hierarchy : 컨투어의 상하구조
# cv2.findContours(입력 이미지, 컨투어를 찾는 방법, 컨투어를 찾을 때 사용하는 근사화 방법)
# RETR_LIST : 모든 컨투어 라인을 찾지만, 상하구조(hierachy)관계를 구성하지 않음
# CHAIN_APPROX_SIMPLE : 컨투어 라인을 그릴 수 있는 포인트만 반환
contours, hierarchy = cv2.findContours(image_adapthresh,
mode=cv2.RETR_LIST,
method=cv2.CHAIN_APPROX_SIMPLE)
# 원본 이미지와 같은 크기, 채널을 가지는 검은색(0 : zero) 배경의 이미지 생성
image_contour = np.zeros((height, width, channel), dtype=np.uint8)
# 검은색 배경의 이미지에 컨투어 표시
# cv2.drawContours(입력 이미지, 컨투어 라인 정보, 컨투어 라인 번호, 색상, 두께)
cv2.drawContours(image_contour,
contours=contours,
contourIdx=-1,
color=(255, 255, 255),
thickness=2)
logger.info("It draw a contour", extra=logger_data)
# 원본 이미지와 같은 크기, 채널을 가지는 검은색 배경의 이미지 생성
image_contours_box = np.zeros((height, width, channel), dtype=np.uint8)
# 모든 컨투어 박스의 정보를 저장
# 컨투어 박스 : 하나의 컨투어를 감싸는 박스 -> QR 코드를 찾기 위해 박스의 크기 및 비율 등을 비교하기 위해 사용
list_contours = []
# 각 컨투어의 인덱스, 동일한 컨투어인지 비교하는데에 사용
index = 0
# 입력한 이미지에서 추출해낸 컨투어가 존재하지 않을 경우
if not contours:
# 인식 실패한 이미지 저장
# Image.fromarray : numpy 배열을 이미지 객체로 변경(서버에 업로드 하기 위해서는 실제 이미지로 변경해야 함)
image_fail = Image.fromarray(image)
# createFolder : 해당 폴더가 없을 경우 폴더를 만드는 함수
createFolder(key_fail_path)
# 서버 업로드
image_fail.save(key_fail_path + "/" + image_name)
logger.error("Fail image upload", extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "ERROR"
output = None
message = "Image is one color"
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
# findContours 함수로 찾아낸 컨투어들을 이용하여 컨투어 박스를 구하고, 각 컨투어의 정보 저장
for contour in contours:
# boundingRect : 컨투어를 둘러싸는 박스의 정보 추출
x, y, w, h = cv2.boundingRect(contour)
# 검은색 배경의 이미지에 컨투어 박스 표시
# rectangle : 입력 이미지에 직사각형을 그림
# cv2.rectangle(입력 이미지, 직사각형의 왼쪽 위의 점, 직사각형의 오른쪽 아래 점, 색상, 두께)
cv2.rectangle(image_contours_box,
pt1=(x, y),
pt2=(x + w, y + h),
color=(255, 255, 255),
thickness=2)
# 컨투어 정보 저장
# x, y : 직사각형의 왼쪽 위의 지점
# x_end, y_end : 직사각형의 오른쪽 아래 지점, w 와 h 는 x 또는 y 의 점까지 포함한 길이이기 때문에 -1 추가
list_contours.append({
'contour': contour,
'index': index,
'x': x,
'y': y,
'x_end': x + w - 1,
'y_end': y + h - 1,
'w': w,
'h': h,
'cx': int(x + (w / 2)),
'cy': int(y + (h / 2))
})
index += 1
logger.info("It find contour", extra=logger_data)
# 너무 작은 컨투어 박스(길이가 10픽셀 이하)는 제거
# QR 코드의 인식 코드의 너비, 높이의 비율이 약 1
# 컨투어 박스의 비율이 1/2이하 또는 2 이상인 것 제거
# 크기 또는 비율 조건에 맞지 않은 컨투어 박스를 제외한 컨투어 박스를 저장할 리스트
list_contours_except_mini = []
# 크기 또는 비율 조건에 맞지 않은 컨투어 박스를 제외한 컨투어 박스를 그릴 이미지
image_contours_box_except_mini = np.zeros((height, width, channel),
dtype=np.uint8)
for contour in list_contours:
# 현재 컨투어의 x, y, w, h
x = contour['x']
y = contour['y']
w = contour['w']
h = contour['h']
# 너비가 10픽셀 이하인 컨투어 박스 제외
if w < 10:
continue
# 비율 조건에 맞지 않은 컨투어 박스 제외
if w / h < 1 / 2 or w / h > 2:
continue
# 입력 이미지의 너비와 높이의 90프로 이상인 컨투어박스(입력 이미지의 크기와 같은 컨투어 박스) 제외
if w > width * 0.9:
continue
if h > height * 0.9:
continue
# cv2.rectangle(입력 이미지, 직사각형의 왼쪽 위의 점, 직사각형의 오른쪽 아래 점, 색상, 두께)
cv2.rectangle(image_contours_box_except_mini,
pt1=(x, y),
pt2=(x + w, y + h),
color=(255, 255, 255),
thickness=2)
# 기준에 맞는 컨투어들 따로 저장
list_contours_except_mini.append(contour)
logger.info("It exclude contours that are too small or too large",
extra=logger_data)
# 작은 컨투어를 제외하였더니 남은 컨투어가 없는 경우
if not list_contours_except_mini:
# 인식 실패한 이미지 저장
# Image.fromarray : numpy 배열을 이미지 객체로 변경(서버에 업로드 하기 위해서는 실제 이미지로 변경해야 함)
image_fail = Image.fromarray(image)
# createFolder : 해당 폴더가 없을 경우 폴더를 만드는 함수
createFolder(key_fail_path)
# 서버 업로드
image_fail.save(key_fail_path + "/" + image_name)
logger.error("Fail image upload", extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "ERROR"
output = None
message = "Image is not QR code"
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
# QR 코드의 인식 코드 후보군의 개수
count = 0
# QR 코드의 인식 코드 후보군들의 리스트를 저장한 리스트
list_contours_QR_possible_list = []
# 컨투어 박스 리스트(list_contours_except_mini)에서 하나의 컨투어(contour_1)를 기준으로 또 다른 컨투어(contour_2)와 비교하여 인식 코드일 가능성이 있는지 판단
# 두번째 컨투어(contour_2)가 첫번째 컨투어(contour_1)에 포함되어 있다고 전제하고 그 조건을 벗어나는 경우는 제외
for contour_1 in list_contours_except_mini:
# QR 코드의 인식 코드일 가능성이 있는 컨투어 박스들을 저장한 리스트
list_contours_QR_possible = []
for contour_2 in list_contours_except_mini:
# 첫번째 컨투어의 정보
x_1 = contour_1['x']
y_1 = contour_1['y']
x_end_1 = contour_1['x_end']
y_end_1 = contour_1['y_end']
w_1 = contour_1['w']
h_1 = contour_1['h']
cx_1 = contour_1['cx']
cy_1 = contour_1['cy']
# 두번째 컨투어의 정보
x_2 = contour_2['x']
y_2 = contour_2['y']
x_end_2 = contour_2['x_end']
y_end_2 = contour_2['y_end']
w_2 = contour_2['w']
h_2 = contour_2['h']
cx_2 = contour_2['cx']
cy_2 = contour_2['cy']
# 비교하는 두 컨투어가 일치할 경우 제외
if contour_1['index'] == contour_2['index']:
continue
# 두번째 컨투어가 첫번째 컨투어 안에 속해있지 않은 경우 제외
if x_1 > x_2 or y_1 > y_2 or x_end_1 < x_end_2 or y_end_1 < y_end_2:
continue
# 첫번째 컨투어보다 두번째 컨투어의 면적이 더 클 경우 제외
if w_1 * h_1 < w_2 * h_2:
continue
# 첫번째 컨투어의 너비와 높이보다 두번째 컨투어의 너비와 높이가 넓은 경우 제외
if w_1 < w_2 or h_1 < h_2:
continue
# 첫번째 컨투어의 중심점이 두번째 컴투어의 내부에 있지 않을 경우 제외
if cx_1 < x_2 or cx_1 > x_end_2 or cy_1 < y_2 or cy_1 > y_end_2:
continue
# 두번째 컨투어가 첫번째 컨투어 면적의 1/10보다 작은 경우
if w_2 * h_2 < (w_1 * h_1) / 10:
continue
# 해당 조건을 만족하는 두번째 컨투어들을 저장
list_contours_QR_possible.append(contour_2)
# 두번째 컨투어가 하나라도 저장이 되었을 경우에만 첫번째 컨투어 저장
if list_contours_QR_possible:
# QR 코드의 인식 코드일 가능성이 있는 컨투어 박스들을 그릴 이미지
image_contours_QR = np.zeros((height, width, channel),
dtype=np.uint8)
# QR 코드의 인식 코드일 가능성이 있는 컨투어 박스들 그리기
# cv2.rectangle(입력 이미지, 직사각형의 왼쪽 위의 점, 직사각형의 오른쪽 아래 점, 색상, 두께)
for contour in list_contours_QR_possible:
cv2.rectangle(image_contours_QR,
pt1=(contour['x'], contour['y']),
pt2=(contour['x'] + contour['w'],
contour['y'] + contour['h']),
color=(255, 255, 255),
thickness=2)
# 첫번째 컨투어 저장
list_contours_QR_possible.append(contour_1)
# 기준이 되었던 첫번째 컨투어는 다른 색상으로 그리기
# cv2.rectangle(입력 이미지, 직사각형의 왼쪽 위의 점, 직사각형의 오른쪽 아래 점, 색상, 두께)
cv2.rectangle(image_contours_QR,
pt1=(x_1, y_1),
pt2=(x_1 + w_1, y_1 + h_1),
color=(0, 0, 255),
thickness=2)
# 컨투어 박스가 총 2개 이하인 것 제외
if len(list_contours_QR_possible) < 3:
continue
# QR 인식 코드 최종 후보군 저장
list_contours_QR_possible_list.append(
list_contours_QR_possible)
count += 1
logger.info("Only store the contour box that matches the QR code",
extra=logger_data)
# QR 코드의 인식 코드 후보군이 존재하지 않는 경우
if not list_contours_QR_possible_list:
# 인식 실패한 이미지 저장
# Image.fromarray : numpy 배열을 이미지 객체로 변경(서버에 업로드 하기 위해서는 실제 이미지로 변경해야 함)
image_fail = Image.fromarray(image)
# createFolder : 해당 폴더가 없을 경우 폴더를 만드는 함수
createFolder(key_fail_path)
# 서버 업로드
image_fail.save(key_fail_path + "/" + image_name)
logger.error("Fail image upload", extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "ERROR"
output = None
message = "Image is not QR code"
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
# QR 코드의 인식 코드 후보군들을 하나의 리스트에 저장
# 최종 후보군 컨투어 박스들을 그리는 이미지
image_contours_QR_except_equal = np.zeros((height, width, channel),
dtype=np.uint8)
# 최종 후보군 컨투어박스들을 저장하는 리스트
list_contours_except_equal = []
# 후보군에 들었던 모든 컨투어 저장
for list_contours in list_contours_QR_possible_list:
for contour in list_contours:
# 최종 후보군(컨투어)들의 인덱스를 담은 리스트(저장 시 중복 확인)
list_index_contours_except_equal = []
for contour_except_equal in list_contours_except_equal:
list_index_contours_except_equal.append(
contour_except_equal['index'])
# 저장한 컨투어가 하나이상 존재할 경우
if list_contours_except_equal:
# 저장하려는 컨투어가 이미 저장되어 있을 경우
if contour['index'] in list_index_contours_except_equal:
continue
# 저장하려는 컨투어가 저장되어 있지 않을 경우
else:
list_contours_except_equal.append(contour)
# 저장한 컨투어가 없을 경우
else:
list_contours_except_equal.append(contour)
logger.info("Combine all Contour Boxes", extra=logger_data)
# 최종 후보군에 저장된 컨투어 박스가 존재할 경우 해당 컨투어 박스 그리기
if list_contours_except_equal:
for contour in list_contours_except_equal:
# cv2.rectangle(입력 이미지, 직사각형의 왼쪽 위의 점, 직사각형의 오른쪽 아래 점, 색상, 두께)
cv2.rectangle(image_contours_QR_except_equal,
pt1=(contour['x'], contour['y']),
pt2=(contour['x'] + contour['w'],
contour['y'] + contour['h']),
color=(0, 0, 255),
thickness=2)
# 최종 후보군이 존재하지 않는 경우
else:
# 인식 실패한 이미지 저장
# Image.fromarray : numpy 배열을 이미지 객체로 변경(서버에 업로드 하기 위해서는 실제 이미지로 변경해야 함)
image_fail = Image.fromarray(image)
# createFolder : 해당 폴더가 없을 경우 폴더를 만드는 함수
createFolder(key_fail_path)
# 서버 업로드
image_fail.save(key_fail_path + "/" + image_name)
logger.error("Fail image upload", extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "ERROR"
output = None
message = "Final candidate for Contour Box 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 = "403"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 최종 후보군에 든 컨투어 박스의 가장자리 크롭
x_start = width
y_start = height
x_end = 0
y_end = 0
# 최종 후보군들의 가장자리 값 구하기
for contour in list_contours_except_equal:
if contour['x'] < x_start:
x_start = contour['x']
if contour['y'] < y_start:
y_start = contour['y']
if contour['x_end'] > x_end:
x_end = contour['x_end']
if contour['y_end'] > y_end:
y_end = contour['y_end']
# QR 코드라고 인식한 부분의 너비와 높이
QR_width = x_end - x_start
QR_height = y_end - y_start
# 실제 QR 코드보다 여유를 두고 크롭
x_start = int(x_start - QR_width * 0.1)
y_start = int(y_start - QR_height * 0.1)
x_end = int(x_end + QR_width * 0.1)
y_end = int(y_end + QR_height * 0.1)
logger.info("Obtain the size of the image you want to crop",
extra=logger_data)
# 크롭할 이미지의 크기가 음수거나 원본 이미지의 크기를 벗어날 경우 0 또는 원본 이미지의 크기로 설정
if x_start < 0:
x_start = 0
if y_start < 0:
y_start = 0
if x_end > width:
x_end = width
if y_end > height:
y_end = height
# 크롭할 너비, 높이, 중심점
QR_width = x_end - x_start
QR_height = y_end - y_start
QR_cx = int(x_start + QR_width / 2)
QR_cy = int(y_start + QR_height / 2)
# QR 코드로 인식한 부분을 검은 이미지에 표시
# cv2.rectangle(입력 이미지, 직사각형의 왼쪽 위의 점, 직사각형의 오른쪽 아래 점, 색상, 두께)
cv2.rectangle(image_contours_QR_except_equal,
pt1=(x_start, y_start),
pt2=(x_end, y_end),
color=(0, 0, 255),
thickness=2)
cv2.rectangle(image_contours_QR_except_equal,
pt1=(QR_cx, QR_cy),
pt2=(QR_cx, QR_cy),
color=(255, 0, 0),
thickness=5)
# 원본 이미지에 QR 코드로 인식한 부분 크롭
# getRectSubPix : 직사각형의 모양으로 이미지 크롭
# cv2.getRectSubPix(입력 이미지, 크롭 이미지의 크기, 크롭 이미지의 중심점)
image_crop = cv2.getRectSubPix(image,
patchSize=(QR_width, QR_height),
center=(QR_cx, QR_cy))
logger.info("Crop the image", extra=logger_data)
# cv2.imread 를 이용하여 불러와 있는 이미지를 인식할 경우
decode_data = decode(image_crop)
logger.info("Recognize the image", extra=logger_data)
# 이미지를 크롭한 것만으로 인식에 성공한 경우
if decode_data:
logger.info("Image recognition succeed", extra=logger_data)
# 이미지 인식
url = decode_data[0].data.decode('utf-8')
# 회사에서 사용하는 QR 코드의 경우 앞의 16자리까지가 QR 코드의 값이므로 16자리까지 문자열 자르기
url = url[:16]
# 출력값에 인식한 결과값 추가
qr_data = {}
qr_data['qr_key'] = url
# 크롭한 이미지 저장
# Image.fromarray : numpy 배열을 이미지 객체로 변경(서버에 업로드 하기 위해서는 실제 이미지로 변경해야 함)
image_crop_scalar = Image.fromarray(image_crop)
# createFolder : 해당 폴더가 없을 경우 폴더를 만드는 함수
createFolder(key_success_path)
# 서버 업로드
image_crop_scalar.save(key_success_path + "/" + image_name)
logger.error("Success image upload", extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "REQUEST"
output = None
message = ""
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 = []
data.append(qr_data)
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
logger.info("Image recognition failed", extra=logger_data)
logger.info("Blur the image", extra=logger_data)
# 이미지를 크롭하였으나 인식에 실패한 경우 -> 화면 울림 현상이 있는 경우
# 화면에 있는 QR 코드를 찍었을 경우 화면 울림 현상 완화
# 원본 이미지에서 크롭하였으니 다시 흑백 변환
# cvtColor : 경계값을 추출하기 위해 흑백 변환
# COLOR_RGB2GRAY : RGB 에서 GRAY 로 변환
# cv2.cvtColor(변환할 이미지, 변환할 방식)
image_crop_gray = cv2.cvtColor(image_crop, cv2.COLOR_RGB2GRAY)
image_crop_blur = image_crop_gray
# 블러 처리 횟수
count_blur = 0
# 인식이 될 때까지 블러 처리
while True:
image_crop_blur = blur(image_crop_blur)
decode_data_blur = decode(image_crop_blur)
count_blur += 1
# 블러처리한 이미지가 인식이 될 경우 종료
if decode_data_blur:
break
# 1000번을 블러 처리 해도 인식이 되지 않을 경우 인식 실패로 판단
if count_blur == 100:
logger.info("Image recognition failed", extra=logger_data)
# 인식 실패한 이미지 저장
# Image.fromarray : numpy 배열을 이미지 객체로 변경(서버에 업로드 하기 위해서는 실제 이미지로 변경해야 함)
image_fail = Image.fromarray(image_crop_blur)
# createFolder : 해당 폴더가 없을 경우 폴더를 만드는 함수
createFolder(key_fail_path)
# 서버 업로드
image_fail.save(key_fail_path + "/" + image_name)
logger.error("Fail image upload", extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "ERROR"
output = None
message = "Failed to recognize"
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 = "406"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 이미지 인식
url = decode_data_blur[0].data.decode('utf-8')
# 회사에서 사용하는 QR 코드의 경우 앞의 16자리까지가 QR 코드의 값이므로 16자리까지 문자열 자르기
url = url[:16]
# 출력값에 인식값 추가
qr_data = {}
qr_data['qr_key'] = url
# 인식 성공
# 블러처리한 이미지 저장
# Image.fromarray : numpy 배열을 이미지 객체로 변경(서버에 업로드 하기 위해서는 실제 이미지로 변경해야 함)
image_crop_blur = Image.fromarray(image_crop_blur)
# createFolder : 해당 폴더가 없을 경우 폴더를 만드는 함수
createFolder(key_success_path)
# 서버 업로드
image_crop_blur.save(key_success_path + "/" + image_name)
logger.error("Success image upload", extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "REQUEST"
output = None
message = "crop_qr 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(qr_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("##################### crop_qr 에서 EXCEPTION error 발생")
print("error type : ", type(e))
print("error : ", e)
error = {}
error['error'] = e
# 인식 실패한 이미지 저장
# Image.fromarray : numpy 배열을 이미지 객체로 변경(서버에 업로드 하기 위해서는 실제 이미지로 변경해야 함)
image_fail = Image.fromarray(image)
# createFolder : 해당 폴더가 없을 경우 폴더를 만드는 함수
createFolder(key_fail_path)
# 서버 업로드
image_fail.save(key_fail_path + "/" + image_name)
logger.error("Fail image upload", extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
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 = []
result = "fail"
status = "405"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
def access(user_id, user_ip):
# 로그를 남기기 위한 값
# 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 access", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_id'] = user_id
input['user_ip'] = user_ip
log_request = "access"
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
# IP를 이용하여 사용자 key 설정
# user_key : 접속해있는 사용자에 대한 일회용 아이디, 접속한 사용자의 ip 4자리 합 + 랜덤 4자리 수
user_ip_list = user_ip.split('.')
user_ip_start = 0
for i in user_ip_list:
user_ip_start += int(i)
user_ip_start = str(user_ip_start).zfill(4)
user_ip_end = random.randint(0, 9999)
user_ip_end = str(user_ip_end).zfill(4)
user_key = user_ip_start + user_ip_end
logger.info("Set the user key", extra=logger_data)
# 접속 테이블에 저장
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
data = []
try:
cursor.callproc('SP_KEYM_ADD_USR_ACCESS_INFO',
[user_key, user_id, user_ip])
logger.info("Store the information of the user who is connected",
extra=logger_data)
user_info = {}
user_info['user_key'] = user_key
data.append(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 = "access 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 = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
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 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 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 upload_file(user_key, log_request, index, file, file_name, file_size):
# log_request = "set_user_info"
print("********** " + log_request + " **********")
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
# 파일이 실제로 존재하는 지 확인
if not file:
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
return send
# 입력받은 사용자 키를 이용하여 사용자의 아이디 조회
send = get_user_info_from_key(user_key)
user_id = send['data'][0]['result_data_1']
# 서버에 저장할 첨부파일명 변경(현재날짜 + 현재시간 + 등록한 사용자 ID)
if file_name:
file_name_split = file_name.split('.')
extension = file_name_split[1]
else:
extension = "zip"
file_name_ori = file_name
file_name = time.strftime('%Y%m%d%H%M%S', time.localtime(
time.time())) + user_id + "." + extension
# 각 요청에 따라 경로 설정 및 수정 프로시저 호출
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
# 인식모듈 등록 또는 수정을 요청헀을 경우
if log_request == 'LGMOD0005' or log_request == 'LGMOD0003':
file_path = module_path
# 인식모듈 수정을 요청하여 원래 게시글에 첨부파일이 존재했었을 경우(첨부파일 변경)
# 입력한 인덱스에 해당하는 게시글에 저장되어있던 첨부파일이 존재하는지 확인하기 위한 절차이므로 인식모듈 상세조회 코드 입력(기본권한, 작성자 중요X)
send = get_module_info(user_key, "LGMOD0001", index)
if send['data'][0]['FILE_EXIST_FLAG'] == "Y":
file_path_exist = send['data'][0]['FILE_PATH']
file_name_exist = send['data'][0]['FILE_NAME']
# 서버에 등록된 파일 삭제
del_file_dir(file_path_exist, file_name_exist)
file_exist_flag = "Y"
# 인식모듈 테이블에 파일 정보 저장
cursor.callproc('SP_KEYM_SET_MODULE_FILE_INFO', [
index, file_name_ori, file_name, file_path, file_size,
file_exist_flag
])
# 공지사항 등록 또는 수정을 요청했을 경우
else:
file_path = notice_path
# 공지사항 파일 테이블에 파일 정보 저장
# 해당 경로에 변경한 이름으로 파일 서버에 업로드
createFolder(file_path)
file.save(file_path + file_name)
# 로그 API 호출
# 상태코드 : 요청
# 요청코드 : 인식모듈 등록 또는 수정 또는 공지사항 등록 또는 수정
# log_status = 'LGSTA0001'
# log(user_id, log_status, log_request)
data = []
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# 로그 API 호출
# 상태코드 : 예외
# 요청코드 : 인식모듈 등록 또는 수정 또는 공지사항 등록 또는 수정
# log_status = 'LGSTA0005'
# log(user_id, log_status, log_request)
data = []
status = '401'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
return send
finally:
connection.close()
def set_user_API_req(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_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['log_request'] = log_request
# log_request = "set_user_API_req"
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
# 입력받은 사용자 키를 이용하여 사용자의 정보 조회
send = get_user_info_from_key(user_key)
# 접속해있는 사용자가 아닐 경우
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":
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
# 접속한 사용자의 마지막 API 호출시간 수정
cursor.callproc('SP_KEYM_SET_USR_ACCESS_INFO', [user_key])
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = send['data'][0]['result_data_1']
log_status = "REQUEST"
output = None
message = 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.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
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)
data = []
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = ""
log_status = "EXCEPTION"
output = ""
message = e
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
status = '402'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
def add_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 add_module_info(user_key, module_name, version, memo):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request create_qr", extra=logger_data)
log_request = "add_module_info"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
logger.info("Request set_user_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['module_name'] = module_name
input['version'] = version
input['memo'] = memo
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
input_list = [user_key, module_name, version, memo]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "404"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 입력받은 사용자 키를 이용하여 사용자의 아이디, 권한 조회
send = get_user_info_from_key(user_key)
logger.info("Get user information", extra=logger_data)
# 접속해있는 사용자가 아닐 경우
if send['status'] == "201":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 접속 여부 확인 도중 DB 에러가 난 경우
elif send['status'] == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = send['data'][0]['error']
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 현재 접속 중인 사용자일 경우
elif send['status'] == "200":
# 인식모듈 등록 권한이 있는지 확인
user_auth_list = send['data'][0]['AUTH']
# 인식모듈 등록 권한 'AUMOD0005'
request_auth = 'AUMOD0005'
logger.info("Check authority", extra=logger_data)
for auth in user_auth_list:
# 권한이 존재하는 경우
if auth == request_auth:
logger.info("Authority exists", extra=logger_data)
# 인식모듈 게시글을 등록한 사용자 id
user_id = send['data'][0]['result_data_1']
# 첨부파일이 존재하지 않을 경우 첨부파일 관련 정보 None 으로 설정
file_name_ori = None
file_name = None
file_path = module_tmp_path
file_size = None
logger.info("You have not added an attachment to the post",
extra=logger_data)
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
# 인식모듈 게시글을 저장하는 포르시저 호출
try:
cursor.callproc('SP_KEYM_ADD_MODULE_INFO', [
user_id, module_name, file_name_ori, file_name,
file_path, file_size, version, memo
])
logger.info("save module post information",
extra=logger_data)
# 등록한 모듈의 인덱스값을 반환하기 위해 등록되어있는 모듈 게시글의 모든 정보를 가져옴
send = get_module_list(user_key, "0", "0", "0", "0", "0",
"0", "0", "0")
# 등록된 모듈 게시글의 인덱스값이 가장 큰 값(가장 최신값)을 저장
module_list = send['data']
module_index = module_list[0]['IX_KMMITN_MODULEINFO']
data = []
module_info = {}
module_info['index'] = module_index
data.append(module_info)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "add_module_info success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
status = "200"
result = "success"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "exception error"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '403'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
# 인식모듈 등록 권한이 존재하지 않는 경우
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "permission error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "402"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
def set_user_info(user_key, log_request, user_pw, user_name, company_name,
department, position, phone_number, email):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request set_user_info", extra=logger_data)
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['log_request'] = log_request
input['user_pw'] = user_pw
input['user_name'] = user_name
input['company_name'] = company_name
input['department'] = department
input['position'] = position
input['phone_number'] = phone_number
input['email'] = email
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
# log_request = "set_user_info"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, "set_user_info")
input_list = [
user_key, log_request, user_pw, user_name, company_name, department,
position, phone_number, email
]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "403"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 요청코드 종류 : 자기 정보 수정, 사용자 정보 수정
# 자기 정보 수정 'LGUSE0010'
# user_pw, company_name, department, position, phone_number, email 수정가능
if log_request == "LGUSE0010":
request_type = "set_my_info"
# 사용자 정보 수정 'LGUSE0005'
# user_name, company_name, department, position, phone_number, email 수정가능
elif log_request == "LGUSE0005":
request_type = "set_user_info"
# 위 패턴으로 요청한 기능 판단
send = check_auth(user_key, request_type)
data = []
status = send['status']
# 접속해 있는 사용자가 아닌 경우
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 필요한 권한이 존재하지 않는 경우
elif status == "401":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "You don't have permission"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 필요한 권한이 존재하는 경우
elif status == "200":
# API 를 호출한 사용자의 ID
user_id = send['data'][0]['result_data_1']
if request_type == "set_my_info":
user_name = None
# 비밀번호는 수정하지 않는 경우
if user_pw == '0':
user_pw = None
elif request_type == "set_user_info":
user_pw = None
# 사용자 정보 수정하는 프로시저 호출
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
cursor.callproc('SP_KEYM_SET_USR_INFO', [
user_id, user_pw, user_name, company_name, department,
position, phone_number, email
])
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "set_user_info success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "exception error"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
result = "fail"
status = "402"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
def get_user_info(user_key, user_id, log_request):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
# user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request get_user_info", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_id'] = user_id
input['user_ip'] = user_ip
input['log_request'] = log_request
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, "get_user_info")
input_list = [user_key, user_id, "get_user_info"]
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
status = check_text("input_db", input_data)
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "403"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 사용자 (상세)정보 조회(user_key)
if log_request == 'LGUSE0004':
request_type = "get_user_info"
# 사용자 정보 수정(user_key)
elif log_request == 'LGUSE0005':
request_type = "set_user_info"
# 자기 정보 수정(user_key)
elif log_request == 'LGUSE0010':
request_type = "set_my_info"
# ID 중복 확인(user_id)
else:
request_type = "login_before"
# 요청이 ID 중복 확인일 경우 user_id 로 사용자 정보 조회
if request_type == "login_before":
status = check_text('id', user_id)
# 입력받은 ID가 영어, 숫자 이외의 문자가 있는 경우
if status == '400':
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "The conditions of the input value are not correct"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
cursor.callproc('SP_KEYM_GET_USR_DETAILS_INFO', [user_id])
column_names_list = [x[0] for x in cursor.description]
result_user_info = []
for row in cursor.fetchall():
result_user_info.append(dict(zip(column_names_list, row)))
print(result_user_info)
# 입력한 ID에 해당하는 사용자 정보가 존재하지 않는 경우
if not result_user_info:
data = []
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "User information does not exist"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "201"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
# 입력한 ID에 해당하는 사용자 정보가 존재하는 경우
userinfo = result_user_info[0]
auth_list = userinfo['AUTH'].split(',')
userinfo['AUTH'] = auth_list
data = result_user_info
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "get_user_info success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = '200'
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = "exception error"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '401'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
# 요청이 ID 중복 확인이 아닌 경우 user_key 로 권한 조회 후 사용자 정보 조회
else:
user_info = get_user_info_from_key(user_key)
user_auth_list = user_info['data'][0]['AUTH']
user_id = user_info['data'][0]['result_data_1']
request_auth = ""
# 요청이 사용자 (상세) 정보 조회인 경우
if request_type == "get_user_info":
request_auth = 'AUUSE0001'
# 요청이 사용자 정보 수정에서 조회한 경우
elif request_type == "set_user_info":
request_auth = 'AUUSE0002'
# 요청이 자기 정보 수정에서 조회한 경우
elif request_type == "set_my_info":
request_auth = 'AUUSE0007'
for auth in user_auth_list:
# 요청한 권한이 존재하는 경우
if auth == request_auth:
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
cursor.callproc('SP_KEYM_GET_USR_DETAILS_INFO', [user_id])
column_names_list = [x[0] for x in cursor.description]
result_user_info = []
for row in cursor.fetchall():
result_user_info.append(
dict(zip(column_names_list, row)))
# 입력한 ID에 해당하는 사용자 정보가 존재하지 않는 경우
if not result_user_info:
data = []
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "User information does not exist"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "201"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
# 입력한 ID에 해당하는 사용자 정보가 존재하는 경우
userinfo = result_user_info[0]
auth_list = userinfo['AUTH'].split(',')
userinfo['AUTH'] = auth_list
data = result_user_info
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = data
message = "get_user_info success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = e
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '401'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
# 요청하는 권한이 존재하지 않는 경우
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "ERROR"
output = ""
message = "permission error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "402"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
def get_key_info(user_key, index):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request get_key_info", extra=logger_data)
log_request = "get_key_info"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
logger.info("Request set_user_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['index'] = index
input_list = [user_key, index]
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
try:
# 입력값에서 디비 또는 API 파라미터에 입력할 수 없는 특수문자가 포함되어 있는 경우
for input_data in input_list:
# check_text : 입력받은 문자열이 적합한지 판단
# check_text(문자열 타입, 문자열)
# 문자열 타입이 input_db 일 경우 db 에 입력할 수 있는지 판단(특수문자 여부)
status = check_text("input_db", input_data)
# 문자열에 특수문자가 있는 경우
if status == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "Input data include special character"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "403"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 입력받은 사용자 키를 이용하여 사용자의 아이디, 권한 조회
send = get_user_info_from_key(user_key)
logger.info("Get user information", extra=logger_data)
# 접속해있는 사용자가 아닐 경우
if send['status'] == "201":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 접속 여부 확인 도중 DB 에러가 난 경우
elif send['status'] == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = send['data'][0]['error']
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 현재 접속 중인 사용자일 경우
elif send['status'] == "200":
# 인식키 조회 권한이 있는 확인
user_auth_list = send['data'][0]['AUTH']
# 인식키 조회 권한 'AUKEY0003'
request_auth = 'AUKEY0003'
logger.info("Check authority", extra=logger_data)
for auth in user_auth_list:
# 권한이 존재하는 경우
if auth == request_auth:
logger.info("Authority exists", extra=logger_data)
# 인식키 정보 조회
cursor.callproc('SP_KEYM_GET_KEY_DETAILS_INFO', [index])
column_names_list = [x[0] for x in cursor.description]
result_key_info = []
for row in cursor.fetchall():
result_key_info.append(
dict(zip(column_names_list, row)))
key_info = result_key_info[0]
# 인식키를 발급받은 사용자의 아이디
user_id = key_info['FK_KMKITN_KEYINFO']
# 사용자 정보 조회
user_info = get_user_info(user_key, user_id, '0')
user_info = user_info['data']
# 사용자 상태 한글로 변경
for info in user_info:
info['LOGIN'] = "******"
if info['DELETE_FLAG'] == "Y":
info['LOGIN'] = "******"
elif info['WITHDRAW_FLAG'] == "Y":
info['LOGIN'] = "******"
logger.info("change the state of a user",
extra=logger_data)
# 사용자 비밀번호가 속해있을 경우 삭제
key_list = user_info[0].keys()
# get_user_info 이용하여 가져온 정보 중 get_key_info 에서 필요없는 정보 제외
if "AUTH" in key_list:
del user_info[0]["AUTH"]
if "AUTH_GROUP_NAME" in key_list:
del user_info[0]["AUTH_GROUP_NAME"]
if "AUTH_GRUOP_ID" in key_list:
del user_info[0]["AUTH_GRUOP_ID"]
if "DATE_LAST" in key_list:
del user_info[0]["DATE_LAST"]
if "DATE_REG" in key_list:
del user_info[0]["DATE_REG"]
if "DELETE_FLAG" in key_list:
del user_info[0]["DELETE_FLAG"]
if "FK_KMUITN_USERINFO" in key_list:
del user_info[0]["FK_KMUITN_USERINFO"]
if "LOGIN_APPROVAL_FLAG" in key_list:
del user_info[0]["LOGIN_APPROVAL_FLAG"]
if "SESSION_ID" in key_list:
del user_info[0]["SESSION_ID"]
if "TIME_LAST" in key_list:
del user_info[0]["TIME_LAST"]
if "TIME_REG" in key_list:
del user_info[0]["TIME_REG"]
if "WITHDRAW_FLAG" in key_list:
del user_info[0]["WITHDRAW_FLAG"]
logger.info(
"Delete information that is not needed for the output",
extra=logger_data)
# 아이디가 총 두번 포함되므로 제외
if "result_data_1" in key_list:
del user_info[0]["result_data_1"]
# 비밀번호 제외
if "result_data_2" in key_list:
del user_info[0]["result_data_2"]
# 출력값에 인식키 정보와 사용자의 정보가 모두 필요하므로 인식키 정보와 사용자 정보를 가지는 딕셔너리를 합침
key_info.update(user_info[0])
data = []
data.append(key_info)
# 로그 저장
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "REQUEST"
output = data
message = "get_key_info success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
# 인식키 조회 권한이 존재하지 않을 경우
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "permission error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "404"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = e
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '402'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
def issue_key(user_key, index, user_ip, req_serial, version, memo):
# 로그를 남기기 위한 값
# user_ip : API 를 호출한 사용자의 ip
# user_id : API 를 호출한 사용자의 id
# user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
user_id = None
# 파이썬의 logging 함수를 불러오는 함수
logger = set_log()
# 받아온 user_ip, user_id 를 로그에 추가
logger_data = {'clientip': user_ip, 'user_id': user_id}
logger.info("Request issue_key", extra=logger_data)
log_request = "issue_key"
# 사용자의 마지막 API 변경 함수
set_user_API_req(user_key, log_request)
logger.info("Request set_user_API_req", extra=logger_data)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['user_key'] = user_key
input['index'] = index
input['req_serial'] = req_serial
input['version'] = version
if memo == "0":
memo = None
input['memo'] = memo
log_request = "issue_key"
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
# 입력받은 사용자 키를 이용하여 사용자의 아이디, 권한 조회
send = get_user_info_from_key(user_key)
logger.info("Get user information", extra=logger_data)
# 접속해있는 사용자가 아닐 경우
if send['status'] == "201":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "User need login"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 접속 여부 확인 도중 DB 에러가 난 경우
elif send['status'] == "400":
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "EXCEPTION"
output = ""
message = send['data'][0]['error']
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function, input,
output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "401"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 현재 접속 중인 사용자일 경우
elif send['status'] == "200":
# 이미지가 실제로 존재하는 지 확인
'''
if not image:
data = []
result = "fail"
status = "402"
send = set_send(data, result, status)
return send
'''
# 인식키 발급 권한이 있는지 확인
user_auth_list = send['data'][0]['AUTH']
engine = create_engine(db_data)
connection = engine.raw_connection()
cursor = connection.cursor()
logger.info("Check authority", extra=logger_data)
try:
user_id = send['data'][0]['result_data_1']
# 사용자 정보 조회
cursor.callproc('SP_KEYM_GET_USR_DETAILS_INFO', [user_id])
column_names_list = [x[0] for x in cursor.description]
result_user_info = []
for row in cursor.fetchall():
result_user_info.append(dict(zip(column_names_list, row)))
company_id = result_user_info[0]['FK_KMUITN_USERINFO']
# phone_number = result_user_info[0]['PHONE_NUMBER']
# 전화번호가 하이픈(-)이 포함된 채로 저장되어 있었을 경우
'''
if '-' in phone_number:
print(phone_number)
number_list = phone_number.split('-')
phone_number = ""
for number_list in (0, len(number_list)-1):
print(number_list)
phone_number += number_list
print(phone_number)
'''
# 사용자가 속해있는 회사 정보 조회
cursor.callproc('SP_KEYM_GET_COM_DETAILS_INFO', [company_id])
column_names_list = [x[0] for x in cursor.description]
result_company_info = []
for row in cursor.fetchall():
result_company_info.append(dict(zip(column_names_list, row)))
user_code = result_company_info[0]['USER_CODE']
# user_code = "fa"
phone_number = "01027231797"
# 인식키 발급 권한 : 직원 발급 요청 'AUKEY0001', 파트너 발급 요청 'AUKEY0002'
if user_code == "fa":
request_auth = "AUKEY0001"
else:
request_auth = "AUKEY0002"
for auth in user_auth_list:
# 권한이 있을 경우 이미지 이름 변경 후 서버에 이미지 업로드
if auth == request_auth:
logger.info("Authority exists", extra=logger_data)
code_check_version = "version"
app_version = key_data['app_version']
# check_version API 호출 (GET)
url_check_version = key_url + user_code + "/" + phone_number + "/" + code_check_version + "/" + app_version + "/Keona"
response_check_version = requests.get(url_check_version)
logger.info("call check_version API", extra=logger_data)
data_check_version = json.loads(
response_check_version.text)
if data_check_version['Result'] == "ok":
logger.info("check_version API call succeeded",
extra=logger_data)
session_key = data_check_version['SessionKey']
# check_version API 호출 실패
else:
logger.info("check_version API call failed",
extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "REQUEST"
output = data_check_version
message = "check_version API error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "403"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# DB 저장
cursor.callproc('SP_KEYM_ADD_KEY_VERSION_INFO', [
index, company_id, user_code, user_id, phone_number,
app_version, session_key
])
logger.info("save check_version API information",
extra=logger_data)
column_names_list = [x[0] for x in cursor.description]
result_key_info = []
for row in cursor.fetchall():
result_key_info.append(
dict(zip(column_names_list, row)))
# key version 테이블에 저장한 index 로 변경하여 key_info 테이블에 해당 index 로 저장
index = result_key_info[0]['IN_INT_PK_KMKVTN_KEYVERSION']
code_create_key = "makekey"
# ip 이용하여 주소 정보 찾기
location_data = get_default_location(user_id)
logger.info("Find address information using ip",
extra=logger_data)
country = location_data['geoLocation']['country']
r1 = location_data['geoLocation']['r1']
r2 = location_data['geoLocation']['r2']
r3 = location_data['geoLocation']['r3']
address = r1 + " " + r2 + " " + r3
latitude = str(location_data['geoLocation']['lat'])
longitude = str(location_data['geoLocation']['long'])
logger.info("call create_key API", extra=logger_data)
# create_key API 호출 (POST)
url_create_key = key_url + user_code + "/" + session_key + "/" + code_create_key + "/" + version + "/Keona"
location = latitude + "," + longitude
post_data = {
"location": location,
"phonenumber": phone_number,
"req_serial": req_serial
}
response_create_key = requests.post(url_create_key,
data=post_data)
data_create_key = json.loads(response_create_key.text)
if data_create_key['Result'] != "ok":
logger.info("create_key API call failed",
extra=logger_data)
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "ERROR"
output = data_create_key
message = "create_key API error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "404"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
logger.info("create_key API call succeeded",
extra=logger_data)
data_create_key['qr_key'] = req_serial
issue_key = data_create_key['Key']
city = r1
state = r2
street = r3
user_name = result_user_info[0]['USER_NAME']
# DB 저장
cursor.callproc('SP_KEYM_ADD_KEY_INFO', [
index, company_id, user_code, user_id, user_name,
session_key, version, latitude, longitude,
phone_number, req_serial, issue_key, memo, address,
country, city, state, street
])
logger.info("save create_key API information",
extra=logger_data)
column_names_list = [x[0] for x in cursor.description]
result_key_info = []
for row in cursor.fetchall():
result_key_info.append(
dict(zip(column_names_list, row)))
data = []
data.append(data_create_key)
# 로그 저장
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "REQUEST"
output = data
message = "issue_key success"
success_flag = "Y"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api,
function, input, output, message,
success_flag)
logger.info(message, extra=logger_data)
logger.debug(log_db, extra=logger_data)
result = "success"
status = "200"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.debug(send, extra=logger_data)
return send
# 인식키 발급 권한이 존재하지 않을 경우
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
log_status = "ERROR"
output = ""
message = "permission error"
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
result = "fail"
status = "405"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
except Exception as e:
print("error type : ", type(e))
print("error : ", e)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# 회사 API 연결에 실패한 경우 랜덤값 출력하는 파일로 연결
print("10061" in str(e))
if "10061" in str(e):
# DB 에 저장할 check_version api 값 임의 설정
check_version_api_value = {}
check_version_api_value['index'] = index
check_version_api_value['company_id'] = company_id
check_version_api_value['user_code'] = user_code
check_version_api_value['user_id'] = user_id
check_version_api_value['phone_number'] = phone_number
check_version_api_value['app_version'] = app_version
check_version_api_value['session_key'] = "session_key_tmp"
# DB 에 저장할 create_key api 값 임의 설정
create_key_api_value = {}
create_key_api_value['index'] = index
create_key_api_value['company_id'] = company_id
create_key_api_value['user_code'] = user_code
create_key_api_value['user_id'] = user_id
create_key_api_value['user_name'] = result_user_info[0][
'USER_NAME']
create_key_api_value['session_key'] = "session_key_tmp"
create_key_api_value['version'] = version
# ip 이용하여 주소 정보 찾기
location_data = get_default_location(user_id)
country = location_data['geoLocation']['country']
r1 = location_data['geoLocation']['r1']
r2 = location_data['geoLocation']['r2']
r3 = location_data['geoLocation']['r3']
address = r1 + " " + r2 + " " + r3
latitude = str(location_data['geoLocation']['lat'])
longitude = str(location_data['geoLocation']['long'])
create_key_api_value['latitude'] = latitude
create_key_api_value['longitude'] = longitude
create_key_api_value['phone_number'] = phone_number
create_key_api_value['req_serial'] = req_serial
create_key_api_value['issue_key'] = None
create_key_api_value['memo'] = memo
create_key_api_value['address'] = address
create_key_api_value['country'] = country
city = r1
state = r2
street = r3
create_key_api_value['city'] = city
create_key_api_value['state'] = state
create_key_api_value['street'] = street
Key = issue_key_random_result(version, check_version_api_value,
create_key_api_value)
print("대체 함수 실행")
key_result = {}
key_result['Key'] = Key
key_result['Result'] = "success"
key_result['qr_key'] = req_serial
data = []
data.append(key_result)
status = "201"
result = "success"
send = set_send(data, result, status)
return send
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = ""
log_status = "EXCEPTION"
output = ""
message = e
success_flag = "N"
# log : DB 에 로그를 저장하는 함수
# log_db : DB 에 저장한 로그값
log_db = log(user_id, log_status, log_request, api, function,
input, output, message, success_flag)
logger.error(message, extra=logger_data)
logger.error(log_db, extra=logger_data)
data = []
status = '480'
result = "fail"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
finally:
connection.close()
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 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 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 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 create_qr(url, image_name):
# 로그를 남기기 위한 값
# 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)
# DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의
input = {}
input['url'] = url
input['image_name'] = image_name
log_request = "create_qr"
api = os.path.split(__file__)[1]
function = sys._getframe().f_code.co_name
try:
# 입력값이 하나라도 없을 경우
if url == "" or url is None or image_name == "" or image_name is None:
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "ERROR"
output = ""
message = "URL or QR name is 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)
error = {}
error['error'] = message
data = []
data.append(error)
result = "fail"
status = "400"
# set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등)
send = set_send(data, result, status)
logger.error(send, extra=logger_data)
return send
# 입력한 이미지 이름에 확장자 설정
qr_name = image_name + ".png"
# DB 또는 서버에 저장할 QR 코드 이미지의 이름으로 변경(현재 날짜 + 현재 시간)
qr_name_ori = qr_name
qr_name = time.strftime('%Y%m%d%H%M%S', time.localtime(
time.time())) + ".png"
# 이미지 저장 경로 설정
image_path = key_path
# createFolder : 해당 폴더가 없을 경우 폴더를 만드는 함수
createFolder(image_path)
# 입력한 url 을 포함하는 QR 코드 이미지 생성
image = qrcode.make(url)
# QR 코드 이미지 서버에 업로드
image.save(key_path + qr_name)
logger.info("Image upload", extra=logger_data)
# DB 에 저장할 QR 코드 정보 설정
qr_data = {}
qr_data['OR_NAME_ORI'] = qr_name_ori
qr_data['QR_NAME'] = qr_name
qr_data['QR_PATH'] = key_path + qr_name
qr_data['QR_URL'] = url
# user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag
user_id = None
log_status = "REQUEST"
output = qr_data
message = "create_qr 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(qr_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
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 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()
