def post(self, company_id):
c = CompanyNew.get_by_id(int(company_id))
c.app_title = self.request.get("app_title")
c.description = self.request.get("description")
c.address = self.request.get("address")
try:
c.latitude, c.longitude = get_address_coordinates(c.address)
except Exception as e:
logging.exception(e)
c.phone = self.request.get("phone")
c.site = self.request.get("site")
c.email = self.request.get("email")
c.cities = self.request.get("cities").split(",")
c.min_order_sum = int(self.request.get("min_order_sum"))
c.schedule = ast.literal_eval(self.request.get("schedule"))
c.email_for_orders = filter(None, self.request.get("email_for_orders").split(','))
c.new_endpoints = bool(self.request.get("new_endpoints"))
c.iiko_stop_lists_enabled = bool(self.request.get("iiko_stop_lists_enabled"))
c.is_iiko_system = bool(self.request.get("platius"))
c.platius_login = self.request.get("platius_login")
c.platius_org_id = self.request.get("platius_id")
c.alpha_login = self.request.get("alpha_login")
c.alpha_pass = self.request.get("alpha_pass")
c.support_emails = self.request.get("support_emails").split(",")
c.app_name = self.request.get("user_agent").split(",")
c.auto_token = self.request.get("auto_token")
c.additional_categories = parse_additional_categories(self.request.get("additional_categories"))
c.put()
platius_logins = [key.id() for key in PlatiusLogin.query().fetch(keys_only=True)]
self.render('company/edit.html', company=c, platius_logins=platius_logins, success=True)
def send_confirmation(order_key):
order = order_key.get()
company = CompanyNew.get_by_iiko_id(order.venue_id)
phone = order.customer.get().phone
sms_text = _CONFIRMATION_TEXT % (order.number, company.app_title)
success, _ = sms_pilot.send_sms("INFORM", [phone[1:]], sms_text)
def _handle(order_id):
from methods.orders.change import do_load
order = Order.order_by_id(order_id)
logging.info('searching for move, number %s, id %s', order.number,
order.order_id)
try:
customer = order.customer.get()
company = CompanyNew.get_by_iiko_id(order.venue_id)
orders = get_orders(company, date.today(), date.today())
for iiko_order in orders['deliveryOrders']:
if iiko_order['number'] == order.number \
and iiko_order['customer']['phone'][-10:] == customer.phone[-10:] \
and Order.parse_status(iiko_order['status']) != Order.CANCELED:
logging.info("found move: %s" % iiko_order['orderId'])
logging.info(iiko_order)
order.order_id = iiko_order['orderId']
do_load(order, order.order_id, order.venue_id, iiko_order)
break
else:
if order.payment_type == PaymentType.CARD:
message = u"№ заказа: %s<br/>" \
u"Сумма: %s<br/>" \
u"Клиент: %s %s<br/>" \
u"ID платежа: %s" % (order.number, order.initial_sum, customer.phone, customer.name, order.alfa_order_id)
mandrill.send_email(
"*****@*****.**", ["*****@*****.**"],
["*****@*****.**", "*****@*****.**"],
u"[ОЭ] Отмена заказа с безналичной оплатой", message)
send_order_status_push(order)
except Exception as e:
send_error("order", "OE move checker: exception on %s" % order.number,
repr(e))
def post(self, order_id):
order = Order.order_by_id(order_id)
meal_rate = float(self.request.get('meal_rate'))
service_rate = float(self.request.get('service_rate'))
comment = self.request.get('comment')
rate = OrderRate(meal_rate=meal_rate,
service_rate=service_rate,
comment=comment)
order.rate = rate
order.put()
is_negative = 0 < meal_rate < 4 or 0 < service_rate < 4
if is_negative or rate.comment:
company = CompanyNew.get_by_iiko_id(order.venue_id)
customer = order.customer.get()
dt = DeliveryTerminal.get_by_id(order.delivery_terminal_id)
body = u"Клиент: %s %s<br>" \
u"Заказ №%s<br>" \
u"Точка: %s<br>" \
u"Оценка еды: %d из 5<br>" \
u"Оценка обслуживания: %d из 5<br>" % \
(customer.phone, customer.name, order.number, dt.name, meal_rate, service_rate)
if comment:
body += u"Комментарий: %s" % comment
logging.info(body)
to = company.support_emails
cc = ['*****@*****.**', '*****@*****.**']
subject = u'Негативный отзыв о заказе' if is_negative else u'Отзыв о заказе с комментарием'
mandrill.send_email('*****@*****.**', to, cc, subject,
body)
self.render_json({})
def get(self):
now = datetime.datetime.now()
delta = datetime.timedelta(minutes=MINUTES_INTERVAL)
orders = Order.query(Order.status == Order.CREATING,
Order.created <= now - delta).fetch()
if orders:
infos = []
for order in orders:
info = [("id", order.order_id),
("payment type", order.payment_type),
("payment id", order.alfa_order_id)]
to_delete = False
iiko_order = order_info1(order.order_id, order.venue_id)
if 'httpStatusCode' not in iiko_order:
info.append(('found', True))
order.load_from_object(iiko_order)
else:
if order.payment_type == PaymentType.CARD:
try:
company = CompanyNew.get_by_iiko_id(order.venue_id)
delivery_terminal = DeliveryTerminal.get_by_id(order.delivery_terminal_id) \
if order.delivery_terminal_id else None
# check payment status
status = alfa_bank.check_extended_status(
company, delivery_terminal,
order.alfa_order_id)["alfa_response"]
info.append(("status check result", status))
# if status check was successful:
if str(status.get("errorCode", '0')) == '0':
# money already deposited -- do not delete
if status['orderStatus'] == 2:
info.append(("ERROR", "deposited"))
# money approved -- reverse
elif status['orderStatus'] == 1:
reverse_result = alfa_bank.get_back_blocked_sum(
company, delivery_terminal,
order.alfa_order_id)
info.append(
("reverse result", reverse_result))
if str(reverse_result.get(
'errorCode', '0')) == '0':
to_delete = True
# any other status is OK to delete
else:
to_delete = True
except Exception as e:
info.append(("exception", repr(e)))
else:
to_delete = True
if to_delete:
order.key.delete()
info.append(("deleted", True))
infos.append(info)
mail_body = "Orders with creating status\n"
mail_body += "List of orders:\n" + \
"\n\n".join("\n".join("%s: %s" % t for t in info) for info in infos)
admin.send_error("order", "Orders crashed while creating",
mail_body)
def get(self):
result = []
for c in CompanyNew.query().fetch():
result.append({
'id': c.iiko_org_id,
'app_name': c.app_title,
'name': c.app_title
})
self.render_json({"legals": result})
def post(self, company_id):
c = CompanyNew.get_by_id(int(company_id))
if 'reload' in self.request.params:
_load_delivery_terminals(c)
time.sleep(0.5)
dts = DeliveryTerminal.query(DeliveryTerminal.company_id == c.key.id()).fetch()
else:
dts = DeliveryTerminal.query(DeliveryTerminal.company_id == c.key.id()).fetch()
for dt in dts:
param_name = 'active_%s' % dt.key.id()
dt.active = bool(self.request.get(param_name))
ndb.put_multi(dts)
self.render('company/terminals/list.html', company=c, dts=dts)
def apply_lpq_discounts(order):
company = CompanyNew.get_by_iiko_id(order.venue_id)
for item in order.items:
if item['category'] in _TEN_PERCENT_ALWAYS_CATEGORIES \
and order.delivery_terminal_id not in _TEN_PERCENT_EXCLUDED_VENUES:
_add_discount(order, item, 0.1)
elif item['category'] in _EVENING_CATEGORIES:
if order.delivery_terminal_id in _EVENING_SCHEDULE:
schedule = [_EVENING_SCHEDULE[order.delivery_terminal_id]]
local_date = order.date + timedelta(
seconds=company.get_timezone_offset())
if working_hours.is_datetime_valid(schedule, local_date,
order.is_delivery):
_add_discount(order, item, 0.3)
def get(self, company_id):
company = CompanyNew.get_by_id(int(company_id))
menu = get_menu(company.iiko_org_id, force_reload=True)
def process_category(category, names, dst):
names.append(category['name'])
if category['products']:
dst.append((" > ".join(names), category['products']))
for subcat in category['children']:
process_category(subcat, names, dst)
names.pop()
result = []
for cat in menu:
process_category(cat, [], result)
self.render('/mt/reports/view_menu.html', menu=result)
def get(self):
address = self.request.get('address')
city = self.request.get('city')
street = self.request.get('street')
if address:
if ' ' not in address:
return self.render_json([])
words = address.split(' ', 1)
city = words[0]
street = words[1]
ua = self.request.user_agent
name = ua.split('/', 1)[0].lower().strip()
logging.debug('searching for company with name %r', name)
company = CompanyNew.query(CompanyNew.app_name == name).get()
logging.debug('result: %s' % company)
if company:
logging.debug('searching by iiko')
output_data = complete_address_input_by_iiko(company, city, street)
else:
logging.debug('searching by kladr')
output_data = complete_address_input_by_kladr(city, street)
return self.render_json(output_data)
def to_dict(self):
company = CompanyNew.get_by_id(self.company_id)
return {
'active':
self.active,
'venueId':
self.key.id(),
'name':
self.name,
'address':
self.address,
'latitude':
self.location.lat,
'longitude':
self.location.lon,
'logoUrl':
'',
'phone':
self.phone,
'payment_types':
[x.to_dict() for x in ndb.get_multi(company.payment_types)],
'schedule':
self.schedule or company.schedule,
}
def get(self):
companies = CompanyNew.query(CompanyNew.iiko_stop_lists_enabled == True).fetch()
for company in companies:
get_company_stop_lists(company, force_reload=True)
def get(self, company_id):
c = CompanyNew.get_by_id(int(company_id))
dts = DeliveryTerminal.query(DeliveryTerminal.company_id == c.key.id()).fetch()
self.render('company/terminals/list.html', company=c, dts=dts)
def update_number_in_auto(order):
auto_token = CompanyNew.get_by_iiko_id(order.venue_id).auto_token
path = '/orders/%s/add_number' % order.key.id()
params = {'token': auto_token, 'number': order.number}
_request(path, params)
def _get_dummy_company(iiko_api_login, new_endpoints):
return CompanyNew(iiko_login=iiko_api_login,
platius_login=iiko_api_login,
iiko_org_id='00000000-0000-0000-0000-000000000000',
platius_org_id='00000000-0000-0000-0000-000000000000',
new_endpoints=new_endpoints)
def get_payment_types(org_id):
company = CompanyNew.get_by_iiko_id(org_id)
result = get_request(company, '/paymentTypes/getPaymentTypes',
{'organization': org_id})
obj = json.loads(result)
return obj
def approve(order):
company = CompanyNew.get_by_iiko_id(order.venue_id)
if company.auto_token and order.source == AUTO_APP_SOURCE:
confirm_order(order, company.auto_token)
send_order_status_push(order)
def _render(self, companies=None, logins=None, **kwargs):
if not companies:
companies = CompanyNew.query().fetch()
if not logins:
logins = [key.id() for key in IikoApiLogin.query().fetch(keys_only=True)]
self.render('company/list.html', companies=companies, logins=logins, **kwargs)
def get(self):
today = date.today()
start_date = today - timedelta(days=DAYS_TO_FETCH)
for org_id in RECOMMENDATION_COMPANIES:
company = CompanyNew.get_by_iiko_id(org_id)
logging.debug("building category dict")
menu = list_menu(org_id)
item_categories = {}
for product in menu:
item_categories[product['productId']] = product['extCatId']
logging.debug("history fetch start")
history = get_orders(company, start_date, today,
'CLOSED')['deliveryOrders']
logging.debug("counting start")
item_count_by_category = defaultdict(
Counter
) # cat_id -> (item_id -> num of orders) for popular section
pair_order_count = defaultdict(
Counter) # item1_id -> (item2_id -> num of orders)
for order in history:
item_ids = set(item['id'] for item in order['items']
if item['id'] in item_categories)
for item_id in item_ids:
item_count_by_category[
item_categories[item_id]][item_id] += 1
for other_item_id in item_ids:
if other_item_id != item_id:
k = 1
if item_categories[item_id] == item_categories[
other_item_id]:
k = 0.2
pair_order_count[item_id][other_item_id] += k
logging.debug("building global popular")
popular_pairs = [
c.most_common(1)[0] for c in item_count_by_category.values()
]
most_common = sorted(popular_pairs,
key=lambda pair: pair[1],
reverse=True)[:5]
logging.info(most_common)
logging.debug("building objects")
recs = []
for item_id in pair_order_count:
rec_ids = [
rec_id for rec_id, count in
pair_order_count[item_id].most_common(3)
]
recs.append(
Recommendation(company=company.key,
item_id=item_id,
recommendations=rec_ids))
logging.debug("fetching old rec keys")
old_rec_keys = Recommendation.query(
Recommendation.company == company.key).fetch(keys_only=True)
logging.debug("removing old recs")
ndb.delete_multi(old_rec_keys)
logging.debug("putting new recs")
ndb.put_multi(recs)
logging.debug("finished")
def get(self, company_id):
c = CompanyNew.get_by_id(int(company_id))
platius_logins = [key.id() for key in PlatiusLogin.query().fetch(keys_only=True)]
self.render('company/edit.html', company=c, platius_logins=platius_logins)
def get(self):
login = self.request.get("login")
orgs = get_orgs(login, True)
new_orgs = [org for org in orgs if not CompanyNew.get_by_iiko_id(org["id"])]
self.render('company/create.html', login=login, orgs=new_orgs)