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 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 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 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 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 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 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 add_user_info(user_id, user_pw, user_name, company_name, department, position, phone_number, email): # 로그를 남기기 위한 값 # user_ip : API 를 호출한 사용자의 ip # user_id : API 를 호출한 사용자의 id user_ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr) # user_id = None # 파이썬의 logging 함수를 불러오는 함수 logger = set_log() # 받아온 user_ip, user_id 를 로그에 추가 logger_data = {'clientip': user_ip, 'user_id': user_id} logger.info("Request add_user_info", extra=logger_data) # DB 에 로그를 남기기 위해 입력값, 요청값, api, function 명 등을 정의 input = {} input['user_id'] = user_id input['user_pw'] = user_pw input['user_name'] = user_name input['company_name'] = company_name input['department'] = department input['position'] = position input['phone_number'] = phone_number input['email'] = email log_request = "add_user_info" api = os.path.split(__file__)[1] function = sys._getframe().f_code.co_name status = "200" # 입력된 정보 타입, 크기 확인 status_id = check_type_len('user_id', user_id) status_pw = check_type_len('user_pw', user_pw) status_name = check_type_len('user_name', user_name) status_company = check_type_len('company', company_name) status_department = check_type_len('department', department) status_position = check_type_len('position', position) status_phone_number = check_type_len('phone_number', phone_number) status_email = check_type_len('email', email) logger.info("Check the type and size of the input value", extra=logger_data) if status_id == "400": status = "400" elif status_id == "401": status = "401" if status_pw == "400": status = "402" elif status_pw == "401": status = "403" if status_name == "400": status = "404" elif status_name == "401": status = "405" if status_company == "400": status = "406" elif status_company == "401": status = "407" if status_department == "400": status = "408" elif status_department == "401": status = "409" if status_position == "400": status = "410" elif status_position == "401": status = "411" if status_phone_number == "400": status = "412" elif status_phone_number == "401": if phone_number != '0': status = "413" else: status = "200" if status_email == "400": status = "414" elif status_email == "401": status = "415" # 입력값 중 하나라도 조건에 맞지 않으면 리턴 if status != "200": # user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag user_id = None log_status = "ERROR" output = "" message = "The type and size of the input value are not appropriate" success_flag = "N" # log : DB 에 로그를 저장하는 함수 # log_db : DB 에 저장한 로그값 log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag) logger.error(message, extra=logger_data) logger.error(log_db, extra=logger_data) data = [] result = "fail" # set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등) send = set_send(data, result, status) logger.error(send, extra=logger_data) return send # 조건이 있는 값 적합성 확인 status_id = check_text('id', user_id) status_pw = check_text('pw', user_pw) status_name = check_text('name', user_name) status_company = check_text('company', company_name) status_department = check_text('department', department) logger.info("Check the conditions of the input values", extra=logger_data) # 조건에 맞지 않은 값이 존재하는 경우 if status_id != "200": status = "416" if status_pw != "200": status = "417" if status_name != "200": status = "418" if status_company != "200": status = "419" if status_department != "200": status = "420" if status != "200": # user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag user_id = None log_status = "ERROR" output = "" message = "The conditions of the input value are not correct" success_flag = "N" # log : DB 에 로그를 저장하는 함수 # log_db : DB 에 저장한 로그값 log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag) logger.error(message, extra=logger_data) logger.error(log_db, extra=logger_data) data = [] result = "fail" # set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등) send = set_send(data, result, status) logger.error(send, extra=logger_data) return send # 입력된 값이 없는 것 중 null 가능 값은 None 으로 변환 if not department or department == "" or department == '0': department = None if not position or position == "" or position == '0': position = None if not phone_number or phone_number == "" or phone_number == '0': phone_number = None if not email or email == "" or email == '0': email = None # 아이디 중복 확인 user_list = get_user_info("0", user_id, "login_before") status = user_list['status'] # ID 에 영어, 숫자 이외의 문자가 있는 경우 if status == "400": status = "416" message = "The ID does not meet the conditions" # 동일한 ID 조회 과정에서 DB 에러가 난 경우 elif status == "401": status = "421" message = "DB error occurred while inquiring the same ID" # 동일한 ID 가 존재하는 경우 elif status == "200": status = "422" message = "The same ID exists" # 동일한 ID 가 존재하지 않는 경우 else: status = "200" if status != "200": # user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag user_id = None log_status = "ERROR" output = "" success_flag = "N" # log : DB 에 로그를 저장하는 함수 # log_db : DB 에 저장한 로그값 log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag) logger.error(message, extra=logger_data) logger.error(log_db, extra=logger_data) data = [] result = "fail" # set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등) send = set_send(data, result, status) logger.error(send, extra=logger_data) return send # 회사명 존재 확인 company_list = get_company_list('0', company_name, '0', '0') status = company_list['status'] data = company_list['data'] logger.info("Check that the selected company name exists", extra=logger_data) # 동일한 회사명 조회 과정에서 DB 에러가 난 경우 if status == "400": status = "423" message = "DB error occurred while inquiring the same company name" # 동일한 회사명이 존재하지 않는 경우 elif status == "201": status = "424" message = "The same company name does not exist" # 동일한 회사명이 존재하는 경우 else: for company in data: company_name_exist = company['COMPANY_NAME'] if company_name == company_name_exist: status = "200" # 사용자가 선택한 회사명의 회사 ID company_id_exist = company['PK_KMPTTN_PARTNER'] break # 입력한 회사명이 포함되는 회사명이 존재하나 완벽하게 일치하지는 않는 경우 동일한 회사명이 존재하지 않는 경우로 설정 else: status = "424" message = "The same company name does not exist" if status != "200": # user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag user_id = None log_status = "ERROR" output = "" success_flag = "N" # log : DB 에 로그를 저장하는 함수 # log_db : DB 에 저장한 로그값 log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag) logger.error(message, extra=logger_data) logger.error(log_db, extra=logger_data) data = [] result = "fail" # set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등) send = set_send(data, result, status) logger.error(send, extra=logger_data) return send # 사용자 정보 저장 engine = create_engine(db_data) connection = engine.raw_connection() cursor = connection.cursor() try: cursor.callproc('SP_KEYM_ADD_USR_INFO', [ user_id, user_pw, user_name, company_id_exist, department, position, phone_number, email ]) logger.info("Store the user's information", extra=logger_data) except Exception as e: print("error type : ", type(e)) print("error : ", e) # user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag user_id = None log_status = "EXCEPTION" output = "" message = "exception error" success_flag = "Y" # log : DB 에 로그를 저장하는 함수 # log_db : DB 에 저장한 로그값 log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag) logger.error(message, extra=logger_data) logger.error(log_db, extra=logger_data) data = [] result = "fail" status = "425" # set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등) send = set_send(data, result, status) logger.error(send, extra=logger_data) return send finally: connection.close() data = [] # user_id, log_status, log_request, api, function, input, output, message, success_flag, display_flag user_id = None log_status = "REQUEST" output = data message = "add_user_info success" success_flag = "Y" # log : DB 에 로그를 저장하는 함수 # log_db : DB 에 저장한 로그값 log_db = log(user_id, log_status, log_request, api, function, input, output, message, success_flag) logger.info(message, extra=logger_data) logger.debug(log_db, extra=logger_data) # 성공 여부 반환 result = "success" status = "200" # set_send : API 출력값 정렬 함수(아이디, 비밀번호 변수명 변경, 날짜 정보 형태 타입 변경 등) send = set_send(data, result, status) logger.debug(send, extra=logger_data) return send
def set_user_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 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 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 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_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()