def post(self):
token = self.request.get("token")
admin = Admin.query(Admin.token == token).get()
if not admin:
self.abort(401)
delivery_terminal = DeliveryTerminal.get_by_id(
admin.delivery_terminal_id)
if not delivery_terminal:
self.send_error(u'Вы не привязаны к точке')
stop_list = json.loads(self.request.get('stop_list'))
for item_id in stop_list.get('stopped'):
item = get_product_from_menu(admin.company_id, product_id=item_id)
if not item:
return self.send_error(u'Продукт не найден')
if item_id in delivery_terminal.item_stop_list:
return self.send_error(u'Продукт %s уже в стоп-листе' %
item.get('name', ''))
delivery_terminal.item_stop_list.append(item_id)
for item_id in stop_list.get('recovered'):
item = get_product_from_menu(admin.company_id, product_id=item_id)
if not item:
return self.send_error(u'Продукт не найден')
if item_id not in delivery_terminal.item_stop_list:
return self.send_error(u'Продукт %s еще не в стоп-листе' %
item.get('name', ''))
delivery_terminal.item_stop_list.remove(item_id)
delivery_terminal.put()
self.render_json({'success': True})
def post(self):
status_list = list()
# parse data
logging.info(self.request.get('json'))
arr = json.loads(self.request.get('json'))
for item in arr["orders"]:
# get ids and info
delivery_terminal_id = item['venue_id']
delivery_terminal = DeliveryTerminal.get_by_id(delivery_terminal_id)
if not delivery_terminal:
# old version: got organization id instead of DT id
delivery_terminal = DeliveryTerminal.get_any(delivery_terminal_id)
delivery_terminal_id = delivery_terminal.key.id()
order_id = item['order_id']
order_info = order_info1(order_id, delivery_terminal.iiko_organization_id)
if 'httpStatusCode' not in order_info:
address = delivery_terminal.address
name = delivery_terminal.name
# make dict
status_list.append({
'order_id': order_id,
'number': order_info['number'],
'venue_id': delivery_terminal_id,
'status': Order.parse_status(order_info['status']),
'address': address,
'name': name,
'createdTime': order_info['createdTime']
})
else:
logging.warning('order %s not found' % order_id)
self.render_json({"orders": status_list})
def get(self, delivery_terminal_id):
delivery_terminal = DeliveryTerminal.get_by_id(delivery_terminal_id)
if delivery_terminal:
iiko_org_id = delivery_terminal.iiko_organization_id
else:
iiko_org_id = delivery_terminal_id
return self.render_json(
{"types": CompanyNew.get_payment_types(iiko_org_id)})
def get(self):
token = self.request.get("token")
admin = Admin.query(Admin.token == token).get()
if not admin:
self.abort(401)
self.render_json({
'dynamic':
DeliveryTerminal.get_by_id(
admin.delivery_terminal_id).dynamic_dict()
})
def get(self, delivery_terminal_id):
delivery_terminal = DeliveryTerminal.get_by_id(delivery_terminal_id)
if delivery_terminal:
iiko_org_id = delivery_terminal.iiko_organization_id
else:
iiko_org_id = delivery_terminal_id
force_reload = "reload" in self.request.params
filtered = "all" not in self.request.params
menu = get_menu(iiko_org_id,
force_reload=force_reload,
filtered=filtered)
if iiko_org_id == CompanyNew.COFFEE_CITY:
menu = fix_syrop.set_syrop_modifiers(menu)
menu = fix_modifiers_by_own.remove_modifiers(menu)
add_additional_categories(CompanyNew.get_by_iiko_id(iiko_org_id), menu)
self.render_json({'menu': menu})
def post(self):
company_id = self.request.get_range('company_id')
if not company_id:
delivery_terminal_id = self.request.get('venue_id')
company_id = DeliveryTerminal.get_by_id(delivery_terminal_id).company_id
company = CompanyNew.get_by_id(company_id)
if company.iiko_org_id not in (CompanyNew.COFFEE_CITY, CompanyNew.EMPATIKA):
self.render_error("Unknown company")
return
customer_id = self.request.get('customer_id')
phone = filter_phone(self.request.get('phone'))
provider = self.request.get('provider')
social_id = self.request.get('social_id')
# 1: check if this social id was already used
same_social_id = CATSocialId.query(CATSocialId.venue_id == company.iiko_org_id,
CATSocialId.provider == provider,
CATSocialId.social_id == social_id).get()
if same_social_id:
self.render_error(u"Данная учетная запись в социальной сети уже была привязана")
return
# 2: get customer info from iiko (this attempts to get customer_id if we only have phone)
if not customer_id:
iiko_customer = get_customer_by_phone(company, phone)
if 'httpStatusCode' in iiko_customer:
iiko_customer = {'phone': phone, 'balance': 0}
customer_id = iiko_customer.get('id')
else:
iiko_customer = get_customer_by_id(company, customer_id)
# 3: if we got customer_id, check if this customer already has an account of this provider
if customer_id:
same_customer_and_provider = CATSocialId.query(CATSocialId.venue_id == company.iiko_org_id,
CATSocialId.customer_id == customer_id,
CATSocialId.provider == provider).get()
if same_customer_and_provider:
self.render_error(u"Вы уже привязывали учетную запись в этой социальной сети")
return
# 4: add points
iiko_customer['balance'] += 20
customer_id = create_or_update_customer(company, iiko_customer)
CATSocialId(venue_id=company.iiko_org_id, customer_id=customer_id, provider=provider, social_id=social_id).put()
self.render_json({'customer_id': customer_id, 'balance': iiko_customer['balance']})
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 get_dt(dt_id):
if not dt_id:
return None
if dt_id not in dt_map:
dt_map[dt_id] = DeliveryTerminal.get_by_id(dt_id)
return dt_map[dt_id]
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)