def find_seller_name(**kwargs): """ 셀러 리스트 목록 찾는 API API 작성: 최진아 Header: Authorizaion: jwt Args: seller_name : 셀러 한글 이름 Returns: {data : seller_list}, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: Key의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: role_id = kwargs['role_id'] seller_name = request.args['seller_name'] db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 # 마스터 권한 전용이므로 셀러인 경우 요청 drop if role_id == SELLER_ROLE_ID: return jsonify(message="UNAUTHORIZED"), 401 # 권한 정보가 없는 경우 에러 if main_dao.role(db, role_id) is None: return jsonify(message="DATA_DOES_NOT_EXIST"), 404 if role_id == MASTER_ROLE_ID: seller_data = product_dao.similar_seller_name(db, seller_name) seller_list = [{ "id": seller['user_id'], "name": seller['seller_name'], "image": seller['profile_image'] }for seller in seller_data] return jsonify(data=seller_list), 200 except pymysql.err.InternalError: return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: return jsonify(message="DATA_ERROR"), 400 except KeyError: return jsonify(message="KEY_ERROR"), 400 except Exception as e: return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def product_list(**kwargs): """상품관리 리스트 및 필터 API 작성: 최진아 Header: Authorizaion: jwt Query Strings: 필터링 옵션 start_period: 조회 시작 기간 end_period: 조회 마지막 기간 seller_name: 셀러 한글 이름 seller_attribute: 셀러 구분 product_name: 상품명 product_id: 상품번호 code: 상품코드 on_sale : 판매여부 on_list: 진열여부 discount: 할인여부 limit : pagination offset : pagination Returns: {data = product_list}, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: 컬럼의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 ValidationError : 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: # filter의 validation 확인 validate(request.args, PRODUCT_FILTER_SCHEMA) role_id = kwargs['role_id'] user_id = kwargs['user_id'] # pagination 조건 생성 filter_dict = {} filter_dict['limit'] = request.args.get('limit', 10, int) filter_dict['offset'] = request.args.get('offset', 0, int) # 권한이 마스터인 경우의 필터 조건 생성 if role_id == MASTER_ROLE_ID: filter_list = ['start_period', 'end_period', 'seller_name', 'user_id', 'product_name', 'product_id', 'code', 'on_sale', 'on_list', 'discount'] for filter_key in filter_list: filter_dict[filter_key] = request.args.get(filter_key, None) if filter_dict['end_period']: end_date = parse(filter_dict['end_period']) add_date = datetime.timedelta(days = 1) end_period = end_date + add_date filter_dict['end_period'] = end_period # seller_attribute_id 값 리스트로 저장 / 잘못된 필터 데이터가 들어오면 에러 return seller_attribute_check_list = ['1','2','3','4','5','6','7'] seller_attributes = tuple(request.args.getlist('seller_attribute', None)) for seller_attribute in seller_attributes: if seller_attribute not in seller_attribute_check_list: return jsonify(message = "DATA_ERROR"), 400 filter_dict['seller_attribute'] = seller_attributes db = get_db_connector() #seller_name을 user_id로 변환 if filter_dict['seller_name']: filter_dict['user_id'] = product_dao.get_id_from_seller_name(db, filter_dict['seller_name']) # Select로 검색하는 값이 한번에 여러개 들어온 경우 에러 return select_check_list = [filter_dict['product_name'], filter_dict['product_id'], filter_dict['code']] if select_check_list.count(None) == 0 or select_check_list.count(None) == 1: return jsonify(message = "DATA_ERROR"), 400 # 권한이 셀러인 경우의 필터 조건 생성 if role_id == SELLER_ROLE_ID: filter_list = ['start_period', 'end_period', 'product_name', 'product_id', 'code', 'on_sale', 'on_list', 'discount'] for filter_key in filter_list: filter_dict[filter_key] = request.args.get('filter_key', None) # 셀러권한인 경우 셀러 아이디를 필터에 추가 filter_dict['user_id'] = user_id # Select로 검색하는 값이 한번에 여러개 들어온 경우 에러 return select_check_list = [filter_dict['product_name'], filter_dict['product_id'], filter_dict['code']] if select_check_list.count(None) == 0 or select_check_list.count(None) == 1: return jsonify(message = "DATA_ERROR"), 400 if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 if main_dao.role(db, role_id) is None: return jsonify(message="DATA_DOES_NOT_EXIST"), 404 products_data = product_dao.product_list(db, filter_dict) quantity = product_dao.count_product_list(db, filter_dict) product_list = { "quantity": quantity, "product": [{ "created_at": product['create_at'], "image": product_dao.find_first_image(db, product['id']), "product_name": product['name'], "product_code": product['code'], "product_id" : product['product_id'], "seller_attribute": product_dao.find_seller_attribute(db, product['seller_attribute_id']), "seller_name": product['seller_name'], "price": product['price'], "discount_price": product['discount_price'] if product['discount_price'] else product['price'], "discount_rate": product['discount_rate'], "on_sale": product['on_sale'], "on_list": product['on_list'], "discount": 0 if product['discount_rate'] == 0 else 1 } for product in products_data]} return jsonify(data = product_list), 200 except pymysql.err.InternalError: return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: return jsonify(message="DATA_ERROR"), 400 except KeyError: return jsonify(message="KEY_ERROR"), 400 except ValidationError as e: error_path = str(e.path)[8:-3] return jsonify(message=f"{error_path.upper()}_VALIDATION_ERROR"), 400 except Exception as e: return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def change_product_status(**kwargs): """상품 상태 변경 API API 작성: 최진아 Header: Authorizaion: jwt Args: code : 상품 코드 on_sale: 판매여부 on_list: 진열여부 Returns: {message: ''}, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: Key의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 ValidationError : 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: validate(request.json, PRODUCT_STATUS_SCHEMA) # 상품 코드를 이용하여 이전의 데이터 및 정보 불러오기 product_code=request.json['product_code'] db = get_db_connector() previous_product_detail_id = product_dao.find_product(db, product_code)['id'] previous_data = product_dao.find_product(db, product_code) product_detail_id = previous_data['id'] images_data = product_dao.find_images(db, product_detail_id) options_data = product_dao.find_options(db, product_detail_id) tags_data = product_dao.find_product_tags(db, product_detail_id) # 변경 값 받아와서 이전 값에서 변경하기 on_sale = request.json.get('on_sale', None) on_list = request.json.get('on_list', None) if on_sale is not None: if not (on_sale == 1 or on_sale == 0) : return jsonify(message = "DATA_ERROR"), 400 previous_data['on_sale'] = on_sale if on_list is not None: if not (on_list == 1 or on_list == 0): return jsonify(message = "DATA_ERROR"), 400 previous_data['on_list'] = on_list db.begin() # 변경된 데이터 삽입 후 삽입 된 번호 return product_detail_id = product_dao.insert_product_details(db, previous_data) # 이전 product_detail의 enddate 날짜 변경 previous_enddate = product_dao.find_product_date(db,product_detail_id) product_dao.change_product_date(db, previous_enddate, previous_product_detail_id) # 리스트로 들어온 태그 데이터 삽입 for tag in tags_data: tag_id = product_dao.find_tag_id(db, tag['name'])['id'] product_dao.insert_product_tag(db, product_detail_id, tag_id) # 리스트로 들어온 imgae_data 삽입 for image in images_data: large_url = image['large_url'] medium_url = image['medium_url'] small_url = image['small_url'] list_order = image['list_order'] image_id = product_dao.insert_image(db, large_url, medium_url, small_url) product_dao.insert_product_images(db, product_detail_id, image_id, list_order) # 리스트로 들어온 option_data 추가 for option in options_data: color_id = option['color_id'] size_id = option['size_id'] stock = option['stock'] code = option['code'] product_dao.insert_options(db, product_detail_id, color_id, size_id, stock, code) db.commit() return (''), 200 except pymysql.err.InternalError: db.rollback() return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: db.rollback() return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: db.rollback() return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: db.rollback() return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: db.rollback() return jsonify(message="DATA_ERROR"), 400 except KeyError: db.rollback() return jsonify(message=f"KEY_ERROR"), 400 except ValidationError as e: error_path = str(e.path)[8:-3] return jsonify(message=f"{error_path.upper()}_VALIDATION_ERROR"), 400 except Exception as e: db.rollback() return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def change_product_information(**kwargs): """상품 수정 API API 작성: 최진아 Header: Authorizaion: jwt Args: "seller_id" : 셀러 아이디, "product_code": 상품코드, "on_sale": 판매여부, "on_list": 진열여부, "first_category_id": 1차 카테고리, "second_category_id": 2차 카테고리, "manufacturer": 제조사, "manufacture_date": 제조일자, "manufacture_country_id": 원산지 id, "name": 상품명, "description_short": 한줄 상품 설명, "images": { "url": 이미지 url } "color_filter_id": 색상필터(썸네일 이미지), "style_filter_id": 스타일필터, "description_detail": 상세 상품 정보, "option": { "code": 옵션 상품 코드, "color_name": 옵션 색상 이, "size_name": 옵션 size 이름, "stock": 재고 수량 } "price": 판매가, "discount_rate": 할인율, "discount_price": 할인판매가, "discount_start": 할인기간 시작일, "discount_end": 할인기간 종료일, "min_sales_unit": 최소판매수량, "max_sales_unit": 최대판매수량, "tag" : { "name": 상품 태그 } Returns: {message: ''}, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: Key의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 ValidationError : 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: validate(request.json, CHANGE_PRODUCT_SCHEMA) data = request.json if data['max_sales_unit'] is None: data['max_sales_unit'] = 20 if data['min_sales_unit'] is None: data['min_sales_unit'] = 1 db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 data['modifier_id'] = kwargs['user_id'] product_code = data['product_code'] # 상품 코드를 이용하여 product_id를 구하고 data에 key,value 추가 product_id = product_dao.find_product(db, product_code)['product_id'] previous_product_detail_id = product_dao.find_product(db, product_code)['id'] data['product_id'] = product_id tag_data = data['tag'] image_data = data['images'] option_data = data['option'] # 이미지가 5개를 넘어서 들어오는 경우 if len(image_data) >= 6: return jsonify(message = "DATA_ERROR"), 400 # 옵션 중복 값 확인 option_duplicate_check=[] # (color_name,size_name)쌍으로 중복 체크 for option in option_data: if ((option['color_name'],option['size_name'])) in option_duplicate_check: return jsonify(message = "DATA_ERROR"), 400 else: option_duplicate_check.append((option['color_name'],option['size_name'])) # 기존의 옵션 코드에 저장된 내용과 현재 옵션값으로 받아온 정보가 다른 경우 체크 for option in option_data: if option['code']: option_details=product_dao.find_option_code(db, int(option['code'])) if (option_details['size_id'],option_details['color_id']) != (product_dao.get_option_size_id(db,option['size_id']),product_dao.get_option_color_id(db, option['color_id'])): return jsonify(message = "DATA_ERROR"), 400 # 최소 판매 수량이 20개를 초과한 경우 에러 if data['min_sales_unit'] > 20: return jsonify(message="DATA_ERROR"), 400 # 최대 판매 수량이 20개를 초과한 경우 에러 if data['max_sales_unit'] > 20: return jsonify(message="DATA_ERROR"), 400 # required가 아닌 항목이 Null값으로도 들어오지 않은 경우 처리 if 'description_short' not in data: data['descriotion_short'] = None if 'discount_rate' not in data: data['discount_rate'] = 0 if 'discount_price' not in data: data['discount_price'] = None if 'discount_start' not in data: data['discount_start'] = None if 'discount_end' not in data: data['discount_end'] = None # 상품 정보 고시 에러확인 manufacture_list = [data['manufacture_country_id'], data['manufacturer'], data['manufacture_date']] # 직접 입력인 경우 None이 존재하면 안됨 if manufacture_list.count(None) == 1 or manufacture_list.count(None) == 2: return jsonify(message = "DATA_ERROR"), 400 # 아래에서 data 입력위해 불필요한 list_data 삭제 rm_data = ['images','option','tag'] for rm in rm_data: del data[rm] price = data['price'] discount_rate = data['discount_rate'] discount_price = data['discount_price'] # 할인율이 없는데 할인가가 있는 경우 에러 return if discount_rate == 0 and discount_price is not None: return jsonify(message = "DATA_ERROR"), 400 # 할인율이 음수인 경우 에러 return elif discount_rate < 0: return jsonify(message = "DATA_ERROR"), 400 # 할인율이 100%가 넘는 경우 에러 return elif discount_rate >= 100: return jsonify(message = "DATA_ERROR"), 400 # 할인율이 있고 할인가가 없는 경우 할인가 계산 elif discount_rate !=0 and discount_price is None: discount_data = math.floor(price*((100-discount_rate)/100)/10)*10 data['discount_price'] = int(discount_data) db.begin() product_change_service(db, previous_product_detail_id, data, tag_data, image_data, option_data) db.commit() return (''), 200 except pymysql.err.InternalError: db.rollback() return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: db.rollback() return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: db.rollback() return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: db.rollback() return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: db.rollback() return jsonify(message="DATA_ERROR"), 400 except KeyError: db.rollback() return jsonify(message=f"KEY_ERROR"), 400 except ValidationError as e: error_path = str(e.path)[8:-3] return jsonify(message=f"{error_path.upper()}_VALIDATION_ERROR"), 400 except Exception as e: db.rollback() return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def history(**kwargs): """상품 수정의 수정 이력 API API 작성: 최진아 Header: Authorizaion: jwt Args: code : 상품 코드 Returns: {data : history_list}, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: Key의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 product_code=request.args.get('code') role_id = kwargs['role_id'] # 마스터 권한 전용이므로 마스터가 아닌 경우 요청 drop if role_id == SELLER_ROLE_ID: return jsonify(message="UNAUTHORIZED"), 401 # 권한 정보를 찾을 수 없을 때 if main_dao.role(db, role_id) is None: return jsonify(message="DATA_DOES_NOT_EXIST"), 404 if role_id == MASTER_ROLE_ID: history_data = product_dao.find_product_history(db, product_code) history_list =[ { "modified_data" : history['startdate'], "on_sale": history['on_sale'], "on_list": history['on_list'], "price": history['price'], "discount_price": history['discount_price'] if history['discount_price'] else history['price'], "discount_rate": history['discount_rate'] if history['discount_rate'] else 0, "modifier": user_dao.get_account_from_id(db, history['modifier_id']), "group": "브랜디" } for history in history_data] return jsonify(data=history_list), 200 except pymysql.err.InternalError: return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: return jsonify(message="DATA_ERROR"), 400 except KeyError: return jsonify(message="KEY_ERROR"), 400 except Exception as e: return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def get(self, **kwargs): """회원정보 수정 페이지의 값을 뿌려주는 API API 작성: 손진현 Header: Authorizaion: jwt URL params: <string:user_account>: 마스터권한일 경우 대상 Returns: { message: STATUS_MESSAGE token: JWT_TOKEN }, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: 컬럼의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ try: db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 # master 권한일 경우 urlparameter에서 대상 account를 가져오고 account에 해당하는 user_id를 가져온다 if kwargs['role_id'] == self.MASTER_ROLE_ID: user_account = kwargs.get('user_account', '') user_id = user_dao.get_id_from_account(db, user_account) # seller 권한일 경우 token에서 user_id를 가져오고 id에 해당하는 account를 가져온다 elif kwargs['role_id'] == self.SELLER_ROLE_ID: user_id = kwargs['user_id'] user_account = user_dao.get_account_from_id(db, user_id) # get_id_from_account, get_account_from_id중 하나라도 제대로 동작하지 않았을 경우 400 if user_account is None or user_id is None: return jsonify(message="INVALID_REQUEST"), 400 result = get_user_data_service(db, user_id, user_account, kwargs['role_id']) return jsonify(user_data_formatter(*result)), 200 except pymysql.err.INVALID_REQUESTternalError: db.rollback() return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: db.rollback() return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: db.rollback() return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: db.rollback() return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: db.rollback() return jsonify(message="DATA_ERROR"), 400 except KeyError: db.rollback() return jsonify(message="KEY_ERROR"), 400 except Exception as e: db.rollback() return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def get_product_information(**kwargs): """ 상품 수정시 기본 정보 보내주는 API API 작성: 최진아 Header: Authorizaion: jwt URL params: <string:product_code>: 상품 코드 Args: product_code : 상품 코드, Returns: {data : product_data}, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: Key의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 product_code=request.args.get('code') data = product_dao.find_product(db, product_code) seller_id = product_dao.get_seller_from_code(db, product_code) first_category_id = data['first_category_id'] second_category_id = data['second_category_id'] product_detail_id = data['id'] category_data = product_dao.find_category(db, first_category_id, second_category_id) images_data = product_dao.find_images(db, product_detail_id) options_data = product_dao.find_options(db, product_detail_id) tags_data = product_dao.find_product_tags(db, product_detail_id) product_data = product_data_service(db, seller_id, product_code, data, category_data, images_data, options_data, tags_data) return jsonify(data=product_data), 200 except pymysql.err.InternalError: return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: return jsonify(message="DATA_ERROR"), 400 except KeyError: return jsonify(message="KEY_ERROR"), 400 except Exception as e: return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def save_product(**kwargs): """ 상품등록 API API 작성: 최진아 Header: Authorizaion: jwt Args: "seller_id": 판매자 id, "on_sale": 판매여부, "on_list": 진열여부, "first_category_id": 1차 카테고리, "second_category_id": 2차 카테고리, "manufacturer": 제조사, "manufacture_date": 제조일자, "manufacture_country_id": 원산지 id, "name": 상품명, "description_short": 한줄 상품 설명, "images": { "url": 이미지 url } "color_filter_id": 색상필터(썸네일 이미지), "style_filter_id": 스타일필터,름 "description_detail": 상세 상품 정보, "option": { "color_name": 름, "size_name": 옵션 size 이름, "stock": 재고 수량 } "price": 판매가, "discount_rate": 할인율, "discount_price": 할인판매가, "discount_start": 할인기간 시작일, "discount_end": 할인기간 종료일, "min_sales_unit": 최소판매수량, "max_sales_unit": 최대판매수량, "tag" : { "name": 상품 태 } Returns: {message: ''}, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: Key의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 ValidationError : 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: validate(request.json, PRODUCT_SCHEMA) data = request.json db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 user_id = kwargs['user_id'] role_id = kwargs['role_id'] product_number = str(product_dao.count_product(db) + 1) code = "SB" + product_number.zfill(18) # 권한이 Master인 경우 seller_id는 data에서 들어온 seller_id if role_id == MASTER_ROLE_ID: seller_id = data['seller_id'] # 권한이 Seller인 경우 seller_id는user_id elif role_id == SELLER_ROLE_ID: seller_id = user_id elif main_dao.role(db, role_id) is None: return jsonify(message="DATA_DOES_NOT_EXIST"), 404 tag_data = data['tag'] image_data = data['images'] option_data = data['option'] # 이미지가 5개를 넘어서 들어오는 경우 if len(image_data) >= 6: return jsonify(message="DATA_ERROR"), 400 # 옵션 중복 값 확인 option_duplicate_check = [] # (color_name,size_name)쌍으로 중복 체크 for option in option_data: if ((option['color_name'], option['size_name'])) in option_duplicate_check: return jsonify(message="DATA_ERROR"), 400 else: option_duplicate_check.append( (option['color_name'], option['size_name'])) # 최소 판매 수량이 20개를 초과한 경우 에러 if data['min_sales_unit'] > 20: return jsonify(message="DATA_ERROR"), 400 # 최대 판매 수량이 20개를 초과한 경우 에러 if data['max_sales_unit'] > 20: return jsonify(message="DATA_ERROR"), 400 # required가 아닌 항목이 Null값으로도 들어오지 않은 경우 처리 if 'description_short' not in data: data['descriotion_short'] = None if 'discount_rate' not in data: data['discount_rate'] = 0 if 'discount_price' not in data: data['discount_price'] = None if 'discount_start' not in data: data['discount_start'] = None if 'discount_end' not in data: data['discount_end'] = None # 상품 정보 고시 에러확인 manufacture_list = [ data['manufacture_country_id'], data['manufacturer'], data['manufacture_date'] ] # 직접 입력인 경우 None이 존재하면 안됨 if manufacture_list.count(None) == 1 or manufacture_list.count( None) == 2: return jsonify(message="DATA_ERROR"), 400 # 아래에서 data 입력위해 불필요한 list_data 삭제 rm_data = ['images', 'option', 'tag'] for rm in rm_data: del data[rm] price = data['price'] discount_rate = data['discount_rate'] discount_price = data['discount_price'] # 할인율이 없는데 할인가가 있는 경우 에러 return if discount_rate == 0 and discount_price is not None: return jsonify(message="DATA_ERROR"), 400 # 할인율이 음수인 경우 에러 return if discount_rate < 0: return jsonify(message="DATA_ERROR"), 400 # 할인율이 100%가 넘는 경우 에러 return if discount_rate >= 100: return jsonify(message="DATA_ERROR"), 400 # 할인율이 있고 할인가가 없는 경우 할인가 계산 elif discount_rate != 0 and discount_price is None: discount_data = math.floor(price * ((100 - discount_rate) / 100) / 10) * 10 data['discount_price'] = int(discount_data) db.begin() product_save_service(db, data, seller_id, user_id, code, tag_data, image_data, option_data) db.commit() return jsonify(message="SUCCESS"), 200 except pymysql.err.InternalError: db.rollback() return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: db.rollback() return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: db.rollback() return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: db.rollback() return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: db.rollback() return jsonify(message="DATA_ERROR"), 400 except KeyError: db.rollback() return jsonify(message=f"KEY_ERROR"), 400 except ValidationError as e: error_path = str(e.path)[8:-3] return jsonify(message=f"{error_path.upper()}_VALIDATION_ERROR"), 400 except Exception as e: db.rollback() return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def product_information(**kwargs): """상품 등록시 옵션 및 필터 정보 전달 API API 작성: 최진아 Header: Authorizaion: jwt Returns: {data : information_data}, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: Key의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 countries = product_dao.country_data(db) colors = product_dao.option_color(db) sizes = product_dao.option_size(db) color_filters = product_dao.color_filter(db) style_filters = product_dao.style_filter(db) information_data = [{ "country": [{ "id": country.get('id'), "name": country.get('name')} for country in countries], "option_color": [{ "id": color.get('id'), "name": color.get('name')} for color in colors], "option_size": [{ "id": size.get('id'), "name": size.get('name')} for size in sizes], "color_filter": [{ "id": color_data.get('id'), "name": color_data.get('name'), "name_eng": color_data.get('name_eng'), "image_url": color_data.get('image_url')} for color_data in color_filters], "style_filter": [{ "id": style_data.get('id'), "name": style_data.get('name')} for style_data in style_filters]}] return jsonify(data=information_data), 200 except pymysql.err.InternalError: return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: return jsonify(message="DATA_ERROR"), 400 except KeyError: return jsonify(message="KEY_ERROR"), 400 except Exception as e: return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def post(self): """회원가입 API API 작성: 손진현 Args: account: 계정명 password: 비밀번호 seller_name: 셀러명 seller_name_eng: 셀러명(영문) cs_number: 고객센터 전화번호 seller_attribute_id: 셀러 속성 id site_url: 셀러 사이트 url Returns: {message: STATUS_MESSAGE}, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: Key의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 ValidationError : 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: # JSON SCHEMA를 이용한 Validation validate(request.json, SIGN_UP_SCHEMA) data = request.json # DB 커넥터 정의 및 에러 핸들 db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 # 입력받은 acount로 중복된 유저인지 조회 user_id = user_dao.get_id_from_account(db, data['account']) if user_id: return jsonify(message="ACCOUNT_DUPLICATED"), 409 # bcrypt 라이브러리를 이용하여 비밀번호를 SHA256으로 해 data['password'] = bcrypt.hashpw(data['password'].encode('utf-8'), bcrypt.gensalt()).decode('utf-8') db.begin() sign_up_service(db, data) db.commit() return jsonify(message="SIGN_UP_COMPLETE"), 200 except pymysql.err.InternalError: db.rollback() return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: db.rollback() return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: db.rollback() return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: db.rollback() return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: db.rollback() return jsonify(message="DATA_ERROR"), 400 except ValidationError as e: error_path = str(e.path)[8:-3] return jsonify( message=f"{error_path.upper()}_VALIDATION_ERROR"), 400 except Exception as e: db.rollback() return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def user_status(**kwargs): """마스터 유저의 셀러 정보 수정 페이지의 액션 버튼을 통해 셀러의 상태를 조정하는 API API 작성: 손진현 Headers: Authorizaion: jwt Url Params: <string:user_account>: 대상 user의 id Body: action: 유저에게 적용할 action id Returns: { message: STATUS_MESSAGE token: JWT_TOKEN }, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: 컬럼의 무결성을 해쳤을 때 발생 UserNotExistError: urlparams로 전달받은 seller가 존재하지 않을 때 WrongActionError: seller의 현재 상태에 적용되지 않는 action 버튼일 때 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 # 마스터 권한 전용 메뉴이므로 마스터 토큰이 아닐 경우 요청 drop if not kwargs['role_id'] == User.MASTER_ROLE_ID: return jsonify(message="NOT_AUTHORIZED_USER"), 403 # 해당 유저에게 유효한 액션인지 확인 user_status_update_validate_service(db, request.json['action'], kwargs['target_id']) # user_id : url params로 전달된 변경할 대상 유저의 id값 # modifier_id : 토큰으로부터 추출된 master의 id값 # action : query string으로 전달된 유저에 적용될 action id값 db.begin() user_status_update_service(db, user_id=kwargs['target_id'], modifier_id=kwargs['user_id'], action=request.json['action']) db.commit() return jsonify(''), 200 except pymysql.err.InternalError: db.rollback() return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: db.rollback() return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: db.rollback() return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: db.rollback() return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: db.rollback() return jsonify(message="DATA_ERROR"), 400 except UserNotExistError: db.rollback() return jsonify(message="USER_DOES_NOT_EXIST"), 400 except WrongActionError: db.rollback() return jsonify(message="USER_DOES_NOT_SUPPORT_THIS_ACTION"), 400 except KeyError: db.rollback() return jsonify(message="KEY_ERROR"), 400 except Exception as e: db.rollback() return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def user_list(**kwargs): """마스터 유저의 셀러 정보 수정 페이지의 리스트를 리턴하는 API API 작성: 손진현 Header: Authorizaion: jwt Query Strings: 필터링 옵션 id: 유저 번호 account: 셀러 계정 seller_name_eng : 셀러 영어 이름 seller_name : 셀러 한글 이름 manager_name : 담당자 이름 seller_status : 셀러 상태 manager_phone : 담당자 전화번호 manager_email : 담당자 이메일 seller_attribute : 셀러 속성 Returns: { message: STATUS_MESSAGE token: JWT_TOKEN }, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: 컬럼의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 # 마스터 권한 전용 메뉴이므로 마스터 토큰이 아닐 경우 요청 drop if kwargs['role_id'] != User.MASTER_ROLE_ID: return jsonify(message="NOT_AUTHORIZED_USER"), 403 filter_validation_service(request.args) lists = get_seller_list_service(db, request.args) return jsonify(**lists), 200 except pymysql.err.INVALID_REQUESTternalError: db.rollback() return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: db.rollback() return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: db.rollback() return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: db.rollback() return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: db.rollback() return jsonify(message="DATA_ERROR"), 400 except KeyError: db.rollback() return jsonify(message="KEY_ERROR"), 400 except Exception as e: db.rollback() return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def sign_in(): """로그인 API API 작성: 손진현 Args: account: 계정명, password: 비밀번호 Returns: { message: STATUS_MESSAGE token: JWT_TOKEN }, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: Key의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 ValidationError : 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: # JSON SCHEMA를 이용한 Validation validate(request.json, SIGN_IN_SCHEMA) data = request.json # DB 정의 및 에러 핸들 db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 # 액세스 토큰에 담을 role_id, user_id와 비밀번호, 셀러 권한을 페치한다 result = user_dao.get_id_role_password_status_from_account( db, data['account']) # account가 존재하지 않아 아무것도 페치되지 않았을 경우 핸들 if not result: return jsonify(message="ACCOUNT_DOES_NOT_EXIST"), 400 # hash된 password가 일치하지 않을 때 사용 if not bcrypt.checkpw(data['password'].encode('utf-8'), result['password'].encode('utf-8')): return jsonify(message="PASSWORD_MISMATCH"), 400 # 유저의 role이 셀러이며 status가 입점대기일 때 403 에러 발생 if (result['role_id'] == User.SELLER_ROLE_ID and result['status_id'] == User.BASIC_STATUS_ID): return jsonify(message="NOT_AUTHORIZED_USER"), 403 # jwt 작성 token = jwt.encode( { 'role_id': result['role_id'], 'user_id': result['id'], 'exp': datetime.utcnow() + timedelta(hours=1) }, SERCRET, HASH_ALGORITHM) return jsonify(message="SIGN_IN_COMPLETE", token=token), 200 except pymysql.err.InternalError: return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: return jsonify(message="DATA_ERROR"), 400 except ValidationError as e: error_path = str(e.path)[8:-3] return jsonify(message=f"{error_path.upper()}_VALIDATION_ERROR"), 400 except Exception as e: return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def put(self, **kwargs): """회원정보 수정 페이지에서 입력받은 값으로 회원정보를 수정하는 API API 작성: 손진현 Header: Authorizaion: jwt Args: profile_image: 프로필 이미지(url), seller_attribute: 셀러 속성 id, seller_name: 셀러 이름, seller_name_eng: 셀러 영어 이름, seller_account: 셀러 계정, background_image: 배경 이미지(url), introduction_short: 셀러 한줄 소개, introduction_detail: 셀러 상세 소개, site_url: 홈페이지, manager: { "name: 담당자 이름, "phone": 담당자 전화번호, "email": 담당자 이메일 } cs_phone: 고객센터 전화번호, zip_code: 우편번호, address: 주소, address_detail: 상세 주소, weekday_start_time: 고객센터 운영시작시간(주중), weekday_end_time: 고객센터 운영종료시간(주중), weekend_start_time: 고객센터 운영시작시간(주말), weekend_end_time: 고객센터 운영시작시간(주말), bank: 정산은행, bank_account_name: 예금주, bank_account_number: 계좌번호 height: 모델 키, top_size: 모델 상의 사이즈, bottom_size: 모델 하의 사이즈, foot_size: 모델 발 사이즈 Returns: {message: STATUS_MESSAGE}, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: 컬럼의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ try: db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 # master 권한일 경우에 대한 validation 및 urlparameter에서 가져온 account에 해당하는 user_id를 조회 if kwargs['role_id'] == self.MASTER_ROLE_ID: validate(request.json, USER_DATA_MODIFY_MASTER) user_id = user_dao.get_id_from_account(db, kwargs['user_account']) modifier_id = kwargs['user_id'] # seller 권한일 경우에 대한 validation 및 token에서 user_id를 조회 elif kwargs['role_id'] == self.SELLER_ROLE_ID: validate(request.json, USER_DATA_MODIFY_SELLER) user_id = kwargs['user_id'] modifier_id = user_id # user_id가 존재하지 않을 경우 유효하지 않은 동작으로 400 출력 if user_id is None: return jsonify(message="INVALID_REQUEST"), 400 # request로 전달받은 json을 테이블별로 정렬 details, managers = user_data_deformatter(**request.json) db.begin() user_update_service(db, user_id, modifier_id, details, managers) db.commit() return jsonify(''), 200 except pymysql.err.InternalError: db.rollback() return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: db.rollback() return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: db.rollback() return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: db.rollback() return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: db.rollback() return jsonify(message="DATA_ERROR"), 400 except KeyError: db.rollback() return jsonify(message="KEY_ERROR"), 400 except Exception as e: db.rollback() return jsonify(message=f"{e}"), 500 finally: if db: db.close()
import os import sys import pymysql ROOT_DIR = os.path.dirname(os.path.abspath("API")) BASE_DIR = os.path.dirname(os.path.abspath(__file__)) sys.path.extend([ROOT_DIR]) os.chdir(BASE_DIR) from create_table_utils import init_database, import_aquery_to_list from connections import get_db_connector db = get_db_connector() cursor = db.cursor() db.begin() init_database(db) with open('aquery_exports/brandi_20200612_28_25.txt', 'r') as aquery_file: TABLE_QUERIES = import_aquery_to_list(aquery_file) for query in TABLE_QUERIES: cursor.execute(query) db.commit() cursor.close() db.close() print('COMPLETE')
def product_category(**kwargs): """상품 등록시 카테고리 정보 전달 API API 작성: 최진아 Header: Authorizaion: jwt Args: user_id: 접속 아이디, seller_id : 셀러 아이디, attribute_group_id: 판매자 속성 Returns: {data : category_list}, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: Key의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 user_id = kwargs['user_id'] role_id = kwargs['role_id'] if role_id == MASTER_ROLE_ID: seller_id = request.args.get('seller_id') attribute_group_id = product_dao.get_attribute_group_id(db, seller_id) elif role_id == SELLER_ROLE_ID : attribute_group_id = product_dao.get_attribute_group_id(db, user_id) elif main_dao.role(db, role_id) is None: return jsonify(message="DATA_DOES_NOT_EXIST"), 404 first_category_data = product_dao.first_category(db, attribute_group_id) category_list = [{ "id": category.get('id'), "name": category.get('name'), "second_category": [{ "id":category_detail.get('id'), "name":category_detail.get('name') }for category_detail in product_dao.second_category(db,category.get('id'))] }for category in first_category_data] return jsonify(data=category_list), 200 except pymysql.err.InternalError: return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: return jsonify(message="DATA_ERROR"), 400 except KeyError: return jsonify(message="KEY_ERROR"), 400 except Exception as e: return jsonify(message=f"{e}"), 500 finally: if db: db.close()
def category(**kwargs): """사이드바 예시 API API 작성: 최진아 Args: role_id : user의 권한 확인 Returns: {data : sidebar_list}, http status code Exceptions: InternalError: DATABASE가 존재하지 않을 때 발생 OperationalError: DATABASE 접속이 인가되지 않았을 때 발생 ProgramingError: SQL syntax가 잘못되었을 때 발생 IntegrityError: Key의 무결성을 해쳤을 때 발생 DataError: 컬럼 타입과 매칭되지 않는 값이 DB에 전달되었을 때 발생 KeyError: 엔드포인트에서 요구하는 키값이 전달되지 않았을 때 발생 """ db = None try: db = get_db_connector() if db is None: return jsonify(message="DATABASE_INIT_ERROR"), 500 role_id = kwargs['role_id'] if main_dao.role(db, role_id) is None: return jsonify(message="DATA_DOES_NOT_EXIST"), 404 data = main_dao.sidebar_list(db, role_id) sidebar = [{ "id": side_list.get('id'), "name": side_list.get('name'), "detail_data": [{ "id": detail.get('id'), "name": detail.get('name') } for detail in main_dao.sidebar_detail_list( db, side_list.get('id'))] } for side_list in data] return jsonify(data=sidebar), 200 except pymysql.err.InternalError: return jsonify(message="DATABASE_DOES_NOT_EXIST"), 500 except pymysql.err.OperationalError: return jsonify(message="DATABASE_AUTHORIZATION_DENIED"), 500 except pymysql.err.ProgrammingError: return jsonify(message="DATABASE_SYNTAX_ERROR"), 500 except pymysql.err.IntegrityError: return jsonify(message="FOREIGN_KEY_CONSTRAINT_ERROR"), 500 except pymysql.err.DataError: return jsonify(message="DATA_ERROR"), 400 except KeyError: return jsonify(message="KEY_ERROR"), 400 except Exception as e: return jsonify(message=f"{e}"), 500 finally: if db: db.close()
import os import sys ROOT_DIR = os.path.dirname(os.path.abspath("API")) BASE_DIR = os.path.dirname(os.path.abspath(__file__)) sys.path.extend([ROOT_DIR]) os.chdir(BASE_DIR) from create_table_utils import init_database, import_aquery_to_list from connections import get_db_connector db = get_db_connector() cursor = get_db_connector() db.begin() init_database(db) with open('aquery_exports/brandi_20200530_29_44.txt', 'r') as aquery_file: TABLE_QUERIES = import_aquery_to_list(aquery_file) for query in TABLE_QUERIES: cursor.execute(query) db.commit() cursor.close() db.close() print('COMPLETE')