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)
