def login_as(account): user = users.get_current_user() session_ = users.get_current_session() if not (user and session_): logging.warning("login_as called from unauthenticated context") return # Get service identities of session.user if session_.user.email() == account: session_ = switch_to_service_identity(session_, None, False, False) users.update_session_object(session_, session_.user) logging.info("Switching session of %s from %s to %s", session_.user, user, account) return session_.user.email() else: service_identity_user = users.User(account) logging.info("Validating if %s has a role in %s", session_.user, service_identity_user) if session_.has_access(account): service_profile = get_service_profile(get_service_user_from_service_identity_user(service_identity_user)) if service_profile.expiredAt > 0: raise ServiceExpiredException() session_ = switch_to_service_identity(session_, service_identity_user, False, False) service_user, _ = get_service_identity_tuple(service_identity_user) users.update_session_object(session_, service_user) logging.info("Switching session of %s from %s to %s", session_.user, user, service_identity_user) return service_identity_user.email() logging.critical("%s tried getting access to %s!", session_.user, account)
def __init__(self, user, is_mfr=False, skip_create_session=False, set_google_user=True): from rogerthat.rpc import users self.previous_current_user = users.get_current_user() self.previous_current_session = users.get_current_session() self.previous_current_guser = gusers.get_current_user() user.is_mfr = is_mfr self._set_user(user, skip_create_session, set_google_user)
def delete_table(table_id, force): from solutions.common.bizz.reservation import get_shift_by_datetime, delete_table as delete_table_bizz service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity dtsTO = DeleteTableStatusTO() status, reservations = delete_table_bizz(service_user, service_identity, table_id, force) dtsTO.success = status dtsTO.reservations = list() if not status: for r in reservations: dtrTO = DeleteTableReservationTO() dtrTO.reservation = RestaurantReservationTO.fromReservation(r) shift, start_time = get_shift_by_datetime(service_user, service_identity, r.date) if shift: details = RestaurantShiftDetailsTO() details.shift = RestaurantShiftTO.fromShift(shift) details.start_time = TimestampTO.fromDatetime(start_time) details.reservations = list() for reservation in get_restaurant_reservation(service_user, service_identity, start_time): details.reservations.append(RestaurantReservationTO.fromReservation(reservation)) dtrTO.shift = details else: dtrTO.shift = None dtsTO.reservations.append(dtrTO) return dtsTO
def get(self): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity slide_id = self.request.get('i') if not slide_id: self.redirect("/ourcityapp") return slide_id = long(slide_id) if is_default_service_identity(service_identity): service_identity_user = service_user else: service_identity_user = create_service_identity_user(service_user, service_identity) def trans(): slide = SolutionLoyaltySlide.get_by_id(slide_id, parent=parent_key_unsafe(service_identity_user, SOLUTION_COMMON)) return slide slide = db.run_in_transaction(trans) if not slide: self.redirect("/ourcityapp") return server_settings = get_server_settings() jinja_template = JINJA_ENVIRONMENT.get_template('loyalty_preview.html') self.response.out.write(jinja_template.render({'slide_id': slide_id, 'full_url': slide.slide_url(), 'overlay_url': '%s/common/loyalty/slide/overlay' % (server_settings.baseUrl)}))
def get_statistics(year, month, day): from solutions.common.bizz.reservation import get_statistics as get_statistics_bizz service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity date = datetime(year, month, day) return get_statistics_bizz(service_user, service_identity, date)
def get(self): customer_id = int(self.request.get("customer_id")) try: customer = Customer.get_by_id(customer_id) except CustomerNotFoundException: self.abort(404) current_user = users.get_current_user() current_customer = get_customer(current_user) sln_settings = get_solution_settings(current_user) if not sln_settings.can_edit_services( current_customer) or not current_customer.can_edit_service( customer): logging.warn( 'Service or user %s is trying to login to the dashboard of %s', current_user.email(), customer.name) self.abort(401) service_identity_user = create_service_identity_user( users.User(customer.service_email)) current_session = users.get_current_session() new_secret, new_session = create_session(service_identity_user, ignore_expiration=True) set_cookie(self.response, get_server_settings().cookieSessionName, new_secret) new_session = switch_to_service_identity(new_session, service_identity_user, read_only=False, shop=current_session.shop, layout_only=True) new_session.parent_session_secret = current_session.secret new_session.put() self.redirect("/")
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 get_reservations(year, month, day, hour, minute): from solutions.common.bizz.reservation import get_shift_by_datetime, get_next_shift service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity result = list() shift, start_time = get_shift_by_datetime(service_user, service_identity, datetime(year, month, day, hour, minute)) if shift: details = RestaurantShiftDetailsTO() details.shift = RestaurantShiftTO.fromShift(shift) details.start_time = TimestampTO.fromDatetime(start_time) details.reservations = list() for reservation in get_restaurant_reservation(service_user, service_identity, start_time): details.reservations.append(RestaurantReservationTO.fromReservation(reservation)) result.append(details) shift, start_time = get_next_shift(service_user, service_identity, shift, start_time) if shift: details = RestaurantShiftDetailsTO() details.shift = RestaurantShiftTO.fromShift(shift) details.start_time = TimestampTO.fromDatetime(start_time) details.reservations = list() for reservation in get_restaurant_reservation(service_user, service_identity, start_time): details.reservations.append(RestaurantReservationTO.fromReservation(reservation)) result.append(details) return result
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 create_channel_token(): user = users.get_current_user() session = users.get_current_session() user_channel_id = get_uid(user.email()) session_channel_id = get_uid(session.key()) token = firebase.create_custom_token(user_channel_id, session_channel_id) return token, user_channel_id, session_channel_id
def load_chance_user(email, app_id): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity app_user = create_app_user_by_email(email, app_id) r = LoyaltyLotteryChanceTO() r.total_visits, r.my_visits, r.chance = calculate_chance_for_user(service_user, service_identity, app_user) return r
def delete_loyalty_slide(slide_id): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity try: loyalty_bizz.delete_loyalty_slide(service_user, service_identity, slide_id) return RETURNSTATUS_TO_SUCCESS except BusinessException, e: return ReturnStatusTO.create(False, e.message)
def save_shifts(shifts): from solutions.common.bizz.reservation import save_shifts as save_shifts_bizz try: service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity save_shifts_bizz(service_user, service_identity, shifts) return RETURNSTATUS_TO_SUCCESS except BusinessException, e: return ReturnStatusTO.create(False, e.message)
def log_error(description, errorMessage, timestamp, user_agent): request = LogErrorRequestTO() request.description = description request.errorMessage = errorMessage request.mobicageVersion = u"web" request.platform = 0 request.platformVersion = user_agent request.timestamp = timestamp from rogerthat.bizz.system import logErrorBizz return logErrorBizz(request, users.get_current_user(), session=users.get_current_session())
def update_loyalty_admin(admin_app_user_email, admin_name, admin_functions): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity try: loyalty_bizz.update_loyalty_admin( service_user, service_identity, admin_app_user_email, admin_name, admin_functions) return RETURNSTATUS_TO_SUCCESS except BusinessException, e: return ReturnStatusTO.create(False, e.message)
def rest_get_news_promoted_count(app_ids): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity if is_default_service_identity(service_identity): service_identity_user = create_service_identity_user(service_user) else: service_identity_user = create_service_identity_user( service_user, service_identity) return get_sponsored_news_count(service_identity_user, app_ids)
def update_table(table): from solutions.common.bizz.reservation import update_table as update_table_bizz try: service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity update_table_bizz(service_user, service_identity, table) return RETURNSTATUS_TO_SUCCESS except BusinessException, e: return ReturnStatusTO.create(False, e.message)
def post(self): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity slide_id = self.request.get("slide_id", "") if slide_id == "": slide_id = None else: slide_id = long(slide_id) slide_name = self.request.get("slide_name", "") try: slide_time = long(self.request.get("slide_time", 10)) except: self.response.out.write(broadcast_via_iframe_result(u"solutions.common.loyalty.slide.post_result", error=u"Please fill in valid time!")) return uploaded_file = self.request.POST.get('slide_file') # type: FieldStorage if not slide_id and not isinstance(uploaded_file, FieldStorage): self.response.out.write(broadcast_via_iframe_result(u"solutions.common.loyalty.slide.post_result", error=u"Please select a picture!")) return if not slide_id: sln_settings = get_solution_settings(service_user) if SolutionModule.HIDDEN_CITY_WIDE_LOTTERY in sln_settings.modules: service_identity_user = create_service_identity_user_wo_default(service_user, service_identity) p = parent_key_unsafe(service_identity_user, SOLUTION_COMMON) sli = SolutionLoyaltySlide.all(keys_only=True).ancestor(p).get() if sli: self.response.out.write(broadcast_via_iframe_result(u"solutions.common.loyalty.slide.post_result", error=u"A city can only have 1 active slide at a time!")) return gcs_filename = None content_type = None if isinstance(uploaded_file, FieldStorage): content_type = uploaded_file.type if not content_type.startswith("image/"): self.response.out.write(broadcast_via_iframe_result(u"solutions.common.loyalty.slide.post_result", error=u"The uploaded file is not an image!")) return date = datetime.datetime.now().strftime('%Y-%m-%d_%H:%M:%S') gcs_filename = '%s/oca/loyalty_slides/%s/%s_%s.%s' % (ROGERTHAT_ATTACHMENTS_BUCKET, service_user.email(), date, uploaded_file.filename, get_extension_for_content_type(content_type)) upload_to_gcs(uploaded_file.value, content_type, gcs_filename) put_loyalty_slide(service_user, service_identity, slide_id, slide_name, slide_time, gcs_filename, content_type) self.response.out.write(broadcast_via_iframe_result(u"solutions.common.loyalty.slide.post_result"))
def get_broken_reservations(): from solutions.common.dal.reservations import get_broken_reservations as dal_get_broken_reservations service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity settings = get_restaurant_settings(service_user, service_identity) result = [] for reservation in dal_get_broken_reservations(service_user, service_identity): alternative_shifts = [shift.name for shift in settings.shifts if reservation.date.isoweekday() in shift.days] result.append(RestaurantBrokenReservationTO.fromReservation(reservation, alternative_shifts)) return result
def load_loyalty_export_list(cursor=None): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity sln_settings = SolutionSettings.get(SolutionSettings.create_key(service_user)) exports_q = SolutionLoyaltyExport.list_by_service_user(service_user, service_identity) exports_q.with_cursor(cursor) exports_list = exports_q.fetch(10) cursor = unicode(exports_q.cursor()) to = SolutionLoyaltyExportListTO.create(cursor, [SolutionLoyaltyExportTO.from_model(e, sln_settings.main_language) for e in exports_list]) return to
def locations_use(service_identity): service_user = users.get_current_user() session_ = users.get_current_session() sln_settings = get_solution_settings(service_user) new_service_identity = ServiceIdentity.DEFAULT if sln_settings.identities: if service_identity in sln_settings.identities: new_service_identity = service_identity if session_.service_identity != new_service_identity: session_ = set_service_identity(session_, new_service_identity) send_message_to_session(service_user, session_, u"solutions.common.locations.update", si=new_service_identity)
def delete_holiday(holiday): from solutions.common.bizz.holiday import delete_holiday as delete_holiday_bizz service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity try: delete_holiday_bizz(service_user, service_identity, holiday) return RETURNSTATUS_TO_SUCCESS except BusinessException, e: sln_settings = get_solution_settings(service_user) return ReturnStatusTO.create( False, common_translate(sln_settings.main_language, SOLUTION_COMMON, e.message))
def save_out_of_office_message(message): from solutions.common.bizz.holiday import save_out_of_office_message as save_oof_message service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity try: save_oof_message(service_user, service_identity, message) return RETURNSTATUS_TO_SUCCESS except BusinessException, e: sln_settings = get_solution_settings(service_user) return ReturnStatusTO.create( False, common_translate(sln_settings.main_language, SOLUTION_COMMON, e.message))
def get(self): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity year = self.request.get('y') month = self.request.get('m') export = SolutionLoyaltyExport.get(SolutionLoyaltyExport.create_key(service_user, service_identity, year, month)) if export: self.response.headers['Content-Type'] = 'application/pdf' self.response.headers['Content-Disposition'] = str( 'attachment; filename=loyalty_export %s-%s.pdf' % (month, year)) self.response.write(export.pdf) self.response.set_status(200) else: self.response.set_status(404)
def load_loyalty_settings(): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity def trans(): sln_l_settings = SolutionLoyaltySettings.get_by_user(service_user) if is_default_service_identity(service_identity): sln_li_settings = sln_l_settings else: sln_li_settings = SolutionLoyaltyIdentitySettings.get_by_user(service_user, service_identity) return sln_l_settings, sln_li_settings xg_on = db.create_transaction_options(xg=True) sln_l_settings, sln_li_settings = db.run_in_transaction_options(xg_on, trans) return LoyaltySettingsTO.fromSolutionLoyaltySettingsObject(sln_l_settings, sln_li_settings) if sln_l_settings else None
def rest_delete_service(service_email): city_service_user = users.get_current_user() city_customer = get_customer(city_service_user) customer = Customer.get_by_service_email(service_email) if not city_customer.can_edit_service(customer): lang = get_solution_settings(city_service_user).main_language logging.warn(u'Service %s tried to save service information for customer %d', city_service_user, customer.id) return ReturnStatusTO.create(False, translate(lang, SOLUTION_COMMON, 'no_permission')) cancel_subscription(customer.id, Customer.DISABLED_REASONS[Customer.DISABLED_ASSOCIATION_BY_CITY], True) session = users.get_current_session() service_identity = session.service_identity send_message_to_session(city_service_user, session, [{u"type": u"solutions.common.services.deleted", u'service_email': service_email, u'service_organization_type': customer.organization_type}], si=service_identity) return RETURNSTATUS_TO_SUCCESS
def get(self): user_email = self.request.get('user') if not user_email: self.error(500) logging.error("user not provided") return user = users.User(user_email) if user != users.get_current_user(): session = users.get_current_session() if not session.has_access(user_email): self.error(500) logging.error("Logged in user %s does not have access to %s", session.user, user_email) return profile = get_service_or_user_profile(user) self.response.headers['Content-Type'] = "image/png" avatarId = -1 if not profile or not profile.avatarId else profile.avatarId self.response.out.write(get_avatar_cached(avatarId))
def load_specific_loyalty_settings(loyalty_type): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity sln_settings = get_solution_settings(service_user) if SolutionModule.HIDDEN_CITY_WIDE_LOTTERY in sln_settings.modules: loyalty_type = None def trans(): sln_l_settings = SolutionLoyaltySettings.get_by_user(service_user) if is_default_service_identity(service_identity): sln_li_settings = sln_l_settings else: sln_li_settings = SolutionLoyaltyIdentitySettings.get_by_user(service_user, service_identity) return sln_l_settings, sln_li_settings xg_on = db.create_transaction_options(xg=True) sln_l_settings, sln_li_settings = db.run_in_transaction_options(xg_on, trans) return LoyaltySettingsTO.fromSolutionLoyaltySettingsObject(sln_l_settings, sln_li_settings, loyalty_type) if sln_l_settings else None
def load_loyalty_scans(): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity sln_settings = get_solution_settings(service_user) loyalty_settings = SolutionLoyaltySettings.get_by_user(service_user) loyalty_scans = SolutionLoyaltyScan.get_by_service_user(service_user, service_identity) r = [] for c in loyalty_scans: visits = [] if loyalty_settings.loyalty_type == SolutionLoyaltySettings.LOYALTY_TYPE_REVENUE_DISCOUNT: visits = get_solution_loyalty_visits_for_revenue_discount( c.service_user, c.service_identity, c.app_user, loyalty_settings.x_visits) else: visits = get_solution_loyalty_visits_for_stamps( c.service_user, c.service_identity, c.app_user, loyalty_settings.x_stamps) r.append(LoyaltyScanTO.fromSolutionLoyaltyScanObject(c, loyalty_settings, sln_settings, visits)) return r
def append_firebase_params(params): """A utility function to append firebase required paramaters to a dict. Args: params (dict) """ from rogerthat.models import ServiceIdentity session = users.get_current_session() if session: server_settings = get_server_settings() token, user_channel_id, session_channel_id = create_channel_token() params['firebase_api_key'] = server_settings.firebaseApiKey params['firebase_auth_domain'] = server_settings.firebaseAuthDomain params['firebase_database_url'] = server_settings.firebaseDatabaseUrl params['firebase_token'] = token params['user_channel_id'] = user_channel_id params['session_channel_id'] = session_channel_id params['service_identity'] = session.service_identity or ServiceIdentity.DEFAULT
def add_loyalty_lottery_info(winnings, date): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity sln_settings = get_solution_settings(service_user) try: now_ = now() end_timestamp = date.toEpoch() if end_timestamp <= (now_ + 24 * 3600): raise BusinessException("end-date-24h-in-future") ll_info = SolutionLoyaltyLottery.load_pending(service_user, service_identity) if ll_info: if end_timestamp <= ll_info.end_timestamp: raise BusinessException("lottery-time-bigger-first-upcoming") service_identity_user = create_service_identity_user_wo_default(service_user, service_identity) ll_info = SolutionLoyaltyLottery(parent=parent_key_unsafe(service_identity_user, SOLUTION_COMMON)) ll_info.timestamp = now_ ll_info.end_timestamp = end_timestamp ll_info.schedule_loot_time = ll_info.end_timestamp - 24 * 3600 ll_info.winnings = winnings ll_info.winner = None ll_info.winner_info = None ll_info.winner_timestamp = 0 ll_info.skip_winners = [] ll_info.pending = True ll_info.redeemed = False ll_info.claimed = False ll_info.put() sln_settings.updates_pending = True put_and_invalidate_cache(sln_settings) broadcast_updates_pending(sln_settings) send_message(service_user, u"solutions.common.loyalty.lottery.update", service_identity=service_identity) return RETURNSTATUS_TO_SUCCESS except BusinessException, e: return ReturnStatusTO.create(False, common_translate(sln_settings.main_language, SOLUTION_COMMON, e.message))
def 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 load_detail_customer_points(loyalty_type, email, app_id): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity app_user = create_app_user_by_email(email, app_id) if loyalty_type == SolutionLoyaltySettings.LOYALTY_TYPE_REVENUE_DISCOUNT: visits = get_solution_loyalty_visits_for_revenue_discount(service_user, service_identity, app_user) elif loyalty_type == SolutionLoyaltySettings.LOYALTY_TYPE_LOTTERY: visits = get_solution_loyalty_visits_for_lottery(service_user, service_identity, app_user) else: visits = get_solution_loyalty_visits_for_stamps(service_user, service_identity, app_user) r = LoyaltyCustomerPointsTO() # XXX: don't use get_profile_infos profile_infos = get_profile_infos([app_user], allow_none_in_results=True) for app_user, profile_info in zip([app_user], profile_infos): if not profile_info or profile_info.isServiceIdentity: continue r.user_details = ExtendedUserDetailsTO.fromUserProfile(profile_info, None) app_info = get_app_info_cached(r.user_details.app_id) r.user_details.app_name = app_info.name r.visits = [SolutionLoyaltyVisitTO.fromModel(visit) for visit in visits] return r
def stop_session(self): current_session = users.get_current_session() session.drop_session(current_session) server_settings = get_server_settings() set_cookie(self.response, server_settings.cookieSessionName, current_session.parent_session_secret or "") self.redirect("/")
def create_channel_for_current_session(): return channel.create_channel(create_channel_id(users.get_current_session()))
def load_loyalty_slides(): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity return [LoyaltySlideTO.fromSolutionLoyaltySlideObject(c) for c in get_solution_loyalty_slides(service_user, service_identity)]
def stop_session(self): session.drop_session(users.get_current_session()) server_settings = get_server_settings() set_cookie(self.response, server_settings.cookieSessionName, "") self.redirect("/")
def get(self): user = users.get_current_user() if not user: signin_path = self.get_custom_signin_path(self.get_request_host()) if signin_path and self.request.path != signin_path: return self.redirect(signin_path) session_ = None user_services = None owning_user_services = None should_show_service_picker = False session_user = None session_service_identity_user = None loading_enabled = False if user: session_ = users.get_current_session() # Support reloading user_account = self.request.get("user") if user_account and user_account != user.email(): if not login_as(user_account): self.response.write("<html><body>You don't have access to account %s. This problem is logged and may cause legal action against you.</body></html>" % user_account) return user = users.get_current_user() session_ = users.get_current_session() mobile_count = get_user_active_mobiles_count(user) my_profile_info = get_profile_info(user, skip_warning=True) if not my_profile_info: my_profile_info = create_user_profile(user, user.email()) myavatarid = my_profile_info.avatarId if my_profile_info.isServiceIdentity: myname = my_profile_info.name or my_profile_info.qualifiedIdentifier or user.email() else: myname = my_profile_info.name or user.email() if my_profile_info.owningServiceEmails and my_profile_info.isCreatedForService: should_show_service_picker = True my_owning_service_identity_users = [create_service_identity_user(users.User(owning_service_email)) for owning_service_email in my_profile_info.owningServiceEmails] my_owning_service_identities = get_service_identities_by_service_identity_users(my_owning_service_identity_users) result = list() for si in my_owning_service_identities: result.append(dict(is_default=si.is_default, service_user=si.service_user.email(), service_identity_user=si.service_identity_user.email(), name=si.name, description=si.description, avatar_url=si.avatarUrl)) owning_user_services = result myname = myname.replace("\\", "\\\\").replace("'", "\\'") is_service = my_profile_info.isServiceIdentity is_trial_service_ = is_trial_service(get_service_user_from_service_identity_user(user)) if is_service else False loading_enabled = not is_service user_services = session_.service_users session_user = session_.user session_service_identity_user = session_.service_identity_user else: mobile_count = 0 my_profile_info = None myavatarid = None myname = None is_service = False is_trial_service_ = False user_services = None owning_user_services = None template_params = { 'appscale': APPSCALE, 'continue': "/", 'debug': DEBUG, 'user': user, 'myavatarid': myavatarid, 'myname': myname, 'mobile_count': mobile_count, 'is_service': is_service, 'is_trial_service': is_trial_service_, 'session': users.create_logout_url("/") if user else users.create_login_url("/"), "loading_enabled": loading_enabled, 'user_services': user_services, 'owning_user_services': owning_user_services, 'session_user': session_user, 'session_service_identity_user': session_service_identity_user, 'service_profile': None, 'email': self.request.get("email", None)} channel.append_firebase_params(template_params) if user: profile = get_service_or_user_profile(user) if is_service: if profile.tos_version != get_current_document_version(DOC_TERMS_SERVICE) and not profile.solution: logging.info('Redirecting to service terms and conditions page') self.redirect('/terms-and-conditions') return elif profile.tos_version != get_current_document_version(DOC_TERMS) and not profile.isCreatedForService: logging.info('Redirecting to user terms and conditions page') self.redirect('/terms-and-conditions') return else: profile = None if is_service: service_profile = profile template_params['service_profile'] = service_profile if not self.request.get('sp') and service_profile.solution: params = self.request.GET redirect_url = '/%s/' % service_profile.solution if params: params = dict((k, v.decode('utf8')) for k, v in params.iteritems()) redirect_url = "%s?%s" % (redirect_url, urllib.urlencode(params)) logging.info("Redirecting to url: %s" % redirect_url) self.redirect(redirect_url) return if user: if should_show_service_picker: page = "pick_account.html" else: page = "main.html" else: template_params["bg_image_uri"] = _get_front_page_image_by_ip(os.environ.get('HTTP_X_FORWARDED_FOR', None)) page = 'main_unauthenticated.html' path = os.path.join(os.path.dirname(__file__), page) self.response.out.write(template.render(path, template_params))
def orders_load(): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity return map(SolutionOrderTO.fromModel, get_solution_orders(service_user, service_identity))
def rest_get_app_statistics(): service_identity = users.get_current_session().service_identity return get_app_statistics(service_identity)