def dict(self):
from models import Client
from models.config.config import config
from methods.rendering import timestamp
item_dicts = [si.get().dict() for si in self.share_items]
if self.recipient_id:
recipient_dict = Client.get(self.recipient_id).dict()
else:
recipient_dict = {}
recipient_dict.update({
'initial_name': self.recipient_name,
'initial_phone': self.recipient_phone
})
sender = Client.get(self.client_id)
sender_dict = sender.dict()
share = Share.get_by_id(self.share_id)
text = u'Дарю тебе подарок в приложении %s! Установи его: %s или введи в нем промо-код %s' % \
(config.APP_NAME, share.channel_urls[0].url, self.promo_code.id())
return {
'items': item_dicts,
'recipient': recipient_dict,
'sender': sender_dict,
'status': self.status,
'sms_text': text,
'created': timestamp(self.created),
'updated': timestamp(self.updated)
}
def dict(self):
from methods.rendering import timestamp
return {
'sender': self.sender.get().dict(),
'created': timestamp(self.created),
'updated': timestamp(self.updated),
'status': self.status
}
def post(self, order_id):
order = self.user.order_by_id(int(order_id))
if order.status != ON_THE_WAY:
self.abort(400)
done_order(order, self.user.namespace)
self.render_json({
"success":
True,
"delivery_time":
timestamp(order.delivery_time),
"actual_delivery_time":
timestamp(order.actual_delivery_time)
})
def post_resto_place_order(resto_company, resto_venue, resto_customer,
auto_client, order, items, gifts, payment_dict,
address, order_uuid):
from methods.proxy.resto.payment_types import REVERSE_PAYMENT_TYPE_MAP
from methods.proxy.resto.company import REVERSE_DELIVERY_TYPE_MAP
path = '/api/venue/%s/order/new' % resto_venue.key.id()
payload = {
'source': 'auto_app',
'id': order_uuid,
'custom_data': '',
'bonus_sum': order.wallet_payment,
'discount_sum': order.init_total_sum - order.total_sum,
'gifts': json.dumps(gifts),
'customer_id': resto_customer.resto_customer_id,
'address': json.dumps(address),
'comment': order.comment,
'binding_id': payment_dict.get('binding_id'),
'alpha_client_id': payment_dict.get('client_id'),
'name': auto_client.name,
'phone': auto_client.tel,
'date': timestamp(order.delivery_time),
'paymentType': REVERSE_PAYMENT_TYPE_MAP[order.payment_type_id],
'items': json.dumps(items),
'sum': order.init_total_sum,
'deliveryType': REVERSE_DELIVERY_TYPE_MAP[order.delivery_type]
}
return _post_request(resto_company, path, payload=payload)
def dict(self, client=None):
logging.info(client)
last_order = None
last_order_timestamp = 0
if client:
last_order = Order.query(Order.client_id == client.key.id()).order(
-Order.date_created).get()
logging.info(last_order)
if last_order:
last_order_timestamp = timestamp(last_order.date_created)
return {
'type': GEO_PUSH_MODULE,
'info': {
'head':
self.head,
'text':
self.text,
'days_without_order':
self.days_without_order,
'days_without_push':
self.days_without_push,
'last_order':
last_order is not None,
'last_order_timestamp':
last_order_timestamp,
'points':
[point.dict(index) for index, point in enumerate(self.points)]
}
}
def dict_with_title(self):
return {
"id": str(self.key.id()),
"title": self.title or "",
"text": self.text,
"start": timestamp(self.start),
"image_url": self.image_url if self.image_url else None
}
def get_orders_info(self, orders, begin, end):
goods_number = 0
order_number = len(orders)
order_sum = 0
client_ids = []
for order in orders:
goods_number += len(order.items)
order_sum += order.sum
if not order.customer.id() in client_ids:
client_ids.append(order.customer.id())
return {
"goods_number": goods_number,
"order_number": order_number,
"order_sum": order_sum,
"client_number": len(client_ids),
"begin": timestamp(begin),
"end": timestamp(end - timedelta(minutes=1))
}
def dict_old(self):
text = self.text
if self.title:
text = u"{0}\n{1}".format(self.title, self.text)
return {
"id": str(self.key.id()),
"text": text,
"start": timestamp(self.start),
"image_url": self.image_url if self.image_url else None
}
def _get_orders_info(orders, begin, end):
def _add(dct, order):
dct['order_number'] += 1
dct['goods_number'] += len(order.item_details)
dct['gift_number'] += len(order.gift_details) + len(
order.order_gift_details)
dct['order_sum'] += order.total_sum - order.wallet_payment
if not order.client_id in dct['client_ids']:
dct['client_ids'].append(order.client_id)
def make_dict():
return {
'goods_number': 0,
'order_number': 0,
'order_sum': 0,
'gift_number': 0,
'client_ids': []
}
ios = make_dict()
android = make_dict()
all = make_dict()
for order in orders:
_add(all, order)
if order.device_type == IOS_DEVICE:
_add(ios, order)
elif order.device_type == ANDROID_DEVICE:
_add(android, order)
ios['client_number'] = len(ios['client_ids'])
android['client_number'] = len(android['client_ids'])
all['client_number'] = len(all['client_ids'])
return {
"android": android,
"ios": ios,
"all": all,
"begin": timestamp(begin),
"end": timestamp(end - timedelta(minutes=1))
}
def get(self):
now = datetime.utcnow()
timestamp_from = self.request.get_range("timestamp")
time = datetime.fromtimestamp(timestamp_from)
orders = self.user.query_orders(Order.updated >= time).fetch()
new = [order for order in orders if order.date_created > time]
updated = [order for order in orders if order.date_created <= time]
self.render_json({
"new_orders": [o.dict() for o in new],
"updated_orders": [o.dict() for o in updated],
"timestamp": timestamp(now)
})
def get(self):
now = datetime.datetime.utcnow()
timestamp_from = self.request.get_range("timestamp")
time = datetime.datetime.fromtimestamp(timestamp_from)
orders = self.user.query_orders(Order.updated >= time).fetch()
new = [order for order in orders if order.date_created > time]
updated = [order for order in orders if order.date_created <= time]
self.render_json({
"new_orders": [o.dict(extra_fields_in_comment=self._is_android_barista_app) for o in new],
"updated": [o.dict(extra_fields_in_comment=self._is_android_barista_app) for o in updated],
"timestamp": timestamp(now)
})
def send(self, new_time=None, silent=False):
"""Sends notification to selected namespaces
:param new_time: optional param to set time to send notification. If not specified sets to None
:param silent
"""
if new_time:
self.data['timestamp'] = timestamp(new_time)
self.data['time_str'] = self.order.delivery_time_str
if silent:
self.data['content-available'] = 1
return super(OrderPush, self)._send_push()
def post(self, order_id):
order = self.user.order_by_id(int(order_id))
if order.status not in [NEW_ORDER, CONFIRM_ORDER]:
self.abort(400)
if order.status == NEW_ORDER and (order.delivery_type
in [DELIVERY, PICKUP]
and config.APP_KIND == AUTO_APP):
return self.render_error(u'Необходимо сначала подтвердить заказ')
try:
done_order(order, self.user.namespace)
except Exception as e:
send_error('Close error', 'Barista error in closing order', str(e))
return self.render_error(
u'Непредвиденная ошибка! Повторите позднее! Не отменяйте заказ, если он уже оплачен!'
)
self.render_json({
"success":
True,
"delivery_time":
timestamp(order.delivery_time),
"actual_delivery_time":
timestamp(order.actual_delivery_time)
})
def _send_push(self):
from models.config.config import config
logging.debug(
"data:{}, dev_type: {}, parsekey: {}, parserest: {}".format(
self.data, self.device_type, config.PARSE_APP_API_KEY,
config.PARSE_REST_API_KEY))
if not self.data or self.device_type not in DEVICE_CHOICES or not config.PARSE_APP_API_KEY or not config.PARSE_REST_API_KEY:
logging.warning(
u'Невозможно послать уведомление, data=%s, device_type=%s' %
(self.data, self.device_type))
return
payload = {
'channels':
self.channels,
'type':
DEVICE_TYPE_MAP[self.device_type],
'expiry':
timestamp(datetime.datetime.utcnow() +
datetime.timedelta(days=365)),
'data':
self.data,
}
headers = {
'Content-Type': 'application/json',
'X-Parse-Application-Id': config.PARSE_APP_API_KEY,
'X-Parse-REST-API-Key': config.PARSE_REST_API_KEY
}
logging.debug(headers)
try:
result = json.loads(
urlfetch.fetch('https://api.parse.com/1/push',
payload=json.dumps(payload),
method='POST',
headers=headers,
validate_certificate=False,
deadline=10).content)
logging.info(result)
if result and (result.get('code') or result.get('error')):
text = u'Namespace = %s\nCode = %s, Error = %s' % (
namespace_manager.get_namespace(), result.get('code'),
result.get('error'))
send_error('push', u'Ошибка Parse', text)
except Exception as e:
text = str(e)
send_error('push', u'Parse упал', text)
result = None
return result
def get_time_zone(lat, lon):
params = {
'location': '%s,%s' % (lat, lon),
'timestamp': timestamp(datetime.utcnow()),
'key': API_KEY
}
url = '%s?%s' % (BASE_URL, urllib.urlencode(params))
logging.info(url)
response = urlfetch.fetch(url)
response = json.loads(response.content)
if response.get('status') == 'OK':
return {
'offset': response['rawOffset'] / 3600,
'name': response['timeZoneId']
}
def history_dict(self):
dct = self.status_dict()
if self.delivery_slot_id > 0:
delivery_slot = DeliverySlot.get_by_id(self.delivery_slot_id)
else:
delivery_slot = None
gifts = self.grouped_item_dict(self.gift_details, gift=True)
gifts.extend(self.grouped_item_dict(self.order_gift_details))
venue = Venue.get(self.venue_id)
dct.update({
"delivery_type":
self.delivery_type,
"address":
self.address.dict() if self.address else None,
"delivery_time":
timestamp(self.delivery_time) if self.delivery_time else 0,
"delivery_time_str":
self.delivery_time_str,
"delivery_slot":
delivery_slot.dict() if delivery_slot else None,
"delivery_slot_str":
delivery_slot.name if delivery_slot
and delivery_slot.slot_type == DeliverySlot.STRINGS else None,
"payment_type_id":
self.payment_type_id,
"total":
self.total_sum,
"menu_sum":
sum([
item_detail.price / 100.0 for item_detail in self.item_details
]),
"wallet_payment":
self.wallet_payment,
"delivery_sum":
self.delivery_sum,
"venue_id":
str(self.venue_id),
"venue":
None if not venue else venue.admin_dict(),
"items":
self.grouped_item_dict(self.item_details),
"gifts":
gifts
})
return dct
def get(self):
venue = self.venue_or_error
orders = self._get_orders()
if not venue:
for order in orders:
order.comment += u' Точка: %s' % Venue.get(
order.venue_id).title
dct = {
'orders': [
order.dict(
extra_fields_in_comment=self._is_android_barista_app)
for order in orders if order.status != CREATING_ORDER
]
}
if self._with_timestamp:
dct['timestamp'] = timestamp(datetime.datetime.utcnow())
self.render_json(dct)
def post_resto_check_order(resto_company, venue, resto_item_dicts, auto_client,
resto_client, total_sum, delivery_time,
delivery_type):
from methods.proxy.resto.company import REVERSE_DELIVERY_TYPE_MAP
path = '/api/get_order_promo'
payload = {
'venue_id': venue.key.id(),
'phone': auto_client.tel,
'customer_id': resto_client.key.id() if resto_client else None,
'sum': total_sum,
'date': timestamp(delivery_time),
'items': json.dumps(resto_item_dicts),
'deliveryType': REVERSE_DELIVERY_TYPE_MAP[delivery_type]
}
return _post_request(resto_company, path, payload=payload)
def get(self):
last_time = int(self.request.get('last_time'))
start = datetime.fromtimestamp(last_time)
orders = Order.query(Order.delivery_type == DELIVERY, Order.status.IN(NOT_CANCELED_STATUSES),
Order.date_created > start)\
.order(-Order.date_created).fetch()
orders = _update_order_info(orders)
if orders:
last_time = timestamp(orders[0].date_created) + 1
self.render_json({
'orders': [
_order_delivery_dict(order, Client.get(order.client_id))
for order in orders
],
'last_time':
last_time
})
def dict(self, extra_fields_in_comment=True):
dct = self.history_dict()
client = Client.get(self.client_id)
dct.update({
"total_sum":
self.total_sum,
"actual_delivery_time":
timestamp(self.actual_delivery_time)
if self.actual_delivery_time else None,
"client":
client.dict(with_extra_fields=not extra_fields_in_comment),
"pan":
self.pan,
"comment":
self.get_comment(client, extra_fields=extra_fields_in_comment),
"return_comment":
self.return_comment
})
if not extra_fields_in_comment:
from models.config.config import config
from methods.rendering import latinize
extra = []
if config.ORDER_MODULE and config.ORDER_MODULE.status == STATUS_AVAILABLE:
for field in config.ORDER_MODULE.extra_fields:
key = latinize(field.title)
value = self.extra_data and self.extra_data.get(key)
extra.append({
"field": key,
"title": field.title,
"value": value
})
if config.ORDER_MODULE.enable_number_of_people:
extra.append({
"field": "num_people",
"title": u"Количество персон",
"value": self.extra_data.get('num_people')
})
if config.ORDER_MODULE.enable_change:
extra.append({
"field": "cash_change",
"title": u"Сдача с",
"value": self.extra_data.get('cash_change')
})
dct["extra_data"] = extra
return dct
def get(self):
orders = Order.query(Order.delivery_type == DELIVERY, Order.status.IN(NOT_CANCELED_STATUSES))\
.order(-Order.date_created).fetch()
orders = _update_order_info(orders)
proxy_statuses = []
for status in NOT_CANCELED_STATUSES:
proxy_statuses.append({
'value': status,
'name': STATUS_MAP[status]
})
if orders:
last_time = timestamp(orders[0].date_created) + 1
else:
last_time = 0
self.render(
'/delivery/orders.html', **{
'last_time': last_time,
'orders': orders,
'statuses': proxy_statuses,
'status_new': NEW_ORDER,
'status_confirmed': CONFIRM_ORDER,
'status_closed': READY_ORDER,
'status_cancelled': CANCELED_BY_BARISTA_ORDER
})
def _get_filename(model_name, id, uniq):
tmstmp = timestamp(datetime.utcnow())
return '/%s/%s/%s/%s/%s/%s' % (_BUCKET, namespace_manager.get_namespace(),
model_name, id, uniq, tmstmp)
def get(self):
orders = self._get_orders()
dct = {'orders': [order.dict() for order in orders if order.status != CREATING_ORDER]}
if self._with_timestamp:
dct['timestamp'] = timestamp(datetime.datetime.utcnow())
self.render_json(dct)