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