def common_new_chat_message(parent_message_key, message_key, sender, message, answers, timestamp, tag, service_identity,
attachments):
if tag and tag.startswith(POKE_TAG_INBOX_FORWARDING_REPLY):
info = json.loads(tag[len(POKE_TAG_INBOX_FORWARDING_REPLY):])
message_key = info['message_key']
sim_parent = SolutionInboxMessage.get(reconstruct_key(db.Key(message_key)))
if sim_parent.awaiting_first_message:
sim_parent.awaiting_first_message = False
sim_parent.put()
else:
service_user = sim_parent.service_user
sln_settings = get_solution_settings(service_user)
sent_by_service = True
if sim_parent.sender.email == sender.email and sim_parent.sender.app_id == sender.app_id:
sent_by_service = False
picture_attachments = []
video_attachments = []
for a in attachments:
if a.content_type.startswith("image"):
picture_attachments.append(a.download_url)
if a.content_type.startswith("video"):
video_attachments.append(a.download_url)
if sent_by_service:
sim_parent, _ = add_solution_inbox_message(service_user, message_key, sent_by_service, [sender], timestamp, message, picture_attachments, video_attachments, mark_as_unread=False, mark_as_read=True)
else:
sim_parent, _ = add_solution_inbox_message(service_user, message_key, sent_by_service, [sender], timestamp, message, picture_attachments, video_attachments)
sln_i_settings = get_solution_settings_or_identity_settings(sln_settings, service_identity)
send_message(service_user, u"solutions.common.messaging.update",
service_identity=service_identity,
message=serialize_complex_value(SolutionInboxMessageTO.fromModel(sim_parent, sln_settings, sln_i_settings, True), SolutionInboxMessageTO, False))
member_sender_user = create_app_user_by_email(sim_parent.sender.email, sim_parent.sender.app_id)
sln_i_settings = get_solution_settings_or_identity_settings(sln_settings, service_identity)
members = [MemberTO.from_user(users.User(f)) for f in sln_i_settings.inbox_forwarders]
if member_sender_user.email() not in sln_i_settings.inbox_forwarders:
members.append(MemberTO.from_user(member_sender_user))
users.set_user(service_user)
try:
messaging.add_chat_members(sim_parent.message_key, members)
finally:
users.clear_user()
else:
raise NotImplementedError()
def new_inbox_message(sln_settings,
message,
parent_chat_key=None,
service_identity=None,
**kwargs):
service_identity = service_identity or ServiceIdentity.DEFAULT
service_user = sln_settings.service_user
language = sln_settings.main_language
si = get_service_identity(
create_service_identity_user(service_user, service_identity))
user_details = UserDetailsTO.create(service_user.email(), si.name,
language, si.avatarUrl, si.app_id)
if not parent_chat_key:
category = kwargs.get('category')
category_key = kwargs.get('category_key')
reply_enabled = kwargs.get('reply_enabled', False)
message = create_solution_inbox_message(service_user, service_identity,
category, category_key, True,
[user_details], now(), message,
reply_enabled)
else:
message, _ = add_solution_inbox_message(service_user, parent_chat_key,
False, [user_details], now(),
message, **kwargs)
return message
def send_message_for_pharmacy_order(service_user, order_key, order_status, message):
from solutions.common.bizz.messaging import send_inbox_forwarders_message
azzert(order_status in SolutionPharmacyOrder.ORDER_STATUSES)
def txn():
m = SolutionPharmacyOrder.get(order_key)
azzert(service_user == m.service_user)
if m.status == SolutionPharmacyOrder.STATUS_RECEIVED and m.status != order_status:
m.status = order_status
m.put()
return m
order = db.run_in_transaction(txn)
sm_data = []
sm_data.append({u"type": u"solutions.common.pharmacy_orders.update"})
sln_settings = get_solution_settings(service_user)
if message:
if order.solution_inbox_message_key:
sim_parent, _ = add_solution_inbox_message(
service_user, order.solution_inbox_message_key, True, None, now(), message, mark_as_unread=False, mark_as_read=True)
send_inbox_forwarders_message(service_user, sim_parent.service_identity, None, message, {
'if_name': sim_parent.sender.name,
'if_email': sim_parent.sender.email
}, message_key=sim_parent.solution_inbox_message_key, reply_enabled=sim_parent.reply_enabled)
sln_i_settings = get_solution_settings_or_identity_settings(sln_settings, order.service_identity)
sm_data.append({u"type": u"solutions.common.messaging.update",
u"message": serialize_complex_value(SolutionInboxMessageTO.fromModel(sim_parent, sln_settings, sln_i_settings, True), SolutionInboxMessageTO, False)})
else:
sln_main_branding = get_solution_main_branding(service_user)
branding = sln_main_branding.branding_key if sln_main_branding else None
member = MemberTO()
member.alert_flags = Message.ALERT_FLAG_VIBRATE
member.member = order.sender.email
member.app_id = order.sender.app_id
messaging.send(parent_key=None,
parent_message_key=None,
message=message,
answers=[],
flags=Message.FLAG_ALLOW_DISMISS,
members=[member],
branding=branding,
tag=None,
service_identity=order.service_identity)
elif order.solution_inbox_message_key:
sim_parent = SolutionInboxMessage.get(order.solution_inbox_message_key)
if not sim_parent.read:
sim_parent.read = True
sim_parent.put()
deferred.defer(update_user_data_admins, service_user, order.service_identity)
sln_i_settings = get_solution_settings_or_identity_settings(sln_settings, order.service_identity)
sm_data.append({u"type": u"solutions.common.messaging.update",
u"message": serialize_complex_value(SolutionInboxMessageTO.fromModel(sim_parent, sln_settings, sln_i_settings, True), SolutionInboxMessageTO, False)})
send_message(service_user, sm_data, service_identity=order.service_identity)
def delete_sandwich_order(service_user, service_identity, sandwich_id, message):
from solutions.common.bizz.messaging import send_inbox_forwarders_message
sln_settings = get_solution_settings(service_user)
def txn():
m = SandwichOrder.get_by_order_id(service_user, service_identity, sln_settings.solution, sandwich_id)
azzert(service_user == m.service_user)
m.deleted = True
m.put()
return m
xg_on = db.create_transaction_options(xg=True)
sandwich_order = db.run_in_transaction_options(xg_on, txn)
sm_data = [{u"type": u"solutions.common.sandwich.orders.deleted", u'sandwich_id': sandwich_id}]
if message:
if sandwich_order.solution_inbox_message_key:
sim_parent, _ = add_solution_inbox_message(service_user, sandwich_order.solution_inbox_message_key, True, None, now(), message, mark_as_unread=False, mark_as_read=True, mark_as_trashed=True)
send_inbox_forwarders_message(service_user, sim_parent.service_identity, None, message, {
'if_name': sim_parent.sender.name,
'if_email':sim_parent.sender.email
}, message_key=sim_parent.solution_inbox_message_key, reply_enabled=sim_parent.reply_enabled)
sln_i_settings = get_solution_settings_or_identity_settings(sln_settings, sandwich_order.service_identity)
sm_data.append({u"type": u"solutions.common.messaging.update",
u"message": serialize_complex_value(SolutionInboxMessageTO.fromModel(sim_parent, sln_settings, sln_i_settings, True), SolutionInboxMessageTO, False)})
else:
branding = get_solution_main_branding(service_user).branding_key
member = MemberTO()
member.alert_flags = Message.ALERT_FLAG_VIBRATE
member.member = sandwich_order.sender.email
member.app_id = sandwich_order.sender.app_id
messaging.send(parent_key=None,
parent_message_key=None,
message=message,
answers=[],
flags=Message.FLAG_ALLOW_DISMISS,
members=[member],
branding=branding,
tag=None,
service_identity=sandwich_order.service_identity)
elif sandwich_order.solution_inbox_message_key:
sim_parent = SolutionInboxMessage.get(sandwich_order.solution_inbox_message_key)
if not sim_parent.trashed and not sim_parent.deleted:
sim_parent.trashed = True
sim_parent.put()
deferred.defer(update_user_data_admins, service_user, sandwich_order.service_identity)
sln_i_settings = get_solution_settings_or_identity_settings(sln_settings, sandwich_order.service_identity)
sm_data.append({u"type": u"solutions.common.messaging.update",
u"message": serialize_complex_value(SolutionInboxMessageTO.fromModel(sim_parent, sln_settings, sln_i_settings, True), SolutionInboxMessageTO, False)})
send_message(service_user, sm_data, service_identity=sandwich_order.service_identity)
def _send_event_notification(sln_settings, service_user, service_identity,
user_details, event, event_guest):
from solutions.common.bizz.messaging import send_inbox_forwarders_message
status = translate(sln_settings.main_language, SOLUTION_COMMON,
event_guest.status_str)
status_message = translate(sln_settings.main_language,
SOLUTION_COMMON,
u'events_status_notification',
status=status,
event=event.title)
create_chat = True
if event_guest.chat_key:
create_chat = SolutionInboxMessage.get(event_guest.chat_key) is None
if create_chat:
event_key = unicode(event.key())
message = create_solution_inbox_message(
service_user, service_identity,
SolutionInboxMessage.CATEGORY_AGENDA, event_key, False,
user_details, now(), status_message, True)
event_guest.chat_key = message.solution_inbox_message_key
event_guest.put()
app_user = user_details[0].toAppUser()
else:
message, _ = add_solution_inbox_message(service_user,
event_guest.chat_key, False,
user_details, now(),
status_message)
app_user = None
send_inbox_forwarders_message(
service_user,
service_identity,
app_user,
status_message, {
'if_name': user_details[0].name,
'if_email': user_details[0].email
},
message_key=message.solution_inbox_message_key,
reply_enabled=message.reply_enabled,
send_reminder=False)
# show as last message
sln_i_settings = get_solution_settings_or_identity_settings(
sln_settings, service_identity)
message_to = SolutionInboxMessageTO.fromModel(message, sln_settings,
sln_i_settings, True)
send_message(service_user,
u'solutions.common.messaging.update',
service_identity=service_identity,
message=serialize_complex_value(message_to,
SolutionInboxMessageTO,
False))
def reply_sandwich_order(service_user, service_identity, sandwich_id, message=unicode):
from solutions.common.bizz.messaging import send_inbox_forwarders_message
sln_settings = get_solution_settings(service_user)
sandwich_order = SandwichOrder.get_by_order_id(service_user, service_identity, sln_settings.solution, sandwich_id)
azzert(service_user == sandwich_order.service_user)
sandwich_order.status = SandwichOrder.STATUS_REPLIED
sandwich_order.put()
sm_data = []
sm_data.append({u"type": u"solutions.common.sandwich.orders.update"})
if sandwich_order.solution_inbox_message_key:
sim_parent, _ = add_solution_inbox_message(service_user, sandwich_order.solution_inbox_message_key, True, None, now(), message, mark_as_unread=False, mark_as_read=True)
send_inbox_forwarders_message(service_user, sim_parent.service_identity, None, message, {
'if_name': sim_parent.sender.name,
'if_email':sim_parent.sender.email
}, message_key=sim_parent.solution_inbox_message_key, reply_enabled=sim_parent.reply_enabled)
sln_i_settings = get_solution_settings_or_identity_settings(sln_settings, sandwich_order.service_identity)
sm_data.append({u"type": u"solutions.common.messaging.update",
u"message": serialize_complex_value(SolutionInboxMessageTO.fromModel(sim_parent, sln_settings, sln_i_settings, True), SolutionInboxMessageTO, False)})
else:
sln_main_branding = get_solution_main_branding(service_user)
branding = sln_main_branding.branding_key if sln_main_branding else None
member = MemberTO()
member.alert_flags = Message.ALERT_FLAG_VIBRATE
member.member = sandwich_order.sender.email
member.app_id = sandwich_order.sender.app_id
messaging.send(parent_key=None,
parent_message_key=None,
message=message,
answers=[],
flags=Message.FLAG_ALLOW_DISMISS,
members=[member],
branding=branding,
tag=None,
service_identity=sandwich_order.service_identity)
send_message(service_user, sm_data, service_identity=sandwich_order.service_identity)
def trans():
sm_data = []
if sln_loyalty_lottery.winner_timestamp != 0:
logging.debug("loyalty lottery loot: update winner %s",
sln_loyalty_lottery.winner)
sim_parent, _ = add_solution_inbox_message(
service_user,
sln_loyalty_lottery.solution_inbox_message_key,
True,
None,
now_,
msg_sorry,
mark_as_read=True)
if sim_parent.message_key_by_tag:
message_key_by_tag = json.loads(sim_parent.message_key_by_tag)
if message_key_by_tag.get(u"loyalty_lottery_loot", None):
deferred.defer(_messaging_seal,
service_user,
message_key_by_tag[u"loyalty_lottery_loot"],
sim_parent.message_key,
sim_parent.message_key,
1,
_transactional=True)
send_inbox_forwarders_message(
service_user,
service_identity,
None,
msg_sorry, {
'if_name': user_detail.name,
'if_email': user_detail.email
},
message_key=sim_parent.solution_inbox_message_key,
reply_enabled=sim_parent.reply_enabled,
send_reminder=False)
deferred.defer(send_email_to_user_for_loyalty_update, service_user,
service_identity, sln_loyalty_lottery.winner,
msg_sorry, False)
sm_data.append({
u"type":
u"solutions.common.messaging.update",
u"message":
serialize_complex_value(
SolutionInboxMessageTO.fromModel(sim_parent, sln_settings,
sln_i_settings, True),
SolutionInboxMessageTO, False)
})
logging.debug("loyalty lottery loot: new winner %s", winner)
sim_parent = create_solution_inbox_message(
service_user,
service_identity,
SolutionInboxMessage.CATEGORY_LOYALTY,
unicode(sln_loyalty_lottery_key),
True, [user_detail],
now_,
msg_ok,
True,
mark_as_read=True)
sln_loyalty_lottery.solution_inbox_message_key = sim_parent.solution_inbox_message_key
if sln_loyalty_lottery.winner:
if not sln_loyalty_lottery.skip_winners:
sln_loyalty_lottery.skip_winners = []
sln_loyalty_lottery.skip_winners.append(sln_loyalty_lottery.winner)
sln_loyalty_lottery.pending = False
sln_loyalty_lottery.winner = winner
sln_loyalty_lottery.winner_info = SolutionUser.fromTO(
user_detail) if user_detail else None
sln_loyalty_lottery.winner_timestamp = now_
sln_loyalty_lottery.put()
send_inbox_forwarders_message(
service_user,
service_identity,
None,
msg_ok, {
'if_name': user_detail.name,
'if_email': user_detail.email
},
message_key=sim_parent.solution_inbox_message_key,
reply_enabled=sim_parent.reply_enabled,
send_reminder=False,
answers=[btn],
store_tag=u"loyalty_lottery_loot",
flags=message_flags)
deferred.defer(send_email_to_user_for_loyalty_update, service_user,
service_identity, sln_loyalty_lottery.winner, msg_ok,
False, sim_parent.solution_inbox_message_key)
sm_data.append({
u"type":
u"solutions.common.messaging.update",
u"message":
serialize_complex_value(
SolutionInboxMessageTO.fromModel(sim_parent, sln_settings,
sln_i_settings, True),
SolutionInboxMessageTO, False)
})
sm_data.append({u"type": u"solutions.common.loyalty.lottery.update"})
send_message(service_user, sm_data, service_identity=service_identity)
deferred.defer(_continue,
service_user,
service_identity,
sln_loyalty_lottery_key,
_transactional=True)
