def trans(): si_chunk = db.get(si_keys_chunk) for si in reversed(si_chunk): if not si.serviceData: si_chunk.remove(si) continue old_ancestor = si.serviceData._ancestor new_ancestor = _create_new_key(job, si.serviceData._ancestor) for chunk in chunks(si.serviceData._keys.values(), 5): _migrate_models(job, db.get([KVBucket.create_key(bucket_id, old_ancestor) for bucket_id in chunk])) for chunk in chunks(si.serviceData._blob_keys.values(), 5): for blob_bucket_ids in chunk: _migrate_models(job, db.get([KVBlobBucket.create_key(blob_bucket_id, old_ancestor) for blob_bucket_id in blob_bucket_ids])) si.serviceData._ancestor = new_ancestor if si_chunk: put_and_invalidate_cache(*si_chunk) if si_keys: # there is still work to do deferred.defer(_2500_migrate_service_data, job_key, si_keys, _transactional=True, _queue=MIGRATION_QUEUE) return False return True
def trans(): to_put = list() service_profile = get_service_profile(service_user) service_profile.expiredAt = now() service_profile.enabled = False to_put.append(service_profile) service_identity_keys = get_service_identities_query(service_user, True) search_configs = db.get( [SearchConfig.create_key(create_service_identity_user(users.User(key.parent().name()), key.name())) for key in service_identity_keys]) svc_index = search.Index(name=SERVICE_INDEX) loc_index = search.Index(name=SERVICE_LOCATION_INDEX) for search_config in search_configs: if search_config: search_config.enabled = False to_put.append(search_config) on_trans_committed(_cleanup_search_index, search_config.service_identity_user.email(), svc_index, loc_index) for objects_to_put in chunks(to_put, 200): put_and_invalidate_cache(*objects_to_put) deferred.defer(cleanup_sessions, service_user, _transactional=True) deferred.defer(cleanup_friend_connections, service_user, _transactional=True)
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
def trans(): if static_content_id: sc = SolutionStaticContent.get( SolutionStaticContent.create_key( service_user, static_content_id)) if not sc: logging.error( u"Failed to update static content with id '%s' for user %s", static_content_id, service_user) return sln_settings if sc.old_coords != coords and sc.provisioned: sc.old_coords = sc.coords else: sc = SolutionStaticContent(parent=parent_key( sln_settings.service_user, SOLUTION_COMMON)) sc.old_coords = coords sc.icon_label = icon_label sc.icon_name = icon_name sc.text_color = None sc.background_color = None sc.html_content = None sc.sc_type = SolutionStaticContent.TYPE_PDF sc.visible = visible sc.coords = coords sc.provisioned = False sc.deleted = False if branding_hash: sc.branding_hash = branding_hash sln_settings.updates_pending = True put_and_invalidate_cache(sc, sln_settings) return sln_settings
def trans(): followed_new_group = False to_put = list() for discussion_group in SolutionDiscussionGroup.list(service_user): kv_store_dict = discussion_group.members.to_json_dict() was_following = app_user_email in kv_store_dict['members'] now_following = discussion_group.id in selected_ids if was_following != now_following: if now_following: followed_new_group = True logging.debug('Adding %s to discussion group "%s"', app_user_email, discussion_group.topic) kv_store_dict['members'].append(app_user_email) on_trans_committed(add_to_chat, discussion_group.message_key) else: logging.debug('Removing %s from discussion group "%s"', app_user_email, discussion_group.topic) kv_store_dict['members'].remove(app_user_email) on_trans_committed(rm_from_chat, discussion_group.message_key) to_put.append(discussion_group) # We need to set members again to force the KVStore to be put discussion_group.members.from_json_dict(kv_store_dict) if to_put: put_and_invalidate_cache(*to_put) return followed_new_group
def edit_loyalty_lottery_info(key, winnings, date): ll_info_edit = SolutionLoyaltyLottery.get(key) if not ll_info_edit: 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: 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_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.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 trans(): if new_event.id: event = get_event_by_id(service_user, sln_settings.solution, new_event.id) if new_event.new_picture: event.picture_version += 1 else: event = Event( parent=parent_key(service_user, sln_settings.solution)) event.picture_version = 0 event.title = new_event.title event.place = new_event.place event.organizer = new_event.organizer event.description = new_event.description start_dates = [] for start_date in new_event.start_dates: start_dates.append(start_date.toEpoch()) start_dates_sorted, end_dates_sorted = zip( *sorted(zip(start_dates, new_event.end_dates))) startDates = list(start_dates_sorted) new_event.end_dates = list(end_dates_sorted) event.last_start_date = max(startDates) event.start_dates = start_dates event.end_dates = new_event.end_dates event.first_start_date = event.get_first_event_date() event.url = new_event.external_link event.picture = picture event.calendar_id = new_event.calendar_id sln_settings.updates_pending = True put_and_invalidate_cache(event, sln_settings) return sln_settings
def _migrate_sids(job, old_sids): @db.non_transactional def put_new_short_urls(new_sids): new_short_urls = [get_shorturl_for_qr(job.to_service_user, new_sid.key().id())[0] for new_sid in new_sids] _put_and_invalidate_cache_and_allocate_ids(*new_short_urls) return new_short_urls @db.non_transactional def delete_old_short_urls(old_sids): old_short_url_keys = [db.Key.from_path(ShortURL.kind(), ServiceInteractionDef.shortUrl.get_value_for_datastore(qr).id()) for qr in old_sids] db.delete(old_short_url_keys) new_sids = _migrate_models(job, old_sids, delete_old_models=False, put_new_models=True) new_short_urls = put_new_short_urls(new_sids) for new_sid, new_short_url in zip(new_sids, new_short_urls): new_sid.shortUrl = new_short_url old_qr_template_key = ServiceInteractionDef.qrTemplate.get_value_for_datastore(new_sid) if old_qr_template_key: new_sid.qrTemplate = _create_new_key(job, old_qr_template_key) put_and_invalidate_cache(*new_sids) delete_old_short_urls(old_sids) db.delete(old_sids) return new_sids
def enable_or_disable_solution_module(service_user, module, enabled): """Add or remove the module from solution settings""" if module not in SolutionModule.FUNCTIONALITY_MODUELS: return sln_settings = get_solution_settings(service_user) # for broadcast module, it can be enabled only if module == SolutionModule.BROADCAST: if enabled: set_default_broadcast_types(sln_settings) else: return to_put = [] if enabled: activate_solution_module(sln_settings, module) if module == SolutionModule.ORDER: order_settings = set_advanced_order_settings(sln_settings) if order_settings: to_put.append(order_settings) elif module == SolutionModule.HIDDEN_CITY_WIDE_LOTTERY: deactivate_solution_module(sln_settings, SolutionModule.LOYALTY) # don't enable loyalty if this is a city service if module == SolutionModule.LOYALTY and SolutionModule.CITY_APP in sln_settings.modules: return else: deactivate_solution_module(sln_settings, module) sln_settings.updates_pending = True to_put.append(sln_settings) put_and_invalidate_cache(*to_put) broadcast_updates_pending(sln_settings)
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 trans(): sln_settings = get_solution_settings(service_user) new_coords = map(int, [ static_content.position.x, static_content.position.y, static_content.position.z ]) if static_content.id is MISSING or static_content.id is None: sc = SolutionStaticContent(parent=parent_key( service_user, SOLUTION_COMMON), deleted=False) sc.old_coords = new_coords else: sc = SolutionStaticContent.get( SolutionStaticContent.create_key(service_user, static_content.id)) if sc.old_coords != new_coords and sc.provisioned: sc.old_coords = sc.coords sc.icon_label = static_content.icon_label sc.icon_name = static_content.icon_name if static_content.sc_type == SolutionStaticContent.TYPE_OWN: sc.text_color = static_content.text_color sc.background_color = static_content.background_color sc.html_content = static_content.html_content sc.branding_hash = branding_hash elif static_content.sc_type == SolutionStaticContent.TYPE_WEBSITE: sc.website = static_content.website sc.sc_type = static_content.sc_type sc.visible = static_content.visible sc.provisioned = False sc.coords = new_coords sc.put() sln_settings.updates_pending = True put_and_invalidate_cache(sc, sln_settings) return sln_settings
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)
def trans(): sln_settings = get_solution_settings(service_user) service_identity_user = create_service_identity_user_wo_default( service_user, service_identity) if group_purchase.id: sgp = SolutionGroupPurchase.get_by_id( group_purchase.id, parent_key_unsafe(service_identity_user, sln_settings.solution)) if group_purchase.new_picture: sgp.picture_version += 1 else: sgp = SolutionGroupPurchase(parent=parent_key_unsafe( service_identity_user, sln_settings.solution)) sgp.picture_version = 0 sgp.title = group_purchase.title sgp.description = group_purchase.description sgp.units = group_purchase.units sgp.unit_description = group_purchase.unit_description sgp.unit_price = group_purchase.unit_price sgp.min_units_pp = group_purchase.min_units_pp sgp.max_units_pp = group_purchase.max_units_pp sgp.time_from = group_purchase.time_from sgp.time_until = group_purchase.time_until sgp.picture = picture sln_settings.updates_pending = True put_and_invalidate_cache(sgp, sln_settings) return sln_settings
def trans_create(): rogerthat_profile = get_service_or_user_profile(users.User(email)) if rogerthat_profile and isinstance(rogerthat_profile, ServiceProfile): from rogerthat.bizz.service import AppFailedToCreateUserProfileWithExistingServiceException raise AppFailedToCreateUserProfileWithExistingServiceException(email) user_profile = get_user_profile(app_user, cached=False) is_new_profile = False if not user_profile: deactivated_user_profile = get_deactivated_user_profile(app_user) if deactivated_user_profile: deferred.defer(reactivate_user_profile, deactivated_user_profile, app_user, _transactional=True) ActivationLog(timestamp=now(), email=app_user.email(), mobile=None, description="Reactivate user account by registering a paper loyalty card").put() else: is_new_profile = True avatar, image = _create_new_avatar(app_user, add_trial_overlay=False) user_profile = UserProfile(parent=parent_key(app_user), key_name=app_user.email()) user_profile.name = name user_profile.language = language user_profile.avatarId = avatar.key().id() user_profile.app_id = app_id _calculateAndSetAvatarHash(user_profile, image) pp = ProfilePointer(key=db.Key.from_path(ProfilePointer.kind(), user_code)) pp.user = app_user pp.short_url_id = short_url_id if is_new_profile: put_and_invalidate_cache(user_profile, pp, ProfilePointer.create(app_user)) else: pp.put()
def trans_create(avatar, image, share_sid_key): azzert(not get_service_profile(service_user, cached=False)) azzert(not get_default_service_identity_not_cached(service_user)) profile = ServiceProfile(parent=parent_key(service_user), key_name=service_user.email()) profile.avatarId = avatar.key().id() _calculateAndSetAvatarHash(profile, image) service_identity_user = create_service_identity_user(service_user, ServiceIdentity.DEFAULT) service_identity = ServiceIdentity(key=ServiceIdentity.keyFromUser(service_identity_user)) service_identity.inheritanceFlags = 0 service_identity.name = name service_identity.description = "%s (%s)" % (name, service_user.email()) service_identity.shareSIDKey = share_sid_key service_identity.shareEnabled = False service_identity.creationTimestamp = now() service_identity.appIds = supported_app_ids update_result = update_func(profile, service_identity) if update_func else None put_and_invalidate_cache(profile, service_identity, ProfilePointer.create(service_user), ProfileHashIndex.create(service_user)) deferred.defer(create_default_qr_templates, service_user, _transactional=True) return profile, service_identity, update_result
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 _translate_all_message_flows(service_user): '''update all multi-language flows after editable set was deployed''' from rogerthat.bizz.service.mfd import render_xml_for_message_flow_design, render_js_for_message_flow_designs, \ get_message_flow_design_context logging.debug("Re-translating all message flows of %s" % service_user.email()) translator = None puts = list() multilanguage_flows = get_multilanguage_message_flow_designs_by_status(service_user, MessageFlowDesign.STATUS_VALID) for mfd in multilanguage_flows: if translator is None: translator = get_translator(service_user, ServiceTranslation.MFLOW_TYPES) try: context = get_message_flow_design_context(mfd) if mfd.definition else None render_xml_for_message_flow_design(mfd, translator, context) puts.append(mfd) except: logging.warning("Could not translate msg flow", exc_info=True) try: changed_languages = render_js_for_message_flow_designs(puts) except: logging.warning("Could not render JS for flows", exc_info=True) changed_languages = None put_and_invalidate_cache(*puts) if not changed_languages: from rogerthat.bizz.job.update_friends import schedule_update_all_friends_of_service_user schedule_update_all_friends_of_service_user(service_user, bump_service_version=True, clear_broadcast_settings_cache=True)
def trans(): sln_settings = get_solution_settings(service_user) sln_i_settings = get_solution_settings_or_identity_settings( sln_settings, service_identity) sln_i_settings.holiday_out_of_office_message = db.Text(message) sln_settings.updates_pending = True put_and_invalidate_cache(sln_settings, sln_i_settings) return sln_settings
def get_profile_for_facebook_user(access_token, app_user, update=False, language=DEFAULT_LANGUAGE, app_id=App.APP_ID_ROGERTHAT): gapi = facebook.GraphAPI(access_token) fields = ["id", "first_name", "last_name", "name", "verified", "locale", "gender", "email", "birthday", "link"] fb_profile = gapi.get_object("me", fields=','.join(fields)) logging.debug("/me graph response: %s", fb_profile) if not app_user: if "email" in fb_profile: app_user = create_app_user(users.User(fb_profile["email"]), app_id) else: raise FailedToBuildFacebookProfileException( localize(language, 'There is no e-mail address configured in your facebook account. Please use the e-mail based login.')) # TODO we should validate app.user_regex # TODO we should check if email is not used for a service account couple_facebook_id_with_profile(app_user, access_token) profile = get_user_profile(app_user) if not profile or update: if not profile: profile = FacebookUserProfile(parent=parent_key(app_user), key_name=app_user.email()) profile.app_id = app_id avatar = Avatar(user=app_user) else: avatar = get_avatar_by_id(profile.avatarId) if not avatar: avatar = Avatar(user=app_user) if fb_profile.get("name"): profile.name = fb_profile["name"] else: profile.name = get_human_user_from_app_user(app_user).email().replace("@", " at ") if profile.birthdate is None and fb_profile.get("birthday"): birthday = fb_profile["birthday"].split("/") profile.birthdate = get_epoch_from_datetime( datetime.date(int(birthday[2]), int(birthday[0]), int(birthday[1]))) if profile.gender is None and fb_profile.get("gender"): gender = fb_profile["gender"] if gender == "male": profile.gender = UserProfile.GENDER_MALE elif gender == "female": profile.gender = UserProfile.GENDER_FEMALE else: profile.gender = UserProfile.GENDER_CUSTOM avatar = _get_and_save_facebook_avatar(app_user, fb_profile["id"], profile, avatar) profile.avatarId = avatar.key().id() profile.language = language profile.profile_url = fb_profile.get("link") profile.access_token = access_token profile.version = 1 put_and_invalidate_cache(profile, ProfilePointer.create(app_user)) update_friends(profile, [u"name", u"avatar"]) update_mobiles(app_user, profile) return profile
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 trans(): sc = SolutionCalendar(parent=parent_key(sln_settings.service_user, sln_settings.solution), name="Default", deleted=False) sc.put() sln_settings.default_calendar = sc.calendar_id put_and_invalidate_cache(sln_settings) return sc
def trans(): user_profile = get_user_profile(app_user) if not user_profile: logging.info("unsubscribe_from_reminder_email account that does not exists: %s", app_user) return False user_profile.unsubscribed_from_reminder_email = True put_and_invalidate_cache(user_profile) return True
def trans(): job = db.get(job_key) for si_email, granted_roles in p.grants.iteritems(): if si_email.startswith(si_user_email + '/'): si_user = users.User(si_email) for role in granted_roles: p.revoke_role(si_user, role) job.add_service_grant(si_user, p.user, role) put_and_invalidate_cache(p, job)
def trans(): mfd_list = [ mfd for mfd in get_message_flow_designs_by_status( service_user, MessageFlowDesign.STATUS_VALID) if mfd.xml and not mfd.definition ] # XML-only flows render_js_for_message_flow_designs(mfd_list, notify_friends=False) for chunk in chunks(mfd_list, 200): put_and_invalidate_cache(*chunk) schedule_update_all_friends_of_service_user(service_user)
def trans(): sln_settings = get_solution_settings(service_user) sln_settings.updates_pending = True menu = get_restaurant_menu(service_user, sln_settings.solution) menu.name = name put_and_invalidate_cache(sln_settings, menu) return sln_settings
def clear_table_id_in_reservations(service_user, service_identity, table_id): service_identity_user = create_service_identity_user_wo_default( service_user, service_identity) qry = RestaurantReservation.all().filter("service_user =", service_identity_user) qry.filter('tables =', table_id) reservations = qry.fetch(None) for r in reservations: r.tables.remove(table_id) put_and_invalidate_cache(*reservations)
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 _set_main_service_email(app_key, main_services): app = db.get(app_key) if app: app_id = app.app_id if app_id in [App.APP_ID_ROGERTHAT, App.APP_ID_OSA_LOYALTY]: return if app_id in main_services: app.main_service = main_services[app.app_id] put_and_invalidate_cache(app)
def trans(): mobile, ms, my_profile = db.get((mobile_key, ms_key, get_user_profile_key(current_user))) ms.majorVersion = majorVersion ms.minorVersion = minorVersion ms.lastHeartBeat = now_time if appType != MISSING: mobile.type = my_profile.mobiles[mobile.account].type_ = appType if simCountry != MISSING: mobile.simCountry = simCountry if simCountryCode != MISSING: mobile.simCountryCode = simCountryCode if simCarrierCode != MISSING: mobile.simCarrierCode = simCarrierCode if simCarrierName != MISSING: mobile.simCarrierName = simCarrierName if netCountry != MISSING: mobile.netCountry = netCountry if netCountryCode != MISSING: mobile.netCountryCode = netCountryCode if netCarrierCode != MISSING: mobile.netCarrierCode = netCarrierCode if netCarrierName != MISSING: mobile.netCarrierName = netCarrierName if deviceModelName != MISSING: mobile.hardwareModel = deviceModelName if osVersion != MISSING: mobile.osVersion = osVersion if localeCountry != MISSING: mobile.localeCountry = localeCountry if localeLanguage != MISSING: mobile.localeLanguage = localeLanguage if timezone != MISSING: mobile.timezone = timezone if timezoneDeltaGMT != MISSING: mobile.timezoneDeltaGMT = timezoneDeltaGMT language = mobile.localeLanguage if language: if '-' in language: language = get_iso_lang(language.lower()) elif mobile.localeCountry: language = '%s_%s' % (mobile.localeLanguage, mobile.localeCountry) if my_profile.language != language: my_profile.language = language # trigger friend.update service api call deferred.defer(update_friend_service_identity_connections, my_profile.key(), _transactional=True) db.delete_async(get_broadcast_settings_flow_cache_keys_of_user(my_profile.user)) my_profile.country = mobile.netCountry or mobile.simCountry or mobile.localeCountry my_profile.timezone = mobile.timezone my_profile.timezoneDeltaGMT = mobile.timezoneDeltaGMT put_and_invalidate_cache(ms, mobile, my_profile)
def get_profile_for_google_user(email, language, name): user = users.User(email) user_profile = get_user_profile(user) if not user_profile: user_profile = UserProfile(parent=parent_key(user), key_name=user.email()) user_profile.name = name if name else user.email() user_profile.language = language user_profile.version = 1 put_and_invalidate_cache(user_profile, ProfilePointer.create(user)) update_friends(user_profile) return user_profile
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 update_friend(friend, mobile): request = UpdateFriendRequestTO() request.friend = friend request.generation = friend_map.generation # deprecated request.status = status capi_calls = updateFriend(update_friend_response, logError, target_user, request=request, DO_NOT_SAVE_RPCCALL_OBJECTS=True, MOBILE_ACCOUNT=mobile, SKIP_ACCOUNTS=skip_mobiles) for capi_call in capi_calls: capi_call.update_status = status put_and_invalidate_cache(*capi_calls) return request.friend
def trans(): settings = get_solution_settings(service_user) event = get_event_by_id(service_user, settings.solution, event_id) if event: if event.source == Event.SOURCE_CMS: event.delete() else: event.deleted = True event.put() settings.updates_pending = True put_and_invalidate_cache(settings) return settings
def _migrate_profile(profile_keys): profiles = db.get(profile_keys) # type: list[ServiceProfile] to_put = [] for profile in profiles: if not profile.callBackURI: logging.info('Updating callBackURI from %s to %s', profile.callBackURI, 'mobidick') profile.callBackURI = 'mobidick' profile.testCallNeeded = False profile.enabled = True to_put.append(profile) if to_put: put_and_invalidate_cache(*to_put)
def _update_next_charge_date(order_key, default_next_charge_date, all_products): """Set next charge date to next month.""" order = Order.get(order_key) def is_free_subscription(order_item): product = all_products[order_item.product_code] return product.is_subscription and product.price == 0 order_items = order.list_items() if any((is_free_subscription(item) for item in order_items)): order.next_charge_date = default_next_charge_date put_and_invalidate_cache(order)
def trans(): sln_settings = get_solution_settings(service_user) sln_i_settings = get_solution_settings_or_identity_settings( sln_settings, service_identity) for i in range(len(sln_i_settings.holidays) / 2): if sln_i_settings.holidays[2 * i] == holiday.start: del sln_i_settings.holidays[2 * i:2 * i + 2] break else: raise InvalidHolidayException('holiday-not-found') sln_settings.updates_pending = True put_and_invalidate_cache(sln_settings, sln_i_settings) return sln_settings
def _remove_new_event_item(sln_settings): users.set_user(sln_settings.service_user) try: service_menu = system.get_menu() current_coords = get_coords_of_service_menu_item(service_menu, POKE_TAG_NEW_EVENT) logging.info("remove new event item for %s coords %s", sln_settings.service_user, current_coords) if current_coords: system.delete_menu_item(current_coords) sln_settings.events_branding_hash = None put_and_invalidate_cache(sln_settings) deferred.defer(common_provision, sln_settings.service_user) finally: users.clear_user()
def trans(): new_branding = store_branding_zip(service_user, zip_, description, skip_meta_file) if original_branding_hashes: # Mark brandings with same description as deleted deferred.defer(_mark_brandings_deleted, original_branding_hashes, _transactional=True) # Replace branding hash in menu items for menu_item in menu_items: menu_item.screenBranding = new_branding.hash to_put = menu_items # Replace branding hash in message flows branding_hash_re = re.compile('|'.join(original_branding_hashes)) for flow in message_flows: must_update = False if flow.definition: updated_flow_def = branding_hash_re.sub(new_branding.hash, flow.definition) if flow.definition != updated_flow_def: flow.definition = updated_flow_def must_update = True if flow.xml: updated_xml = branding_hash_re.sub(new_branding.hash, flow.xml) if flow.xml != updated_xml: flow.xml = updated_xml # update flow definitions render_js_for_message_flow_designs([flow], False) must_update = True else: logging.debug('Not updating flow %s xml because its xml is %s', flow.name, flow.xml) if must_update: to_put.append(flow) # Replace branding hash in service identities for service_identity in service_identities: # type: ServiceIdentity assert isinstance(service_identity, ServiceIdentity) if service_identity.contentBrandingHash in original_branding_hashes: service_identity.contentBrandingHash = new_branding.hash if service_identity.descriptionBranding in original_branding_hashes: service_identity.descriptionBranding = new_branding.hash if service_identity.menuBranding in original_branding_hashes: service_identity.menuBranding = new_branding.hash if service_identity.homeBrandingHash in original_branding_hashes: service_identity.homeBrandingHash = new_branding.hash to_put.append(service_identity) put_and_invalidate_cache(*to_put) schedule_update_all_friends_of_service_user(get_service_profile(service_user), bump_service_version=True) return new_branding, original_branding_hashes
def add_translations_to_all_app_brandings(service_user, branding_translations_dict): # branding_translations_dict: { en_text : { web_lang : translation } } for translations in branding_translations_dict.itervalues(): for web_lang in translations.keys(): iso_lang = get_iso_lang(web_lang) translations[iso_lang] = translations.pop(web_lang) new_translations_content = _get_translations_js_content(service_user, branding_translations_dict) replaced_brandings = dict() # { old_branding_hash : new_branding_hash } to_put = list() smis = list() for old_branding in Branding.list_by_type(service_user, Branding.TYPE_APP): if old_branding.timestamp < 0: continue with closing(StringIO(old_branding.blob)) as stream: with ZipFile(stream) as zip_file: try: old_translations_content = zip_file.read(TRANSLATIONS_JS_FILE) except KeyError: continue # __translations__.js not found ==> it did not contain <x-rogerthat-t> tags if new_translations_content != old_translations_content: zip_content = replace_file_in_zip(zip_file, TRANSLATIONS_JS_FILE, new_translations_content) new_branding_hash = hashlib.sha256(zip_content).hexdigest().upper() kwargs = copy_model_properties(old_branding) kwargs['blob'] = db.Blob(zip_content) kwargs['timestamp'] = now() to_put.append(Branding(key_name=new_branding_hash, **kwargs)) old_branding.timestamp *= -1 to_put.append(old_branding) replaced_brandings[old_branding.hash] = new_branding_hash for smi in get_service_menu_items_by_screen_branding(service_user, old_branding.hash): smi.screenBranding = new_branding_hash to_put.append(smi) smis.append(smi) if to_put: logging.info('Updating %s models', len(to_put)) put_and_invalidate_cache(*to_put) if smis: schedule_update_all_friends_of_service_user(service_user, bump_service_version=True) system.brandings_updated(brandings_updated_response_handler, logServiceError, get_service_profile(service_user), brandings=UpdatedBrandingTO.from_dict(replaced_brandings), reason=UpdatedBrandingTO.REASON_NEW_TRANSLATIONS)
def trans(): sln_settings = get_solution_settings(service_user) sln_i_settings = get_solution_settings_or_identity_settings( sln_settings, service_identity) i = 0 while i < len(sln_i_settings.holidays) / 2: if holiday.start < sln_i_settings.holidays[2 * i]: break i += 1 sln_i_settings.holidays.insert(2 * i, holiday.start) sln_i_settings.holidays.insert(2 * i + 1, holiday.end) sln_settings.updates_pending = True put_and_invalidate_cache(sln_settings, sln_i_settings) return sln_settings
def trans(old_default_app_key): new_default_app = get_app_by_id(app_id) if new_default_app.key() == old_default_app_key: return new_default_app.is_default = True if old_default_app_key: old_default_app = App.get(old_default_app_key) old_default_app.is_default = False put_and_invalidate_cache(new_default_app, old_default_app) on_trans_committed(logging.info, "Default app updated from %s (%s) to %s (%s)", old_default_app.app_id, old_default_app.name, new_default_app.app_id, new_default_app.name) else: put_and_invalidate_cache(new_default_app)
def trans_create(): azzert(not get_user_profile(app_user, cached=False)) avatar, image = _create_new_avatar(app_user, add_trial_overlay=False) user_profile = UserProfile(parent=parent_key(app_user), key_name=app_user.email()) user_profile.name = name user_profile.language = language user_profile.avatarId = avatar.key().id() user_profile.app_id = get_app_id_from_app_user(app_user) _calculateAndSetAvatarHash(user_profile, image) put_and_invalidate_cache(user_profile, ProfilePointer.create(app_user), ProfileHashIndex.create(app_user)) return user_profile
def _put_and_invalidate_cache_and_allocate_ids(*models): @db.non_transactional def _allocate_non_transactional(): _allocate() def _allocate(): from google.appengine.api import datastore datastore._GetConnection()._reserve_keys([m.key() for m in models if m.key().id() is not None]) put_and_invalidate_cache(*models) if db.is_in_transaction(): _allocate_non_transactional() else: _allocate()
def trans(): app = get_app(app_id) to_put = [app] app.admin_services = data.admin_services app.name = data.name app.type = data.type app.main_service = data.main_service app.facebook_app_id = data.facebook_app_id app.ios_app_id = data.facebook_app_secret app.android_app_id = data.android_app_id app.dashboard_email_address = data.dashboard_email_address app.contact_email_address = data.contact_email_address app.user_regex = data.user_regex app.demo = data.demo app.beta = data.beta app.secure = data.secure app.chat_enabled = data.chat_enabled app.mdp_client_id = data.mdp_client_id app.mdp_client_secret = data.mdp_client_secret app.owncloud_base_uri = data.owncloud_base_uri app.owncloud_admin_username = data.owncloud_admin_username app.owncloud_admin_password = data.owncloud_admin_password if set(app.embedded_apps).symmetric_difference(data.embedded_apps): deferred.defer(send_update_all_embedded_apps, app_id, _countdown=2, _transactional=True) app.embedded_apps = data.embedded_apps old_auto_connected_services = {acs.service_identity_email for acs in app.auto_connected_services} app.auto_connected_services = AutoConnectedServices() for acs in data.auto_connected_services: service_identity_user = add_slash_default(users.User(acs.service_identity_email)) if service_identity_user in identities_to_patch: si = get_service_identity(service_identity_user) si.appIds.append(app_id) to_put.append(si) acs.service_identity_email = service_identity_user.email() app.auto_connected_services.add(acs) new_acs = [acs for acs in app.auto_connected_services if acs.service_identity_email not in old_auto_connected_services] if new_acs: logging.info('There are new auto-connected services for %s: %s', app_id, [acs.service_identity_email for acs in new_acs]) for acs in new_acs: deferred.defer(connect_auto_connected_service, app_id, acs, _transactional=True) put_and_invalidate_cache(*to_put) return app
def trans(old_default_app): old_default_app_key = old_default_app and old_default_app.key() new_default_app = get_app(app_id) if new_default_app.key() == old_default_app_key: return new_default_app new_default_app.is_default = True if old_default_app_key: old_default_app.is_default = False put_and_invalidate_cache(new_default_app, old_default_app) on_trans_committed(logging.info, 'Default app updated from %s (%s) to %s (%s)', old_default_app.app_id, old_default_app.name, new_default_app.app_id, new_default_app.name) else: put_and_invalidate_cache(new_default_app) return new_default_app
def trans(): sln_settings = get_solution_settings(service_user) translated_broadcast_types = get_translated_broadcast_types( sln_settings) diff = set(translated_broadcast_types).symmetric_difference( broadcast_types) if diff: raise InvalidBroadcastTypeException(diff.pop()) sln_settings.broadcast_types = [ translated_broadcast_types[bt] for bt in broadcast_types ] sln_settings.updates_pending = True put_and_invalidate_cache(sln_settings) broadcast_updates_pending(sln_settings)
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
def setup_qr_templates(self, app_id): app = App.get(App.create_key(app_id)) app.qrtemplate_keys = list() description = u"DEFAULT" key_name = create_qr_template_key_name(app_id, description) store_template(None, DEFAULT_QR_CODE_OVERLAY, description, u"".join(("%X" % c).rjust(2, '0') for c in DEFAULT_QR_CODE_COLOR), key_name) app.qrtemplate_keys.append(key_name) description = u"HAND" key_name = create_qr_template_key_name(app_id, description) store_template(None, HAND_ONLY_QR_CODE_OVERLAY, description, u"".join(("%X" % c).rjust(2, '0') for c in DEFAULT_QR_CODE_COLOR), key_name) app.qrtemplate_keys.append(key_name) put_and_invalidate_cache(app)
def create_prospect_from_customer(customer): azzert(customer.prospect_id is None and customer.service_email) contact = Contact.get_one(customer.key()) azzert(contact) si = get_default_service_identity(users.User(customer.service_email)) prospect = Prospect(key_name=str(uuid.uuid4()) + str(uuid.uuid4())) prospect.name = customer.name prospect.address = ', '.join(filter(None, [customer.address1 + ((' ' + customer.address2) if customer.address2 else ''), customer.zip_code, customer.city, OFFICIALLY_SUPPORTED_COUNTRIES.get(customer.country, customer.country)])) prospect.phone = contact.phone_number prospect.email = contact.email prospect.type = ['establishment'] if customer.organization_type == OrganizationType.EMERGENCY: prospect.type.append('health') prospect.customer_id = customer.id prospect.status = Prospect.STATUS_CUSTOMER prospect.app_id = si.app_id solution_server_settings = get_solution_server_settings() prospect.add_comment(u'Converted customer to prospect', users.User(solution_server_settings.shop_no_reply_email)) try: result = geo_code(prospect.address) except GeoCodeZeroResultsException: try: result = geo_code(' '.join(filter(None, [customer.zip_code, customer.city, OFFICIALLY_SUPPORTED_COUNTRIES.get(customer.country, customer.country)]))) except GeoCodeZeroResultsException: logging.warn('Could not geo_code customer: %s', db.to_dict(customer)) return prospect.geo_point = db.GeoPt(result['geometry']['location']['lat'], result['geometry']['location']['lng']) customer.prospect_id = prospect.id prospect.customer_id = customer.id logging.info('Creating prospect: %s', db.to_dict(prospect, dict(prospect_id=prospect.id))) put_and_invalidate_cache(customer, prospect) return prospect
def _delete_ownership_users(service_email): to_put = [] for up in UserProfile.all().filter("owningServiceEmails =", service_email): if service_email in up.owningServiceEmails: up.owningServiceEmails.remove(service_email) if list(get_user_active_mobiles(up.user)): if not up.owningServiceEmails: up.isCreatedForService = False to_put.append(up) else: if not up.owningServiceEmails: deferred.defer(delete_account, up.user, _countdown=5) else: to_put.append(up) if to_put: put_and_invalidate_cache(*to_put)
def trans(): app = get_app(app_id) to_be_put = [app] si_users = [add_slash_default(users.User(acs.service_identity_email)) for acs in services] service_identities = get_service_identities_by_service_identity_users(si_users) for si, acs in zip(service_identities, services): if not si: raise ServiceWithEmailDoesNotExistsException(acs.service_identity_email) if app_id not in si.appIds: si.appIds.append(app_id) to_be_put.append(si) acs.service_identity_email = si.user.email() app.auto_connected_services.add(acs) put_and_invalidate_cache(*to_be_put)
def delete_app(app_id): app = get_app(app_id) validate_can_delete_app(app) to_delete = [ AppSettings.create_key(app_id), app.key() ] to_put = [] for profile_key in UserProfile.all(keys_only=True).filter('app_id', app_id): delete_account(users.User(profile_key.parent().name())) for other_app in App.all(): if app_id in other_app.orderable_app_ids: other_app.orderable_app_ids.remove(app_id) to_put.append(other_app) db.delete(to_delete) if to_put: put_and_invalidate_cache(to_put)
def trans_create(avatar_image): azzert(not get_user_profile(app_user, cached=False)) avatar, image = _create_new_avatar(app_user, False, avatar_image) user_profile = UserProfile(parent=parent_key(app_user), key_name=app_user.email()) user_profile.name = name user_profile.language = language user_profile.avatarId = avatar.key().id() user_profile.app_id = get_app_id_from_app_user(app_user) user_profile.owncloud_password = owncloud_password if tos_version: user_profile.tos_version = tos_version if consent_push_notifications_shown: user_profile.consent_push_notifications_shown = True _calculateAndSetAvatarHash(user_profile, image) put_and_invalidate_cache(user_profile, ProfilePointer.create(app_user), ProfileHashIndex.create(app_user)) return user_profile
def trans(): to_put = set() service_profile = get_service_profile(service_user) if not service_profile.editableTranslationSet: logging.error("Deploy translation error - no editable translation found for svc %s" % service_user.email()) return # 1. Archive old active translation set if service_profile.activeTranslationSet: old_active_translation_set = ServiceTranslationSet.get(service_profile.activeTranslationSet) old_active_translation_set.status = ServiceTranslationSet.ARCHIVED to_put.add(old_active_translation_set) # 2. Promote old editable translation set to new active service_profile.activeTranslationSet = service_profile.editableTranslationSet to_put.add(service_profile) new_active_translation_set = ServiceTranslationSet.get(service_profile.activeTranslationSet) new_active_translation_set.status = ServiceTranslationSet.ACTIVE to_put.add(new_active_translation_set) # 3. Create new editable translation set new_editable_translation_set = ServiceTranslationSet.create_editable_set(service_user) new_editable_translation_set.latest_export_timestamp = new_active_translation_set.latest_export_timestamp service_profile.editableTranslationSet = str(new_editable_translation_set.key()) to_put.add(new_editable_translation_set) # 4. Copy existing translations to new branding_translations_dict = None for tr in ServiceTranslation.all().ancestor(new_active_translation_set).fetch(None): translation_dict = tr.translation_dict if tr.translation_type == ServiceTranslation.BRANDING_CONTENT: branding_translations_dict = translation_dict to_put.add(ServiceTranslation.create(new_editable_translation_set, tr.translation_type, translation_dict)) # 5. Store all in db put_and_invalidate_cache(*to_put) return service_profile, branding_translations_dict
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
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)
def trans(): # type: () -> tuple[Mobile, UserProfile, bool] keys = (mobile_key, ms_key, get_user_profile_key(current_user)) mobile, ms, my_profile = db.get(keys) # type: (Mobile, MobileSettings, UserProfile) if mobile.account not in my_profile.mobiles: logging.warn('Mobile account "%s" of user %s has been unregistered', mobile.account, current_user) return mobile, my_profile, False if appType != MISSING: mobile.type = my_profile.mobiles[mobile.account].type_ = appType if simCountry != MISSING: mobile.simCountry = simCountry if simCountryCode != MISSING: mobile.simCountryCode = simCountryCode if simCarrierCode != MISSING: mobile.simCarrierCode = simCarrierCode if simCarrierName != MISSING: mobile.simCarrierName = simCarrierName if netCountry != MISSING: mobile.netCountry = netCountry if netCountryCode != MISSING: mobile.netCountryCode = netCountryCode if netCarrierCode != MISSING: mobile.netCarrierCode = netCarrierCode if netCarrierName != MISSING: mobile.netCarrierName = netCarrierName if deviceModelName != MISSING: mobile.hardwareModel = deviceModelName if osVersion != MISSING: mobile.osVersion = osVersion if localeCountry != MISSING: mobile.localeCountry = localeCountry if localeLanguage != MISSING: mobile.localeLanguage = localeLanguage if timezone != MISSING: mobile.timezone = timezone if timezoneDeltaGMT != MISSING: mobile.timezoneDeltaGMT = timezoneDeltaGMT if deviceId != MISSING: mobile.deviceId = deviceId language = mobile.localeLanguage if language: should_update_embedded_apps = False if '-' in language: language = get_iso_lang(language.lower()) elif mobile.localeCountry: language = '%s_%s' % (mobile.localeLanguage, mobile.localeCountry) if my_profile.language != language: my_profile.language = language # trigger friend.update service api call deferred.defer(update_friend_service_identity_connections, my_profile.key(), [u"language"], _transactional=True) db.delete_async(get_broadcast_settings_flow_cache_keys_of_user(my_profile.user)) if embeddedApps: should_update_embedded_apps = True deferred.defer(update_look_and_feel_for_user, current_user, _transactional=True, _queue=FAST_QUEUE) # User updated to app version x.1.x, send custom translations # todo: this will also trigger when user updates from 3.0.x to 3.1.x which we don't really want should_update_embedded_apps = should_update_embedded_apps or majorVersion > 1 and ms.majorVersion == 0 # Update when embedded apps are different should_update_embedded_apps = should_update_embedded_apps or not set(embeddedApps).issubset( set(my_profile.embedded_apps or [])) if should_update_embedded_apps: deferred.defer(update_embedded_app_translations_for_user, current_user, embeddedApps, language, _transactional=True) ms.majorVersion = majorVersion ms.minorVersion = minorVersion ms.lastHeartBeat = now_time my_profile.country = mobile.netCountry or mobile.simCountry or mobile.localeCountry my_profile.timezone = mobile.timezone my_profile.timezoneDeltaGMT = mobile.timezoneDeltaGMT my_profile.embedded_apps = embeddedApps must_update_app_settings = False if my_profile.tos_version != get_current_document_version(DOC_TERMS): if mobile.is_android: version = Features.ASK_TOS.android elif mobile.is_ios: version = Features.ASK_TOS.ios else: version = Version(0, 1) must_update_app_settings = Version(majorVersion, minorVersion) >= version put_and_invalidate_cache(ms, mobile, my_profile) return mobile, my_profile, must_update_app_settings
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 post(self): from rogerthat.pages.shortner import get_short_url_by_code from rogerthat.service.api import friends as service_api_friends version = self.request.get("version", None) install_id = self.request.get("install_id", None) registration_time = self.request.get("registration_time", None) device_id = self.request.get("device_id", None) registration_id = self.request.get("registration_id", None) qr_url = self.request.get("qr_url", None) signature = self.request.get("signature", None) language = self.request.get("language", None) country = self.request.get("country", None) app_id = self.request.get("app_id", App.APP_ID_ROGERTHAT) use_xmpp_kick_channel = self.request.get('use_xmpp_kick', 'true') == 'true' GCM_registration_id = self.request.get('GCM_registration_id', '') if '-' in language: language = get_iso_lang(language.lower()) elif language and country: language = '%s_%s' % (language, country) server_settings = get_server_settings() calculated_signature = sha256_hex(version + " " + install_id + " " + registration_time + " " + device_id + " " + \ registration_id + " " + qr_url + base64.b64decode(server_settings.registrationMainSignature.encode("utf8"))) try: if signature.upper() != calculated_signature.upper(): logging.error("Invalid request signature.") self.response.set_status(500) return app = _verify_app_id(app_id) azzert(app is not None, "app_id is not found") bizz_check(install_id and qr_url, u"Could not validate QR code") installation = Installation.get_by_key_name(install_id) if not installation: platform = self.request.get("platform", None) if platform == "android": mobile_type = Mobile.TYPE_ANDROID_HTTP elif platform == "iphone": if use_xmpp_kick_channel: mobile_type = Mobile.TYPE_IPHONE_HTTP_XMPP_KICK else: mobile_type = Mobile.TYPE_IPHONE_HTTP_APNS_KICK elif platform == "windows_phone": mobile_type = Mobile.TYPE_WINDOWS_PHONE else: logging.error("Unknown platform: %s" % platform) self.response.set_status(500) return now_ = now() installation = Installation(key_name=install_id, version=version, platform=mobile_type, timestamp=now_, app_id=app_id) installation_log = InstallationLog(parent=installation, timestamp=now_, description="Installed with language %s" % language) installation_log_app_id = InstallationLog(parent=installation, timestamp=now_, description="Installed with app_id: %s" % app_id) put_and_invalidate_cache(installation, installation_log, installation_log_app_id) InstallationLog(parent=installation, timestamp=now(), description="Creating qr based profile & validating registration request. Language: %s, QR url: %s" % (language, qr_url)).put() m = re.match('(.*)/(M|S)/(.*)', qr_url) bizz_check(m, u"Could not validate QR code") entry_point = m.group(2) code = m.group(3) bizz_check(entry_point == "S", u"Could not validate QR code") su = get_short_url_by_code(code) bizz_check(su, u"Could not validate QR code") logging.debug("register_via_qr qr_url: %s", qr_url) logging.debug("register_via_qr su.full: %s", su.full) match = re.match("^/q/s/(.+)/(\\d+)$", su.full) bizz_check(match, u"Could not validate QR code") user_code = match.group(1) service_profile = get_service_profile_via_user_code(user_code) bizz_check(service_profile, u"Could not validate QR code") service_user = service_profile.user sid = int(match.group(2)) service_interaction_def = get_service_interaction_def(service_user, int(sid)) service_identity_user = create_service_identity_user(service_user, service_interaction_def.service_identity) service_identity = get_identity_from_service_identity_user(service_identity_user) svc_profile = get_service_profile(service_user) logging.debug("register_via_qr service_identity_user: %s", service_identity_user) human_user = users.User(u"*****@*****.**" % uuid.uuid4().get_hex()) app_user = create_app_user(human_user, app_id) from rogerthat.bizz.profile import _create_new_avatar avatar, _ = _create_new_avatar(app_user, add_trial_overlay=False) user_profile = UserProfile(parent=parent_key(app_user), key_name=app_user.email()) user_profile.name = None user_profile.language = language user_profile.avatarId = avatar.key().id() user_profile.app_id = get_app_id_from_app_user(app_user) user_details = [UserDetailsTO.fromUserProfile(user_profile)] r = service_api_friends.register(None, None, svc_profile, service_identity=service_identity, user_details=user_details, origin=REGISTRATION_ORIGIN_QR, PERFORM_CALLBACK_SYNCHRONOUS=True) logging.debug("register_via_qr with id: %s", r) bizz_check(r == ACCEPT_ID or r == ACCEPT_AND_CONNECT_ID, u"Service denied your install") installation.service_identity_user = service_identity_user installation.service_callback_result = r installation.qr_url = su.full[4:] installation.put() # Create registration entry. self.response.headers['Content-Type'] = 'text/json' registration = Registration(parent=parent_key(app_user), key_name=registration_id) registration.timestamp = int(registration_time) registration.device_id = device_id registration.pin = -1 registration.timesleft = -1 registration.installation = installation registration.language = language registration.put() account, registration.mobile, age_and_gender_set = register_mobile(human_user, app_id=app_id, use_xmpp_kick_channel=use_xmpp_kick_channel, GCM_registration_id=GCM_registration_id, language=registration.language) installation_log = InstallationLog(parent=installation, timestamp=now(), profile=get_user_profile(app_user), \ description="Profile created & registration request validated.", \ registration=registration, mobile=registration.mobile) db.put([registration, installation_log]) self.response.out.write(json.dumps(dict(account=account.to_dict(), email=human_user.email(), age_and_gender_set=age_and_gender_set))) except BusinessException, be: logging.debug("BusinessException during via QR handler %s", be) self.response.set_status(500) return
def trans_update(mfds): service_profile = get_service_profile(service_user) service_profile.version += 1 put_and_invalidate_cache(service_profile, *mfds)