def products_category(): """ 상품 카테고리 list Author: Chae hyun Kim Returns: - 200: { "message" : "SUCCESS" "result" : { "data" : category_list, "totalCount" : 2차 카테고리 총 갯수 } } """ connection = None try: connection = connect_db() produts_category_service = ProductService() category_list = produts_category_service.products_category( connection) return category_list except Exception as e: if connection: connection.rollback raise e finally: if connection: connection.close()
def get_question_open(): """ [서비스] 제품 상세페이지에서 질문 올릴 때 질문유형 선택 드롭박스 Author: Ji Yoon Lee Args: - token(str): 로그인 user의 token이 header에 담겨 들어와 로그인 유효성 검사를 거침 Returns: - 200 : { 'message': 'SUCCESS', 'result': { 'data': 질문 유형 목록 } } - 400: "요청에 실패하였습니다" Note: 회원만 질문을 남길 수 있음 """ connection = None try: connection = connect_db() if connection: product_service = ProductService() type_list = product_service.get_question_open(connection) return type_list except Exception as e: if connection: connection.rollback() raise ApiException(400, REQUEST_FAILED) finally: if connection: connection.close()
def product_detail(product_id): """ [서비스] 제품 상세페이지 제품정보 가져오기 Author: Ji Yoon Lee Args: - product_id (path parameter) Returns: - 200 : { 'message': 'SUCCESS', 'result': { 'product': 상품정보 } } - 400: "요청에 실패하였습니다" """ connection = None try: connection = connect_db() if connection: product_service = ProductService() product_detail = product_service.get_product_detail( product_id, connection) return product_detail except Exception as e: if connection: connection.rollback() raise ApiException(400, REQUEST_FAILED) finally: if connection: connection.close()
def patch(*args): data = request.json for row in data: # product_id가 없을 때 if row.get("product_id") is None: raise InvalidParamError(NOT_EXIST_PRODUCT_ID, 400) # product_id가 숫자가 아닐 때 if type(row.get("product_id")) is not int: raise InvalidParamError(INVALID_PRODUCT_ID, 400) product_service = ProductService() connection = None try: connection = connect_db() result = product_service.update_product_list(connection, data) return jsonify({"data": result}) except Exception as e: connection.rollback() raise e finally: if connection is not None: connection.close()
def post_product_qna(): """ [서비스] 제품 상세페이지에서 질문 등록 Author: Ji Yoon Lee Args: - token(str): 로그인 user의 token이 header에 담겨 들어와 로그인 유효성 검사를 거침 - body(dict): 'questionType', 'content', 'isPrivate'(비공개글일시), 'productId' Returns: - 200 : { 'message': 'SUCCESS', 'result': { 'data': { 등록된 질문 id, 질문 로그 id } } } - 400: '요청에 실패하였습니다', 필수 parameter 미입력시 '** 정보를 입력해 주세요' - 401: '로그인이 필요합니다' """ connection = None try: user_id = g.token_info['user_id'] data = request.json if user_id is None: raise ApiException(401, LOGIN_REQUIRED) if 'questionType' not in data: raise ApiException(400, SELECT_QUESTION_TYPE) if 'content' not in data: raise ApiException(400, CONTENT_MISSING) if 'productId' not in data: raise ApiException(400, PRODUCT_INFO_MISSING) connection = connect_db() question_info = { 'question_type_id': data['questionType'], 'contents': data['content'], 'is_private': data.get('isPrivate', 1), 'product_id': data['productId'], 'user_id': user_id } product_service = ProductService() product_qna = product_service.post_product_qna( question_info, connection) connection.commit() return product_qna except ApiException as e: if connection: connection.rollback() raise ApiException(400, REQUEST_FAILED) finally: if connection: connection.close()
def get_product_qna(product_id): """ [서비스] 제품 상세페이지에서 해당 상품 관련 질문 답변 Author: Ji Yoon Lee Args: - token(str): 로그인 user의 token이 header에 담겨 들어와 로그인 유효성 검사를 거침 - product_id (path parameter) - limit(int): 한 페이지에 보여질 게시물 수 (질문기준 갯수) - offset(int): 페이지 이동 시, 몇번째 게시물부터 보여줄 지 Returns: - 200 : { 'message': 'SUCCESS', 'result': { 'data': { 질문 정보, 답변 정보(답변 있을시) } } } - 400: 존재하지 않는 상품의 경로로 들어온 경우 '잘못된 경로입니다' Note: - token 유무 상관없이 제품 상페페이지 접근 가능. - 단, token이 있고 해당 유저가 상품 질문을 남긴 경우, 자신이 등록한 글과 해당 답변은 열람 가능 - 글 등록시 공개로 등록된 글은 본인의 글 아니여도 누구나 열람 가능 - 자신의 아이디와 판매자의 브랜드 이름은 공개 - 다른 회원이 올린 비공개 게시물은 아이디 부분 비공개처리 """ connection = None try: # 회원인지 비회원인지 확인. 회원이라면 회원 특정. if "token_info" in g: user_id = g.token_info["user_id"] else: user_id = None info = { 'user_id': user_id, 'product_id': product_id, 'limit': int(request.args.get("limit", 5)), 'offset': int(request.args.get("offset", 0)) } connection = connect_db() if connection: product_service = ProductService() product_qna = product_service.get_product_qna(info, connection) return product_qna except Exception as e: if connection: connection.rollback() raise ApiException(400, WRONG_URI_PATH) finally: if connection: connection.close()
def products_list(): """ products list Author: Chae hyun Kim Args: - query parameter : 필요할 경우 category의 id, limit과 offset 조건을 query paramter로 받는다 Returns: - 200: { "message" : "SUCCESS", "result" : { "data" : product list, "totalCount" : 상품 총 갯수 } } Note: - filtering 조건으로 category의 id가 query parameter를 통해 들어올 경우 해당 조건에 해당하는 product list로 결과 반환 """ MINIMUM_CATEGORY_NUMBER = 4 MAXIMUM_CATEGORY_NUMBER = 5 connection = None try: connection = connect_db() products_service = ProductService() page_condition = {} category = request.args.get('category', None) limit = request.args.get('limit', None) offset = request.args.get('offset', None) # filtering 조건으로 들어올 category의 값이 허용 범위를 넘었을 경우 에러 반환 if category is not None: if int(category) < MINIMUM_CATEGORY_NUMBER or int( category) > MAXIMUM_CATEGORY_NUMBER: raise ApiException(404, INVALID_FILTER_CONDITION) page_condition['category'] = category # "더보기"를 누르기 전 limit 조건이 들어오지 않았을 경우 기본으로 30으로 지정 if limit is None: page_condition['limit'] = 30 else: page_condition['limit'] = int(limit) # "더보기"를 누르기 전 offset 조건이 들어오지 않았을 경우 기본으로 0으로 지정 if offset is None: page_condition['offset'] = 0 else: page_condition['offset'] = int(offset) product_list = products_service.products_list( connection, page_condition) return product_list except Exception as e: if connection: connection.rollback raise e finally: if connection: connection.close()
def store_rating(): rating_dict = request.form.to_dict(flat=False) print(request.form) try: ProductService.store_rating(rating_dict) return "success" except KeyError: return "failure"
def delete(): productService = ProductService() productId = request.args.get("id") if productId is None: return ("forbidden", 403) result = json.dumps({"successful": productService.delete(productId)}) productService.dispose() return (result, 200)
def post(self, valid: ValidRequest): data = valid.get_form() data["account_id"] = g.account_info.get("account_id") data["account_type"] = g.account_info.get("account_type") # json 형태로 오는 options 따로 변수 선언 후 제거 options = literal_eval(data["options"]) del data["options"] main_image_file = request.files.get("main_image_file") image_files = request.files.getlist("image_files") if data["account_type"] not in [ MASTER_ACCOUNT_TYPE, SELLER_ACCOUNT_TYPE ]: raise UnauthorizedError(UNAUTHORIZED, 401) product_service = ProductService() image_service = ImageService() connection = None s3_connection = None image_urls = [] try: connection = connect_db() s3_connection = connect_s3() # 상품 등록 data = product_service.insert_new_product(connection, data, options) # 메인 이미지 S3 등록 image_urls.append( image_service.image_upload(s3_connection, main_image_file)) # 다른 이미지 S3 등록 for image_file in image_files: image_urls.append( image_service.image_upload(s3_connection, image_file)) product_service.insert_new_product_images(connection, data, image_urls) connection.commit() return jsonify({"message": "success"}) except Exception as e: connection.rollback() raise e finally: if connection is not None: connection.close()
def get(self, valid: ValidRequest): """어드민 상품 관리 리스트 Author: 이서진 Returns: - 200: "data": { "count": 상품 리스트 총 개수 "products": [ { "created_at": 상품 등록 시간, "discount_start_time": 상품 할인 시작 시간, "discount_end_time": 상품 할인 끝 시간, "discount_rate": 상품 할인율, "image_url": 상품 대표 이미지 주소, "is_displayed": 진열 여부, "is_sold": 판매 여부, "name": 상품 이름, "price": 가격, "product_code": 상품 코드, "product_number": 상품 번호, "seller_category": 셀러 속성 } ] } - 400: validate param 오류 """ filters = valid.get_params() filters["account_id"] = g.account_info.get("account_id") filters["account_type"] = g.account_info.get("account_type") if filters["account_type"] not in [ MASTER_ACCOUNT_TYPE, SELLER_ACCOUNT_TYPE ]: raise UnauthorizedError(UNAUTHORIZED, 401) product_service = ProductService() connection = None try: connection = connect_db() result = product_service.get_product_list(connection, filters) return jsonify({"data": result}) except Exception as e: raise e finally: if connection is not None: connection.close()
def find(): productService = ProductService() productId = request.args.get("id") if productId is None: return None product = productService.find(productId) result = json.dumps(product.dicted()) productService.dispose() return (result, 200)
def modify(): productService = ProductService() flag = False try: product = Product.dict2Obj(json.loads(request.data)) flag = productService.modify(product) except: return ("forbidden", 403) result = json.dumps({"successful": flag}) productService.dispose() return (result, 200)
def apply_rule(self): ipad = ProductService().get_product('ipd') ipad_count = self.shopping_cart.products.count(ipad) if ipad_count > 4: self.shopping_cart.total -= ipad_count * (ipad.price - 499.99) return self.shopping_cart
def create_app(test_config=None): app = Flask(__name__) app.config['JSON_AS_ASCII'] = False CORS(app) if test_config is None: app.config.from_pyfile("config.py") else: app.config.update(test_config) product_dao = ProductDao() seller_dao = SellerDao() order_dao = OrderDao() user_dao = UserDao() coupon_dao = CouponDao() event_dao = EventDao() services = Services services.product_service = ProductService(product_dao, app.config) services.seller_service = SellerService(seller_dao, app.config) services.order_service = OrderService(order_dao, app.config) services.user_service = UserService(user_dao, app.config) services.coupon_service = CouponService(coupon_dao, app.config) services.event_service = EventService(event_dao, app.config) create_endpoints(app, services) return app
def findWarning(): productService = ProductService() num = request.args.get("num") if num is None: return None products = productService.findWarning(int(num)) result = [] for product in products: result.append(product.dicted()) productService.dispose() return (json.dumps(result), 200)
def create_app(test_config=None): app = Flask(__name__) app.json_encoder = CustomEncoder CORS(app, resources={r'*': {'origins': '*'}}) if test_config is None: app.config.from_pyfile('config.py') else: app.config.update(test_config) #persistence layer account_dao = AccountDao() seller_dao = SellerDao() order_dao = OrderDao() product_dao = ProductDao() #business layer account_service = AccountService(account_dao, config) seller_service = SellerService(seller_dao, config) order_service = OrderService(order_dao) product_service = ProductService(product_dao) #presentation layer(엔드포인트 생성) app.register_blueprint(create_account_endpoints(account_service)) app.register_blueprint(create_seller_endpoints(seller_service)) app.register_blueprint(create_order_endpoints(order_service)) app.register_blueprint(create_product_endpoints(product_service)) return app
def apply_rule(self): macbook_pro = ProductService().get_product('mbp') macbook_pro_count = self.shopping_cart.products.count(macbook_pro) vga_adapter = ProductService().get_product('vga') vga_count = self.shopping_cart.products.count(vga_adapter) if macbook_pro_count >= 1: # if vga adapters are already added, apply price discount if vga_count >= macbook_pro_count: self.shopping_cart.total -= macbook_pro_count * vga_adapter.price # if vga adapter numbers are not matching macbook pro numbers, add more elif vga_count < macbook_pro_count: self.shopping_cart.total -= vga_count * vga_adapter.price for _ in range(macbook_pro_count - vga_count): self.shopping_cart.products.append(vga_adapter) return self.shopping_cart
def get(*args, seller_category_id, product_category_id=None): filters = dict(request.args) filters["seller_category_id"] = seller_category_id filters["product_category_id"] = product_category_id product_service = ProductService() connection = None try: connection = connect_db() result = product_service.get_product_category_list(connection, filters) return jsonify({"data": result}) except Exception as e: raise e finally: if connection is not None: connection.close()
def create_app(test_config=None): def get_session(): session = Session() return session app = Flask(__name__) CORS(app, resources={r'*': {'origins': '*'}}) @app.errorhandler(Exception) def handle_invalid_usage(error): if isinstance(error, InvalidRequest): return {'message': str(error)}, 400 else: response = jsonify(error) response.status_code = error.status_code return response from contextlib import suppress from flask.json import JSONEncoder class MyJSONEncoder(JSONEncoder): def default(self, obj): # Optional: convert datetime objects to ISO format with suppress(AttributeError): return obj.isoformat() return dict(obj) app.json_encoder = MyJSONEncoder if test_config is None: app.config.from_pyfile("config.py") else: app.config.update(test_config) database = create_engine(app.config['DB_URL'], encoding='utf-8', max_overflow=0) Session = sessionmaker(bind=database, autocommit=False) # Persistence Layer seller_dao = SellerDao() product_dao = ProductDao() order_dao = OrderDao() # Business Layer services = Services services.seller_service = SellerService(seller_dao, app.config) services.product_service = ProductService(product_dao) services.order_service = OrderService(order_dao, seller_dao) seller_endpoints(app, services, get_session) product_endpoints(app, services, get_session) order_endpoints(app, services, get_session) return app
def apply_rule(self): apple_tv = ProductService().get_product('atv') apple_tv_count = self.shopping_cart.products.count(apple_tv) if apple_tv_count >= 3: # get the number of 3 for 2 sets of apple tv sets_applied_discount = (apple_tv_count - apple_tv_count % 3) / 3 # apply discount to the sets, one apply tv for free in each set discount = sets_applied_discount * apple_tv.price self.shopping_cart.total -= discount return self.shopping_cart
def get_other_products(): """ [서비스] 판매자의 다른상품 5개 추천 Author: Ji Yoon Lee Args: - query string: 'sellerId', 'productId' Returns: - 200 : { 'message': 'SUCCESS', 'result': { 'data': { 상품정보 } } } - 400: '요청에 실패하였습니다', 필수 parameter 미입력시 '** 정보를 입력해 주세요' """ connection = None try: info = { "seller_id": int(request.args['sellerId']), "product_id": int(request.args['productId']) } connection = connect_db() if connection: product_service = ProductService() products_list = product_service.get_other_products( info, connection) return products_list except Exception as e: if connection: connection.rollback() raise ApiException(400, REQUEST_FAILED) finally: if connection: connection.close()
def create_app(test_config=None): """ Returns : 생성된 플라스크 앱 객체 Authors : [email protected](김기욱) [email protected](김태하) History : 2020-10-11 : Caching 구현 2020-10-02 : ASCCI형식 False로 변경(김기욱) 2020-09-17 : 초기 생성(김기욱 김태하) """ app = Flask(__name__) app.config['JSON_AS_ASCII'] = False app.config['CACHE_TYPE'] = 'simple' cache.init_app(app) #SetUp CORS CORS(app) #SetUp config if test_config is None: app.config.from_pyfile('config.py') else: app.config.update(test_config) #SetUp Persistence Layer product_dao = ProductDao() search_dao = SearchDao() user_dao = UserDao() question_dao = QuestionDao() coupon_dao = CouponDao() purchase_dao = PurchaseDao() #SetUp Business Layer services = Services services.product_service = ProductService(product_dao) services.user_service = UserService(user_dao) services.question_service = QuestionService(question_dao) services.coupon_service = CouponService(coupon_dao) services.search_service = SearchService(search_dao) services.purchase_service = PurchaseService(purchase_dao) #SetUp Presentation Layer create_endpoints(app, services) return app
def create_app(test_config=None): app = Flask(__name__) if test_config is None: app.config.from_pyfile('config.py') else: app.config.update(test_config) # pool size : 1000, max_overflow=100 인 QueuePool로 DB 연결 설정 database = create_engine(app.config['DB_URL'], encoding='utf-8', pool_size=1000, max_overflow=100, poolclass=QueuePool) # database engin와 연동된 session maker 생성, connection 필요시마다 session instance 생성 Session = sessionmaker(bind=database) # CORS 설정 CORS(app, resources={r'*': {'origins': '*'}}) # Persistence layer order_dao = OrderDao() user_dao = UserDao() seller_dao = SellerDao() product_dao = ProductDao() qna_dao = QnADao() review_dao = ReviewDao() coupon_dao = CouponDao() # Business layer order_service = OrderService(order_dao) user_service = UserService(user_dao) seller_service = SellerService(seller_dao) product_service = ProductService(product_dao) qna_service = QnAService(qna_dao) review_service = ReviewService(review_dao) coupon_service = CouponService(coupon_dao) # Presentation layer app.register_blueprint(create_order_endpoints(order_service, Session)) app.register_blueprint(create_user_endpoints(user_service, Session)) app.register_blueprint(create_seller_endpoints(seller_service, Session)) app.register_blueprint(create_product_endpoints(product_service, Session)) app.register_blueprint(create_qna_endpoints(qna_service, Session)) app.register_blueprint(create_review_endpoints(review_service, Session)) app.register_blueprint(create_coupon_endpoints(coupon_service, Session)) return app
def get(*args): """메인 상품 리스트 Author: 이서진 Returns: 200: { } """ filters = { "offset": int(request.args.get("offset", 0)), "limit": int(request.args.get("limit", 30)) } if filters.get("offset") < 0: filters["offset"] = 0 if filters.get("limit") < 1: filters["limit"] = 1 product_service = ProductService() connection = None try: connection = connect_db() result = product_service.get_product_list(connection, filters) return jsonify({"data": result}) except Exception as e: raise e finally: if connection is not None: connection.close()
def create_app(test_config=None): app = Flask(__name__) if test_config is None: app.config.from_pyfile("config.py") else: app.config.update(test_config) # DB 연결 database = create_engine( app.config["DB_URL"], encoding="utf-8", pool_size=1000, max_overflow=100, poolclass=QueuePool, ) # database와 연동된 session maker 생성, connection 필요시마다 session instace 생성 Session = sessionmaker(bind=database) # CORS 설정 CORS(app, resources={r"*": {"origins": "*"}}) # Persistance layer user_dao = UserDao() product_dao = ProductDao() qna_dao = QnaDao() order_dao = OrderDao() review_dao = ReviewDao() event_dao = EventDao() # Business layer user_service = UserService(user_dao) product_service = ProductService(product_dao) qna_service = QnaService(qna_dao) order_service = OrderService(order_dao) review_service = ReviewService(review_dao) event_service = EventService(event_dao) # Presentation layer app.register_blueprint(create_user_endpoints(user_service, Session)) app.register_blueprint(create_product_endpoints(product_service, Session)) app.register_blueprint(create_qna_endpoints(qna_service, Session)) app.register_blueprint(create_order_endpoints(order_service, Session)) app.register_blueprint(create_review_endpoints(review_service, Session)) app.register_blueprint(create_event_endpoints(event_service, Session)) return app
def create_app(): """ Returns : 생성된 플라스크 앱 객체 Authors : [email protected] (손수정) [email protected] (이곤호) History : 2020-08-19 ([email protected]) : 초기 생성 2020-08-25 ([email protected]) : AdminProduct 관련 추가 """ app = Flask(__name__) app.json_encoder = CustomJSONEncoder #CORS 설정 CORS(app) #config 설정 app.config.from_pyfile("config.py") # DAO 생성 user_dao = UserDao() order_dao = OrderDao() product_dao = ProductDao() # Service 생성 user_service = UserService(user_dao) order_service = OrderService(order_dao) product_service = ProductService(product_dao) # view blueprint 등록 app.register_blueprint(create_user_endpoints(user_service)) app.register_blueprint(create_admin_user_endpoints(user_service)) app.register_blueprint(create_admin_order_endpoints(order_service)) app.register_blueprint(service_product_endpoint(product_service)) app.register_blueprint(create_admin_product_endpoints(product_service)) app.register_blueprint(create_service_order_endpoints(order_service)) return app
def index(): productService = ProductService() currentIndex = request.args.get("page") if currentIndex is None: return ("forbidden", 403) lastIndex = math.ceil(productService.count() / float(pageSize)) products = productService.list(int(currentIndex) - 1, pageSize) result = [] for product in products: result.append(product.dicted()) result = json.dumps({ "currentIndex": currentIndex, "lastIndex": lastIndex, "products": result }) productService.dispose() return (result, 200)
def show_product(id): service = ProductService() product = service.find_one(id) print(product) return render_template("view.html", product=product)
def list_products(): service = ProductService() products = service.find_all() return render_template("catalog.html", prodocts=products)