def delete(self, request, order_id): # Request data parsing try: open_id = request.META['HTTP_OPEN_ID'] access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1] logger_info.info(open_id + ':' + access_token + ':' + order_id) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) # Get purchase order instance try: order = Order.objects.get(open_id=open_id, order_id=order_id) purchase_order = PurchaseOrder.objects.get(open_id=open_id, order_id=order.order_id) except Exception as e: logger_error.error(str(e)) error_code = code.ERROR_3002_PURCHASE_ORDER_NOT_FOUND result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code)) result.set_error(error_code) return Response(result.get_response(), result.get_code()) # Check order status to edit if order.order_status != 0: error_code = code.ERROR_3009_ORDER_EDIT_NOT_AVAILABLE logger_error.error(error_code) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code)) result.set_error(error_code) return Response(result.get_response(), result.get_code()) # Refund payment header = {'open-id': open_id} url = urlmapper.get_url('PAYMENT') + '/' + order_id + '/detail' response = requests.delete(url, headers=header) order.order_status = 11 order_history = json.loads(order.order_status_history) order_history.append(dateformatter.get_order_status_history(11)) order.order_status_history = json.dumps(order_history) order.operation_status = 10 order_operation_history = json.loads(order.operation_status_history) order_operation_history.append(dateformatter.get_order_status_history(10)) order.operation_status_history = json.dumps(order_operation_history) # Add order cancel date order.order_cancel_date = datetime.today() order.save() if response.status_code != code.ARIES_200_SUCCESS: purchase_order.status = 6 purchase_order.save() result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_4003_PAYMENT_REFUND_FAIL)) result.set_error(code.ERROR_4003_PAYMENT_REFUND_FAIL) return Response(result.get_response(), result.get_code()) else: # Refund success purchase_order.status = 5 purchase_order.save() # Coupon restore coupon_list = json.loads(purchase_order.coupon_list) for coupon in coupon_list: coupon_id = coupon['coupon_id'] coupon = CustomerCoupon.objects.get(id=coupon_id) current_date = date.today() if current_date <= coupon.end_date: coupon.status = 0 coupon.used_date = current_date coupon.save() url = urlmapper.get_url('USER_NOTIFICATION') + '/coupon/0/1' headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token} requests.get(url, headers=headers) else: coupon.status = 2 coupon.used_date = current_date coupon.save() # Product stock update product_list = json.loads(purchase_order.product_list) payload = {'trade_type': 1, 'product_list': product_list, 'validate_str': 'GoDbAcKeNdS'} url = urlmapper.get_url('PRODUCT_STOCK') response = requests.post(url, json=payload) logger_info.info(response.text) # Order canceled headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token} payload = {'order_id': order_id} url = urlmapper.get_url('OPERATION_ORDER_CANCELED') response = requests.post(url, headers=headers, json=payload) logger_info.info(response.text) # First purchase canceled first_purchase_count = EventOrderHistory.objects.filter(open_id=open_id).count() if first_purchase_count == 1: first_purchase = EventOrderHistory.objects.get(open_id=open_id) first_purchase.event_target = False first_purchase.save() result = ResultResponse(code.ARIES_200_SUCCESS, 'success') return Response(result.get_response(), result.get_code())
def get(self, request, hub_id, date, table_id, shipping_type): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') target_db = 'default' if request.META.get('HTTP_ACCEPT_LANGUAGE'): accept_lang = request.META['HTTP_ACCEPT_LANGUAGE'] if 'zh' in accept_lang: target_db = 'aries_cn' try: shipping_methods = ShippingMethod.objects.using(target_db).filter(hub_id=hub_id) shipping_method_list = ShippingMethodListSerializer(shipping_methods, many=True).data result.set('shipping_detail', shipping_method_list) except ShippingMethod.DoesNotExist: print("ShippingMethod is not defined for hub id: {0}".format(hub_id)) error_code = code.ERROR_3012_NOT_SUPPORT_DELIVERY_METHOD result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code)) result.set_error(code.ERROR_3012_NOT_SUPPORT_DELIVERY_METHOD) return Response(result.get_response(), result.get_code()) except Exception as e: print(e) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED) return Response(result.get_response(), result.get_code()) # Default value dlv_schedules = '' try: # print(str(date)) today = datetime.datetime.strptime(date, '%Y-%m-%d').date() next_working_day = today + datetime.timedelta(days=30) dlv_schedules = DeliverySchedule.objects.filter(working_day__range=[today, next_working_day]) shipping_avail = ShippingAvailability.objects.get(ds_id=dlv_schedules[0], hub_id=hub_id) time_slots_avail = json.loads(shipping_avail.shipping_availability_table) for target_slot in time_slots_avail: if str(target_slot['index']) == table_id: for target_slot_avail in target_slot['shipping']: if str(target_slot_avail['shipping_type']) == shipping_type: result.set('availability', target_slot_avail['available']) result.set('delivery_start_time', target_slot['starttime']) result.set('delivery_end_time', target_slot['endtime']) return Response(result.get_response(), result.get_code()) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Invalid timetable index or shipping type') result.set_error(code.ERROR_3007_DELIVERY_SCHEDULE_INVALID) except DeliverySchedule.DoesNotExist: print("No delivery schedule is found for date at {0},hub {1}".format(str(date), str(hub_id))) error_code = code.ERROR_3011_NO_AVAILABLE_DELIVERY_SCHEDULE result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code)) result.set_error(error_code) return Response(result.get_response(), result.get_code()) except ShippingAvailability.DoesNotExist: print("No shipping schedule is found for ds_id-{0},hub {1}".format(str(dlv_schedules.id), str(hub_id))) error_code = code.ERROR_3011_NO_AVAILABLE_DELIVERY_SCHEDULE result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code)) result.set_error(error_code) return Response(result.get_response(), result.get_code()) except Exception as e: print(e) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED) return Response(result.get_response(), result.get_code())
def post(self, request, hub_id, time): result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS) logger_info.info(str(time)) lang_info = header_parser.parse_language_v2(request.META) cn_header = lang_info.cn_header target_db = lang_info.target_db os_type = lang_info.os_type try: product_list = request.data['product_list'] except Exception as e: print(e) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) product_manager = ProductManagerV3(logger_info, logger_error) menu_manager = MenuManager(logger_info, logger_error) restaurant_manager = RestaurantManager(logger_info, logger_error) hub_manager = HubManagerV2(logger_info, logger_error) product_list = hub_manager.get_product_list(product_list, hub_id) stock_list = hub_manager.get_stock_list(hub_id, product_list, target_db, os_type) if len(stock_list) >= 1: for product in stock_list: # Get product data product_data = product_manager.get_product_for_valid( product['product_id'], cn_header) # Set time bomb information if 'time_bomb_info' in product: product['time_bomb_info']['stock'] = product['stock'] product['time_bomb_info']['has_stock'] = True product_data['price_discount'] = product['price_discount'] product_data['event_product'] = product['event_product'] product_data['price_discount_event'] = True product['product'] = product_data # Get menu data menu_id = product_data['menu'] menu_data = menu_manager.get_menu_data( target_db, menu_id, product_data['sales_time'], cn_header) menu_data['review_statics'] = menu_manager.get_menu_statics( menu_id) menu_data[ 'restaurant'] = restaurant_manager.get_restaurant_data( menu_data['restaurant'], target_db) product['product']['menu'] = menu_data # Delete unusable field del product['product_id'] del product['menu_id'] del product['prev_product_id'] result.set('product_list', stock_list) else: result.set('product_list', []) return Response(result.get_response(), result.get_code())
def get(self, request, time_bomb_id): lang_info = parse_language_v2(request.META) lang_type = 1 if lang_info.cn_header else 0 cn_header = lang_info.cn_header target_db = lang_info.target_db os_type = lang_info.os_type self.logger_info.info('os_type : ' + self.OS_TYPE[os_type]) try: # Get time bomb data time_bomb_manager = TimeBombManager(self.logger_info, self.logger_error) time_bomb = time_bomb_manager.get_time_bomb( time_bomb_id, lang_type, os_type) hub_id = time_bomb['hub'] # Default product list setting product_list = [] # Get product data and check sold out if time_bomb['status'] == self.STATUS_AVAILABLE: product_manager = ProductManagerV3(self.logger_info, self.logger_error) product_id_list = time_bomb['products'] product_list = product_manager.get_product_list_from_ids( product_id_list) # Get menu id and check stock stock_manager = StockManager(self.logger_info, self.logger_error) menu_id_list = [product['menu'] for product in product_list] # Check if status is sold out or available if stock_manager.check_sold_out(hub_id, menu_id_list): time_bomb['status'] = self.STATUS_SOLD_OUT # For menu data parsing menu_manager = MenuManagerV2(self.logger_info, self.logger_error) # Discount information discount_map = product_manager.get_time_bomb_discount_info( time_bomb_id, product_id_list, cn_header) # Stock information stock_map = stock_manager.get_stock_map(hub_id, menu_id_list) for product in product_list: menu_manager.get_menu_data(product, target_db, cn_header) if product['id'] in discount_map: discount_info = discount_map[product['id']] # Stock check if product['menu']['id'] in stock_map: discount_info['has_stock'] = True discount_info['stock'] = stock_map[product['menu'] ['id']] add_discount_information(product, discount_info) except DataValidationError as instance: message, err_code = instance.args result = ResultResponse(code.ARIES_400_BAD_REQUEST, message, err_code) except Exception as e: self.logger_info.info(str(e)) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) else: result = ResultResponse(code.ARIES_200_SUCCESS, 'success') result.set('status', time_bomb['status']) result.set('products', product_list) return Response(result.get_response(), result.get_code())
def post(self, request): request_data = request.data if request_data.get('notification_order'): notification_order = request_data.get('notification_order') else: notification_order = False logger_info.info('Payment Initation : ' + str(request_data)) try: order_id = request_data['order_id'] payment_data = request_data['payment_raw_data'] payment_type = request_data['payment_type'] except Exception as e: logger_error.error(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) if payment_type == 0: request_data['payment_raw_data'] = json.dumps(payment_data) elif payment_type == 2 or payment_type == 3: request_data['payment_raw_data'] = json.dumps(payment_data) logger_info.info('Raw_Data : ' + str(request_data['payment_raw_data'])) # Check if the payment exists payment_count = Payment.objects.filter(order_id=order_id).count() if payment_count != 0: payment = Payment.objects.get(order_id=order_id) if payment.payment_status == 0 or payment.payment_status == 1: result = ResultResponse(code.ARIES_200_SUCCESS, 'success') return Response(result.get_response(), result.get_code()) # Set payment status request_data['payment_status'] = self.PAYMENT_CREATED payment_serializer = PaymentSerializer(data=request_data) if payment_serializer.is_valid(): payment_serializer.save() payment = Payment.objects.get(order_id=order_id) else: print(payment_serializer.errors) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) # Set alipay client alipay_client = AliPay( debug=settings.DEBUG, appid=resources.get_alipay_app_id(), app_notify_url=urlmapper.get_url('ALIPAY_CALLBACK_URL'), app_private_key_path=resources.get_viastelle_pri_key(), alipay_public_key_path=resources.get_viastelle_pub_key(), sign_type='RSA2' ) if payment_type == self.ALIPAY_APP_PAYMENT and not notification_order: # RSA signing check for sync alipay_app_result = payment_data['alipay_trade_app_pay_response'] sign = payment_data['sign'] content = json.loads(payment_data['content']) sign_result = alipay_client.verify(content, sign) response_code = int(alipay_app_result['code']) alipay_app_result['order_id'] = order_id alipay_app_result['alipay_trade_app_pay_response'] = content alipay_app_result['alipay_trade_app_pay_validation'] = sign_result serializer = AlipayPaymentSerializer(data=alipay_app_result) if serializer.is_valid(): serializer.save() else: logger_info.info(serializer.errors) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) # Check validation if response_code == 10000: payment.payment_status = 1 payment.save() else: payment.payment_status = 4 payment.save() result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_4004_PAYMENT_INTERFACE_FAILED)) result.set_error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED) return Response(result.get_response(), result.get_code()) elif payment_type == self.ALIPAY_MOBILE_PAYMENT or notification_order: # Mobile payment logger_info.info('MOBILE_PAYMENT' + str(payment_data)) # Query to alipay server query_response = alipay_client.api_alipay_trade_query( out_trade_no=order_id, ) logger_info.info('-----------------') logger_info.info(str(query_response)) payment_count = AlipayPaymentTransaction.objects.filter(out_trade_no=order_id).count() if payment_count <= 0: # Query response to AlipayPaymentSerializer logger_info.info(type(payment_data)) alipay_payment = { 'alipay_trade_validation': False, 'code': query_response['code'], 'msg': query_response['msg'], 'app_id': payment_data['app_id'], 'charset': payment_data['charset'], 'out_trade_no': payment_data['out_trade_no'], 'seller_id': payment_data['seller_id'], 'timestamp': query_response['send_pay_date'], 'total_amount': payment_data['total_amount'], 'trade_no': payment_data['trade_no'] } serializer = AlipayPaymentSerializer(data=alipay_payment) if serializer.is_valid(): serializer.save() else: logger_info.info(serializer.errors) query_count = AlipayQueryTransaction.objects.filter(order_id=order_id).count() if query_count <= 0: serializer = AlipayQuerySerializer(data=query_response) query_response['order_id'] = order_id if serializer.is_valid(): serializer.save() else: logger_info.info(serializer.errors) logger_info.info('Before code == 10000') if query_response['code'] == '10000': payment.payment_status = 1 payment.save() else: payment.payment_status = 4 payment.save() logger_error.error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_4004_PAYMENT_INTERFACE_FAILED)) result.set_error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED) return Response(result.get_response(), result.get_code()) result = ResultResponse(code.ARIES_200_SUCCESS, 'success') return Response(result.get_response(), result.get_code())
def get(self, request): # Response object result = ResultResponse(code.ARIES_200_SUCCESS, 'success') # Get access token try: access_token = str( request.META['HTTP_AUTHORIZATION']).split(' ')[1] api_request_util.get_admin_token_validate_v2(access_token) hub_id = 1 delivery_schedule = int(request.GET.get('delivery_schedule')) delivery_date = request.GET.get('delivery_date') # Date information parsing # Format : '2017-04-06' target_date = datetime.strptime(delivery_date, '%Y-%m-%d').date() except AuthInfoError: result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Token or user not found') return Response(result.get_response(), result.get_code()) except Exception as e: logger_error.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Bad request') return Response(result.get_response(), result.get_code()) # Get order list try: order_list = list() preparing_list = list() if delivery_schedule <= 0: orders = Order.objects.filter( hub_id=hub_id, delivery_date=target_date).order_by('-id') else: orders = Order.objects.filter( hub_id=hub_id, delivery_date=target_date, delivery_schedule=delivery_schedule).order_by('-id') serializer = OrderListSerializer(orders, many=True) order_data = serializer.data for order in order_data: order['order_status_history'] = json.loads( order['order_status_history']) order['operation_status_history'] = json.loads( order['operation_status_history']) order[ 'delivery_schedule_time'] = product_util.get_delivery_schedule_str( order['delivery_schedule']) order_list.append(order) if 1 <= order['operation_status'] <= 4: preparing_list.append(order) payload = { 'orders': order_list, 'preparing_orders': preparing_list } result.set('result', payload) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code())
def get(self, request): print(request) result = ResultResponse(code.ARIES_200_SUCCESS, 'success') return Response(result.get_response(), result.get_code())
def operation(self, request): path = request.path_info.split('/') print(path) for item in path: if len(item) <= 0: path.remove(item) domain = path[0] # Domain mapper if self.mapper.get(domain): domain_url = self.mapper.get(domain) if request.path_info == '/products': url = domain_url + request.path_info + '/' else: url = domain_url + request.path_info else: result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'BAD REQUEST') return Response(result.get_response(), result.get_code()) headers = { 'authorization': request.META.get('HTTP_AUTHORIZATION'), 'open-id': request.META.get('HTTP_OPEN_ID'), 'content-type': request.content_type, 'accept-language': request.META.get('HTTP_ACCEPT_LANGUAGE'), 'hub-id': request.META.get('HTTP_HUB_ID'), 'os-type': request.META.get('HTTP_OS_TYPE') } # Request section added method = request.method.lower() method_map = { 'get': requests.get, 'post': requests.post, 'put': requests.put, 'delete': requests.delete } for k, v in request.FILES.items(): request.data.pop(k) # Query string parser if method == 'get': query_str = {} for query_key in request.GET: query_str[query_key] = request.GET[query_key] if len(query_str) >= 1: index = 0 url += '?' for query_key in query_str.keys(): url = url + query_key + '=' + query_str[query_key] if index < len(query_str) - 1: url += '&' index += 1 # Content type parse if request.content_type and 'application/json' in request.content_type.lower( ): data = json.dumps(request.data) headers['content-type'] = request.content_type response = method_map[method](url, headers=headers, data=data) elif 'file' in request.FILES: file = request.FILES['file'] files = {'file': file} del headers['content-type'] response = method_map[method](url, headers=headers, files=files) else: data = request.data response = method_map[method](url, headers=headers, data=data) if response.headers.get('Content-Type', '').lower() == 'application/json': data = response.json() else: data = response.content logger.info( request.META.get('REMOTE_ADDR') + ' ' + str(response.status_code) + ' ' + request.path_info) return Response(data=data, status=response.status_code)
def post(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') request_data = request.data lang_info = parse_language_v2(request.META) logger_info.info(request_data) try: login_type = request_data['login_type'] login_key = request_data['login_key'] login_value = request_data['login_value'] login_sns_open_id = '' login_sns_access_token = '' login_sns_refresh_token = '' login_type = int(login_type) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) # Mobile app/web: 0, QQ: 1, WeChat: 2, Password registration: 3 # Check sms verification & user count if login_type == 0: user_count = User.objects.filter(mdn=login_key).count() # MDN is only one in member pool if user_count >= 1: result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_1005_USER_ALREADY_REGISTRATION)) result.set_error(code.ERROR_1005_USER_ALREADY_REGISTRATION) logger_error.error( get_msg(code.ERROR_1005_USER_ALREADY_REGISTRATION)) return Response(result.get_response(), result.get_code()) today = datetime.datetime.today() sms_auth = SmsAuthHistory.objects.filter( date=today, target_mdn=login_key).latest('id') sms_auth_count = sms_auth.verification_count if not sms_auth.has_verified or sms_auth_count > 3: result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND)) result.set_error(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND) logger_error.error( get_msg(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND)) return Response(result.get_response(), result.get_code()) response = requests.get( urlmapper.get_url('USER_SMS_VERIFICATION') + login_key) if response.status_code != code.ARIES_200_SUCCESS: result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND)) result.set_error(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND) logger_error.error( get_msg(code.ERROR_1008_SMS_VALIDATION_INFO_NOT_FOUND)) return Response(result.get_response(), result.get_code()) # create open id random_token = str(uuid.uuid4()).split('-') open_id = str(random_token[0] + random_token[2] + random_token[4]).upper() # get token from server if login_type is 0: payload = {'user_open_id': open_id, 'user_account': login_key} else: payload = { 'user_open_id': open_id, 'user_account': login_sns_open_id } response = requests.post(urlmapper.get_url('PLATFORM_SERVER'), json=payload) if response.status_code == code.ARIES_200_SUCCESS: response_json = response.json() token = response_json['token'] token = str(token).upper() else: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'API connection fail') result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED) logger_error.error(response.text) return Response(result.get_response(), result.get_code()) # Sign-up user if login_type is 0: user_instance = User.objects.create(open_id=open_id, mdn=login_key, name=login_key, mdn_verification=True, access_token=token, parent_type=0) else: user_instance = User.objects.create(open_id=open_id, mdn='', name=open_id[:6], mdn_verification=False, access_token=token) UserLoginInfo.objects.create( user=user_instance, login_type=login_type, login_key=login_key, login_value=login_value, login_sns_open_id=login_sns_open_id, login_sns_access_token=login_sns_access_token, login_sns_refresh_token=login_sns_refresh_token) UserInfo.objects.create(user=user_instance, number_of_logon=0) user_notify_info = UserNotifyInfo.objects.create( user=user_instance) UserGrade.objects.create(user=user_instance, type=0, extra_meal_point=0, upgrade_date=datetime.datetime.now()) ShoppingBag.objects.create(user=user_instance, ) user_serializer = UserAccountSerializer(user_instance) user_data = user_serializer.data # User notify data notify_info = UserNotifyInfo.objects.get(user=user_instance) notify_info_serializer = UserNotifyInfoSerializer(notify_info) notify_info_data = notify_info_serializer.data del notify_info_data['id'] del notify_info_data['user'] user_data['notification_info'] = notify_info_data # User grade data user_grade = UserGrade.objects.get(user=user_instance) grade_serializer = UserGradeSerializer(user_grade) user_data['grade'] = grade_serializer.data user_data['connection_account'] = json.loads( user_data['connection_account']) result.set('auto_registration', False) result.set('user', user_data) # If there is Member promotion, call member coupon interface member_promo_result = request_member_promotion( open_id, 0, lang_info.accept_lang) result.set_map(member_promo_result) logger_info.info('[views_sign][SignUp][post][' + str(member_promo_result) + ']') if member_promo_result['has_member_promotion']: user_notify_info.has_new_coupon = True user_notify_info.coupon_count = 1 user_notify_info.save() # If there is a registration with referrer, update referrer count if 'referrer_id' in request_data: logger_info.info('[views_sign][SignUp][post][' + 'REFERRER SIGNUP' + ']') user_mdn = user_instance.mdn user_referral_service = UserReferralService( logger_info, logger_error) # Check if its mdn was used for registration before registration_check = user_referral_service.read_user_referral_info_check( user_mdn) if registration_check: share_id = request_data['referrer_id'] referrer_open_id = request_share_id_validation(share_id) # Save User referral history logger_info.info('[views_sign][SignUp][post][' + str(open_id) + ']') logger_info.info('[views_sign][SignUp][post][' + str(user_mdn) + ']') logger_info.info('[views_sign][SignUp][post][' + str(share_id) + ']') logger_info.info('[views_sign][SignUp][post][' + str(referrer_open_id) + ']') ref = user_referral_service.create_user_referral_info( open_id, user_mdn, share_id, referrer_open_id) logger_info.info('[views_sign][SignUp][post][' + str(ref) + ']') user_service = UserService(logger_info, logger_error) referrer_user = user_service.get_user_instance( referrer_open_id) referrer_notify_info = user_service.get_user_notify_info( referrer_user) referrer_notify_info.has_referral_event = True referrer_notify_info.save() logger_info.info( '[views_sign][SignUp][post][Notification information saved]' ) # Send notification user_manager_v2 = UserManagerV2(logger_info, logger_error) user_manager_v2.send_sign_up_push(referrer_open_id, True) logger_info.info( '[views_sign][SignUp][post][Send push completed]') else: logger_info.info( '[views_sign][SignUp][post][Referral already registration.]' ) # Change user info user_info = UserInfo.objects.get(user=user_instance) user_info.number_of_logon = F('number_of_logon') + 1 user_info.date_account_last_modified = datetime.datetime.now() if 'os_type' in request_data: if request_data['os_type'] == 0 or request_data['os_type'] == 1: user_info.os_type = request_data['os_type'] user_info.save() return Response(result.get_response(), status=result.get_code()) else: result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Sign up method not supported') logger_info.info('Sign up method not supported') return Response(result.get_response(), result.get_code())
def post(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') logger_info.info(request.data) serializer = UserLoginInfoSerializer(data=request.data) if serializer.is_valid(): request_data = serializer.data else: logger_info.info(serializer.errors) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'request data invalid') return Response(result.get_response(), result.get_code()) try: login_type = request_data['login_type'] if login_type == 0: login_key = request_data['login_key'] login_info = UserLoginInfo.objects.filter(login_type=0, login_key=login_key) if login_info.count() >= 1: login_info = UserLoginInfo.objects.get(login_type=0, login_key=login_key) else: return Response(result.get_response(), result.get_code()) user = login_info.user payload = { 'user_open_id': user.open_id, 'user_account': login_key } response = requests.delete( urlmapper.get_url('PLATFORM_SERVER'), json=payload) logger_info.info(response.text) elif login_type == 1 or login_type == 4: # QQ case open_id = request_data['login_sns_open_id'] access_token = request_data['login_sns_access_token'] user = User.objects.get(open_id=open_id, access_token=access_token) login_info = UserLoginInfo.objects.filter(login_type=1, user=user) if login_info.count() >= 1: login_info = UserLoginInfo.objects.get(login_type=1, user=user) user = login_info.user payload = { 'user_open_id': user.open_id, 'user_account': login_info.login_sns_open_id } response = requests.delete( urlmapper.get_url('PLATFORM_SERVER'), json=payload) logger_info.info(response.text) else: # WeChat case open_id = request_data['login_sns_open_id'] access_token = request_data['login_sns_access_token'] user = User.objects.get(open_id=open_id, access_token=access_token) login_info = UserLoginInfo.objects.filter(login_type=2, user=user) if login_info.count() >= 1: login_info = UserLoginInfo.objects.get(login_type=2, user=user) user = login_info.user payload = { 'user_open_id': user.open_id, 'user_account': login_info.login_sns_open_id } response = requests.delete( urlmapper.get_url('PLATFORM_SERVER'), json=payload) logger_info.info(response.text) return Response(result.get_response(), result.get_code()) except Exception as e: logger_info.info(str(e)) return Response(result.get_response(), result.get_code())
def get(self, request, hub_id): lang_info = parse_language_v2(request.META) today = datetime.datetime.today() try: # Latest schedule target_schedule = DeliverySchedule.objects.filter( hub_id=int(hub_id)).latest('-id') delivery_day = today # After 9:00 pm, next day setting if delivery_day.time() > target_schedule.delivery_end: next_day = today + datetime.timedelta(days=1) else: next_day = today time_slots = json.loads(target_schedule.delivery_time_table) available_time = 0 matched_table = [] for target_slot in time_slots: time = datetime.datetime.strptime( next_day.strftime("%Y.%m.%d") + ' ' + target_slot["starttime"], "%Y.%m.%d %I:%M %p") if today > time: available_time += 1 else: table = { 'index': target_slot['index'], 'starttime': target_slot['starttime'], 'endtime': target_slot['endtime'], 'delivery_price': target_schedule.delivery_price } matched_table.append(table) minimum_order_price = target_schedule.minimum_order_price order_available = target_schedule.order_available if lang_info.cn_header: unavailable_msg = target_schedule.unavailable_msg_chn else: unavailable_msg = target_schedule.unavailable_msg_eng if not order_available: order_unavailable_msg = unavailable_msg else: order_unavailable_msg = '' except Exception as e: result = ResultResponse(code.ARIES_400_BAD_REQUEST, str(e)) else: result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS_MSG) result.set('working_day', next_day.strftime('%Y.%m.%d')) result.set('timetable', matched_table) result.set('order_available', order_available) result.set('minimum_order_price', minimum_order_price) result.set('order_unavailable_message', order_unavailable_msg) return Response(result.get_response(), result.get_code())
def sign_up(self, login_type, request_data): if login_type == QQ_APPLICATION: login_key = request_data['login_sns_open_id'] login_sns_open_id = request_data['login_sns_open_id'] login_sns_access_token = request_data['login_sns_access_token'] # Auto sign-up section login_value = '' login_sns_refresh_token = '' # create open id random_token = str(uuid.uuid4()).split('-') open_id = str(random_token[0] + random_token[2] + random_token[4]).upper() # get token from server payload = {'user_open_id': open_id, 'user_account': login_sns_open_id} response = requests.post(urlmapper.get_url('PLATFORM_SERVER'), json=payload) if response.status_code == code.ARIES_200_SUCCESS: response_json = response.json() token = response_json['token'] token = str(token).upper() else: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'API connection fail') result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED) logger_error.error(response.text) return Response(result.get_response(), result.get_code()) # Sign-up user user_instance = User.objects.create( open_id=open_id, mdn='', name=open_id[:6], mdn_verification=False, access_token=token, parent_type=QQ_APPLICATION ) UserLoginInfo.objects.create( user=user_instance, login_type=QQ_APPLICATION, login_key=login_key, login_value=login_value, login_sns_open_id=login_sns_open_id, login_sns_access_token=login_sns_access_token, login_sns_refresh_token=login_sns_refresh_token ) UserInfo.objects.create( user=user_instance, number_of_logon=0 ) UserNotifyInfo.objects.create( user=user_instance ) UserGrade.objects.create( user=user_instance, type=0, extra_meal_point=0, upgrade_date=datetime.datetime.now() ) ShoppingBag.objects.create( user=user_instance, ) user_notify_info = UserNotifyInfo.objects.get(user=user_instance) user_notify_info.coupon_count = 1 user_notify_info.save() # Connection information user_instance.connection_count = F('connection_count') + 1 connect_info = json.loads(user_instance.connection_account) connect_info.append({'login_type': QQ_APPLICATION, 'login_sns_open_id': login_sns_open_id}) user_instance.connection_account = json.dumps(connect_info) user_instance.save() login_info = UserLoginInfo.objects.get(login_sns_open_id=login_sns_open_id) auto_registration = True result = (login_info, login_sns_open_id, auto_registration) elif login_type == WECHAT_APPLICATION or login_type == WECHAT_PUBLIC: login_key = request_data['login_key'] login_value = request_data['login_value'] login_sns_open_id = request_data['login_sns_open_id'] login_sns_access_token = request_data['login_sns_access_token'] login_sns_refresh_token = request_data['login_sns_refresh_token'] # create open id random_token = str(uuid.uuid4()).split('-') open_id = str(random_token[0] + random_token[2] + random_token[4]).upper() # get token from server payload = {'user_open_id': open_id, 'user_account': login_sns_open_id} response = requests.post(urlmapper.get_url('PLATFORM_SERVER'), json=payload) if response.status_code == code.ARIES_200_SUCCESS: response_json = response.json() token = response_json['token'] token = str(token).upper() else: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'API connection fail') result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED) logger_error.error(response.text) return Response(result.get_response(), result.get_code()) # Sign-up user user_instance = User.objects.create( open_id=open_id, mdn='', name=open_id[:6], mdn_verification=False, access_token=token, parent_type=WECHAT_APPLICATION ) UserLoginInfo.objects.create( user=user_instance, login_type=WECHAT_APPLICATION, login_key=login_key, login_value=login_value, login_sns_open_id=login_sns_open_id, login_sns_access_token=login_sns_access_token, login_sns_refresh_token=login_sns_refresh_token ) UserInfo.objects.create( user=user_instance, number_of_logon=0 ) UserNotifyInfo.objects.create( user=user_instance ) UserGrade.objects.create( user=user_instance, type=0, extra_meal_point=0, upgrade_date=datetime.datetime.now() ) ShoppingBag.objects.create( user=user_instance, ) user_notify_info = UserNotifyInfo.objects.get(user=user_instance) user_notify_info.coupon_count = 1 user_notify_info.save() # Connection information user_instance.connection_count = F('connection_count') + 1 connect_info = json.loads(user_instance.connection_account) connect_info.append({'login_type': WECHAT_APPLICATION, 'login_sns_open_id': login_sns_open_id}) user_instance.connection_account = json.dumps(connect_info) user_instance.save() login_info = UserLoginInfo.objects.get(login_sns_open_id=login_sns_open_id) result = (login_info, login_sns_open_id, True) elif login_type == QQ_MOBILE: login_key = request_data['login_key'] login_value = request_data['login_value'] login_sns_open_id = request_data['login_sns_open_id'] login_sns_access_token = request_data['login_sns_access_token'] login_sns_refresh_token = request_data['login_sns_refresh_token'] # create open id random_token = str(uuid.uuid4()).split('-') open_id = str(random_token[0] + random_token[2] + random_token[4]).upper() # get token from server payload = {'user_open_id': open_id, 'user_account': login_sns_open_id} response = requests.post(urlmapper.get_url('PLATFORM_SERVER'), json=payload) if response.status_code == code.ARIES_200_SUCCESS: response_json = response.json() token = response_json['token'] token = str(token).upper() else: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'API connection fail') result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED) logger_error.error(response.text) return Response(result.get_response(), result.get_code()) # Sign-up user user_instance = User.objects.create( open_id=open_id, mdn='', name=open_id[:6], mdn_verification=False, access_token=token, parent_type=QQ_APPLICATION ) UserLoginInfo.objects.create( user=user_instance, login_type=QQ_APPLICATION, login_key=login_key, login_value=login_value, login_sns_open_id=login_sns_open_id, login_sns_access_token=login_sns_access_token, login_sns_refresh_token=login_sns_refresh_token ) UserInfo.objects.create( user=user_instance, number_of_logon=0 ) UserNotifyInfo.objects.create( user=user_instance ) UserGrade.objects.create( user=user_instance, type=0, extra_meal_point=0, upgrade_date=datetime.datetime.now() ) ShoppingBag.objects.create( user=user_instance, ) user_notify_info = UserNotifyInfo.objects.get(user=user_instance) user_notify_info.coupon_count = 1 user_notify_info.save() # Connection information user_instance.connection_count = F('connection_count') + 1 connect_info = json.loads(user_instance.connection_account) connect_info.append({'login_type': QQ_APPLICATION, 'login_sns_open_id': login_sns_open_id}) user_instance.connection_account = json.dumps(connect_info) user_instance.save() login_info = UserLoginInfo.objects.get(login_sns_open_id=login_sns_open_id) result = (login_info, login_sns_open_id, True) elif login_type == MDN_QUICK: login_type = request_data['login_type'] login_key = request_data['login_key'] login_value = '' login_sns_open_id = '' login_sns_access_token = '' login_sns_refresh_token = '' # create open id random_token = str(uuid.uuid4()).split('-') open_id = str(random_token[0] + random_token[2] + random_token[4]).upper() # get token from server payload = {'user_open_id': open_id, 'user_account': login_key} response = requests.post(urlmapper.get_url('PLATFORM_SERVER'), json=payload) if response.status_code == code.ARIES_200_SUCCESS: response_json = response.json() token = response_json['token'] token = str(token).upper() else: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'API connection fail') result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED) logger_error.error(response.text) return Response(result.get_response(), result.get_code()) # Sign-up user user_instance = User.objects.create( open_id=open_id, mdn=login_key, name=login_key, mdn_verification=True, access_token=token, parent_type=MDN_QUICK ) UserLoginInfo.objects.create( user=user_instance, login_type=login_type, login_key=login_key, login_value=login_value, login_sns_open_id=login_sns_open_id, login_sns_access_token=login_sns_access_token, login_sns_refresh_token=login_sns_refresh_token ) UserInfo.objects.create( user=user_instance, number_of_logon=0 ) UserNotifyInfo.objects.create( user=user_instance ) UserGrade.objects.create( user=user_instance, type=0, extra_meal_point=0, upgrade_date=datetime.datetime.now() ) ShoppingBag.objects.create( user=user_instance, ) user_notify_info = UserNotifyInfo.objects.get(user=user_instance) user_notify_info.coupon_count = 1 user_notify_info.save() # Change user info user_info = UserInfo.objects.get(user=user_instance) user_info.number_of_logon = F('number_of_logon') + 1 user_info.date_account_last_modified = datetime.datetime.now() if 'os_type' in request_data: if request_data['os_type'] == 0 or request_data['os_type'] == 1: user_info.os_type = request_data['os_type'] user_info.save() user_login_info = UserLoginInfo.objects.get(login_key=login_key) result = (user_login_info, login_key, True) else: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'NOT SUPPORT LOGIN TYPE') result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED) return Response(result.get_response(), result.get_code()) return result
def get(self, request, time_bomb_id): lang_info = parse_language_v2(request.META) lang_type = 1 if lang_info.cn_header else 0 cn_header = lang_info.cn_header target_db = lang_info.target_db os_type = lang_info.os_type self.logger_info.info('os_type : ' + self.OS_TYPE[os_type]) try: # Get time bomb data time_bomb_manager = TimeBombManager(self.logger_info, self.logger_error) time_bomb_exists = time_bomb_manager.check_time_bomb_exists( time_bomb_id) # Default product list setting product_list = [] if time_bomb_exists: time_bomb = time_bomb_manager.get_time_bomb( time_bomb_id, lang_type, os_type) hub_id = time_bomb['hub'] # Get product data and check sold out if time_bomb['status'] == self.STATUS_AVAILABLE: product_manager = ProductManagerV3(self.logger_info, self.logger_error) product_id_list = time_bomb['products'] product_list = product_manager.get_product_list_from_ids( product_id_list) # Get menu id and check stock stock_manager = StockManager(self.logger_info, self.logger_error) menu_id_list = [ product['menu'] for product in product_list ] # Check if status is sold out or available if stock_manager.check_sold_out(hub_id, menu_id_list): time_bomb['status'] = self.STATUS_SOLD_OUT # For menu data parsing menu_manager = MenuManagerV2(self.logger_info, self.logger_error) # Discount information discount_map = product_manager.get_time_bomb_discount_info( time_bomb_id, product_id_list, cn_header) # Stock information stock_map = stock_manager.get_stock_map( hub_id, menu_id_list) for product in product_list: menu_manager.get_menu_data(product, target_db, cn_header) if product['id'] in discount_map: discount_info = discount_map[product['id']] # Stock check if product['menu']['id'] in stock_map: discount_info['has_stock'] = True discount_info['stock'] = stock_map[ product['menu']['id']] add_discount_information(product, discount_info) else: # Time bomb expired template if cn_header: time_bomb = time_bomb_expired_template_cn() else: time_bomb = time_bomb_expired_template_en() # Add action template # time_bomb_url = 'https://m.viastelle.com/#/promotions/timeBombInt' extra = { 'share_image': '', 'share_title': '', 'share_description': '', 'share_enable': False, 'link': 'https://stg-cli.viastelle.com/dist/#/promotions/timeBombInt' } if cn_header: extra['title'] = '推广' else: extra['title'] = 'PROMOTION' action_object = { 'action_type': 13, 'action_target': 'https://stg-cli.viastelle.com/dist/#/promotions/timeBombInt', 'action_extra': json.dumps(extra) } # Stock api call interval api_call_interval = 60 except DataValidationError as instance: message, err_code = instance.args result = ResultResponse(code.ARIES_400_BAD_REQUEST, message, err_code) except Exception as e: self.logger_info.info(str(e)) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) else: result = ResultResponse(code.ARIES_200_SUCCESS, 'success') result.set_map(time_bomb) result.set('action', action_object) result.set('stock_api_interval', api_call_interval) result.set('products', product_list) return Response(result.get_response(), result.get_code())
def get(self, request, hub_id): # Query the DeliverySchedule DB result = ResultResponse(code.ARIES_200_SUCCESS, 'success') language_info = header_parser.parse_language(request.META) target_db = language_info[1] sales_time = 'ALL_DAY' if request.query_params.get('sales_time'): sales_time = request.query_params.get('sales_time').upper() today = datetime.datetime.today() next_working_day = today + datetime.timedelta(days=30) try: dlv_schedules = DeliverySchedule.objects.filter(working_day__range=[today, next_working_day]) if dlv_schedules.count() <= 0: result.set('timetable', json.loads('[]')) else: target_schedule = dlv_schedules[0] delivery_day = today if delivery_day.time() > dlv_schedules[0].delivery_end: if dlv_schedules.count() > 1: target_schedule = dlv_schedules[1] next_day = target_schedule.working_day else: target_schedule = dlv_schedules[0] next_day = today + datetime.timedelta(days=1) else: next_day = today if sales_time == 'LUNCH': time_table = target_schedule.delivery_time_table_lunch elif sales_time == 'DINNER': time_table = target_schedule.delivery_time_table_dinner else: time_table = target_schedule.delivery_time_table time_slots = json.loads(time_table) result.set('working_day', next_day.strftime('%Y.%m.%d')) available_time = 0 matched_index = [] for target_slot in time_slots: time = datetime.datetime.strptime( next_day.strftime("%Y.%m.%d") + ' ' + target_slot["starttime"], "%Y.%m.%d %I:%M %p" ) if today > time: available_time += 1 else: matched_index.append(target_slot['index']) try: shipping_avail = ShippingAvailability.objects.get(hub_id=hub_id, ds_id=target_schedule) except ShippingAvailability.DoesNotExist: shipping_avail = ShippingAvailability(hub_id=hub_id, ds_id=target_schedule) shipping_avail.save() time_slots_avail = json.loads(shipping_avail.shipping_availability_table) result_list = [target_time for slot in matched_index for target_time in time_slots_avail if slot == target_time['index']] if sales_time == 'LUNCH': result_table = result_list elif sales_time == 'DINNER': result_table = result_list else: result_table = time_slots_avail[available_time:] result.set('timetable', result_table) except DeliverySchedule.DoesNotExist: today = datetime.datetime.today() today = today + datetime.timedelta(1) result.set('timetable', json.loads('[]')) result.set('working_day', today.strftime("%Y.%m.%d")) result.set('shipping_detail', json.loads('[]')) return Response(result.get_response(), result.get_code()) try: shipping_methods = ShippingMethod.objects.using(target_db).filter(hub_id=hub_id) shipping_method_list = ShippingMethodListSerializer(shipping_methods, many=True).data result.set('shipping_detail', shipping_method_list) except ShippingMethod.DoesNotExist: print("ShippingMethod is not defined for hub id: {0}".format(hub_id)) result.set('shipping_detail', json.loads('[]')) except Exception as e: print(e) result.set('shipping_detail', json.loads('[]')) return Response(result.get_response(), result.get_code())
def post(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') request_data = request.data self.logger_info.info(request_data) auth_info = header_parser.parse_auth_info(request) lang_info = parse_language_v2(request.META) open_id = auth_info.open_id access_token = auth_info.access_token cn_header = lang_info.cn_header accept_lang = lang_info.accept_lang os_type = lang_info.os_type hub_id = request_data.get('hub_id', 1) try: # Order reserve manager reserve_manager = OrderReserveManager(self.logger_info, self.logger_error, request_data) # Request data validation request_validation(open_id, access_token, request_data) # Request product validation validation_result = purchase_validation(accept_lang, request_data, os_type) # Product check valid_result = reserve_manager.product_validation(validation_result, cn_header) # Sales time check delivery_time_result = reserve_manager.delivery_time_validation(valid_result, accept_lang, os_type, hub_id) # Product detail setting product_list = reserve_manager.set_product_detail(delivery_time_result) # Delivery detail check reserve_manager.set_delivery_detail(lang_info.cn_header) # Coupon business logic process, product list from sales_time_response coupon_list = request_data['coupon_list'] coupon_manager = CouponManagerV2(self.logger_info, self.logger_error) coupon_manager.coupon_validate(auth_info.open_id, product_list, coupon_list) # Calculate total price coupon_detail = coupon_manager.get_coupon_detail() discount_amount = -coupon_manager.get_discount_price() reserve_manager.set_total_price(coupon_detail, discount_amount, open_id) # Set misc parameters reserve_manager.set_misc_params() # Get payment params from payment parameter factory param_result = reserve_manager.get_payment_param(cn_header) payment_param_factory = PayParamInstance.factory(param_result[0], self.logger_info, self.logger_error) payment_params = payment_param_factory.get_payment_params(param_result[1]) for key in payment_params.keys(): result.set(key, payment_params[key]) # Save purchase order object to database order_id = reserve_manager.save_purchase_order() except DataValidationError as instance: message, err_code = instance.args result = ResultResponse(code.ARIES_400_BAD_REQUEST, message, err_code) except AuthInfoError: result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authentication error') except BusinessLogicError as instance: message, err_code, data_set = instance.args result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, message, err_code) result.set_map(data_set) except Exception as e: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) else: result.set('order_id', order_id) return Response(result.get_response(), result.get_code())
def post(self, request, hub_id=1): try: request_data = request.data request_validation(request_data) menu_id_list = request_data['menu_id_list'] target_db = request_data['target_db'] cn_header = False if target_db == 'default' else True sales_time_str = get_sales_time_str() date_info = get_date_information_v2(hub_id, sales_time_str) lang_info = parse_language_v2(request.META) os_type = lang_info.os_type product_manager = ProductManagerV3(self.logger_info, self.logger_error) product_data = product_manager.get_product_info( hub_id, menu_id_list) menu_manager = MenuManagerV2(self.logger_info, self.logger_error) product_list = [] for product in product_data: product_list.append( menu_manager.get_menu_data(product, target_db, cn_header)) # Check the current available time bomb time_bomb_manager = TimeBombManager(self.logger_info, self.logger_error) time_bomb_id = time_bomb_manager.get_time_bomb_now(hub_id, os_type) # Get time bomb information if time_bomb_id is not None: discount_map = product_manager.get_all_discount_info( time_bomb_id, cn_header) for product in product_list: if product['id'] in discount_map: discount_info = discount_map[product['id']] add_discount_information(product, discount_info) except DataValidationError as instance: message, err_code = instance.args result = ResultResponse(code.ARIES_400_BAD_REQUEST, message, err_code) except Exception as e: self.logger_info.info(str(e)) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, str(e)) else: result = ResultResponse(code.ARIES_200_SUCCESS, self.SUCCESS_MSG) result.set('products', product_list) result.set('hub_id', int(hub_id)) result.set('time_type', date_info.time_type) result.set('phase_next_day', date_info.phase_next_day) result.set('phase_date', date_info.current_date.isoformat()) result.set('order_available', product_util.get_available_time(date_info.time_type)) return Response(result.get_response(), result.get_code())
def post(self, request, folder_name): print(request.META) print(request.FILES) result = ResultResponse(code.ARIES_200_SUCCESS, 'Upload success') try: open_id = request.META['HTTP_OPEN_ID'] access_token = str( request.META['HTTP_AUTHORIZATION']).split(' ')[1] except Exception as e: print(e) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Token or open id invalid') return Response(result.get_response(), result.get_code()) if 'file' in request.FILES: # File object create file = request.FILES['file'] fs = FileSystemStorage() filename = fs.save(file.name, file) # File size check file_size = file.size if file_size >= self.MEGA * 5: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_1102_FILE_OVERSIZE)) result.set_error(code.ERROR_1102_FILE_OVERSIZE) return Response(result.get_response(), result.get_code()) # File name information processing uploaded_file_url = fs.path(filename) upload_filename = self.make_file_name(filename) upload_file_ext = filename.split('.')[-1] upload_name = folder_name + '/' + upload_filename print(upload_name) # Check file format to png or jpg if upload_file_ext.lower() != 'png' and upload_file_ext.lower() != 'jpg'\ and upload_file_ext.lower() != 'jpeg': result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, code_msg.get_msg(code.ERROR_1011_ACCESS_TOKEN_GET_FAIL)) result.set_error(code.ERROR_1101_NOT_SUPPORTED_FILE_FORMAT) print('Error') fs.delete(filename) return Response(result.get_response(), result.get_code()) url = 'http://viastelle-user-storage.oss-cn-shanghai.aliyuncs.com/' + upload_name host = 'viastelle-user-storage.oss-cn-shanghai.aliyuncs.com' hash_value = hashlib.md5() with open(uploaded_file_url, 'rb') as mdfile: for buf in iter(partial(mdfile.read, 128), b''): hash_value.update(buf) content_md5 = base64.b64encode(hash_value.digest()).decode('utf-8') headers = { 'Content-MD5': content_md5, 'Content-Length': str(file_size), 'Content-Type': 'image/' + upload_file_ext, 'Host': host, 'Date': oss.get_gmt_date(), 'Authorization': oss.get_oss_header( upload_filename, 'PUT', content_md5, upload_file_ext, '/viastelle-user-storage/' + folder_name + '/') } with open(uploaded_file_url, 'rb') as upload_file: data = upload_file.read() response = requests.put(url, headers=headers, data=data) if response.status_code is 200: result.set('file_name', upload_name) # Check profile image if folder_name.lower() == 'profile': url = urlmapper.get_url( 'USER_INFO') + '/' + open_id + '/detail' headers = { 'AUTHORIZATION': 'bearer ' + access_token, 'OPEN-ID': open_id } payload = {'profile_image': upload_name} user_response = requests.put(url, headers=headers, json=payload) print(user_response.text) else: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, "File upload fail") fs.delete(filename) else: print('no file!!') result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, "File upload fail") return Response(result.get_response(), result.get_code())
def post(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') # Request data parsing try: request_data = request.data except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) # Set alipay client alipay_client = AliPay( debug=settings.DEBUG, appid=resources.get_alipay_app_id(), app_notify_url=urlmapper.get_url('ALIPAY_CALLBACK_URL'), app_private_key_path=resources.get_viastelle_pri_key(), alipay_public_key_path=resources.get_viastelle_pub_key(), sign_type='RSA2' ) # Notification verification from ALIPAY noti_origin_data = json.dumps(request_data) noti_data = json.loads(noti_origin_data) sign = noti_data.pop('sign') sign_type = noti_data['sign_type'] trade_status = noti_data['trade_status'] verify_result = alipay_client.verify(noti_data, sign) logger_info.info('[notification_data]:' + noti_origin_data) logger_info.info(verify_result) if not verify_result: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_4004_PAYMENT_INTERFACE_FAILED)) result.set_error(code.ERROR_4004_PAYMENT_INTERFACE_FAILED) return Response(result.get_response(), result.get_code()) # Check the order exists try: order_id = noti_data['out_trade_no'] noti_data['order_id'] = order_id noti_data['sign'] = sign noti_data['sign_type'] = sign_type noti_data['alipay_notification_validation'] = verify_result order_count = Order.objects.filter(order_id=order_id).count() purchase_order_count = PurchaseOrder.objects.filter(order_id=order_id).count() if order_count == 0 and purchase_order_count == 1 and trade_status == 'TRADE_SUCCESS': # Order has not created purchase_order = PurchaseOrder.objects.get(order_id=order_id) open_id = purchase_order.open_id url = urlmapper.get_url('USER_PAYMENT_TOKEN') payload = { 'open_id': purchase_order.open_id } response = requests.post(url, json=payload) if response.status_code == 200: response_json = response.json() access_token = response_json['access_token'] else: return Response(result.get_response, result.get_code()) url = urlmapper.get_url('ORDER') headers = { 'open-id': open_id, 'authorization': 'bearer ' + access_token } payload = { 'order_id': order_id, 'payment_type': self.ALIPAY_MOBILE_PAYMENT, 'payment_data': noti_data, 'alipay_notification_order': True } response = requests.post(url, headers=headers, json=payload) logger_info.info(response.text) notification_count = AlipayNotification.objects.filter( order_id=order_id ).count() if notification_count == 0: serializer = AlipayNotificationSerializer(data=noti_data) else: notification_instance = AlipayNotification.objects.get(order_id=order_id) serializer = AlipayNotificationSerializer(notification_instance, data=noti_data, partial=True) if serializer.is_valid(): serializer.save() else: logger_info.info(serializer.errors) except Exception as e: logger_info.info(str(e)) return Response(result.get_response(), result.get_code())
def post(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') request_data = request.data logger_info.info(request_data) language_info = header_parser.parse_language(request.META) cn_header = language_info[0] order_data = dict() coupon_instance_list = list() # for getting daily order index order_manager_v2 = OrderManagerV2(logger_info, logger_error) # Step 1. Request data parsing try: open_id = request.META['HTTP_OPEN_ID'] access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1] order_id = request_data['order_id'] payment_data = request_data['payment_data'] notification_order = request_data.get('alipay_notification_order', False) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid(Token or Open id)') return Response(result.get_response(), result.get_code()) # Step 1.5 order_count = Order.objects.filter(order_id=order_id, open_id=open_id).count() if order_count == 1: order = Order.objects.get(order_id=order_id, open_id=open_id) purchase_order = PurchaseOrder.objects.get(order_id=order_id, open_id=open_id) purchase_order_serializer = UpcomingPurchaseOrderSerializer(purchase_order) purchase_order_data = purchase_order_serializer.data purchase_order_data['order_details'] = json.loads(purchase_order_data['order_details']) purchase_order_data['shipping_detail'] = json.loads(purchase_order_data['shipping_detail']) del purchase_order_data['product_list'] del purchase_order_data['coupon_list'] del purchase_order_data['order_hash'] order_data = UpcomingOrderSerializer(order).data order_data['order_start_date'] = dateformatter.get_ordering_complete_date_fmt(order.order_start_date) order_data['order_status_history'] = json.loads(order_data['order_status_history']) order_data['purchase_order'] = purchase_order_data order_data['order_cancel_date'] = '' # Get Timetable order_data['timetable'] = json.loads('[]') result.set('upcoming_order', order_data) return Response(result.get_response(), result.get_code()) # Step 2. Check payment data validation and coupon check try: purchase_order = PurchaseOrder.objects.get(order_id=order_id, open_id=open_id, status=self.PURCHASE_ORDER_STATUS_CREATED) order_data['purchase_order'] = purchase_order.id payment_type = purchase_order.payment_type # Check payment data validation payload = {'open_id': open_id, 'order_id': order_id, 'payment_type': payment_type, 'payment_raw_data': payment_data, 'price_unit': purchase_order.price_unit, 'price_total': purchase_order.price_total} if notification_order: payload['notification_order'] = True else: payload['notification_order'] = False payment_url = payment_util.get_payment_app_url(purchase_order.payment_type) response = requests.post(payment_url, json=payload) logger_info.info(response.text) payment_result = response.json() if response.status_code != code.ARIES_200_SUCCESS: if response.status_code == code.ARIES_400_BAD_REQUEST: result = ResultResponse(code.ARIES_400_BAD_REQUEST, get_msg(code.ERROR_9000_INTERNAL_API_CALL_FAILED, cn_header)) elif payment_result['error_code'] == code.ERROR_4001_PAYMENT_VALIDATION_FAILED: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_4001_PAYMENT_VALIDATION_FAILED, cn_header)) result.set_error(code.ERROR_4001_PAYMENT_VALIDATION_FAILED) elif payment_result['error_code'] == code.ERROR_4005_PAYMENT_SYNC_ERROR: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_4005_PAYMENT_SYNC_ERROR, cn_header)) purchase_order.status = 3 purchase_order.save() return Response(result.get_response(), result.get_code()) logger_info.info('Payment finished') # Order saved and coupon using section coupon_list = json.loads(purchase_order.coupon_list) logger_info.info(coupon_list) for coupon in coupon_list: coupon_id = coupon['coupon_id'] coupon_count = CustomerCoupon.objects.filter(id=coupon_id).count() if coupon_count == 1: coupon_instance = CustomerCoupon.objects.get(id=coupon_id) coupon_instance.status = 1 coupon_instance.used_date = datetime.now() coupon_instance_list.append(coupon_instance) else: logger_error.error(get_msg(code.ERROR_4001_PAYMENT_VALIDATION_FAILED)) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_4001_PAYMENT_VALIDATION_FAILED)) result.set_error(code.ERROR_4001_PAYMENT_VALIDATION_FAILED) purchase_order.status = 3 purchase_order.save() return Response(result.get_response(), result.get_code()) except Exception as e: logger_error.error(str(e)) error_code = code.ERROR_3002_PURCHASE_ORDER_NOT_FOUND result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code), cn_header) result.set_error(error_code) return Response(result.get_response(), result.get_code()) # Step 3 Order data section logger_info.info('Order data section') # Order data order_data['open_id'] = open_id order_data['hub_id'] = purchase_order.hub_id order_data['order_id'] = order_id order_data['order_status'] = self.ORDER_STATUS_CREATED history_date = dateformatter.get_yyyymmdd_now() history_payload = [{'status': 0, 'datetime': history_date}] order_data['order_status_history'] = json.dumps(history_payload) order_data['order_daily_index'] = order_manager_v2.get_daily_order_index() # Delivery data is_on_site_pickup = purchase_order.delivery_on_site address_id = purchase_order.delivery_address_id # Check if it was on-site pickup or not if is_on_site_pickup: logger_info.info('On site pickup') hub_name = hub_data.get_hub_name(cn_header, purchase_order.hub_id) complete_address = hub_name + '\n - ' + hub_data.get_hub_address(cn_header, purchase_order.hub_id) order_data['delivery_on_site'] = purchase_order.delivery_on_site order_data['delivery_address'] = complete_address else: logger_info.info('NOT on site pickup') try: headers = {'open-id': str(open_id), 'authorization': 'bearer ' + access_token, 'Content-Type': 'application/json'} response = requests.get(urlmapper.get_url('PRODUCT_ADDRESS_DETAIL') + '/' + str(address_id), headers=headers) except Exception as e: logger_info.info(str(e)) if response.status_code == code.ARIES_200_SUCCESS: response_json = response.json()['user_address'] logger_info.info(response_json) # Set delivery address recipient_name = response_json['recipient_name'] recipient_mdn = response_json['recipient_mdn'] if len(recipient_mdn) <= 0 and len(recipient_name) <= 0: delivery_address = response_json['name'] else: delivery_address = response_json['name'] + ' - ' + response_json['detail'] if len(delivery_address) > 300: delivery_address = delivery_address[:300] order_data['delivery_address'] = delivery_address order_data['delivery_address_lat'] = response_json['latitude'] order_data['delivery_address_lng'] = response_json['longitude'] order_data['delivery_recipient_name'] = recipient_name order_data['delivery_recipient_mdn'] = recipient_mdn else: # New address check logger_info.info('Address not found error') result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Address not found') result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED) return Response(result.get_response(), result.get_code()) logger_info.info('After on site pickup') order_data['user_name'] = purchase_order.user_name order_data['user_telephone'] = purchase_order.user_telephone order_data['user_receipt'] = purchase_order.user_receipt order_data['delivery_date'] = purchase_order.delivery_date order_data['delivery_schedule'] = purchase_order.delivery_schedule order_data['delivery_as_fast'] = purchase_order.delivery_as_fast order_data['delivery_customer_name'] = purchase_order.user_name order_data['delivery_telephone_state'] = 0 order_data['delivery_telephone'] = 'Delivery telephone' pre_time = purchase_order.delivery_start_time post_time = purchase_order.delivery_end_time delivery_date = str(purchase_order.delivery_date).replace('-', '.') order_data['delivery_time'] = delivery_date + ', ' + pre_time + '~' + post_time # Shipping data order_data['shipping_method'] = purchase_order.shipping_method order_data['shipping_status'] = 0 # Step 4 logger_info.info('STEP 4') order_count = Order.objects.filter(order_id=order_id, open_id=open_id).count() if order_count == 1: logger_info.info('Order exists') order = Order.objects.get(order_id=order_id, open_id=open_id) purchase_order = PurchaseOrder.objects.get(order_id=order_id, open_id=open_id) purchase_order_serializer = UpcomingPurchaseOrderSerializer(purchase_order) purchase_order_data = purchase_order_serializer.data purchase_order_data['order_details'] = json.loads(purchase_order_data['order_details']) purchase_order_data['shipping_detail'] = json.loads(purchase_order_data['shipping_detail']) del purchase_order_data['product_list'] del purchase_order_data['coupon_list'] del purchase_order_data['order_hash'] order_data = UpcomingOrderSerializer(order).data order_data['order_start_date'] = dateformatter.get_ordering_complete_date_fmt(order.order_start_date) order_data['order_status_history'] = json.loads(order_data['order_status_history']) order_data['purchase_order'] = purchase_order_data order_data['order_cancel_date'] = '' # Get Timetable order_data['timetable'] = json.loads('[]') result.set('upcoming_order', order_data) return Response(result.get_response(), result.get_code()) # Step 5 # Create order object and send order data to client logger_info.info('Step 5') try: order_serializer = OrderSerializer(data=order_data) if order_serializer.is_valid(): order_serializer.save() logger_info.info('Order valid and save success') # Order save success and coupon save for coupon_ins in coupon_instance_list: coupon_ins.save() # User notification url call url = urlmapper.get_url('USER_NOTIFICATION') + '/coupon/1/' + str(len(coupon_instance_list)) headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token} requests.get(url, headers=headers) # Get special instruction and include cutlery information include_cutlery = purchase_order.include_cutlery special_inst = purchase_order.special_instruction # Special instruction and include cutlery save call url = urlmapper.get_url('USER_CART_INFO_SAVE') headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token} json_data = {'include_cutlery': include_cutlery, 'special_instruction': special_inst} requests.put(url, headers=headers, json=json_data) # After user notification logger_info.info('After user notification request') purchase_order_serializer = UpcomingPurchaseOrderSerializer(purchase_order) purchase_order_data = purchase_order_serializer.data purchase_order_data['order_details'] = json.loads(purchase_order_data['order_details']) purchase_order_data['shipping_detail'] = json.loads(purchase_order_data['shipping_detail']) del purchase_order_data['product_list'] del purchase_order_data['coupon_list'] del purchase_order_data['order_hash'] order_data = order_serializer.data order = Order.objects.get(id=order_data['id']) order_data = UpcomingOrderSerializer(order).data order_data['order_start_date'] = dateformatter.get_ordering_complete_date_fmt(order.order_start_date) order_data['order_status_history'] = json.loads(order_data['order_status_history']) order_data['purchase_order'] = purchase_order_data order_data['order_cancel_date'] = '' # Get Timetable logger_info.info('Get time table') order_data['timetable'] = json.loads('[]') result.set('upcoming_order', order_data) # Check on first purchase logger_info.info('Check first purchase') first_order_count = Order.objects.filter(open_id=open_id, order_status__lte=10).count() if first_order_count == 1: hub_id = purchase_order.hub_id event_order_service = EventOrderService(logger_info, logger_error) event_order_service.create_event_order(0, hub_id, open_id, order_id) else: logger_error.error(order_serializer.errors) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Internal server error') return Response(result.get_response(), result.get_code()) purchase_order.status = 1 purchase_order.save() logger_info.info('Purchase order save') # Product stock update product_list = json.loads(purchase_order.product_list) payload = {'trade_type': 0, 'product_list': product_list, 'validate_str': 'GoDbAcKeNdS'} url = urlmapper.get_url('PRODUCT_STOCK') response = requests.post(url, json=payload) logger_info.info(response.text) # Order complete headers = {'open-id': open_id, 'authorization': 'bearer ' + access_token} payload = {'order_id': order_id} url = urlmapper.get_url('OPERATION_ORDER_COMPLETE') response = requests.post(url, headers=headers, json=payload) logger_info.info(response.text) except Exception as e: logger_error.error(str(e)) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Internal server error') return Response(result.get_response(), result.get_code()) # Step 6 # Save payment method and notify to admin server # Upcoming order notification added logger_info.info('Step 6') headers = {'AUTHORIZATION': request.META['HTTP_AUTHORIZATION']} payload = {'latest_payment_method': purchase_order.payment_type} url = urlmapper.get_url('USER_INFO') + '/' + open_id + '/info' response = requests.put(url, headers=headers, json=payload) logger_info.info(response.json()) try: # Hub message logger_info.info('Hub message') order_manager = OrderManager(logger_info, logger_error) order_list_detail = order_manager.get_order_list(order_id) payload = { 'code': 200, 'message': 'success', 'order': order_list_detail, 'type': 1, 'order_id': order_id, 'title': 'Here comes a new order' } url = urlmapper.get_url('HUB_MESSAGE_ANDROID') response = requests.post(url, json=payload) logger_info.info(response.text) except Exception as e: logger_info.info(str(e)) return Response(result.get_response(), result.get_code())
def put(self, request, order_id): request_data = request.data logger_info.info(request_data) result = ResultResponse(code.ARIES_200_SUCCESS, 'success') try: access_token = str( request.META['HTTP_AUTHORIZATION']).split(' ')[1] api_request_util.get_admin_token_validate_v2(access_token) except Exception as e: logger_error.error(str(e)) result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authentication error') return Response(result.get_response(), result.get_code()) # Change order data try: order = Order.objects.get(order_id=order_id) """ order.order_status = 11 order_history = json.loads(order.order_status_history) order_history.append(self.get_order_status_history(11)) order.order_status_history = json.dumps(order_history) order.operation_status = 10 order_operation_history = json.loads(order.operation_status_history) order_operation_history.append(self.get_order_status_history(10)) order.operation_status_history = json.dumps(order_operation_history) """ # Do business logic to each status change_status = request_data['operation_status'] if change_status == 1: logger_info.info('start packaging') if order.order_status == 0: order_history = json.loads(order.order_status_history) order_history.append( dateformatter.get_order_status_history(1)) request_data['order_status'] = 1 request_data['order_status_history'] = json.dumps( order_history) if order.operation_status == 0: order_operation_history = json.loads( order.operation_status_history) order_operation_history.append( dateformatter.get_order_status_history(1)) request_data['operation_status'] = 1 request_data['order_operation_history'] = json.dumps( order_operation_history) elif change_status == 2: logger_info.info('Packaging done') if order.operation_status == 1: order_operation_history = json.loads( order.operation_status_history) order_operation_history.append( dateformatter.get_order_status_history(2)) request_data['operation_status'] = 2 request_data['order_operation_history'] = json.dumps( order_operation_history) elif change_status == 5: logger_info.info('Delivery started') if order.order_status == 1: order_history = json.loads(order.order_status_history) order_history.append( dateformatter.get_order_status_history(2)) request_data['order_status'] = 2 request_data['order_status_history'] = json.dumps( order_history) if order.operation_status == 2: order_operation_history = json.loads( order.operation_status_history) order_operation_history.append( dateformatter.get_order_status_history(3)) request_data['operation_status'] = 5 request_data['order_operation_history'] = json.dumps( order_operation_history) elif change_status == 6: logger_info.info('Delivery completed') if order.order_status == 2: order_history = json.loads(order.order_status_history) order_history.append( dateformatter.get_order_status_history(10)) request_data['order_status'] = 10 request_data['order_status_history'] = json.dumps( order_history) if order.operation_status == 5: order_operation_history = json.loads( order.operation_status_history) order_operation_history.append( dateformatter.get_order_status_history(6)) request_data['operation_status'] = 6 request_data['order_operation_history'] = json.dumps( order_operation_history) serializer = OrderSerializer(order, data=request_data, partial=True) if serializer.is_valid(): serializer.save() order_data = serializer.data result.set('result', order_data) purchase_order = order.purchase_order order_data['order_status_history'] = json.loads( order_data['order_status_history']) order_data['operation_status_history'] = json.loads( order_data['operation_status_history']) order_data['order_details'] = json.loads( purchase_order.order_details) order_data[ 'special_instruction'] = purchase_order.special_instruction order_data['extra_telephone'] = purchase_order.extra_telephone # price information order_data['price_sub_total'] = purchase_order.price_sub_total order_data[ 'price_delivery_fee'] = purchase_order.price_delivery_fee order_data['price_discount'] = purchase_order.price_discount order_data['price_total'] = purchase_order.price_total # Address information (Please check after purchase order model update) order_data['address_id'] = purchase_order.delivery_address_id del order_data['purchase_order'] result.set('order', order_data) else: logger_info.info(serializer.errors) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request_data invalid') return Response(result.get_response(), result.get_code())
def get(self, request, order_id): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') try: open_id = request.META['HTTP_OPEN_ID'] access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1] except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) lang_info = header_parser.parse_language_v2(request.META) accept_lang = lang_info.accept_lang os_type = lang_info.os_type # Check order_id length if len(order_id) < 17: logger_error.error(code.ERROR_9001_PARAMETER_VALIDATION_FAILED) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_9001_PARAMETER_VALIDATION_FAILED)) result.set_error(code.ERROR_9001_PARAMETER_VALIDATION_FAILED) return Response(result.get_response(), result.get_code()) # Request data parsing try: order = Order.objects.get(open_id=open_id, order_id=order_id) purchase_order = PurchaseOrder.objects.get(order_id=order.order_id) purchase_order_serializer = UpcomingPurchaseOrderSerializer(purchase_order) purchase_order_data = purchase_order_serializer.data purchase_order_data['order_details'] = json.loads(purchase_order_data['order_details']) purchase_order_data['shipping_detail'] = json.loads(purchase_order_data['shipping_detail']) del purchase_order_data['product_list'] del purchase_order_data['coupon_list'] del purchase_order_data['order_hash'] if purchase_order_data['extra_telephone'] is None: purchase_order_data['extra_telephone'] = '' if purchase_order_data['special_instruction'] is None: purchase_order_data['special_instruction'] = '' order_serializer = UpcomingOrderSerializer(order) order_data = order_serializer.data order_data['purchase_order'] = purchase_order_data start_date = order.order_start_date.strftime(resources.DATE_WITH_AM_PM) order_data['order_start_date'] = dateformatter.get_yymmdd_time(start_date) del order_data['order_status_history'] if order.order_status == 11: order_cancel_date = order.order_cancel_date if order_cancel_date is not None: order_cancel_date = order.order_cancel_date.strftime(resources.DATE_WITH_AM_PM) order_data['order_cancel_date'] = dateformatter.get_yymmdd_time(order_cancel_date) else: order_data['order_cancel_date'] = '' else: order_data['order_cancel_date'] = '' result.add(order_data) product_list = json.loads(purchase_order.product_list) headers = {'accept-language': accept_lang} json_data = { 'product_list': product_list, 'open_id': open_id, 'order_id': order_id, 'hub_id': purchase_order_data['hub_id'] } response = requests.post(urlmapper.get_url('MENU_VALIDATE'), headers=headers, json=json_data) response_json = response.json() result.set('reviews', response_json['reviews']) result.set('review_items', response_json['review_items']) except Exception as e: logger_info.info(str(e)) print(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) # Get user default hub id user_information = api_request_util.get_user_information(open_id, access_token) hub_id = user_information[1]['user']['default_hub_id'] if user_information[0] else 1 # Recommend product list product_list = api_request_util.get_recommend_products(accept_lang, hub_id, os_type) result.set('products', product_list) return Response(result.get_response(), result.get_code())
def get(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') try: access_token = str( request.META['HTTP_AUTHORIZATION']).split(' ')[1] api_request_util.get_admin_token_validate_v2(access_token) order_id = request.GET.get('order_id') name = request.GET.get('name') mdn = request.GET.get('mdn') open_id = request.GET.get('open_id') page = int(request.GET.get('page')) limit = int(request.GET.get('limit')) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_401_UNAUTHORIZED, 'Authentication error') return Response(result.get_response(), result.get_code()) # Execute query try: request_str = { 'order_id__icontains': order_id, 'user_name__icontains': name, 'user_telephone__icontains': mdn, 'open_id__icontains': open_id } query_str = request_str.copy() for item in request_str.keys(): if request_str[item] is None: query_str.pop(item) logger_info.info(query_str) order_list = list() orders = Order.objects.filter(**query_str) order_count = orders.count() paginator = Paginator(orders, limit) order_objects = paginator.page(page).object_list serializer = OrderListSerializer(order_objects, many=True) order_data = serializer.data for order in order_data: order['order_status_history'] = json.loads( order['order_status_history']) order['operation_status_history'] = json.loads( order['operation_status_history']) order['order_start_date'] = order[ 'order_start_date'][:19].replace('T', ' ') order[ 'delivery_schedule_time'] = product_util.get_delivery_schedule_str( order['delivery_schedule']) order_list.append(order) result_json = {'total_count': order_count, 'orders': order_list} result.set('result', result_json) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Bad request') return Response(result.get_response(), result.get_code())
def put(self, request, order_id): logger_info.info(order_id) request_data = request.data result = ResultResponse(code.ARIES_200_SUCCESS, 'success') # Request data parsing try: open_id = request.META['HTTP_OPEN_ID'] access_token = str(request.META['HTTP_AUTHORIZATION']).split(' ')[1] except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) # Get purchase order instance try: order = Order.objects.get(open_id=open_id, order_id=order_id) purchase_order = PurchaseOrder.objects.get(open_id=open_id, order_id=order.order_id) except Exception as e: logger_error.error(str(e)) error_code = code.ERROR_3002_PURCHASE_ORDER_NOT_FOUND result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code)) result.set_error(error_code) return Response(result.get_response(), result.get_code()) # Check order status to edit if order.order_status != 0: error_code = code.ERROR_3009_ORDER_EDIT_NOT_AVAILABLE logger_error.error(error_code) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code)) result.set_error(error_code) return Response(result.get_response(), result.get_code()) # Applying changed items to purchase order information try: # Check delivery schedule original_schedule = purchase_order.delivery_schedule new_schedule = request_data['delivery_schedule'] if original_schedule != request_data['delivery_schedule']: hub_id = purchase_order.hub_id delivery_date = str(purchase_order.delivery_date)[:10] method = purchase_order.shipping_method if purchase_order.delivery_on_site: method = 1 query_str = '/' + str(hub_id) + '/' + delivery_date + '/' + str(new_schedule) + '/' + str(method) url = urlmapper.get_url('TIMETABLE_LIST') + query_str response = requests.get(url) response_json = response.json() if response.status_code != code.ARIES_200_SUCCESS: api_result = response.json() result = ResultResponse(api_result['code'], api_result['message']) result.set_error(api_result['error_code']) return Response(result.get_response(), result.get_code()) if response_json['availability']: start_time = response_json['delivery_start_time'] end_time = response_json['delivery_end_time'] request_data['delivery_start_time'] = start_time request_data['delivery_end_time'] = end_time if start_time[1:2] == '0': start_time_prefix = start_time[:2] start_time_postfix = start_time[2:] else: start_time_prefix = start_time[:1] start_time_postfix = start_time[1:] if end_time[1:2] == '0': end_time_prefix = end_time[:2] end_time_postfix = end_time[2:] else: end_time_prefix = end_time[:1] end_time_postfix = end_time[1:] post_str = start_time_prefix + start_time_postfix + '-' + end_time_prefix + end_time_postfix order.delivery_time = order.delivery_time[:12] + post_str order.delivery_schedule = new_schedule order.save() else: error_code = code.ERROR_3007_DELIVERY_SCHEDULE_INVALID result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(error_code)) result.set_error(error_code) return Response(result.get_response(), result.get_code()) # Check Address information old_address_id = purchase_order.delivery_address_id new_address_id = request_data['delivery_address_id'] if old_address_id != new_address_id: # Check if hub_id was changed product_list = json.loads(purchase_order.product_list) payload = {'product_list': product_list, 'delivery_schedule': new_schedule} response = requests.post(urlmapper.get_url('PRODUCT_VALIDATION'), json=payload) if response.status_code == code.ARIES_200_SUCCESS: response_json = response.json() else: logger_error.error(response.text) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, code.ERROR_9000_INTERNAL_API_CALL_FAILED) result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED) return Response(result.get_response(), result.get_code()) # Product validation check product_count = response_json['product_count'] if product_count != len(product_list): logger_error.error(code.ERROR_3010_DELIVERY_CHANGE_NOT_ALLOWED) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, code.ERROR_3010_DELIVERY_CHANGE_NOT_ALLOWED) result.set_error(code.ERROR_3010_DELIVERY_CHANGE_NOT_ALLOWED) return Response(result.get_response(), result.get_code()) # If product is valid, change product stock and more address change business logic # TBD headers = {'open-id': str(open_id), 'authorization': 'bearer ' + access_token} response = requests.get(urlmapper.get_url('PRODUCT_ADDRESS_DETAIL') + '/' + str(new_address_id), headers=headers) if response.status_code == code.ARIES_200_SUCCESS: response_json = response.json() else: result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, code.ERROR_9000_INTERNAL_API_CALL_FAILED) result.set_error(code.ERROR_9000_INTERNAL_API_CALL_FAILED) return Response(result.get_response(), result.get_code()) # Register address to database address = response_json['user_address'] order.delivery_address = address['name'] + ' ' + address['detail'] order.save() request_data['delivery_address_id'] = new_address_id order_serializer = PurchaseOrderSerializer(purchase_order, data=request_data, partial=True) if order_serializer.is_valid(): order_serializer.save() purchase_order = PurchaseOrder.objects.get(id=order_serializer.data['id']) purchase_order_serializer = UpcomingPurchaseOrderSerializer(purchase_order) purchase_order_data = purchase_order_serializer.data purchase_order_data['order_details'] = json.loads(purchase_order_data['order_details']) purchase_order_data['shipping_detail'] = json.loads(purchase_order_data['shipping_detail']) del purchase_order_data['product_list'] del purchase_order_data['coupon_list'] del purchase_order_data['order_hash'] order_serializer = UpcomingOrderSerializer(order) order_data = order_serializer.data order_start_date = datetime.strptime((str(order.order_start_date)[:-10]), '%Y-%m-%d %H:%M') order_data['order_start_date'] = order_start_date.strftime('%Y-%m-%d %I:%M %p') order_data['order_status_history'] = json.loads(order_data['order_status_history']) order_data['purchase_order'] = purchase_order_data order_data['order_cancel_date'] = '' # Get Timetable order_status = order_data['order_status'] if order_status == 0: hub_id = purchase_order.hub_id sales_time = product_util.get_sales_time_to_str(purchase_order.sales_time) response = requests.get(urlmapper.get_time_table_url(hub_id, sales_time)) response_json = response.json() order_data['timetable'] = response_json['timetable'] else: order_data['timetable'] = json.loads('[]') result.set('upcoming_order', order_data) else: logger_info.info(order_serializer.errors) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) return Response(result.get_response(), result.get_code())
def delete(self, request, order_id): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') request_data = request.data logger_info.info(request_data) # Request data parsing try: open_id = request.META['HTTP_OPEN_ID'] payment = Payment.objects.get(open_id=open_id, order_id=order_id) except Exception as e: logger_error.info(str(e)) result = ResultResponse(code.ARIES_400_BAD_REQUEST, 'Request data invalid') return Response(result.get_response(), result.get_code()) payment_type = payment.payment_type # Refund business logic if payment_type == 0 or payment_type == 2: alipay_transaction = AlipayPaymentTransaction.objects.get( out_trade_no=order_id) # Check debug state value if settings.STAGE or settings.DEBUG: debug = True else: debug = False alipay = AliPay( appid=resources.get_alipay_app_id(), app_notify_url=resources.get_alipay_notify_url(), app_private_key_path=resources.get_viastelle_pri_key(), alipay_public_key_path=resources.get_viastelle_pub_key(), sign_type='RSA2', debug=debug) refund_result = alipay.api_alipay_trade_refund( out_trade_no=alipay_transaction.out_trade_no, trade_no=alipay_transaction.trade_no, refund_amount=alipay_transaction.total_amount, refund_reason='Customer asked') if refund_result['code'] == '10000': refund_status = 0 payment_status = 5 else: refund_status = 1 payment_status = 6 try: logger_info.info(refund_result) refund_result['order_id'] = order_id refund_result['status'] = refund_status refund_result['alipay_refund_validation'] = True serializer = AlipayRefundSerializer(data=refund_result) if serializer.is_valid(): serializer.save() else: logger_info.info(serializer.errors) payment.payment_status = payment_status payment.save() except Exception as e: logger_info.error(str(e)) result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_4002_PAYMENT_IS_NOT_FOUND)) result.set_error(code.ERROR_4002_PAYMENT_IS_NOT_FOUND) return Response(result.get_response(), result.get_code()) elif payment_type == 1 or payment_type == 3: if payment_type == 1: wechat_app_id = 'viastelle' merchant_id = 'viastelle' else: wechat_app_id = 'viastelle' merchant_id = 'viastelle' transaction = WechatQueryTransaction.objects.get(order_id=order_id) total_fee = transaction.total_fee refund_data = { 'appid': wechat_app_id, 'mch_id': merchant_id, 'nonce_str': payment_util.wechat_payment_str(transaction.order_id), 'transaction_id': transaction.transaction_id, 'out_trade_no': order_id, 'out_refund_no': transaction.transaction_id, 'total_fee': total_fee, 'refund_fee': total_fee } if payment_type == 1: refund_data_xml = payment_util.get_payment_wechat_dict_to_xml( refund_data) else: refund_data_xml = payment_util.get_payment_wechat_public_dict_to_xml( refund_data) logger_info.info(refund_data_xml) # refund_data_signed = utils.calculate_signature(prepaid_object, api_key) # prepaid_data = utils.dict_to_xml(prepaid_object, prepaid_signature) api_cert_dir = '/home/nexttf/workspace/project_aries/config/keys' if payment_type == 1: api_cert = 'app_pay_apiclient_cert.pem' api_key = 'app_pay_apiclient_key.pem' else: api_cert = 'public_pay_apiclient_cert.pem' api_key = 'public_pay_apiclient_key.pem' api_cert_file = os.path.join(api_cert_dir, api_cert) api_key_file = os.path.join(api_cert_dir, api_key) """ verify=True, cert=(self.cert_file, self.key_file)) """ headers = {'Content-Type': 'application/xml'} response = requests.post(url=get_wechat_refund_url(), headers=headers, data=refund_data_xml, verify=True, cert=(api_cert_file, api_key_file)) logger_info.info(response.text) try: refund_result = xmltodict.parse(response.text)['xml'] logger_info.info(refund_result) if refund_result['return_code'] == 'SUCCESS': refund_status = 0 payment_status = 5 else: refund_status = 1 payment_status = 6 validation = payment_util.get_payment_wechat_sign_validation( refund_result) refund_result['status'] = refund_status refund_result['order_id'] = order_id refund_result['wechat_refund_validation'] = validation serializer = WechatRefundSerializer(data=refund_result) if serializer.is_valid(): serializer.save() else: logger_info.info(serializer.errors) payment.payment_status = payment_status payment.save() if refund_status == 1: logger_error.error(code.ERROR_4003_PAYMENT_REFUND_FAIL) result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_4003_PAYMENT_REFUND_FAIL)) result.set_error(code.ERROR_4003_PAYMENT_REFUND_FAIL) return Response(result.get_response(), result.get_code()) except Exception as e: logger_error.error(str(e)) result = ResultResponse( code.ARIES_500_INTERNAL_SERVER_ERROR, get_msg(code.ERROR_4002_PAYMENT_IS_NOT_FOUND)) result.set_error(code.ERROR_4002_PAYMENT_IS_NOT_FOUND) return Response(result.get_response(), result.get_code()) return Response(result.get_response(), result.get_code())
def post(self, request): result = ResultResponse(code.ARIES_200_SUCCESS, 'success') request_data = request.data try: trade_type = request_data['trade_type'] product_list = request_data['product_list'] validate_str = request_data['validate_str'] if validate_str != 'GoDbAcKeNdS': result = ResultResponse(code.ARIES_401_UNAUTHORIZED, get_msg(code.ARIES_401_UNAUTHORIZED)) return Response(result.get_response(), result.get_code()) except Exception as e: logger_error.error(str(e)) result = ResultResponse(code.ARIES_401_UNAUTHORIZED, get_msg(code.ARIES_401_UNAUTHORIZED)) return Response(result.get_response(), result.get_code()) try: sales_status = 1 for product_item in product_list: product_id = product_item['product_id'] quantity = product_item['quantity'] product = Product.objects.get(id=product_id) menu = product.menu hub = product.hub product_stock = HubStock.objects.get(hub=hub, menu=menu) stock_count = product_stock.stock sold_count = product_stock.sold if trade_type == 0: stock_count -= quantity sold_count += quantity else: stock_count += quantity sold_count -= quantity if sold_count <= 0: sold_count = 0 if stock_count <= 0: stock_count = 0 products = Product.objects.filter(hub=hub, menu=menu, status__lte=sales_status) for sold_product in products: sold_product_instance = Product.objects.get( id=sold_product.id) sold_product_instance.status = 0 sold_product_instance.save() if stock_count >= 1: product_status = product.status if product_status == 0: product.status = sales_status product.save() product_stock.stock = stock_count product_stock.sold = sold_count product_stock.save() return Response(result.get_response(), result.get_code()) except Exception as e: logger_info.info(str(e)) result = ResultResponse(code.ARIES_500_INTERNAL_SERVER_ERROR, 'Error : ' + str(e)) return Response(result.get_response(), result.get_code())