def set_avatar(service_user, image):
logging.info('%s: Saving avatar' % service_user.email())
_meta, img_b64 = image.split(',')
jpg_bytes = base64.b64decode(img_b64)
def trans():
avatar_key = SolutionAvatar.create_key(service_user)
avatar, branding_settings, sln_settings = db.get(
(avatar_key, SolutionBrandingSettings.create_key(service_user),
SolutionSettings.create_key(service_user)))
avatar = avatar or SolutionAvatar(key=avatar_key)
avatar.picture = db.Blob(jpg_bytes)
avatar.published = False
avatar.is_default = False
to_put = [avatar, sln_settings]
sln_settings.updates_pending = True
if branding_settings:
branding_settings.modification_time = now()
to_put.append(branding_settings)
put_and_invalidate_cache(*to_put)
return sln_settings
sln_settings = run_in_transaction(trans, xg=True)
send_message(sln_settings.service_user,
'solutions.common.settings.avatar.updated')
broadcast_updates_pending(sln_settings)
def edit_city_wide_lottery_info(key, winnings, date, x_winners):
ll_info_edit = SolutionCityWideLottery.get(key)
if not ll_info_edit:
return RETURNSTATUS_TO_SUCCESS
service_user = users.get_current_user()
sln_settings = get_solution_settings(service_user)
try:
now_ = now()
end_timestamp = date.toEpoch()
if end_timestamp <= (now_ + 24 * 3600):
raise BusinessException("end-date-24h-in-future")
ll_info = SolutionCityWideLottery.load_pending(ll_info_edit.app_id)
if ll_info_edit.key() != ll_info.key() and end_timestamp <= ll_info.end_timestamp:
raise BusinessException("lottery-time-bigger-first-upcoming")
ll_info_edit.end_timestamp = end_timestamp
ll_info_edit.schedule_loot_time = ll_info_edit.end_timestamp - 24 * 3600
ll_info_edit.winnings = winnings
ll_info_edit.x_winners = x_winners
ll_info_edit.put()
send_message(service_user, u"solutions.common.loyalty.lottery.update")
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
return ReturnStatusTO.create(False, common_translate(sln_settings.main_language, SOLUTION_COMMON, e.message))
def add_city_wide_lottery_info(city_app_id, winnings, date, x_winners):
service_user = users.get_current_user()
sln_settings = get_solution_settings(service_user)
try:
now_ = now()
end_timestamp = date.toEpoch()
if end_timestamp <= (now_ + 24 * 3600):
raise BusinessException("end-date-24h-in-future")
ll_info = SolutionCityWideLottery.load_pending(city_app_id)
if ll_info:
logging.warn("end_timestamp: %s", end_timestamp)
logging.warn("ll_info.end_timestamp: %s", ll_info.end_timestamp)
if end_timestamp <= ll_info.end_timestamp:
raise BusinessException("lottery-time-bigger-first-upcoming")
ll_info = SolutionCityWideLottery(parent=SolutionCityWideLottery.create_parent_key(city_app_id))
ll_info.timestamp = now_
ll_info.end_timestamp = end_timestamp
ll_info.schedule_loot_time = ll_info.end_timestamp - 24 * 3600
ll_info.winnings = winnings
ll_info.x_winners = x_winners
ll_info.winners = []
ll_info.winner_info = []
ll_info.skip_winners = []
ll_info.deleted = False
ll_info.pending = True
ll_info.put()
send_message(service_user, u"solutions.common.loyalty.lottery.update")
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
return ReturnStatusTO.create(False, common_translate(sln_settings.main_language, SOLUTION_COMMON, e.message))
def delete_loyalty_lottery_info(key):
ll_info_delete = SolutionLoyaltyLottery.get(key)
if not ll_info_delete:
return RETURNSTATUS_TO_SUCCESS
service_user = users.get_current_user()
session_ = users.get_current_session()
service_identity = session_.service_identity
sln_settings = get_solution_settings(service_user)
try:
ll_info = SolutionLoyaltyLottery.load_pending(service_user, service_identity)
if ll_info_delete.key() == ll_info.key():
raise RETURNSTATUS_TO_SUCCESS
if ll_info_delete.schedule_loot_time > 0:
ll_info_delete.delete()
sln_settings.updates_pending = True
put_and_invalidate_cache(sln_settings)
broadcast_updates_pending(sln_settings)
send_message(service_user, u"solutions.common.loyalty.lottery.update", service_identity=service_identity)
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
return ReturnStatusTO.create(False, common_translate(sln_settings.main_language, SOLUTION_COMMON, e.message))
def set_logo(service_user, image):
logging.info('%s: Saving logo' % service_user.email())
_meta, img_b64 = image.split(',')
jpg_bytes = base64.b64decode(img_b64)
def trans():
logo = get_solution_logo(service_user) or SolutionLogo(
key=SolutionLogo.create_key(service_user))
logo.picture = db.Blob(jpg_bytes)
logo.is_default = False
settings = get_solution_settings(service_user)
settings.updates_pending = True
put_and_invalidate_cache(logo, settings)
deferred.defer(_regenerate_branding_with_logo,
service_user,
_transactional=True)
return settings
common_settings = run_in_transaction(trans, xg=True)
send_message(common_settings.service_user,
'solutions.common.settings.logo.updated')
broadcast_updates_pending(common_settings)
def trans():
voucher_ancestor_key = SolutionCityVoucher.create_parent_key(app_id)
vouchers = SolutionCityVoucher.get_by_id(voucher_ids,
voucher_ancestor_key)
to_put = list()
for voucher, qr_detail in zip(vouchers, qr_details):
voucher.image_uri = qr_detail.image_uri
voucher.content_uri = qr_detail.content_uri
_set_search_fields(voucher)
to_put.append(voucher)
history = SolutionCityVoucherTransaction(parent=voucher)
history.created = voucher.created
history.action = SolutionCityVoucherTransaction.ACTION_CREATED
history.value = 0
history.service_user = None
history.service_identity = None
to_put.append(history)
sln_qr_export = db.get(sln_qr_export_key)
sln_qr_export.ready = True
to_put.append(sln_qr_export)
put_in_chunks(to_put)
channel.send_message(
service_user,
'solutions.common.city.vouchers.qrcode_export.updated')
def controller(job_key, current_phase=None, retry_interval=0):
'''Responsible for chaining the different phases'''
job = _get_job(job_key)
logging.debug('MigrateServiceJob phase %s->%s (key %s)', current_phase, job.phase, job_key)
if job.phase == MigrateServiceJob.PHASE_DONE:
logging.info('Migration of %s to %s completed!', job.from_service_user, job.to_service_user)
return
if job.phase == current_phase:
next_retry_interval = min(retry_interval + 1, 5)
else:
worker = PHASES.get(job.phase)
azzert(worker, 'Unexpected job phase: %s' % job.phase)
kwargs = dict(job_key=job_key, _queue=MIGRATION_QUEUE)
deferred.defer(worker, **kwargs)
channel.send_message(job.executor_user, 'rogerthat.jobs.migrate_service.next_phase',
progress=job.estimate_progress(),
phase=job.phase)
next_retry_interval = 1
deferred.defer(controller, job_key, job.phase, next_retry_interval,
_countdown=next_retry_interval, _queue=HIGH_LOAD_CONTROLLER_QUEUE)
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 get(self):
user = users.get_current_user()
self.stop_session()
channel.send_message(user, u'rogerthat.system.logout')
cont = self.request.get('continue')
if cont:
self.redirect('/%s' % cont)
def post(self):
settings = get_server_settings()
secret = self.request.headers.get("X-Nuntiuz-Secret", None)
if secret != settings.jabberSecret:
logging.error(u"Received unauthenticated callback response, ignoring ...")
return
sik = self.request.headers.get("X-Nuntiuz-Service-Key", None)
if not sik:
logging.error(u"Received invalid Callback response without Service Identifier Key")
return
sik = get_sik(sik)
if not sik:
logging.error("Received invalid Callback response with unknown Service Identifier Key:\nsik: %s\nbody:\n%s" % (
self.request.headers.get("X-Nuntiuz-Service-Key", None), self.request.body))
return
users.set_user(sik.user)
raw_result = self.request.body
try:
from google.appengine.api.memcache import get # @UnresolvedImport
if get(sik.user.email() + "_interactive_logs"):
content_type = self.request.headers.get('content-type', 'unknown')
status = self.request.headers.get('X-Nuntiuz-Service-Status', 'unknown')
if status == "600":
status = "unknown"
result_url = self.request.headers.get('X-Nuntiuz-Service-Result-Url', 'unknown')
channel.send_message(sik.user, "rogerthat.service.interactive_logs", content_type=content_type,
status=status, result_url=result_url, body=raw_result.decode('utf-8', 'replace'))
except:
logging.exception("Error during interactive logging.")
try:
result = json.loads(raw_result)
except Exception:
raw_result_unicode = raw_result.decode('utf-8', 'replace')
logging.warning(u"Could not parse request body as JSON!\n" + raw_result_unicode)
error_code = ERROR_CODE_INVALID_JSON
error_message = u"The JSON_RPC response could not be parsed as a valid JSON."
log_service_activity(sik.user, str(time.time()), ServiceLog.TYPE_CALLBACK, ServiceLog.STATUS_ERROR,
None, None, raw_result_unicode, error_code, error_message)
return
raw_result_unicode = json.dumps(privatize(deepcopy(result)), ensure_ascii=False)
logging.info(u"Incoming call back response:\n" + raw_result_unicode)
if not result:
error_code = ERROR_CODE_INVALID_JSON
error_message = u"The JSON_RPC response could not be parsed as a valid json."
log_service_activity(sik.user, None, ServiceLog.TYPE_CALLBACK, ServiceLog.STATUS_ERROR, None, None,
raw_result_unicode, error_code, error_message)
return
from rogerthat.dal import parent_key
service_api_callback = ServiceAPICallback.get_by_key_name(result["id"], parent=parent_key(sik.user))
if not service_api_callback:
logging.warning(u"Service api call back response record not found !")
return
_process_callback_result(sik, result, raw_result_unicode, service_api_callback, True)
def _repair_order_received(service_user, message_flow_run_id, member, steps, end_id, end_message_flow_id, parent_message_key,
tag, result_key, flush_id, flush_message_flow_id, service_identity, user_details):
from solutions.common.bizz.messaging import send_inbox_forwarders_message
logging.info("_flow_member_result_repair_order: \n %s" % steps)
remarks = _get_value(steps[0], u'message_remarks')
if steps[1].answer_id == u"positive":
picture_url = _get_value(steps[1], u'message_picture')
else:
picture_url = None
sln_settings = get_solution_settings(service_user)
logging.info("Saving repair order from %s" % user_details[0].email)
service_identity_user = create_service_identity_user_wo_default(service_user, service_identity)
o = SolutionRepairOrder(parent=parent_key_unsafe(service_identity_user, sln_settings.solution))
o.description = remarks
o.sender = SolutionUser.fromTO(user_details[0])
o.timestamp = steps[1].received_timestamp
o.status = SolutionRepairOrder.STATUS_RECEIVED
o.picture_url = picture_url
o.user = user_details[0].toAppUser() if user_details else None
msg = common_translate(sln_settings.main_language, SOLUTION_COMMON, 'if-repair-order-received',
remarks=remarks)
message = create_solution_inbox_message(service_user, service_identity, SolutionInboxMessage.CATEGORY_REPAIR, None, False, user_details, steps[1].received_timestamp, msg, True, [picture_url] if picture_url else [])
o.solution_inbox_message_key = message.solution_inbox_message_key
o.put()
message.category_key = unicode(o.key())
message.put()
sln_i_settings = get_solution_settings_or_identity_settings(sln_settings, service_identity)
sm_data = []
sm_data.append({u"type": u"solutions.common.repair_orders.update"})
sm_data.append({u"type": u"solutions.common.messaging.update",
u"message": serialize_complex_value(SolutionInboxMessageTO.fromModel(message, sln_settings, sln_i_settings, True), SolutionInboxMessageTO, False)})
send_message(service_user, sm_data, service_identity=service_identity)
attachments = []
if picture_url:
att = AttachmentTO()
att.content_type = AttachmentTO.CONTENT_TYPE_IMG_JPG
att.download_url = picture_url
att.name = common_translate(sln_settings.main_language, SOLUTION_COMMON, u'picture')
att.size = 0
attachments = [att]
app_user = user_details[0].toAppUser()
send_inbox_forwarders_message(service_user, service_identity, app_user, msg, {
'if_name': user_details[0].name,
'if_email':user_details[0].email
}, message_key=message.solution_inbox_message_key, attachments=attachments, reply_enabled=message.reply_enabled)
def twitter_logout(service_user):
sln_settings = get_solution_settings(service_user)
sln_settings.twitter_oauth_token = None
sln_settings.twitter_oauth_token_secret = None
sln_settings.twitter_username = None
put_and_invalidate_cache(sln_settings)
send_message(service_user,
u"solutions.common.twitter.updated",
username=None)
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 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 reset():
db.delete(RogerthatBackendErrors.get_key())
db.delete(list(get_monitored_services_in_trouble_qry()))
server_settings = get_server_settings()
send_to = server_settings.supportWorkers
send_to.append(server_settings.dashboardEmail)
send_message(map(users.User, send_to),
'shop.monitoring.reset',
skip_dashboard_user=False)
return RETURNSTATUS_TO_SUCCESS
def delete_appointment_weekday_timeframe(service_user, appointment_id):
sln_settings = get_solution_settings(service_user)
sawt = SolutionAppointmentWeekdayTimeframe.get_by_id(appointment_id, parent_key(service_user, sln_settings.solution))
if sawt:
sawt.delete()
sln_settings = get_solution_settings(service_user)
sln_settings.updates_pending = True
put_and_invalidate_cache(sln_settings)
broadcast_updates_pending(sln_settings)
send_message(service_user, u"solutions.common.appointment.settings.timeframe.update")
def send_inbox_message_update(sln_settings, message, service_identity=None):
service_user = sln_settings.service_user
sln_i_settings = get_solution_settings_or_identity_settings(
sln_settings, service_identity)
message_to = SolutionInboxMessageTO.fromModel(message, sln_settings,
sln_i_settings, True)
data = serialize_complex_value(message_to, SolutionInboxMessageTO, False)
channel.send_message(service_user,
u'solutions.common.messaging.update',
message=data,
service_identity=service_identity)
def trans():
user_profile = get_user_profile(app_user)
if not user_profile:
logging.info("delete account that does not exists: %s", app_user)
return
friend_map = get_friends_map(app_user)
users.clear_user()
channel.send_message(app_user, u'rogerthat.system.dologout')
deferred.defer(archiveUserDataAfterDisconnect, app_user, friend_map, user_profile, True, _transactional=True)
def solution_add_admin_to_calendar(service_user, email, tag, result_key,
context, service_identity, user_details):
from solutions.common.bizz.messaging import POKE_TAG_EVENTS_CONNECT_VIA_SCAN
info = json.loads(tag[len(POKE_TAG_EVENTS_CONNECT_VIA_SCAN):])
calendar_id = info.get("calendar_id")
if not calendar_id:
return
sln_settings = get_solution_settings(service_user)
app_user = user_details[0].toAppUser()
create_calendar_admin(calendar_id, app_user, service_user,
sln_settings.solution)
send_message(service_user, u"solutions.common.calendar.update")
def trans():
user_profile = get_user_profile(app_user)
if not user_profile:
logging.info("delete account that does not exists: %s", app_user)
return
friend_map = get_friends_map(app_user)
users.clear_user()
channel.send_message(app_user, u'rogerthat.system.dologout')
deferred.defer(archiveUserDataAfterDisconnect, app_user, friend_map, user_profile, True, _transactional=True)
ActivationLog(timestamp=now(), email=app_user.email(),
description='Delete account | %s' % app_user).put()
def get(self):
email = self.request.get("email", None)
data = self.request.get("data", None)
service_identity = self.request.get("si", None)
user = users.get_current_user()
if user:
users.clear_user()
channel.send_message(user, u'rogerthat.system.logout')
if not email or not data:
logging.warn("not al params received for email: %s and data: %s" % (email, data))
self.redirect("/")
return
try:
data, _ = self.parse_data(email, data)
except:
logging.warn("Could not decipher url! email: %s and data: %s" % (email, data) , exc_info=True)
self.redirect("/")
return
user = users.User(email)
profile = get_service_or_user_profile(user)
if not profile:
logging.warn("profile not found for email: %s" % email)
self.redirect("/")
return
try:
secret, _ = create_session(user, service_identity=service_identity)
except ServiceExpiredException:
return self.redirect('/service_disabled')
server_settings = get_server_settings()
set_cookie(self.response, server_settings.cookieSessionName, secret)
clear_rate_login(user)
update_user_profile_language_from_headers(profile, self.response.headers)
params = self.request.GET
redirect_url = '/'
if params:
params = dict((k, v.decode('utf8')) for k, v in params.iteritems())
del params['email']
del params['data']
if "si" in params:
del params['si']
redirect_url = "%s?%s" % (redirect_url, urllib.urlencode(params))
logging.info("Redirecting to url: %s" % redirect_url)
self.redirect(redirect_url)
def check_i18n_status_of_message_flows(service_user):
from rogerthat.bizz.service.mfd import render_xml_for_message_flow_design
def trans():
translator = get_translator(service_user)
mfds = get_multilanguage_message_flow_designs_by_status(service_user, MessageFlowDesign.STATUS_VALID)
for mfd in mfds:
render_xml_for_message_flow_design(mfd, translator, dict())
put_and_invalidate_cache(*mfds)
run_in_transaction(trans, xg=True)
channel.send_message(service_user, u'rogerthat.mfd.changes')
def _delete_static_content(service_user, static_content_id):
sln_settings, sc = db.get(
(SolutionSettings.create_key(service_user),
SolutionStaticContent.create_key(service_user, static_content_id)))
def trans():
sc.provisioned = False
sc.deleted = True
sln_settings.updates_pending = True
db.put([sln_settings, sc])
return sln_settings
sln_settings = run_in_transaction(trans, True)
send_message(service_user, u"solutions.common.service_menu.updated")
broadcast_updates_pending(sln_settings)
def close_city_wide_lottery_info(key):
service_user = users.get_current_user()
try:
ll_info = SolutionCityWideLottery.get(key)
if ll_info and not ll_info.pending and not ll_info.deleted:
ll_info.deleted = True
ll_info.put()
send_message(service_user, u"solutions.common.loyalty.lottery.update",
service_identity=ll_info.service_identity)
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
sln_settings = get_solution_settings(service_user)
return ReturnStatusTO.create(False, common_translate(sln_settings.main_language, SOLUTION_COMMON, e.message))
def _trigger_update_friend(target_user, friend_map_or_key, profile_info_or_key):
profile_info = db.get(profile_info_or_key) if isinstance(profile_info_or_key, db.Key) else profile_info_or_key
logging.info("Sending out updates for %s (%s)", profile_info.name, profile_info.user.email())
friendTO = send_update_friend_request(target_user, profile_info.user, UpdateFriendRequestTO.STATUS_MODIFIED,
friend_map_or_key)
if friendTO:
if profile_info.isServiceIdentity:
# Send update request over channel API
friend_dict = serialize_complex_value(friendTO, FriendTO, False)
# Preventing "InvalidMessageError: Message must be no longer than 32767 chars"
del friend_dict['appData']
del friend_dict['userData']
channel.send_message(target_user, u'rogerthat.friends.update',
friend=friend_dict)
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 bulk_invite_result(service_user, service_identity, tag, email, result, user_details):
if not tag:
logging.exception("Expected tag in bulk_invite_result")
return
if tag in (SERVICE_AUTOCONNECT_INVITE_TAG, APP_BROADCAST_TAG):
return
try:
key = db.Key(tag)
except db.BadKeyError:
logging.info('Tag is no db.Key: %s. Ignoring...', tag)
return
def trans():
invite = db.get(reconstruct_key(key))
if not invite:
logging.error("Invite object not found in datastore")
return
save_message = False
if "accepted" == result:
invite.status = RestaurantInvite.STATUS_ACCEPTED
save_message = True
else:
invite.status = RestaurantInvite.STATUS_REJECTED
invite.put()
return save_message
save_message = run_in_xg_transaction(trans)
if save_message:
now_ = now()
sln_settings = get_solution_settings(service_user)
msg = common_translate(sln_settings.main_language, SOLUTION_COMMON, 'if-accepted-invitation',
if_name=user_details[0].name,
if_email=user_details[0].email)
message = create_solution_inbox_message(
service_user, service_identity, SolutionInboxMessage.CATEGORY_BULK_INVITE, None, False, user_details, now_, msg, False)
app_user = create_app_user_by_email(user_details[0].email, user_details[0].app_id)
send_inbox_forwarders_message(service_user, service_identity, app_user, msg, {
'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)
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(message, sln_settings, sln_i_settings, True), SolutionInboxMessageTO, False))
def saveSettings(request):
mobile = users.get_current_mobile()
db_settings = MobileSettings.get(mobile)
db_settings.recordPhoneCalls = request.callLogging
db_settings.geoLocationTracking = request.tracking
db_settings.timestamp = int(time.time())
db_settings.version += 1
db_settings.put()
response = SaveSettingsResponse()
response.settings = SettingsTO.fromDBSettings(db_settings, get_app_settings(users.get_current_app_id()))
channel.send_message(
users.get_current_user(),
u'rogerthat.settings.update',
mobile_id=mobile.id)
return response
def post(self):
max_upload_size_mb = 5
max_upload_size = max_upload_size_mb * 1048576 # 1 MB
service_user = get_current_user()
sln_settings = get_solution_settings(service_user)
name = unicode(self.request.get("name"))
logging.info('%s uploads an attachment for broadcasting',
service_user.email())
uploaded_file = self.request.POST.get(
'attachment-files') # type: FieldStorage
try:
if not isinstance(uploaded_file, FieldStorage):
raise BusinessException(
translate(sln_settings.main_language, SOLUTION_COMMON,
'please_select_attachment'))
file_content = uploaded_file.value
if len(file_content) > max_upload_size:
raise BusinessException(
translate(sln_settings.main_language,
SOLUTION_COMMON,
'attachment_too_big',
max_size=max_upload_size_mb))
content_type = uploaded_file.type
if content_type not in AttachmentTO.CONTENT_TYPES:
raise BusinessException(
translate(sln_settings.main_language, SOLUTION_COMMON,
'attachment_must_be_of_type'))
date = datetime.datetime.now().strftime('%Y-%m-%d_%H:%M:%S')
filename = '%s/news/%s/%s_%s' % (ROGERTHAT_ATTACHMENTS_BUCKET,
service_user.email(), date,
uploaded_file.filename)
blob_key = upload_to_gcs(file_content, content_type, filename)
logging.debug('blob key: %s', blob_key)
filename = '/'.join(map(urllib.quote, filename.split('/')))
channel.send_message(
service_user,
'solutions.common.broadcast.attachment.upload.success',
url=get_serving_url(filename),
name=name)
except BusinessException as ex:
channel.send_message(
service_user,
'solutions.common.broadcast.attachment.upload.failed',
message=ex.message)
def _check_reservation(reservation_key, shifts, service_user,
service_identity):
def trans():
reservation = db.get(reservation_key)
if is_flag_set(RestaurantReservation.STATUS_CANCELED,
reservation.status) or is_flag_set(
RestaurantReservation.STATUS_DELETED,
reservation.status):
return False
current_start = reservation.shift_start.hour * 3600 + reservation.shift_start.minute * 60
for shift in shifts:
if not reservation.date.isoweekday() in shift.days:
continue
if current_start == shift.start:
if is_flag_set(RestaurantReservation.STATUS_SHIFT_REMOVED,
reservation.status):
reservation.status = unset_flag(
RestaurantReservation.STATUS_SHIFT_REMOVED,
reservation.status)
reservation.put()
return True
return False
if shift.start <= current_start <= shift.end:
reservation.status = unset_flag(
RestaurantReservation.STATUS_SHIFT_REMOVED,
reservation.status)
reservation.shift_start = datetime(
reservation.shift_start.year,
reservation.shift_start.month, reservation.shift_start.day,
shift.start / 3600, (shift.start % 3600) / 60)
reservation.put()
return True
if not is_flag_set(RestaurantReservation.STATUS_SHIFT_REMOVED,
reservation.status):
reservation.status = set_flag(
RestaurantReservation.STATUS_SHIFT_REMOVED, reservation.status)
reservation.put()
return True
return False
if db.run_in_transaction(trans):
send_message(
service_user,
u"solutions.restaurant.reservations.shift_changes_conflicts",
service_identity=service_identity)
def get(self):
service_user = users.get_current_user()
calendarId = long(self.request.get("state"))
code = self.request.get("code", None)
error = self.request.get("error", None)
if error:
send_message(service_user,
u"solutions.common.calendar.google.callback",
success=False,
calendar_id=calendarId)
else:
success = save_google_credentials(service_user, calendarId, code)
send_message(service_user,
u"solutions.common.calendar.google.callback",
success=success,
calendar_id=calendarId)
self.response.write("Loading...")
def get(self):
service_user_email = self.request.get("s")
service_user = users.User(service_user_email)
denied = self.request.get("denied")
if denied:
self.response.out.write("""<html>
<body><h1>Twitter login cancelled, you can close this window now.</h1></body>
<script>self.close();</script>
</html>""")
else:
oauth_token = self.request.get("oauth_token")
oauth_verifier = self.request.get("oauth_verifier")
logging.info("service_user_email: %s", service_user_email)
logging.info("oauth_token: %s", oauth_token)
logging.info("oauth_verifier: %s", oauth_verifier)
key = AuthToken.key_name(oauth.TWITTER, oauth_token)
auth_model = AuthToken.get_by_key_name(key)
if auth_model:
server_settings = get_server_settings()
solution_server_settings = get_solution_server_settings()
client = oauth.TwitterClient(
solution_server_settings.twitter_app_key,
solution_server_settings.twitter_app_secret,
CALLBACK_URL % (server_settings.baseUrl,
urlencode({"s": service_user.email()})))
r = client.get_user_info(oauth_token, oauth_verifier, True)
sln_settings = get_solution_settings(service_user)
if sln_settings:
sln_settings.twitter_oauth_token = r["token"]
sln_settings.twitter_oauth_token_secret = r["secret"]
sln_settings.twitter_username = r["username"]
put_and_invalidate_cache(sln_settings)
send_message(service_user,
u"solutions.common.twitter.updated",
username=r["username"])
self.response.out.write("""<html>
<body><h1>witter login success, you can close this window now.</h1></body>
<script>self.close();</script>
</html>""")
def trans(service_profile):
azzert(service_profile)
service_profile_updated = False
if not service_profile.autoUpdating and not service_profile.updatesPending:
service_profile.updatesPending = True
service_profile_updated = True
if bump_service_version:
service_profile.version += 1
service_profile_updated = True
if clear_broadcast_settings_cache:
service_profile.addFlag(ServiceProfile.FLAG_CLEAR_BROADCAST_SETTINGS_CACHE)
service_profile_updated = True
if service_profile_updated:
channel.send_message(service_profile.user, 'rogerthat.service.updatesPendingChanged',
updatesPending=service_profile.updatesPending)
service_profile.put()
return service_profile.autoUpdating
def send_signup_update_messages(sln_settings, *messages):
service_identity = ServiceIdentity.DEFAULT
sln_i_settings = get_solution_settings_or_identity_settings(
sln_settings, service_identity)
sm_data = [{u'type': u'solutions.common.customer.signup.update'}]
for message in messages:
message_to = SolutionInboxMessageTO.fromModel(message, sln_settings,
sln_i_settings, True)
sm_data.append({
u'type':
u'solutions.common.messaging.update',
u'message':
serialize_complex_value(message_to, SolutionInboxMessageTO, False)
})
channel.send_message(sln_settings.service_user,
sm_data,
service_identity=service_identity)
def delete_group_purchase(service_user, service_identity, group_purchase_id):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
def txn():
sln_settings = get_solution_settings(service_user)
m = SolutionGroupPurchase.get_by_id(
group_purchase_id,
parent_key_unsafe(service_identity_user, sln_settings.solution))
azzert(service_user == m.service_user)
m.deleted = True
m.put()
xg_on = db.create_transaction_options(xg=True)
db.run_in_transaction_options(xg_on, txn)
send_message(service_user,
u"solutions.common.group_purchase.update",
service_identity=service_identity)
def delete_city_wide_lottery_info(key):
ll_info_delete = SolutionCityWideLottery.get(key)
if not ll_info_delete:
return RETURNSTATUS_TO_SUCCESS
service_user = users.get_current_user()
sln_settings = get_solution_settings(service_user)
try:
ll_info = SolutionCityWideLottery.load_pending(ll_info_delete.app_id)
if ll_info_delete.key() == ll_info.key():
raise RETURNSTATUS_TO_SUCCESS
if ll_info_delete.schedule_loot_time > 0:
ll_info_delete.delete()
send_message(service_user, u"solutions.common.loyalty.lottery.update")
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
return ReturnStatusTO.create(False, common_translate(sln_settings.main_language, SOLUTION_COMMON, e.message))
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 put_loyalty_settings(loyalty_type, loyalty_settings, loyalty_website):
service_user = users.get_current_user()
try:
def trans(loyalty_type):
sln_settings = get_solution_settings(service_user)
if SolutionModule.HIDDEN_CITY_WIDE_LOTTERY in sln_settings.modules:
loyalty_type = SolutionLoyaltySettings.LOYALTY_TYPE_CITY_WIDE_LOTTERY
sln_settings.updates_pending = True
sln_loyalty_settings = SolutionLoyaltySettings.get_by_user(service_user)
if sln_loyalty_settings.loyalty_type != loyalty_type:
sln_loyalty_settings.branding_key = None
sln_settings.loyalty_branding_hash = None
sln_loyalty_settings.loyalty_type = loyalty_type
if sln_loyalty_settings.website != loyalty_website:
sln_loyalty_settings.modification_time = now()
sln_loyalty_settings.website = loyalty_website
if loyalty_type == SolutionLoyaltySettings.LOYALTY_TYPE_REVENUE_DISCOUNT:
sln_loyalty_settings.x_visits = loyalty_settings.x_visits
sln_loyalty_settings.x_discount = loyalty_settings.x_discount
elif loyalty_type == SolutionLoyaltySettings.LOYALTY_TYPE_STAMPS:
sln_loyalty_settings.x_stamps = loyalty_settings.x_stamps
sln_loyalty_settings.stamps_type = loyalty_settings.stamps_type
sln_loyalty_settings.stamps_winnings = loyalty_settings.stamps_winnings
sln_loyalty_settings.stamps_auto_redeem = loyalty_settings.stamps_auto_redeem
put_and_invalidate_cache(sln_loyalty_settings, sln_settings)
return sln_settings
xg_on = db.create_transaction_options(xg=True)
sln_settings = db.run_in_transaction_options(xg_on, trans, loyalty_type)
broadcast_updates_pending(sln_settings)
send_message(service_user, u"solutions.common.loyalty.settings.update")
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
return ReturnStatusTO.create(False, e.message)
def stop_debugging(app_user, mobile_id, debug_request=None, notify_user=True):
# debug_request is not None when debug session timed out
def trans(mobile):
stopped = False
debug_request_from_ds = db.get(StartDebuggingRequest.create_key(app_user, mobile_id))
if debug_request_from_ds:
if not debug_request or debug_request.timestamp == debug_request_from_ds.timestamp:
db.delete_async(debug_request_from_ds)
start_log_forwarding(app_user, None, mobile) # target_jid=None ==> will stop log forwarding
stopped = True
if not APPSCALE and debug_request_from_ds.target_id.startswith('dbg_'):
on_trans_committed(try_or_defer, delete_xmpp_account, debug_request_from_ds.target_id, None)
return stopped
# stop debugging session after timeout, or when user closed the debugging dialog in the web UI
xg_on = db.create_transaction_options(xg=True)
stopped = db.run_in_transaction_options(xg_on, trans, get_mobile_by_id(mobile_id))
if stopped and notify_user:
channel.send_message(app_user, 'rogerthat.settings.stopped_debugging')
def add_loyalty_lottery_info(winnings, date):
service_user = users.get_current_user()
session_ = users.get_current_session()
service_identity = session_.service_identity
sln_settings = get_solution_settings(service_user)
try:
now_ = now()
end_timestamp = date.toEpoch()
if end_timestamp <= (now_ + 24 * 3600):
raise BusinessException("end-date-24h-in-future")
ll_info = SolutionLoyaltyLottery.load_pending(service_user, service_identity)
if ll_info:
if end_timestamp <= ll_info.end_timestamp:
raise BusinessException("lottery-time-bigger-first-upcoming")
service_identity_user = create_service_identity_user_wo_default(service_user, service_identity)
ll_info = SolutionLoyaltyLottery(parent=parent_key_unsafe(service_identity_user, SOLUTION_COMMON))
ll_info.timestamp = now_
ll_info.end_timestamp = end_timestamp
ll_info.schedule_loot_time = ll_info.end_timestamp - 24 * 3600
ll_info.winnings = winnings
ll_info.winner = None
ll_info.winner_info = None
ll_info.winner_timestamp = 0
ll_info.skip_winners = []
ll_info.pending = True
ll_info.redeemed = False
ll_info.claimed = False
ll_info.put()
sln_settings.updates_pending = True
put_and_invalidate_cache(sln_settings)
broadcast_updates_pending(sln_settings)
send_message(service_user, u"solutions.common.loyalty.lottery.update", service_identity=service_identity)
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
return ReturnStatusTO.create(False, common_translate(sln_settings.main_language, SOLUTION_COMMON, e.message))
def create_update_friend_requests(helper, updated_user, friend_map, status, extra_conversion_kwargs=None,
skip_mobiles=None):
"""
Sends the correct request (UpdateFriendRequest or UpdateFriendSetRequest) to the client,
based on the version of the mobile.
Args:
helper(FriendHelper):
updated_user(users.User): The user which has been updated.
friend_map(FriendMap): Friend map of the target user
status(int): The kind of friend update. See UpdateFriendRequestTO.STATUS_*
extra_conversion_kwargs(dict): Optional kwargs to pass to the FriendTO.fromDBFriendDetail method.
skip_mobiles([unicode]): mobile accounts that should be skipped.
Returns:
list[RpcCAPICall]
"""
azzert(status in (UpdateFriendRequestTO.STATUS_ADD,
UpdateFriendRequestTO.STATUS_DELETE,
UpdateFriendRequestTO.STATUS_MODIFIED))
target_user = friend_map.user
if status == UpdateFriendRequestTO.STATUS_DELETE:
friend_detail = None
else:
try:
friend_detail = friend_map.friendDetails[remove_slash_default(updated_user).email()]
except KeyError:
logging.warn("%s not found in the friendMap of %s. Not sending updateFriend request with status=%s",
remove_slash_default(updated_user), target_user, status)
friend_detail = None
if not friend_detail:
return []
friend_to = convert_friend(helper, target_user, friend_detail, status, extra_conversion_kwargs)
capi_calls = do_update_friend_request(target_user, friend_to, status, friend_map, helper, skip_mobiles)
if friend_to and helper.is_service:
channel.send_message(target_user, u'rogerthat.friends.update', friend=friend_to.to_dict())
return capi_calls
def saveSettings(request):
mobile = users.get_current_mobile()
db_settings = get_mobile_settings_cached(mobile)
db_settings.recordPhoneCalls = request.callLogging
db_settings.geoLocationTracking = request.tracking
db_settings.timestamp = int(time.time())
db_settings.version += 1
db_settings.put()
user_profile = get_user_profile(mobile.user)
if MISSING.default(request.push_notifications, None):
if not user_profile.consent_push_notifications_shown:
user_profile.consent_push_notifications_shown = True
user_profile.put()
rest_request = get_current_request()
deferred.defer(save_push_notifications_consent, mobile.user, get_headers_for_consent(rest_request),
u'yes' if request.push_notifications.enabled else u'no')
app_settings = get_app_settings(users.get_current_app_id())
channel.send_message(users.get_current_user(), u'rogerthat.settings.update', mobile_id=mobile.id)
return SaveSettingsResponse(settings=SettingsTO.fromDBSettings(app_settings, user_profile, db_settings))
def ack_test_broadcast(message):
test_person = message.broadcast_test_person
logging.info(u"%s answered broadcast flow" % test_person.email())
btn_index = message.memberStatusses[message.members.index(test_person)].button_index
if btn_index == message.buttons[BROADCAST_RETRY_ID].index:
flow = Broadcast.get(message.broadcast_key).message_flow
start_flow(add_slash_default(message.sender), message_parent_key=message.pkey, flow=flow, members=[test_person],
check_friends=False, result_callback=False,
tag=json.dumps({Broadcast.TAG_MC_BROADCAST: message.broadcast_key}), broadcast_type=message.broadcast_type)
else:
accepted = btn_index == message.buttons[BROADCAST_ACCEPT_ID].index
def txn_update_tester_status():
broadcast = Broadcast.get(message.broadcast_key)
if broadcast:
status = Broadcast.TEST_PERSON_STATUS_ACCEPTED if accepted else Broadcast.TEST_PERSON_STATUS_DECLINED
broadcast.set_status(test_person, status)
broadcast.put()
return bool(broadcast)
if db.run_in_transaction(txn_update_tester_status):
channel.send_message(get_service_user_from_service_identity_user(message.sender),
u'rogerthat.broadcast.changes', broadcast_key=message.broadcast_key)
def forward_log(app_user, message):
channel.send_message(app_user, 'rogerthat.settings.log', message=message)
def post(app_user, location, timestamp, recipients):
def parse_location(friend_language, accuracy, geocoded_results):
# See https://developers.google.com/maps/documentation/geocoding/#Results
if accuracy < 100:
for result in results:
if "street_address" in result["types"]:
return "\n" + localize(friend_language, "Location: %(address)s", address=result["formatted_address"])
return "\n" + localize(friend_language, "Location: %(address)s", address=results[0]["formatted_address"])
address_types = ["neighborhood", "sublocality", "locality", "political", "route"]
for adt in address_types:
for result in results:
if adt in result["types"]:
return "\n" + localize(friend_language, "Location: %(address)s", address=result["formatted_address"])
logging.error("Could not parse geo-coded result!")
loc = GeoPointWithTimestampTO()
loc.latitude = location.latitude
loc.longitude = location.longitude
loc.accuracy = location.accuracy
loc.timestamp = timestamp
maps_lat = loc.latitude / 1000000.0
maps_long = loc.longitude / 1000000.0
current_user, app_id = get_app_user_tuple(app_user)
for recipient in (r for r in recipients if r.target == GetLocationRequestTO.TARGET_SERVICE_LOCATION_TRACKER):
location_with_timestamp = GeoPointWithTimestampTO()
location_with_timestamp.latitude = location.latitude
location_with_timestamp.longitude = location.longitude
location_with_timestamp.accuracy = location.accuracy
location_with_timestamp.timestamp = timestamp
handle_service_tracker_results(app_user, add_slash_default(users.User(recipient.friend)), location_with_timestamp)
to_put = []
for recipient in (r for r in recipients if r.target in (GetLocationRequestTO.TARGET_MOBILE, GetLocationRequestTO.TARGET_MOBILE_FIRST_REQUEST_AFTER_GRANT)):
friend_user = create_app_user(users.User(recipient.friend), app_id)
def trans():
lr = LocationRequest.get_by_key_name(friend_user.email(), parent=parent_key(app_user))
if not lr:
return False
lr.delete()
return True
if not db.run_in_transaction(trans):
continue
profile, friend_profile = get_profile_infos([app_user, friend_user], expected_types=[UserProfile, UserProfile])
if recipient.target == GetLocationRequestTO.TARGET_MOBILE:
m = localize(friend_profile.language, """Received location of %(name)s.
Accuracy: %(accuracy)sm""", name=profile.name, accuracy=loc.accuracy)
else:
m = localize(friend_profile.language, """%(name)s accepted your location sharing request.
Latest information:
Accuracy: %(accuracy)sm""", name=profile.name, accuracy=loc.accuracy)
url = "https://maps.googleapis.com/maps/api/geocode/json?latlng=%s,%s&sensor=true" % (maps_lat, maps_long)
logging.info("Fetching URL: %s" % url)
result = urlfetch.fetch(url)
logging.info("Fetched result: %s" % result.content)
logging.info("Result status code: %s" % result.status_code)
if result.status_code == 200:
results = json.loads(result.content)
if results["status"] == "OK" and results["results"]:
results = results["results"]
location = parse_location(friend_profile.language, loc.accuracy, results)
if location:
m += location
button = ButtonTO()
button.id = u"show_map"
button.caption = localize(friend_profile.language, "Show map")
button.action = u"geo://%s,%s" % (str(maps_lat).replace(',', '.'), str(maps_long).replace(',', '.'))
button.ui_flags = 0
msg_model = sendMessage(MC_DASHBOARD, [UserMemberTO(friend_user)], Message.FLAG_ALLOW_DISMISS, 0, None, m,
[button], None, get_app_by_user(friend_user).core_branding_hash, None, is_mfr=False)
to_put.append(LocationMessage(key=LocationMessage.create_key(app_user, msg_model.key().name()),
receiver=recipient.friend))
ndb.put_multi(to_put)
mobile_recipients = [create_app_user(users.User(r.friend), app_id) for r in recipients if r.target == GetLocationRequestTO.TARGET_MOBILE_FRIENDS_ON_MAP]
request = LocationResultRequestTO()
request.friend = current_user.email()
request.location = loc
locationResult(get_location_result_response_handler, logError, mobile_recipients, request=request)
web_recipients = [r for r in recipients if r.target == GetLocationRequestTO.TARGET_WEB]
for recipient in web_recipients:
friend_user = create_app_user(users.User(recipient.friend), app_id)
channel.send_message(friend_user, 'rogerthat.location.location_response', friend=current_user.email(), location=serialize_complex_value(loc, GeoPointWithTimestampTO, False))
def get(self):
user = users.get_current_user()
self.stop_session()
channel.send_message(user, u'rogerthat.system.logout')
def _send_admin_role_updates(service_identity_user):
channel.send_message(get_service_user_from_service_identity_user(service_identity_user),
u'rogerthat.service.adminsChanged')
def finish_registration(mobile_account, mobileInfo, invitor_code, invitor_secret, ipaddress, anonymous_account=None):
from rogerthat.service.api import friends as service_api_friends
m = get_mobile_by_account(mobile_account)
mobile_key = m.key()
ms_key = get_mobile_settings_cached(m).key()
profile_key = get_user_profile_key(m.user)
def trans():
mobile, ms, my_profile = db.get((mobile_key, ms_key, profile_key))
mobile.status = mobile.status | Mobile.STATUS_REGISTERED
mobile.type = mobileInfo.app_type
mobile.simCountry = mobileInfo.sim_country if mobileInfo.sim_country != MISSING else None
mobile.simCountryCode = mobileInfo.sim_country_code if mobileInfo.sim_country_code != MISSING else None
mobile.simCarrierCode = mobileInfo.sim_carrier_code if mobileInfo.sim_carrier_code != MISSING else None
mobile.simCarrierName = mobileInfo.sim_carrier_name if mobileInfo.sim_carrier_name != MISSING else None
mobile.netCountry = mobileInfo.net_country if mobileInfo.net_country != MISSING else None
mobile.netCountryCode = mobileInfo.net_country_code if mobileInfo.net_country_code != MISSING else None
mobile.netCarrierCode = mobileInfo.net_carrier_code if mobileInfo.net_carrier_code != MISSING else None
mobile.netCarrierName = mobileInfo.net_carrier_name if mobileInfo.net_carrier_name != MISSING else None
mobile.hardwareModel = mobileInfo.device_model_name
mobile.osVersion = mobileInfo.device_os_version if mobileInfo.device_os_version != MISSING else None
mobile.localeLanguage = mobileInfo.locale_language if mobileInfo.locale_language and mobileInfo.locale_language != MISSING else DEFAULT_LANGUAGE
mobile.localeCountry = mobileInfo.locale_country
mobile.timezone = mobileInfo.timezone if mobileInfo.timezone != MISSING else None
mobile.timezoneDeltaGMT = mobileInfo.timezone_delta_gmt if mobileInfo.timezone_delta_gmt != MISSING else None
if mobileInfo.app_major_version != MISSING and mobileInfo.app_minor_version != MISSING:
ms.majorVersion = mobileInfo.app_major_version
ms.minorVersion = mobileInfo.app_minor_version
# This is the official place where we set the profile language
my_profile.language = mobile.localeLanguage
my_profile.country = mobile.netCountry or mobile.simCountry or mobile.localeCountry
my_profile.timezone = mobile.timezone
my_profile.timezoneDeltaGMT = mobile.timezoneDeltaGMT
my_profile.mobiles = MobileDetails()
my_profile.mobiles.addNew(mobile.account, mobile.type, mobile.pushId, mobile.app_id)
put_and_invalidate_cache(mobile, ms, my_profile)
deferred.defer(_finishup_mobile_registration, mobile, invitor_code, invitor_secret, ipaddress, ms_key,
_transactional=True, _queue=FAST_QUEUE)
return mobile, my_profile
mobile, my_profile = run_in_transaction(trans, xg=True)
channel.send_message(mobile.user, u'com.mobicage.registration.finished')
registration = get_registration_by_mobile(mobile)
if registration and registration.installation:
save_successful_registration(registration, mobile, my_profile)
if registration.installation.service_identity_user and (registration.installation.qr_url or registration.installation.oauth_state):
service_identity_user = registration.installation.service_identity_user
service_user, service_identity = get_service_identity_tuple(service_identity_user)
svc_profile = get_service_profile(service_user)
user_details = [UserDetailsTO.fromUserProfile(my_profile)]
user_app_id = get_app_id_from_app_user(mobile.user)
# auto_connected_services
services_to_connect = set()
if registration.installation.service_callback_result == ACCEPT_AND_CONNECT_ID:
def trans_update_app_id():
si = get_service_identity(service_identity_user)
bizz_check(si, "ServiceIdentity %s not found" % service_identity_user)
if user_app_id not in si.appIds:
si.appIds.append(user_app_id)
put_and_invalidate_cache(si)
run_in_transaction(trans_update_app_id)
services_to_connect.add(service_identity_user)
for autoconnect_service_email in registration.installation.auto_connected_services:
if "/" in autoconnect_service_email:
autoconnect_service_identity_user = users.User(autoconnect_service_email)
else:
autoconnect_service_identity_user = create_service_identity_user(
users.User(autoconnect_service_email))
if autoconnect_service_identity_user in services_to_connect:
continue
si = get_service_identity(autoconnect_service_identity_user)
if si and user_app_id in si.appIds:
services_to_connect.add(autoconnect_service_identity_user)
for service_to_connect in services_to_connect:
try_or_defer(makeFriends, mobile.user, service_to_connect, original_invitee=None, servicetag=None,
origin=None, notify_invitee=False, notify_invitor=False, user_data=None)
# roles
if registration.installation.roles:
roles_to_add = defaultdict(set)
for r in parse_complex_value(RegistrationResultRolesTO, json.loads(registration.installation.roles), True):
for role_id in r.ids:
roles_to_add[create_service_identity_user(
users.User(r.service), r.identity or ServiceIdentity.DEFAULT)].add(role_id)
for service_identity_email, role_ids in roles_to_add.iteritems():
service_user, identity = get_service_identity_tuple(users.User(service_identity_email))
grant_service_roles(service_user, identity, mobile.user, list(role_ids))
# callback
if registration.installation.qr_url:
service_api_friends.register_result(register_result_response_receiver, logServiceError, svc_profile,
service_identity=service_identity,
user_details=user_details,
origin=REGISTRATION_ORIGIN_QR)
elif registration.installation.oauth_state:
service_api_friends.register_result(register_result_response_receiver, logServiceError, svc_profile,
service_identity=service_identity,
user_details=user_details,
origin=REGISTRATION_ORIGIN_OAUTH)
else:
app = get_app_by_id(get_app_id_from_app_user(mobile.user))
if app.admin_services:
service_profiles = filter(None, db.get((get_profile_key(users.User(e)) for e in app.admin_services)))
if service_profiles:
user_details = [UserDetailsTO.fromUserProfile(my_profile)]
for service_profile in service_profiles:
service_api_friends.register_result(register_result_response_receiver,
logServiceError,
service_profile,
service_identity=ServiceIdentity.DEFAULT,
user_details=user_details,
origin=REGISTRATION_ORIGIN_DEFAULT)
if anonymous_account:
deferred.defer(migrate_anonymous_account, anonymous_account, mobile.user)
return mobile
def finish_registration(mobile_account, mobileInfo, accounts, invitor_code, invitor_secret, ipaddress):
from rogerthat.service.api import friends as service_api_friends
m = get_mobile_by_account(mobile_account)
mobile_key = m.key()
ms_key = MobileSettings.get(m).key()
profile_key = get_user_profile_key(m.user)
def trans():
mobile, ms, my_profile = db.get((mobile_key, ms_key, profile_key))
mobile.status = mobile.status | Mobile.STATUS_REGISTERED
mobile.type = mobileInfo.app_type
mobile.simCountry = mobileInfo.sim_country if mobileInfo.sim_country != MISSING else None
mobile.simCountryCode = mobileInfo.sim_country_code if mobileInfo.sim_country_code != MISSING else None
mobile.simCarrierCode = mobileInfo.sim_carrier_code if mobileInfo.sim_carrier_code != MISSING else None
mobile.simCarrierName = mobileInfo.sim_carrier_name if mobileInfo.sim_carrier_name != MISSING else None
mobile.netCountry = mobileInfo.net_country if mobileInfo.net_country != MISSING else None
mobile.netCountryCode = mobileInfo.net_country_code if mobileInfo.net_country_code != MISSING else None
mobile.netCarrierCode = mobileInfo.net_carrier_code if mobileInfo.net_carrier_code != MISSING else None
mobile.netCarrierName = mobileInfo.net_carrier_name if mobileInfo.net_carrier_name != MISSING else None
mobile.hardwareModel = mobileInfo.device_model_name
mobile.osVersion = mobileInfo.device_os_version if mobileInfo.device_os_version != MISSING else None
mobile.localeLanguage = mobileInfo.locale_language if mobileInfo.locale_language and mobileInfo.locale_language != MISSING else DEFAULT_LANGUAGE
mobile.localeCountry = mobileInfo.locale_country
mobile.timezone = mobileInfo.timezone if mobileInfo.timezone != MISSING else None
mobile.timezoneDeltaGMT = mobileInfo.timezone_delta_gmt if mobileInfo.timezone_delta_gmt != MISSING else None
if mobileInfo.app_major_version != MISSING and mobileInfo.app_minor_version != MISSING:
ms.majorVersion = mobileInfo.app_major_version
ms.minorVersion = mobileInfo.app_minor_version
# This is the official place where we set the profile language
my_profile.language = mobile.localeLanguage
my_profile.country = mobile.netCountry or mobile.simCountry or mobile.localeCountry
my_profile.timezone = mobile.timezone
my_profile.timezoneDeltaGMT = mobile.timezoneDeltaGMT
my_profile.mobiles = MobileDetails()
my_profile.mobiles.addNew(mobile.account, mobile.type, mobile.pushId, mobile.app_id)
mobile.put()
ms.put()
my_profile.put()
deferred.defer(_finishup_mobile_registration, mobile, accounts, invitor_code, invitor_secret, ipaddress,
ms_key, _transactional=True)
return mobile, my_profile
xg_on = db.create_transaction_options(xg=True)
mobile, my_profile = db.run_in_transaction_options(xg_on, trans)
channel.send_message(mobile.user, u'com.mobicage.registration.finished')
typestr = "Unknown type"
try:
typestr = Mobile.typeAsString(mobile.type)
except ValueError:
pass
server_settings = get_server_settings()
registration = get_registration_by_mobile(mobile)
if registration:
InstallationLog(parent=registration.installation, timestamp=now(), registration=registration,
mobile=mobile, profile=my_profile, description="Registration successful.").put()
if registration.installation and registration.installation.qr_url:
service_user = get_service_user_from_service_identity_user(registration.installation.service_identity_user)
service_identity = get_identity_from_service_identity_user(registration.installation.service_identity_user)
svc_profile = get_service_profile(service_user)
user_details = [UserDetailsTO.fromUserProfile(my_profile)]
if registration.installation.service_callback_result == ACCEPT_AND_CONNECT_ID:
service_identity_user = create_service_identity_user(service_user, service_identity)
si = get_service_identity(service_identity_user)
bizz_check(si, "ServiceIdentity %s not found" % service_identity_user)
xmpp.send_message(server_settings.xmppInfoMembers,
"User %s registered %s (%s) with account:\n%s\nFor service %s %s" % (
mobile.user, mobile.hardwareModel, typestr, mobile.account, si.name,
service_identity_user), message_type=xmpp.MESSAGE_TYPE_CHAT)
app_id = get_app_id_from_app_user(mobile.user)
if app_id not in si.appIds:
si.appIds.append(app_id)
put_and_invalidate_cache(si)
try_or_defer(makeFriends, mobile.user, service_identity_user, original_invitee=None, servicetag=None,
origin=None, notify_invitee=False, notify_invitor=False, user_data=None)
else:
xmpp.send_message(server_settings.xmppInfoMembers, "User %s registered %s (%s) with account:\n%s" % (
mobile.user, mobile.hardwareModel, typestr, mobile.account), message_type=xmpp.MESSAGE_TYPE_CHAT)
service_api_friends.register_result(register_result_response_receiver, logServiceError, svc_profile,
service_identity=service_identity,
user_details=user_details,
origin=REGISTRATION_ORIGIN_QR)
else:
xmpp.send_message(server_settings.xmppInfoMembers, "User %s registered %s (%s) with account:\n%s" % (
mobile.user, mobile.hardwareModel, typestr, mobile.account), message_type=xmpp.MESSAGE_TYPE_CHAT)
app = get_app_by_id(get_app_id_from_app_user(mobile.user))
if app.admin_services:
service_profiles = filter(None, db.get((get_profile_key(users.User(e)) for e in app.admin_services)))
if service_profiles:
user_details = [UserDetailsTO.fromUserProfile(my_profile)]
for service_profile in service_profiles:
service_api_friends.register_result(register_result_response_receiver,
logServiceError,
service_profile,
service_identity=ServiceIdentity.DEFAULT,
user_details=user_details,
origin=REGISTRATION_ORIGIN_DEFAULT)
else:
xmpp.send_message(server_settings.xmppInfoMembers,
"User %s registered %s (%s) with account:\n%s\nBut registration model was not found!" % (
mobile.user, mobile.hardwareModel, typestr, mobile.account),
message_type=xmpp.MESSAGE_TYPE_CHAT)
return mobile
def forward_log(app_user, message):
channel.send_message(app_user, 'rogerthat.settings.log', message=message, silent=True) # don't slog
def cleanup_sessions(service_user):
for user_profile_key in UserProfile.all(keys_only=True).filter('owningServiceEmails', service_user.email()):
drop_sessions_of_user(users.User(user_profile_key.name()))
drop_sessions_of_user(service_user)
send_message(service_user, 'rogerthat.system.logout')
def _send_service_role_grants_updates(service_user):
channel.send_message(service_user, u'rogerthat.service.role.grants.updated')
