def send_expired_voucher_message(voucher_key, sln_settings, days):
voucher = SolutionCityVoucher.get(voucher_key)
if not voucher or days in voucher.expiration_reminders_sent:
return
language = sln_settings.main_language
service_user = sln_settings.service_user
branding = get_solution_main_branding(service_user).branding_key
if voucher.owner:
activation_date = format_timestamp(voucher.activation_date,
sln_settings,
format='medium')
message = common_translate(language,
SOLUTION_COMMON,
u'voucher_expiration_message',
days=days,
date=activation_date)
with users.set_user(sln_settings.service_user):
member = MemberTO()
member.alert_flags = Message.ALERT_FLAG_VIBRATE
member.member = voucher.owner.email()
member.app_id = voucher.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)
voucher.expiration_reminders_sent.append(days)
db.put(voucher)
def try_to_set_location(settings_key):
to_put = set()
def set_location(settings):
if settings.address and not settings.location:
lines = settings.address.splitlines()
if lines[0] == lines[1]:
settings.address = '\n'.join(lines[1:])
to_put.add(settings)
try:
lat, lon = _get_location(settings.address)
settings.location = db.GeoPt(lat, lon)
to_put.add(settings)
except:
logging.warning("Failed to resolve address of %s: %s",
settings.service_user.email(),
settings.address,
exc_info=1)
sln_settings = db.get(settings_key)
if sln_settings:
if sln_settings.identities:
for identity in sln_settings.identities:
identity_settings = get_solution_settings_or_identity_settings(
sln_settings, identity)
set_location(identity_settings)
else:
set_location(sln_settings)
if to_put:
put_and_invalidate_cache(*to_put)
service_user = sln_settings.service_user
main_branding_key = get_solution_main_branding(
service_user).branding_key
populate_identity_and_publish(service_user, main_branding_key)
def _regenerate_branding_with_logo(service_user):
users.set_user(service_user)
logging.info(
"%s: Replacing logo.png in the sln main branding zip with the uploaded logo"
% service_user.email())
logo = get_solution_logo(service_user)
sln_main_branding = get_solution_main_branding(service_user)
zip_content = replace_file_in_zip_blob(sln_main_branding.blob, "logo.jpg",
str(logo.picture))
def trans():
sln_main_branding = get_solution_main_branding(service_user)
sln_main_branding.blob = db.Blob(zip_content)
sln_main_branding.branding_creation_time = 0
common_settings = get_solution_settings(service_user)
common_settings.updates_pending = True
common_settings.events_branding_hash = None
put_and_invalidate_cache(sln_main_branding, common_settings)
return common_settings
common_settings = run_in_transaction(trans, xg=True)
broadcast_updates_pending(common_settings)
def order_sandwich_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):
type_ = get_first_fmr_step_result_value(steps, u'message_type')
topping = get_first_fmr_step_result_value(steps, u'message_topping')
customizations = get_first_fmr_step_result_value(steps, u'message_customize')
remark = get_first_fmr_step_result_value(steps, u'message_remark')
takeaway_time = get_first_fmr_step_result_value(steps, u'message_takeaway_time')
deferred.defer(process_sandwich_order, service_user, service_identity, user_details, type_, topping, customizations,
remark, takeaway_time, parent_message_key)
sln_settings = get_solution_settings(service_user)
main_branding = get_solution_main_branding(service_user)
result = FlowMemberResultCallbackResultTO()
result.type = TYPE_MESSAGE
result.value = MessageCallbackResultTypeTO()
result.value.flags = Message.FLAG_ALLOW_DISMISS | Message.FLAG_AUTO_LOCK
result.value.answers = []
result.value.alert_flags = Message.ALERT_FLAG_SILENT
result.value.attachments = []
result.value.branding = main_branding.branding_key
result.value.dismiss_button_ui_flags = 0
result.value.tag = None
result.value.message = common_translate(sln_settings.main_language, SOLUTION_COMMON, u'order-sandwich-received')
result.value.step_id = u'message_sandwich_ordered'
return result
def broadcast_group_purchase(service_user, service_identity, group_purchase_id,
message):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
sln_settings = get_solution_settings(service_user)
sgp = SolutionGroupPurchase.get_by_id(
group_purchase_id,
parent_key_unsafe(service_identity_user, sln_settings.solution))
sln_main_branding = get_solution_main_branding(service_user)
branding = sln_main_branding.branding_key if sln_main_branding else None
members = dict()
for e in sgp.subscriptions:
if e.sender:
member = MemberTO()
member.alert_flags = Message.ALERT_FLAG_VIBRATE
member.member = e.sender.email
member.app_id = e.sender.app_id
members["%s:%s" % (member.member, member.app_id)] = member
if members:
messaging.send(parent_key=None,
parent_message_key=None,
message=message,
answers=[],
flags=Message.FLAG_ALLOW_DISMISS,
members=members.values(),
branding=branding,
tag=None,
service_identity=service_identity)
def _send_order_confirmation(service_user, lang, 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, order_details):
if now() - steps[-1].acknowledged_timestamp < 10:
alert_flags = Message.ALERT_FLAG_SILENT
else:
alert_flags = Message.ALERT_FLAG_VIBRATE
users.set_user(service_user)
try:
messaging.send(
parent_key=parent_message_key,
parent_message_key=parent_message_key,
message=u'%s\n\n%s:\n%s' %
(translate(lang, SOLUTION_COMMON, u'order_complete_will_notify'),
translate(lang, SOLUTION_COMMON, u'usage-detail'), order_details),
answers=list(),
flags=Message.FLAG_ALLOW_DISMISS | Message.FLAG_AUTO_LOCK,
members=[
MemberTO.from_user(user_details[0].toAppUser(), alert_flags)
],
branding=get_solution_main_branding(service_user).branding_key,
tag=None,
service_identity=service_identity,
alert_flags=alert_flags,
step_id=u'order_complete')
finally:
users.clear_user()
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 trans():
sln_main_branding = get_solution_main_branding(service_user)
sln_main_branding.blob = db.Blob(zip_content)
sln_main_branding.branding_creation_time = 0
common_settings = get_solution_settings(service_user)
common_settings.updates_pending = True
common_settings.events_branding_hash = None
put_and_invalidate_cache(sln_main_branding, common_settings)
return common_settings
def _process_event_reminder(reminder_key):
reminder = EventReminder.get(reminder_key)
service_user = reminder.service_user
settings = get_solution_settings(service_user)
event = Event.get_by_id(reminder.event_id,
parent_key(service_user, settings.solution))
if event and reminder.event_start_epoch in event.start_dates:
now_ = now()
if (now_ +
reminder.remind_before) > (reminder.event_start_epoch +
timezone_offset(settings.timezone)):
if event.place:
place = "\n@ " + event.place + "\n"
else:
place = ""
dt = datetime.datetime.fromtimestamp(reminder.event_start_epoch)
language = settings.main_language or DEFAULT_LANGUAGE
when = "%s, %s" % (format_date(dt, format='full', locale=language),
format_time(dt, format='short',
locale=language))
reminderMessage = "Reminder:\n\nTitle:\n%s\n\nWhen:\n%s\n%s\nDescription:\n%s" % (
event.title, when, place, event.description)
main_branding = get_solution_main_branding(service_user)
human_user = get_human_user_from_app_user(reminder.human_user)
members = list()
members.append(human_user.email())
users.set_user(reminder.service_user)
try:
messaging.send(parent_key=None,
parent_message_key=None,
message=reminderMessage,
answers=[],
flags=Message.FLAG_ALLOW_DISMISS,
members=members,
branding=main_branding.branding_key,
tag=None,
service_identity=reminder.service_identity)
finally:
users.clear_user()
reminder.status = EventReminder.STATUS_REMINDED
reminder.put()
else:
reminder.status = EventReminder.STATUS_REMINDED
reminder.put()
def _set_content_branding(sln_settings):
users.set_user(sln_settings.service_user)
try:
sln_main_branding = get_solution_main_branding(sln_settings.service_user)
populate_identity(sln_settings, sln_main_branding.branding_key)
identities = [None]
if sln_settings.identities:
identities.extend(sln_settings.identities)
for service_identity in identities:
if is_default_service_identity(service_identity):
service_identity_user = create_service_identity_user(sln_settings.service_user)
else:
service_identity_user = create_service_identity_user(sln_settings.service_user, service_identity)
deferred.defer(_update_tablets, service_identity_user, None, _queue=HIGH_LOAD_CONTROLLER_QUEUE)
finally:
users.clear_user()
def get_create_event_flow_xml_for_user(sln_settings, app_user):
flow_name = get_create_event_flow_name(app_user)
main_branding = get_solution_main_branding(sln_settings.service_user)
calendars_admin = get_solution_calendars_for_user(
sln_settings.service_user, sln_settings.solution, app_user)
calendar_count = sum(1 for _ in calendars_admin)
flow_params = dict(flow_name=flow_name,
branding_key=main_branding.branding_key,
language=sln_settings.main_language or DEFAULT_LANGUAGE,
name=sln_settings.name,
calendar_count=calendar_count,
calendars=calendars_admin)
flow = JINJA_ENVIRONMENT.get_template('flows/events_create.xml').render(
flow_params)
return flow
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 get(self, page):
service_user = users.get_current_user()
session_ = users.get_current_session()
service_identity = session_.service_identity
_, extension = os.path.splitext(page.lower())
if extension in (".jpg", ".jpeg"):
self.response.headers['Content-Type'] = "image/jpeg"
elif extension == ".png":
self.response.headers['Content-Type'] = "image/png"
elif extension == ".css":
self.response.headers['Content-Type'] = "text/css"
main_branding = get_solution_main_branding(service_user)
with closing(ZipFile(StringIO(main_branding.blob))) as zip_file:
try:
content = zip_file.read(page)
except KeyError:
if page == 'avatar.jpg':
self.abort(404)
else:
raise
if page == 'branding.html':
doc = html.fromstring(content)
sln_i_settings = None
for elem in doc.xpath("//nuntiuz_identity_name"):
if not sln_i_settings:
if is_default_service_identity(service_identity):
sln_i_settings = get_solution_settings(service_user)
else:
sln_i_settings = get_solution_identity_settings(
service_user, service_identity)
parent = elem.getparent()
elem.drop_tree()
parent.text = sln_i_settings.name
content = etree.tostring(doc) # @UndefinedVariable
self.response.out.write(content)
def put_google_events(service_user, calendar_str_key, calendar_id, solution,
google_calendar_finished, google_events, language):
to_put = []
no_title_text = common_translate(language, SOLUTION_COMMON, '(No title)')
for google_event in google_events:
try:
google_event_id = google_event["id"]
event_parent_key = parent_key(service_user, solution)
event = Event.all().ancestor(event_parent_key).filter(
"source =",
Event.SOURCE_GOOGLE_CALENDAR).filter("external_id =",
google_event_id).get()
if not event:
event = Event(parent=event_parent_key,
source=Event.SOURCE_GOOGLE_CALENDAR,
external_id=google_event_id)
if google_event.get("status", "confirmed") == "cancelled":
if not event.is_saved():
continue
event.deleted = True
elif not event.deleted:
event.deleted = False
event.title = google_event.get('summary', no_title_text)
event.place = google_event.get("location",
u"").replace(u"\n", u" ")
event.organizer = google_event.get("organizer",
{}).get("displayName", u"")
event.description = google_event.get('description', u"")
event.calendar_id = calendar_id
event.external_link = google_event["htmlLink"]
event.start_dates = list()
event.end_dates = list()
if google_event["start"].get("dateTime", None):
start_date_with_tz = dateutil.parser.parse(
google_event["start"]["dateTime"])
end_date_with_tz = dateutil.parser.parse(
google_event["end"]["dateTime"])
day_difference = abs(
(end_date_with_tz - start_date_with_tz).days)
if day_difference == 0:
start_epoch = get_epoch_from_datetime(
datetime(start_date_with_tz.year,
start_date_with_tz.month,
start_date_with_tz.day,
start_date_with_tz.hour,
start_date_with_tz.minute))
event.start_dates.append(start_epoch)
end_epoch = get_epoch_from_datetime(
datetime(end_date_with_tz.year, end_date_with_tz.month,
end_date_with_tz.day, end_date_with_tz.hour,
end_date_with_tz.minute))
end_date = datetime.fromtimestamp(end_epoch)
event.end_dates.append(
int(
timedelta(
hours=end_date.hour,
minutes=end_date.minute,
seconds=end_date.second).total_seconds()))
# TODO: multi day event
# else:
# start_date = datetime.strptime(google_event["start"]["date"], '%Y-%m-%d')
# end_date = datetime.strptime(google_event["end"]["date"], '%Y-%m-%d')
# day_difference = abs((end_date - start_date).days)
if event.start_dates:
event.first_start_date = event.start_dates[0]
event.last_start_date = event.start_dates[-1]
to_put.append(event)
else:
logging.info("Skipping event because it had no start_dates")
logging.debug(google_event)
except:
logging.warn('Failed to put Google Event: %s', google_event)
raise
if to_put:
db.put(to_put)
if google_calendar_finished:
def trans():
scgs = SolutionCalendarGoogleSync.get_by_key_name(
service_user.email())
if not scgs:
return True # update was run from saving a calendar
if calendar_str_key in scgs.google_calendar_keys:
scgs.google_calendar_keys.remove(calendar_str_key)
if not scgs.google_calendar_keys:
scgs.delete()
return True
scgs.put()
return False
if db.run_in_transaction(trans):
from solutions.common.bizz.provisioning import populate_identity_and_publish
sln_settings = get_solution_settings(service_user)
sln_main_branding = get_solution_main_branding(service_user)
deferred.defer(populate_identity_and_publish, sln_settings,
sln_main_branding.branding_key)
def _publish_app_data(sln_settings):
logging.debug('publishing app data for %s' % sln_settings.service_user)
sln_settings.put_identity_pending = False
sln_settings.put()
main_branding = get_solution_main_branding(sln_settings.service_user)
populate_identity_and_publish(sln_settings, main_branding.branding_key)
def _7000_migrate_solution(job_key):
phase = MigrateServiceJob.PHASE_7000_MIGRATE_SOLUTION
next_phase = MigrateServiceJob.PHASE_8000_FINISH_MODELS
# Validate that the job still exists
job = _get_job(job_key, phase)
# Do the work
_log_progress(job)
if job.solution:
logging.info('0/ Migrate the solution models without ancestor, but with service_user as key name.')
def trans0():
new_models = list()
old_models = list()
for model_class in (SolutionMainBranding, SolutionLogo, SolutionAvatar):
old_model = db.get(model_class.create_key(job.from_service_user))
if old_model:
kwargs = copy_model_properties(old_model)
new_model = model_class(key=model_class.create_key(job.to_service_user),
**kwargs)
new_models.append(new_model)
old_models.append(old_model)
if new_models:
put_and_invalidate_cache(*new_models)
if old_models:
db.delete(old_models)
xg_on = db.create_transaction_options(xg=True)
db.run_in_transaction_options(xg_on, trans0)
old_sln_settings = get_solution_settings(job.from_service_user)
identities = [None]
if old_sln_settings.identities:
identities.extend(old_sln_settings.identities)
logging.info('1/ Migrate RestaurantReservations')
for service_identity in identities:
from_si_user = create_service_identity_user_wo_default(job.from_service_user, service_identity)
to_si_user = create_service_identity_user_wo_default(job.to_service_user, service_identity)
while True:
reservations = RestaurantReservation.all().filter('service_user', from_si_user).fetch(300)
if not reservations:
break
for r in reservations:
r.service_user = to_si_user
_put_and_invalidate_cache_and_allocate_ids(*reservations)
logging.info('2/ Migrate EventReminders')
for service_identity in identities:
from_si_user = create_service_identity_user(job.from_service_user)
to_si_user = create_service_identity_user(job.to_service_user)
while True:
reminders = EventReminder.all().filter('service_identity_user', from_si_user).fetch(300)
if not reminders:
break
for r in reminders:
r.service_identity_user = to_si_user
_put_and_invalidate_cache_and_allocate_ids(*reminders)
logging.info('3/ Migrate RestaurantProfile.reserve_flow_part2')
restaurant_profile = db.get(RestaurantProfile.create_key(job.from_service_user))
if restaurant_profile and restaurant_profile.reserve_flow_part2:
old_part2_key = db.Key(restaurant_profile.reserve_flow_part2)
new_part2_key = db.Key.from_path(old_part2_key.kind(), old_part2_key.id_or_name(),
parent=parent_key(job.to_service_user))
logging.debug('New key: %r', new_part2_key)
restaurant_profile.reserve_flow_part2 = str(new_part2_key)
_put_and_invalidate_cache_and_allocate_ids(restaurant_profile)
logging.info('4/ Delete all SolutionQRs. They will be recreated when provisioning.')
for service_identity in identities:
service_identity_user = create_service_identity_user_wo_default(job.from_service_user, service_identity)
db.delete(SolutionQR.all(keys_only=True).ancestor(parent_key_unsafe(service_identity_user, job.solution)))
logging.info('5/ Delete Loyalty QR. It will be recreated when provisioning.')
if SolutionModule.LOYALTY in old_sln_settings.modules:
for service_identity in identities:
if is_default_service_identity(service_identity):
loyalty_i_settings = db.get(SolutionLoyaltySettings.create_key(job.from_service_user))
else:
loyalty_i_settings = db.get(
SolutionLoyaltyIdentitySettings.create_key(job.from_service_user, service_identity))
if loyalty_i_settings:
loyalty_i_settings.image_uri = None
loyalty_i_settings.content_uri = None
_put_and_invalidate_cache_and_allocate_ids(loyalty_i_settings)
logging.info('6/ Change ancestor keys of solution models.')
for solution in ['common', job.solution]:
for service_identity in identities:
if is_default_service_identity(service_identity):
_migrate_ancestor_models(job, parent_key(job.from_service_user, solution))
else:
service_identity_user = create_service_identity_user_wo_default(
job.from_service_user, service_identity)
_migrate_ancestor_models(job, parent_key_unsafe(service_identity_user, solution))
sln_settings = get_solution_settings(job.to_service_user)
sln_main_branding = get_solution_main_branding(job.to_service_user)
users.set_user(job.to_service_user)
try:
populate_identity(sln_settings, sln_main_branding.branding_key)
finally:
users.clear_user()
# Set the next phase
_set_job_in_next_phase(job_key, phase, next_phase)
def _8000_finish_models(job_key):
phase = MigrateServiceJob.PHASE_8000_FINISH_MODELS
next_phase = MigrateServiceJob.PHASE_9000_RECONNECT_FRIENDS
# Validate that the job still exists
job = _get_job(job_key, phase)
# Do the work
_log_progress(job)
try:
logging.info("1/ re_index all service identities asynchronously")
if not is_trial_service(job.to_service_user):
run_job(get_service_identities_query, [job.to_service_user, True],
_re_index_service_identity, [])
logging.info("2/ set solution and enabled on the new ServiceProfile")
def trans2():
to_service_profile = get_service_profile(job.to_service_user)
to_service_profile.enabled = job.service_enabled
to_service_profile.solution = job.solution
to_service_profile.put()
db.run_in_transaction(trans2)
logging.info("3/ couple the service to the customer")
if job.customer_key:
def trans3():
customer = db.get(job.customer_key)
customer.service_email = job.to_service_user.email()
customer.migration_job = None
customer.put()
deferred.defer(re_index_customer, db.Key(job.customer_key),
_queue=MIGRATION_QUEUE, _transactional=True)
db.run_in_transaction(trans3)
else:
logging.debug('There was no customer')
logging.info("4/ grant service roles")
service_grants = job.get_service_grants() # { app_user : { si_user : [roles] } }
for app_user_email, service_grant_dict in service_grants.iteritems():
def trans4():
p = get_user_profile(users.User(app_user_email), cached=False)
for old_si_email, service_roles in service_grant_dict.iteritems():
old_si_user = users.User(old_si_email)
new_si_user = create_service_identity_user(job.to_service_user,
get_identity_from_service_identity_user(old_si_user))
for role in service_roles:
logging.debug("Granting role %s to %s for %s", role, app_user_email, new_si_user)
p.grant_role(new_si_user, role)
p.put()
db.run_in_transaction(trans4)
logging.debug("5/ finish solution models")
if job.solution:
sln_settings = get_solution_settings(job.to_service_user)
main_branding = get_solution_main_branding(job.to_service_user)
users.set_user(job.to_service_user)
try:
if SolutionModule.LOYALTY in sln_settings.modules:
logging.debug('- Provisioning %s', SolutionModule.LOYALTY)
put_loyalty(sln_settings, None, main_branding, sln_settings.main_language, None)
if SolutionModule.QR_CODES in sln_settings.modules:
logging.debug('- Provisioning %s', SolutionModule.QR_CODES)
put_qr_codes(sln_settings, None, main_branding, sln_settings.main_language, None)
logging.debug('- Creating QR codes for calendar admins')
calendars_to_put = []
for sc in SolutionCalendar.all().ancestor(parent_key(sln_settings.service_user, sln_settings.solution)).filter("deleted =", False):
qr_code = create_calendar_admin_qr_code(sc, main_branding.branding_key, sln_settings.main_language)
sc.connector_qrcode = qr_code.image_uri
calendars_to_put.append(sc)
if calendars_to_put:
db.put(calendars_to_put)
logging.debug('- Creating QR codes for inbox forwarding')
flow_identifier = create_inbox_forwarding_flow(main_branding.branding_key, sln_settings.main_language)
qrcode = create_inbox_forwarding_qr_code(None, flow_identifier)
sln_settings.inbox_connector_qrcode = qrcode.image_uri
if sln_settings.identities:
for service_identity in sln_settings.identities:
qrcode = create_inbox_forwarding_qr_code(service_identity, flow_identifier)
def trans():
sln_i_settings = get_solution_identity_settings(sln_settings.service_user, service_identity)
sln_i_settings.inbox_connector_qrcode = qrcode.image_uri
sln_i_settings.put()
db.run_in_transaction(trans)
put_and_invalidate_cache(sln_settings)
finally:
users.clear_user()
else:
logging.debug("The service was not a solution")
except BusinessException, e:
logging.exception("Caught BusinessException")
azzert(False, "Caught BusinessException: %s" % e)
def new_group_purchase_subscription(service_user, service_identity,
group_purchase_id, name, user_detail,
units):
from solutions.common.bizz.provisioning import populate_identity
sln_settings = get_solution_settings(service_user)
if not units > 0:
raise BusinessException(
translate(
sln_settings.main_language, SOLUTION_COMMON,
'new-group-subscription-failure-required-at-least-1-unit'))
main_branding = get_solution_main_branding(service_user)
app_user = user_detail.toAppUser() if user_detail else None
def trans():
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
sgp = SolutionGroupPurchase.get_by_id(
group_purchase_id,
parent_key_unsafe(service_identity_user, sln_settings.solution))
units_user = 0
if user_detail:
for subscription in sgp.subscriptions_for_user(app_user):
units_user += subscription.units
if sgp.max_units_pp and units_user >= sgp.max_units_pp:
raise BusinessException(
translate(sln_settings.main_language, SOLUTION_COMMON,
'new-group-subscription-failure-reached-maximum'))
if sgp.max_units_pp and (units_user + units) > sgp.max_units_pp:
raise BusinessException(
translate(sln_settings.main_language,
SOLUTION_COMMON,
'new-group-subscription-failure-exceeded-maximum',
max_units=sgp.max_units_pp - units_user))
if (sgp.units_available - units) >= 0:
sgpe = SolutionGroupPurchaseSubscription(parent=sgp)
sgpe.sender = SolutionUser.fromTO(
user_detail) if user_detail else None
sgpe.name = name
sgpe.units = units
sgpe.timestamp = now()
sgpe.app_user = app_user
sgpe.put()
units_user += units
else:
raise BusinessException(
translate(sln_settings.main_language, SOLUTION_COMMON,
'new-group-subscription-failure-insufficient-units'))
return sln_settings, sgp, units_user
xg_on = db.create_transaction_options(xg=True)
sln_settings, sgp, units_user = db.run_in_transaction_options(xg_on, trans)
send_message(service_user,
u"solutions.common.group_purchase.update",
service_identity=service_identity)
populate_identity(sln_settings,
main_branding.branding_key) # update service data
system.publish_changes()
if user_detail:
user_data = json.loads(
system.get_user_data(user_detail.email,
["groupPurchaseSubscriptions"],
service_identity, user_detail.app_id))
if user_data["groupPurchaseSubscriptions"] is None:
user_data["groupPurchaseSubscriptions"] = dict()
user_data["groupPurchaseSubscriptions"][unicode(sgp.id)] = units_user
system.put_user_data(user_detail.email, json.dumps(user_data),
service_identity, user_detail.app_id)
return sgp
reason=e.message)
except:
logging.error("Failure when adding new group_purchase subscription",
exc_info=1)
r.result = None
r.error = u"An unknown error occurred"
sgp = SolutionGroupPurchase.get_by_id(
group_purchase_id,
parent_key_unsafe(service_identity_user, sln_settings.solution))
message = translate(sln_settings.main_language,
SOLUTION_COMMON,
'group-subscription-failure-unknown-title',
title=sgp.title)
member = MemberTO()
member.alert_flags = Message.ALERT_FLAG_VIBRATE
member.member = user_details[0].email
member.app_id = user_details[0].app_id
main_branding = get_solution_main_branding(service_user)
messaging.send(parent_key=None,
parent_message_key=None,
message=message,
answers=[],
flags=Message.FLAG_ALLOW_DISMISS,
members=[member],
branding=main_branding.branding_key,
tag=None,
service_identity=service_identity)
return r
