def test_get_friend_emails(self):
FRIEND_AMOUNT = 14
for x in xrange(1, FRIEND_AMOUNT + 1):
print 'Creating friend', x
friend_email = u'*****@*****.**' % x
friend_user = users.User(friend_email)
create_user_profile(friend_user, friend_email)
if x % 2:
convert_user_to_service(friend_user)
print 'Connecting with friend', x
makeFriends(users.get_current_user(), friend_user, users.get_current_user(), servicetag=None,
origin=ORIGIN_USER_INVITE)
start = time.time()
response = getFriendEmails(GetFriendEmailsRequestTO())
l = list()
for email in response.emails:
r = GetFriendRequestTO()
r.email = email
r.avatar_size = 100
l.append(getFriend(r))
print 'getFriendEmails took', time.time() - start, 'seconds'
self.assertEqual(FRIEND_AMOUNT, len(response.emails))
self.assertEqual(FRIEND_AMOUNT, len(l))
def testStoreChunk(self):
chunk_content1 = "bla"
b64_zipped_content1 = base64.b64encode(zlib.compress(chunk_content1))
hash_ = hashlib.sha256(chunk_content1)
chunk_content2 = "bla2"
b64_zipped_content2 = base64.b64encode(zlib.compress(chunk_content2))
hash_2 = hashlib.sha256(chunk_content2)
hash_ = hash_.hexdigest().upper()
service_identity_user = users.User("[email protected]/+default+")
store_chunk(users.get_current_user(), service_identity_user, "parent_message_key", "message_key", 2, 1,
b64_zipped_content1, hash_, None)
hash_2 = hash_2.hexdigest().upper()
store_chunk(users.get_current_user(), service_identity_user, "parent_message_key", "message_key", 2, 2,
b64_zipped_content2, hash_2, None)
photo_upload_result = get_transfer_result("parent_message_key", "message_key")
assert photo_upload_result.total_chunks == 2
chunks = get_transfer_chunks(photo_upload_result.key())
len_chunks = 0
for photo_upload_chunk in chunks:
len_chunks = len_chunks + 1
assert photo_upload_result.total_chunks == len_chunks
chunk_id_check = 1
for photo_upload_chunk in chunks:
assert photo_upload_chunk.number == chunk_id_check
chunk_id_check += 1
def testGetLocation(self):
request = GetLocationRequestTO()
request.friend = users.get_current_user().email()
mobile = users.get_current_mobile()
request.high_prio = False
request.target = GetLocationRequestTO.TARGET_MOBILE if mobile else GetLocationRequestTO.TARGET_WEB
getLocation(get_location_response_handler, logError, users.get_current_user(), request=request)
def testSendLongMessageWithoutSpaces(self):
from rogerthat.bizz.messaging import sendMessage
# Set current mobile to iPhone
users.get_current_mobile().type = Mobile.TYPE_IPHONE_HTTP_APNS_KICK
# Send message
message = u"qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890qwertyuiopasdfghjklzxcvbnm1234567890"
m = sendMessage(MC_DASHBOARD, [UserMemberTO(users.get_current_user())], 1, 0, None, message, [], None, None, None, is_mfr=False)
sendMessage(MC_DASHBOARD, [UserMemberTO(users.get_current_user())], 1, 0, m.mkey, message, [], None, None, None, is_mfr=False)
def testSetUserWith(self):
user1 = users.User(u"*****@*****.**")
set_current_user(user1)
user2 = users.User(u"*****@*****.**")
with set_current_user(user2):
self.assertEqual(users.get_current_user(), user2)
self.assertEqual(users.get_current_user(), user1)
def rm_broadcast_test_person(email, app_id=None):
from rogerthat.bizz.service.broadcast import delete_broadcast_test_person
service_user = users.get_current_user()
default_service_identity_user = create_service_identity_user(service_user, ServiceIdentity.DEFAULT)
app_id = get_and_validate_app_id_for_service_identity_user(default_service_identity_user, app_id, email)
try:
delete_broadcast_test_person(users.get_current_user(), create_app_user(users.User(email), app_id))
return RETURNSTATUS_TO_SUCCESS
except BusinessException, be:
return ReturnStatusTO.create(False, be.message)
def testSetUser(self):
user1 = users.User(u"*****@*****.**")
create_user_profile(user1, user1.email())
set_current_user(user1)
self.assertEqual(users.get_current_user(), user1)
user2 = users.User(u"*****@*****.**")
create_user_profile(user2, user2.email())
set_current_user(user2)
self.assertEqual(users.get_current_user(), user2)
def send_form(parent_key, parent_message_key, member, message, form, flags, alert_flags, branding, tag,
service_identity=None, context=None, attachments=None, app_id=None, broadcast_guid=None, step_id=None):
from rogerthat.bizz.messaging import sendForm
from rogerthat.bizz.service import get_and_validate_service_identity_user, get_and_validate_app_id_for_service_identity_user
flags = 0 # flags are currently not used; clear any flags set by api client (e.g. ALLOW_DISMISS or SHARED_MEMBERS)
service_identity_user = get_and_validate_service_identity_user(users.get_current_user(), service_identity)
app_id = get_and_validate_app_id_for_service_identity_user(service_identity_user, app_id, member)
fm = sendForm(service_identity_user, parent_key if parent_key != MISSING else parent_message_key,
create_app_user(users.User(member), app_id), message, form, flags, branding, tag, alert_flags,
context=context, attachments=attachments, is_mfr=users.get_current_user().is_mfr,
broadcast_guid=broadcast_guid, step_id=step_id)
return fm.mkey
def get(self):
web_user = users.get_current_user()
if not web_user and not self.set_user():
self.abort(401)
return
email, _ = get_app_user_tuple(users.get_current_user())
user_id = get_uid(email.email())
if web_user:
token = create_custom_token(user_id, {})
else:
token = create_custom_token(user_id, {}, True)
response = {
'token': token
}
self.response.write(json.dumps(response))
def order_delete(order_key, message):
service_user = users.get_current_user()
try:
delete_pharmacy_order(service_user, order_key, message)
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
return ReturnStatusTO.create(False, e.message)
def solution_remind_event(service_user, email, method, params, tag,
service_identity, user_details):
settings = get_solution_settings(service_user)
jsondata = json.loads(params)
app_user = create_app_user_by_email(email, user_details[0].app_id)
event_id = long(jsondata['eventId'])
remind_before = int(jsondata['remindBefore'])
if jsondata.get("eventStartEpoch", None):
event_start_epoch = int(jsondata['eventStartEpoch'])
else:
event_start_epoch = get_event_by_id(service_user, settings.solution,
event_id).start_dates[0]
r = SendApiCallCallbackResultTO()
if is_reminder_set(app_user, event_id, event_start_epoch,
remind_before) is False:
er = EventReminder()
er.service_identity_user = create_service_identity_user(
users.get_current_user(), service_identity)
er.human_user = app_user
er.remind_before = remind_before
er.event_id = event_id
er.event_start_epoch = event_start_epoch
er.put()
r.result = u"successfully reminded"
else:
r.result = u"already reminded"
r.error = None
return r
def load_orders():
service_user = users.get_current_user()
customer = get_customer(service_user)
if not customer:
logging.error("Customer not found for %s", service_user)
return []
return [OrderTO.fromOrderModel(order) for order in Order.list_signed(customer)]
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 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 edit_reservation_tables(reservation_key, tables):
from solutions.common.bizz.reservation import edit_reservation_tables as edit_reservation_tables_bizz
try:
edit_reservation_tables_bizz(users.get_current_user(), reservation_key, tables)
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
return ReturnStatusTO.create(False, e.message)
def add_city_wide_lottery_info(city_app_id, winnings, date, x_winners):
service_user = users.get_current_user()
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 = SolutionCityWideLottery.load_pending(city_app_id)
if ll_info:
logging.warn("end_timestamp: %s", end_timestamp)
logging.warn("ll_info.end_timestamp: %s", ll_info.end_timestamp)
if end_timestamp <= ll_info.end_timestamp:
raise BusinessException("lottery-time-bigger-first-upcoming")
ll_info = SolutionCityWideLottery(parent=SolutionCityWideLottery.create_parent_key(city_app_id))
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.x_winners = x_winners
ll_info.winners = []
ll_info.winner_info = []
ll_info.skip_winners = []
ll_info.deleted = False
ll_info.pending = True
ll_info.put()
send_message(service_user, u"solutions.common.loyalty.lottery.update")
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
return ReturnStatusTO.create(False, common_translate(sln_settings.main_language, SOLUTION_COMMON, e.message))
def load_invoices():
service_user = users.get_current_user()
customer = get_customer(service_user)
if not customer:
logging.error("Customer not found for %s", service_user)
return []
return [InvoiceTO.fromInvoiceModel(invoice) for invoice in get_invoices(customer)]
def rest_put_discussion_group(discussion):
service_user = users.get_current_user()
discussion_id = None if discussion.id is MISSING else discussion.id
discussion_group = put_discussion_group(service_user, discussion.topic,
discussion.description,
discussion_id)
return DiscussionGroupTO.from_model(discussion_group)
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 load_unsinged_orders():
service_user = users.get_current_user()
customer = get_customer(service_user)
if not customer:
logging.error("Customer not found for %s", service_user)
return []
return [OrderTO.fromOrderModel(order) for order in Order.list_unsigned(customer) if order.order_number != Order.CUSTOMER_STORE_ORDER_NUMBER]
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_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):
service_user = users.get_current_user()
sln_settings = get_solution_settings(service_user)
if SolutionModule.CITY_VOUCHERS not in sln_settings.modules:
self.response.set_status(404)
return
app_id = self.request.get('a')
customer = get_customer(service_user)
if app_id != customer.app_id:
self.response.set_status(404)
return
year = self.request.get('y')
month = self.request.get('m')
sln_city_voucher_export_key = SolutionCityVoucherExport.create_key(
app_id, year, month)
export = SolutionCityVoucherExport.get(sln_city_voucher_export_key)
if export:
self.response.headers['Content-Type'] = 'application/vnd.ms-excel'
filename = get_exported_filename(sln_settings.main_language, year,
month)
self.response.headers['Content-Disposition'] = str(
'attachment; filename=%s' % filename)
self.response.write(export.xls)
else:
self.response.set_status(404)
def can_edit_city_postal_codes():
service_user = users.get_current_user()
sln_settings = get_solution_settings(service_user)
if SolutionModule.CITY_APP not in sln_settings.modules:
raise BusinessException(common_translate(sln_settings.main_language,
SOLUTION_COMMON, u'insufficient-permissions'))
return sln_settings
def press_menu_item(service, coords, generation, context):
# generation is service identity menuGeneration
from rogerthat.bizz.service import press_menu_item as press_menu_item_bizz
user = users.get_current_user()
service_identity_user = add_slash_default(users.User(service))
azzert(get_friend_serviceidentity_connection(user, service_identity_user), "%s tried to press menu item of service %s" % (user.email(), service))
press_menu_item_bizz(user, service_identity_user, coords, context, generation, timestamp=now())
def remove_order_weekday_timeframe(timeframe_id):
service_user = users.get_current_user()
try:
delete_order_weekday_timeframe(service_user, timeframe_id)
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
return ReturnStatusTO.create(False, e.message)
def edit_city_wide_lottery_info(key, winnings, date, x_winners):
ll_info_edit = SolutionCityWideLottery.get(key)
if not ll_info_edit:
return RETURNSTATUS_TO_SUCCESS
service_user = users.get_current_user()
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 = SolutionCityWideLottery.load_pending(ll_info_edit.app_id)
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.x_winners = x_winners
ll_info_edit.put()
send_message(service_user, u"solutions.common.loyalty.lottery.update")
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
return ReturnStatusTO.create(False, common_translate(sln_settings.main_language, SOLUTION_COMMON, e.message))
def get(self):
service_user = users.get_current_user()
azzert(get_service_profile(service_user)) # must exist
message_flow_designs = get_service_message_flow_designs(service_user)
result = []
for wiring in message_flow_designs:
if wiring.deleted or not wiring.definition:
continue
wiringDefinition = json.loads(wiring.definition)
for k in wiringDefinition.iterkeys():
if k == u"modules":
for m in wiringDefinition[k]:
if m["value"]:
m["config"]["formMessageDef"] = m["value"]
result.append({"name": wiring.name, "language": wiring.language, "working": json.dumps(wiringDefinition)})
if not result:
wiring_id = "Sample message flow"
language = "MessageFlow"
result.append({"name": wiring_id, "language": language, "working": SAMPLE_MF})
message_flow_design = MessageFlowDesign(parent=parent_key(service_user), key_name=wiring_id)
message_flow_design.definition = SAMPLE_MF
message_flow_design.name = wiring_id
message_flow_design.language = language
message_flow_design.design_timestamp = now()
message_flow_design.status = MessageFlowDesign.STATUS_VALID
message_flow_design.js_flow_definitions = JsFlowDefinitions()
message_flow_design.put()
self.response.out.write(json.dumps(result))
def post(self):
description = self.request.get("description", None)
platform = int(self.request.get("platform", 0))
platform_version = self.request.get("platform_version", None)
timestamp = long(self.request.get("timestamp", 0))
mobicage_version = self.request.get("mobicage_version", None)
error_message = self.request.get("error_message", None)
logging.debug("Error logged over HTTP:\n%s", error_message)
ler = LogErrorRequestTO()
ler.description = description
ler.platform = platform
ler.platformVersion = platform_version
ler.timestamp = timestamp
ler.mobicageVersion = mobicage_version
ler.errorMessage = error_message
from rogerthat.bizz.system import logErrorBizz
user = self.request.headers.get("X-MCTracker-User", None)
password = self.request.headers.get("X-MCTracker-Pass", None)
if user and password:
users.set_json_rpc_user(base64.decodestring(user), base64.decodestring(password))
return logErrorBizz(ler, users.get_current_user())
else:
# language = self.request.get("language", None) # Unused
# deviceId = self.request.get("device_id", None) # Unused
install_id = self.request.get("install_id", None)
return logErrorBizz(ler, user=None, install_id=install_id)
def order_send_message(order_key, order_status, message):
service_user = users.get_current_user()
try:
send_message_for_order(service_user, order_key, order_status, message)
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
return ReturnStatusTO.create(False, e.message)
def post(self):
user = users.get_current_user()
app_id = self.request.get("app_id")
if not app_id:
app_id = self.request.POST.get("app_id_hidden", None)
if not app_id:
self.redirect('/admin/osa/launcher/apps')
return
uploaded_file = self.request.POST.get('package') # type: FieldStorage
if not isinstance(uploaded_file, FieldStorage):
self.redirect('/admin/osa/launcher/apps')
return
filename = '%s/oca/launcher/apps/%s.apk' % (ROGERTHAT_ATTACHMENTS_BUCKET, app_id)
upload_to_gcs(uploaded_file.value, uploaded_file.type, filename)
version_code = long(self.request.get("version_code"))
app = OSALauncherApp.get_by_app_id(app_id)
if not app:
app = OSALauncherApp(key=OSALauncherApp.create_key(app_id))
app.user = user
app.timestamp = now()
app.app_id = app_id
app.version_code = version_code
app.package = None
app.put()
self.redirect('/admin/osa/launcher/apps')
def breakFriendship(request):
from rogerthat.bizz.friends import breakFriendShip as bizzBreakFriendship
from rogerthat.rpc import users
user = users.get_current_user()
bizzBreakFriendship(user, users.User(request.friend), users.get_current_mobile())
slog('T', user.email(), "com.mobicage.api.friends.breakFriendShip", email=request.friend)
return None
def putGroup(request):
from rogerthat.bizz.friends import putGroup as putGroupBizz
from rogerthat.rpc import users
response = PutGroupResponseTO()
avatar_hash_str = putGroupBizz(users.get_current_user(), request.guid, request.name, request.members, request.avatar, users.get_current_mobile())
response.avatar_hash = None if avatar_hash_str is None else avatar_hash_str.decode('utf-8')
return response
def del_profile_data(email, profile_data_keys, app_id):
from rogerthat.bizz.profile import set_profile_data
service_user = users.get_current_user()
validate_app_admin(service_user, [app_id])
set_profile_data(service_user,
create_app_user(users.User(email), app_id),
json.dumps(dict(((key, None) for key in profile_data_keys))))
def list_users(app_id, cursor):
service_user = users.get_current_user()
validate_app_admin(service_user, [app_id])
if cursor:
cursor = decrypt(service_user, cursor)
query = get_user_profiles_by_app_id(app_id)
query.with_cursor(cursor)
user_profiles = query.fetch(1000)
cursor = query.cursor()
extra_key = query.fetch(1)
result = AppUserListResultTO()
result.cursor = unicode(encrypt(service_user, cursor)) if len(extra_key) > 0 else None
work = Queue()
results = Queue()
for items in [user_profiles[x:x + 50] for x in xrange(0, len(user_profiles), 50)]:
work.put(items)
def slave():
while True:
try:
user_profiles = work.get_nowait()
except Empty:
break # No more work, goodbye
try:
friendMaps = db.get([get_friends_map_key_by_user(user_profile.user) for user_profile in user_profiles])
for user_profile, friendMap in zip(user_profiles, friendMaps):
results.put(AppUserTO(user_profile, friendMap))
except Exception, e:
results.put(e)
def remove_from_order(item_id):
service_user = users.get_current_user()
customer = get_customer(service_user)
azzert(customer)
customer_store_order_key = Order.create_key(
customer.id, Order.CUSTOMER_STORE_ORDER_NUMBER)
order_item_key = OrderItem.create_key(customer.id,
Order.CUSTOMER_STORE_ORDER_NUMBER,
item_id)
order_item, order = db.get([order_item_key, customer_store_order_key])
if not order_item:
logging.warn(
"Customer %s tried to delete an already deleted item (%s)",
service_user.email(), item_id)
return RETURNSTATUS_TO_SUCCESS
azzert(order)
# Subtract the price from this product, then remove the product.
vat = order_item.count * order_item.price * order.vat_pct / 100
total = order_item.count * order_item.price
total_inc_vat = total + vat
order.amount -= total
order.total_amount -= total_inc_vat
order.vat -= vat
order_item.delete()
order.put()
return RETURNSTATUS_TO_SUCCESS
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 getMessages(cursor):
from rogerthat.rpc import users
user = users.get_current_user()
result = RootMessageListTO()
result.messages, result.cursor = _get_messages(cursor, user)
result.batch_size = MESSAGES_BATCH_SIZE
return result
def uitdatabank_check_cityapp_settings():
service_user = users.get_current_user()
cap = get_cityapp_profile(service_user)
sln_settings = get_solution_settings(service_user)
try:
success, result = get_uitdatabank_events(cap, 1, 50)
if not success:
try:
result = translate(sln_settings.main_language, SOLUTION_COMMON,
result)
except ValueError:
pass
except Exception:
logging.debug('Failed to check uitdatabank.be settings: %s',
dict(key=cap.uitdatabank_key,
regions=cap.uitdatabank_regions),
exc_info=1)
success, result = False, translate(sln_settings.main_language,
SOLUTION_COMMON,
'error-occured-unknown-try-again')
def trans():
cap = get_cityapp_profile(service_user)
if success:
cap.uitdatabank_enabled = True
cap.put()
return RETURNSTATUS_TO_SUCCESS
cap.uitdatabank_enabled = False
cap.put()
return ReturnStatusTO.create(False, result)
return db.run_in_transaction(trans)
def trans():
friendMap = get_friends_map(users.get_current_user())
response = GetFriendEmailsResponseTO()
response.emails = [remove_app_id(f).email() for f in friendMap.friends]
response.generation = friendMap.generation
response.friend_set_version = friendMap.version
return response
def start_admin_debugging(app_user, timeout):
mobiles = list(get_user_active_mobiles(app_user))
azzert(len(mobiles) == 1)
m = mobiles[0]
if m.type in (Mobile.TYPE_IPHONE_HTTP_APNS_KICK,
Mobile.TYPE_IPHONE_HTTP_XMPP_KICK,
Mobile.TYPE_WINDOWS_PHONE) \
or (m.is_android and m.pushId):
# No XMPP account needs to be created
settings = get_server_settings()
jid = base64.b64encode(encrypt_value(md5(settings.secret), users.get_current_user().email().encode('utf8')))
password = None
type_ = CurrentlyForwardingLogs.TYPE_GAE_CHANNEL_API
else:
account = generate_account(u'dbg_%s' % uuid.uuid4().get_hex())
if not APPSCALE:
create_jabber_account(account, None)
jid = account.account
password = account.password
type_ = CurrentlyForwardingLogs.TYPE_XMPP
def trans():
debug_request = StartDebuggingRequest(key=StartDebuggingRequest.create_key(app_user, jid),
timestamp=now())
db.put_async(debug_request)
deferred.defer(stop_debugging, app_user, jid, debug_request=debug_request, notify_user=False,
_countdown=timeout * 60, _transactional=True, _queue=SCHEDULED_QUEUE)
return start_log_forwarding(app_user, jid, xmpp_target_password=password, type_=type_)
xg_on = db.create_transaction_options(xg=True)
return db.run_in_transaction_options(xg_on, trans)
def getFriend(request):
from rogerthat.rpc import users
from rogerthat.dal.friend import get_friends_map
from rogerthat.pages.profile import get_avatar
user = users.get_current_user()
friendMap = get_friends_map(user)
response = GetFriendResponseTO()
response.generation = friendMap.generation
friend = users.User(request.email)
avatar_size = 100 if request.avatar_size is MISSING else request.avatar_size
def populateFriendResponse():
friendDetail = friendMap.friendDetails[friend.email()]
response.friend = FriendTO.fromDBFriendDetail(friendDetail, True, True, targetUser=user)
response.avatar = unicode(base64.b64encode(get_avatar(friendDetail.avatarId, avatar_size)))
if friend.email() in friendMap.friendDetails:
populateFriendResponse()
else:
friend = create_app_user(friend, get_app_id_from_app_user(user))
if friend.email() in friendMap.friendDetails:
populateFriendResponse()
else:
response.friend = None
response.avatar = None
return response
def getStaticFlow(request):
from rogerthat.dal.service import get_service_menu_item_by_coordinates
from rogerthat.rpc import users
service_identity_user = add_slash_default(users.User(request.service))
get_service_identity(service_identity_user) # azzerts
smd = get_service_menu_item_by_coordinates(service_identity_user, request.coords)
if not smd:
logging.info("No menu item found with coords %s" % request.coords)
return None
if smd.isBroadcastSettings:
response = GetStaticFlowResponseTO()
helper = FriendHelper.from_data_store(service_identity_user, FRIEND_TYPE_SERVICE)
response.staticFlow = generate_broadcast_settings_static_flow(helper, users.get_current_user())
return response
if not smd.staticFlowKey:
logging.info("Menu item %s doesn't reference a static flow" % request.coords)
return None
mfd = MessageFlowDesign.get(smd.staticFlowKey)
static_flow = mfd.js_flow_definitions.get_by_hash(request.staticFlowHash)
if not static_flow:
logging.info("No static flow found on MFD '%s' with hash %s" % (mfd.name, request.staticFlowHash))
return None
response = GetStaticFlowResponseTO()
response.staticFlow = static_flow.definition
return response
def get(self):
user = users.get_current_user()
self.response.headers['Content-Type'] = 'text/json'
app_settings = get_app_settings(App.APP_ID_ROGERTHAT)
user_profile = get_user_profile(user)
self.response.out.write(
json.dumps(serialize_complex_value(SettingsTO.fromDBSettings(app_settings, user_profile, Settings.get()), SettingsTO, False)))
def post(self):
params = dict(self.request.POST)
logging.debug("PaymentLoginAppHandler with params %s", params)
user = self.request.headers.get("X-MCTracker-User", None)
password = self.request.headers.get("X-MCTracker-Pass", None)
if not (user and password):
logging.debug("user not provided")
self.response.set_status(500)
return
if not users.set_json_rpc_user(base64.decodestring(user), base64.decodestring(password)):
logging.debug("user not set")
self.response.set_status(500)
return
app_user = users.get_current_user()
state = params["state"]
login_state = get_login_state(state)
if app_user != login_state.app_user:
self.response.set_status(500)
logging.error("%s tried to finish anothers user login %s", app_user, state)
return
token = get_api_module(login_state.provider_id).handle_code(login_state)
logging.debug('Received token: %s', token)
if not finish_login_state(state, token):
logging.debug("user already finished this login")
self.response.set_status(500)
return
args = {"result": "success",
"payment_provider": serialize_complex_value(
get_payment_provider_for_user(app_user, login_state.provider_id), AppPaymentProviderTO, False)}
r = json.dumps(args)
self.response.out.write(r)
def pokeService(request):
from rogerthat.rpc import users
current_user = users.get_current_user()
timestamp = None if request.timestamp is MISSING else request.timestamp
poke_service_by_hashed_tag(current_user, add_slash_default(users.User(request.email)), request.hashed_tag,
request.context, timestamp)
return None
def post(self):
try:
user = users.get_current_user()
tb = TempBlob(parent=parent_key(user))
tb.timeout = now() + 24 * 60 * 60
image = self.request.get("newAvatar")
image_type = imghdr.what(None, image)
try:
img = images.Image(image)
img.horizontal_flip()
img.horizontal_flip()
orig_width = img.width
orig_height = img.height
orig_image = image
size = min(100, 100 * 4000 / max(orig_width, orig_height)) # max 4000 wide/high
while len(image) > (1024 * 1024 - 100 * 1024):
size -= size / 10
img = images.Image(orig_image)
img.resize(orig_width * size / 100, orig_height * size / 100)
image = img.execute_transforms(images.JPEG if image_type == 'jpeg' else images.PNG)
tb.blob = db.Blob(image)
except images.NotImageError:
logging.info("Sending failure to the logged on users (%s) channel" % user.email())
self.response.out.write(broadcast_via_iframe_result(u"rogerthat.profile.avatar_upload_failed", error=u"The uploaded file is not an image!"))
return
except IOError, e:
logging.info("Sending failure to the logged on users (%s) channel" % user.email())
self.response.out.write(broadcast_via_iframe_result(u"rogerthat.profile.avatar_upload_failed", error=e.message))
return
except BadRequestError, e:
logging.info("Sending failure to the logged on users (%s) channel" % user.email())
self.response.out.write(broadcast_via_iframe_result(u"rogerthat.profile.avatar_upload_failed",
error=e.message))
return
def cancel_location_tracker(tracker_key):
from rogerthat.bizz.location import disable_service_location_tracker
"""
Cancels the location tracking for a certain user
"""
service_user = users.get_current_user()
disable_service_location_tracker(service_user, tracker_key)
def get(self):
user = users.get_current_user()
path = os.path.join(os.path.dirname(__file__), "about.html")
self.response.out.write(template.render(path, {
'user':user,
'session':users.create_logout_url("/") if user else users.create_login_url("/")}))
def get(self):
user = users.get_current_user()
key = self.request.GET['key']
tb = TempBlob.get(key)
azzert(tb.parent_key() == parent_key(user))
self.response.headers['Content-Type'] = "image/png"
self.response.out.write(tb.blob)
def get(self):
user = users.get_current_user()
path = os.path.join(os.path.dirname(__file__), 'explorer.html')
self.response.out.write(template.render(path, {
'debug':DEBUG,
'user':user,
'session':create_logout_url("/")}))
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 delete_loyalty_visit(key):
service_user = users.get_current_user()
try:
delete_visit(service_user, key)
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_order_weekday_timeframe(timeframe_id, day, time_from, time_until):
service_user = users.get_current_user()
try:
put_order_weekday_timeframe(service_user, timeframe_id, day, time_from,
time_until)
return RETURNSTATUS_TO_SUCCESS
except BusinessException, e:
return ReturnStatusTO.create(False, e.message)
def get_billing_contacts():
from shop.models import Contact
service_user = users.get_current_user()
customer = get_customer(service_user)
if not customer:
logging.error("Customer not found for %s", service_user)
return []
return [ContactTO.fromContactModel(c) for c in Contact.list(customer)]
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 get(self):
service_user = users.get_current_user()
logo = db.get(self.MODEL_CLASS.create_key(service_user))
self.response.headers['Content-Type'] = "image/png"
if logo and logo.picture:
self.response.out.write(str(logo.picture))
else:
self.response.out.write(self.not_found())
def signup(user, service_name, service_description):
solution_server_settings = get_solution_server_settings()
azzert(users.get_current_user() == users.User(
solution_server_settings.solution_trial_service_email))
user = users.User(user)
from rogerthat.bizz.service.yourservicehere import signup as trial_signup
return trial_signup(user, service_name, service_description, True)
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 get_order_timeframes():
service_user = users.get_current_user()
sln_settings = get_solution_settings(service_user)
return [
SolutionOrderWeekdayTimeframeTO.fromModel(f,
sln_settings.main_language)
for f in SolutionOrderWeekdayTimeframe.list(service_user,
sln_settings.solution)
]
