def get(self):
company_id = self.request.get_range('company_id')
company = CompanyNew.get_by_id(company_id)
if not company.invitation_settings or not company.invitation_settings.enable:
self.abort(403)
customer_id = self.request.get('customer_id')
customer = get_resto_customer(company, customer_id)
if not customer:
self.abort(400)
share = Share(share_type=branch_io.INVITATION, sender=customer.key)
share.put()
if 'iOS' in self.request.headers["User-Agent"]:
user_agent = 'ios'
elif 'Android' in self.request.headers["User-Agent"]:
user_agent = 'android'
else:
user_agent = 'unknown'
urls = [{
'url':
branch_io.create_url(company, share.key.id(), branch_io.INVITATION,
channel, user_agent),
'channel':
channel
} for channel in branch_io.CHANNELS]
share.urls = [url['url'] for url in urls]
share.put()
self.render_json({
'urls': urls,
'text': company.invitation_settings.share_text,
'image_url': company.invitation_settings.share_image
})
def post(self):
company_id = self.request.get_range('company_id')
company = CompanyNew.get_by_id(company_id)
customer_id = self.request.get('customer_id')
customer = get_resto_customer(company, customer_id)
customer.put()
share_data = self.request.get('share_data')
logging.info('shared_data: %s' % share_data)
invitation_response = {}
if share_data:
share_data = json.loads(share_data)
share_id = share_data.get('share_id')
if share_id:
share = Share.get_by_id(int(share_id))
if share.share_type == INVITATION:
if not customer_id:
SharedBonus(sender=share.sender,
recipient=customer.key,
share_id=share.key.id()).put()
invitation_response = {
'success':
True,
'description':
company.invitation_settings.success_message
if company.invitation_settings else 'Success',
}
else:
invitation_response = {
'success':
False,
'description':
company.invitation_settings.failure_message
if company.invitation_settings else 'Fail',
}
self.render_json({
'customer_id':
customer.customer_id
if customer.customer_id else customer.key.id(),
'invitation':
invitation_response
})
def get(self):
company_id = self.request.get_range('company_id')
company = CompanyNew.get_by_id(company_id)
client_id = self.request.get('client_id')
customer = get_resto_customer(company, client_id)
branch_invitation = company.invitation_settings is not None and company.invitation_settings.enable
if branch_invitation and 'orangexpress/1.2.2' in self.request.user_agent:
branch_invitation = Order.query(
Order.customer == customer.key).get() is not None
self.render_json({
'app_name': company.app_title,
'description': company.description,
'min_order_sum': company.min_order_sum,
'cities': company.cities,
'phone': company.phone,
'schedule': company.schedule,
'email': company.email,
'support_emails': company.support_emails,
'site': company.site,
'branch_invitation': branch_invitation,
'branch_gift': company.branch_gift_enable
})
def post(self, delivery_terminal_id):
logging.info(self.request.POST)
custom_data = None
try:
custom_data = json.loads(self.request.get('custom_data'))
except ValueError:
pass
bonus_sum = self.request.get('bonus_sum')
bonus_sum = float(bonus_sum) if bonus_sum else 0.0
discount_sum = self.request.get('discount_sum')
discount_sum = float(discount_sum) if discount_sum else 0.0
customer_id = self.request.get('customer_id') or self.request.get(
'customerId')
address = self.request.get('address')
comment = self.request.get('comment')
binding_id = self.request.get('binding_id')
alpha_client_id = self.request.get('alpha_client_id')
source = self.request.get('source')
delivery_terminal = DeliveryTerminal.get_by_id(delivery_terminal_id)
if delivery_terminal:
org_id = delivery_terminal.iiko_organization_id
else:
org_id = delivery_terminal_id
company = CompanyNew.get_by_iiko_id(org_id)
if not delivery_terminal:
delivery_terminal = DeliveryTerminal.get_any(company.iiko_org_id)
delivery_terminal_id = delivery_terminal.key.id()
response_delivery_terminal_id = delivery_terminal_id
customer = get_resto_customer(company, customer_id)
set_customer_info(company, customer,
self.request.get('name').strip(),
self.request.headers,
filter_phone(self.request.get('phone')), custom_data)
update_customer_id(company, customer)
self.order = order = iiko.Order()
order.order_id = self.request.get('id') or str(uuid.uuid4())
if source == AUTO_APP_SOURCE:
if not company.auto_token:
send_error(
"order",
u"Компания %s не настроена для работы с автоматизацией" %
company.app_title, "")
return self.send_error(
u"Неизвестная системная ошибка, попробуйте позже")
order.source = source
order.date = datetime.datetime.utcfromtimestamp(
int(self.request.get('date')))
order.payment_type = self.request.get('paymentType')
str_date = self.request.get('str_date')
if str_date:
parsed_str_date = parse_str_date(str_date)
if parsed_str_date:
order.date = parsed_str_date - datetime.timedelta(
seconds=company.get_timezone_offset())
else:
logging.warning("Failed to parse str_date: %s", str_date)
order.date = datetime.datetime.now() + datetime.timedelta(
hours=1)
if order.date < datetime.datetime.utcnow() and \
('/2.0 ' in self.request.user_agent or '/2.0.1' in self.request.user_agent):
logging.info('new date(str): %s' % order.date)
order.date += datetime.timedelta(hours=12)
logging.info("ios v2.0 fuckup, adding 12h: %s", order.date)
send_confirmation_sms = False
if company.iiko_org_id in (CompanyNew.EMPATIKA,
CompanyNew.ORANGE_EXPRESS):
confirm_by_phone = self.request.get("confirm_by_phone")
if confirm_by_phone == "1":
comment = u"Клиент просит перезвонить. " + comment
elif confirm_by_phone == "0":
comment = u"Клиенту будет отправлено СМС-подтверждение. " + comment
send_confirmation_sms = True
else:
pass # old version
order.delivery_terminal_id = delivery_terminal_id
order.venue_id = company.iiko_org_id
gifts = json.loads(
self.request.get('gifts')) if self.request.get('gifts') else []
order.customer = customer.key
items = prepare_items(company, json.loads(self.request.get('items')))
order.items = items
order.initial_sum = order.sum = calc_sum(items, company.iiko_org_id)
logging.info("calculated sum: %s, app sum: %s", order.sum,
self.request.get('sum'))
if company.iiko_org_id in (CompanyNew.DIMASH,
CompanyNew.CHAIHANA_LOUNGE):
if 'Android' in self.request.user_agent:
comment = u"Заказ с Android. " + comment
else:
comment = u"Заказ с iOS. " + comment
is_repeated_order = None
if company.iiko_org_id in _FIRST_ORDER_COMMENTS:
comment_first, comment_repeated = _FIRST_ORDER_COMMENTS[
company.iiko_org_id]
is_repeated_order = orders_exist_for_phone(customer.phone)
comment = (comment_repeated
if is_repeated_order else comment_first) + comment
order.comment = comment
delivery_type = self.request.get_range('deliveryType')
order.is_delivery = delivery_type == DeliveryType.DELIVERY
if order.is_delivery:
if not address:
self.abort(400)
try:
order.address = json.loads(address)
prepare_address(order)
except Exception as e:
logging.exception(e)
self.abort(400)
order.delivery_type = None
for company_delivery_type in company.delivery_types:
company_delivery_type = company_delivery_type.get()
if company_delivery_type.delivery_id == delivery_type:
order.delivery_type = company_delivery_type
if order.venue_id == CompanyNew.KUKSU:
kuksu_delivery.check_and_add_delivery(company, order)
# this resets order.delivery_terminal_id if it is delivery (not takeout)
order_dict = prepare_order(order, customer, order.payment_type)
if delivery_terminal_id != order.delivery_terminal_id:
delivery_terminal_id = order.delivery_terminal_id
delivery_terminal = DeliveryTerminal.get_by_id(delivery_terminal_id) \
if delivery_terminal_id else None
validation_result = validate_order(company, delivery_terminal, order,
customer)
if not validation_result['valid']:
return self.send_error(validation_result['errors'][0])
pre_check_result = pre_check_order(company, order_dict)
if 'code' in pre_check_result:
logging.warning('iiko pre check failed')
msg = pre_check_result["description"] or pre_check_result["message"]
send_error("iiko", "iiko pre check failed", msg)
self.abort(400)
order.discount_sum = 0.0
order.bonus_sum = 0.0
if company.is_iiko_system:
create_or_update_customer(company, {'phone': customer.phone})
success = set_discounts_bonuses_gifts(order, order_dict,
discount_sum, bonus_sum,
gifts)
if not success:
self.abort(409)
order.sum -= order.bonus_sum + order.discount_sum
elif company.iiko_org_id == CompanyNew.CHAIHANA_LOUNGE:
assert is_repeated_order is not None
if is_repeated_order:
order.discount_sum = 0.05 * order.sum
else:
order.discount_sum = 0.25 * order.sum
if order.payment_type == PaymentType.COURIER_CARD:
for payment in order_dict['order']['paymentItems']:
if payment['paymentType']['code'] == 'CARD':
payment['sum'] -= order.discount_sum
if order.payment_type == PaymentType.CASH and not order.is_delivery:
payments_list = order_dict['order']['paymentItems']
for payment in payments_list:
if payment['paymentType']['code'] == 'CASH':
payments_list.remove(payment)
break
# pay after pre check
if order.payment_type == PaymentType.CARD:
binding_id = check_binding_id(company, alpha_client_id, binding_id)
success, result = create_payment(company, delivery_terminal, order,
alpha_client_id)
if not success:
self.send_error(result)
return
order.alfa_order_id = result
order.put()
success, result = perform_payment(company, delivery_terminal,
order, order_dict,
order.alfa_order_id, binding_id)
if not success:
self.send_error(u"Не удалось произвести оплату. " + result)
return
result = place_order(company, order_dict)
if 'code' in result.keys():
logging.error('iiko failure')
if order.payment_type == PaymentType.CARD:
# return money
return_result = get_back_blocked_sum(company,
delivery_terminal,
order.alfa_order_id)
logging.info('return')
logging.info(return_result)
msg = result["description"] or result["message"]
send_error("iiko", "iiko place order failed", msg)
self.response.set_status(400)
return self.render_json(result)
customer.customer_id = result['customerId']
customer.put()
order.customer = customer.key
client_info_id = self.request.get_range('user_data_id')
if client_info_id:
client_info = ClientInfo.get_by_id(client_info_id)
if client_info and client_info.customer != customer.key:
client_info.customer = customer.key
client_info.put()
order.order_id = result['orderId']
order.number = result['number']
order.set_status(result['status'])
order.created_in_iiko = parse_iiko_time(result['createdTime'], company)
order.put()
try:
send_order_email(order, customer, company)
except DownloadError:
logging.warning('mandrill is not responsed')
if send_confirmation_sms:
countdown = random.randint(120, 420) # make it realistic
deferred.defer(send_confirmation, order.key, _countdown=countdown)
response_items = order.items
if company.iiko_org_id == CompanyNew.COFFEE_CITY:
response_items = json.loads(json.dumps(order.items))
for item in response_items:
fix_modifiers_by_own.remove_modifiers_from_item(item)
resp = {
'customer_id': customer.customer_id,
'order': {
'order_id': order.order_id,
'resto_id': order.key.id(),
'status': order.status,
'items': response_items,
'sum': order.sum,
'payments':
order_dict['order']['paymentItems'], # it was added
'number': order.number,
'venue_id': response_delivery_terminal_id,
'address': order.address,
'date': int(self.request.get('date')),
},
'error': False,
'error_code': 0,
}
logging.info(resp)
delete_iiko_customer_from_memcache(company.iiko_org_id, customer.phone)
self.render_json(resp)
def post(self):
for k, v in self.request.POST.items():
logging.debug("%s: %s", k, v)
delivery_terminal_id = self.request.get('venue_id')
delivery_terminal = DeliveryTerminal.get_by_id(delivery_terminal_id)
if delivery_terminal:
company = CompanyNew.get_by_id(delivery_terminal.company_id)
else:
company = CompanyNew.get_by_iiko_id(delivery_terminal_id)
customer = get_resto_customer(company, self.request.get('customer_id'))
phone = self.request.get('phone')
if company.iiko_org_id == CompanyNew.COFFEE_CITY:
logging.debug("wow such coffee so city")
create_or_update_customer(company, {'phone': filter_phone(phone)})
set_customer_info(company, customer,
self.request.get('name').strip(),
self.request.headers, filter_phone(phone))
update_customer_id(company, customer)
if not phone:
return self.send_error(u'Введите номер телефона')
phone = filter_phone(phone)
valid, error = check_modifiers_amount(
json.loads(self.request.get('items')), company.iiko_org_id)
if not valid:
return self.send_error(error)
items = prepare_items(company, json.loads(self.request.get('items')))
order = iiko.Order()
order.date = datetime.datetime.fromtimestamp(
self.request.get_range('date'))
order.venue_id = company.iiko_org_id
order.delivery_terminal_id = delivery_terminal_id
order.sum = float(self.request.get('sum'))
order.items = items
delivery_type = self.request.get_range('deliveryType')
order.is_delivery = delivery_type == DeliveryType.DELIVERY
if order.is_delivery:
order.address = {'home': '0'}
order.delivery_type = None
for company_delivery_type in company.delivery_types:
company_delivery_type = company_delivery_type.get()
if company_delivery_type.delivery_id == delivery_type:
order.delivery_type = company_delivery_type
order_dict = prepare_order(order, customer, None)
validation_result = validate_order(company, delivery_terminal, order,
customer)
if not validation_result['valid']:
return self.send_error(validation_result['errors'][0], order.items)
if company.is_iiko_system and order.items:
promos = get_order_promos(order, order_dict)
set_discounts(order, order_dict['order'], promos)
promos = get_order_promos(order, order_dict)
discount_sum = order.discount_sum
max_bonus_payment = promos['maxPaymentSum']
if company.iiko_org_id == CompanyNew.BON_APPETIT:
max_bonus_payment = 0.0
gifts = []
if promos.get('availableFreeProducts'):
for gift in promos['availableFreeProducts']:
gifts.append({
'id': gift['id'],
'code': gift['code'],
'name': gift['name'],
'images': gift['images'],
'weight': gift['weight']
})
accumulated_gifts = 0
if company.iiko_org_id in (CompanyNew.EMPATIKA, ):
free_codes = CAT_FREE_CUP_CODES[company.iiko_org_id]
free_cup = get_product_from_menu(company.iiko_org_id,
product_code=free_codes[0])
FREE_CUP_IN_ORDER = 10
CUPS_IN_ORDER = FREE_CUP_IN_ORDER * CUPS_BEFORE_FREE_CUP
mock_order = copy.deepcopy(order)
mock_order.sum = free_cup['price'] * CUPS_IN_ORDER
mock_order.items = prepare_items(
company, [{
'id': free_cup['productId'],
'name': free_cup['name'],
'amount': CUPS_IN_ORDER
}])
mock_order_dict = prepare_order(mock_order, customer, None)
mock_promos = get_order_promos(mock_order, mock_order_dict)
set_discounts(mock_order, mock_order_dict['order'],
mock_promos)
accumulated_gifts = int(mock_order.discount_sum /
free_cup['price']) - FREE_CUP_IN_ORDER
discount_gifts = 0
if company.iiko_org_id in (CompanyNew.EMPATIKA, ):
for item in order.items:
free_codes = CAT_FREE_CUP_CODES[company.iiko_org_id]
if item['code'] in free_codes:
if item.get('discount_sum'):
price = (item['sum'] +
item['discount_sum']) / item['amount']
discount_gifts += item['discount_sum'] / price
item['amount'] = int(item['amount'])
else:
discount_sum = 0.0
max_bonus_payment = 0.0
gifts = []
accumulated_gifts = discount_gifts = 0
if company.iiko_org_id == CompanyNew.CHAIHANA_LOUNGE:
if orders_exist_for_phone(phone):
discount_sum = 0.05 * order.sum
else:
discount_sum = 0.25 * order.sum
delivery_sum = 0
if company.iiko_org_id == CompanyNew.KUKSU:
if kuksu_delivery.check_delivery(order):
delivery_sum = kuksu_delivery.get_delivery_sum()
iiko_customer = get_customer_by_id(company, customer.customer_id)
result = {
"order_discounts": discount_sum,
"delivery_sum": delivery_sum,
"max_bonus_payment":
max_bonus_payment if max_bonus_payment > 0 else 0,
"gifts": gifts,
"error": False,
"accumulated_gifts": max(0,
int(accumulated_gifts - discount_gifts)),
"items": order.items,
"balance": iiko_customer.get('balance', 0.0)
}
return self.render_json(result)