def _repair_order_received(service_user, message_flow_run_id, member, steps, end_id, end_message_flow_id, parent_message_key,
tag, result_key, flush_id, flush_message_flow_id, service_identity, user_details):
from solutions.common.bizz.messaging import send_inbox_forwarders_message
logging.info("_flow_member_result_repair_order: \n %s" % steps)
remarks = _get_value(steps[0], u'message_remarks')
if steps[1].answer_id == u"positive":
picture_url = _get_value(steps[1], u'message_picture')
else:
picture_url = None
sln_settings = get_solution_settings(service_user)
logging.info("Saving repair order from %s" % user_details[0].email)
service_identity_user = create_service_identity_user_wo_default(service_user, service_identity)
o = SolutionRepairOrder(parent=parent_key_unsafe(service_identity_user, sln_settings.solution))
o.description = remarks
o.sender = SolutionUser.fromTO(user_details[0])
o.timestamp = steps[1].received_timestamp
o.status = SolutionRepairOrder.STATUS_RECEIVED
o.picture_url = picture_url
o.user = user_details[0].toAppUser() if user_details else None
msg = common_translate(sln_settings.main_language, SOLUTION_COMMON, 'if-repair-order-received',
remarks=remarks)
message = create_solution_inbox_message(service_user, service_identity, SolutionInboxMessage.CATEGORY_REPAIR, None, False, user_details, steps[1].received_timestamp, msg, True, [picture_url] if picture_url else [])
o.solution_inbox_message_key = message.solution_inbox_message_key
o.put()
message.category_key = unicode(o.key())
message.put()
sln_i_settings = get_solution_settings_or_identity_settings(sln_settings, service_identity)
sm_data = []
sm_data.append({u"type": u"solutions.common.repair_orders.update"})
sm_data.append({u"type": u"solutions.common.messaging.update",
u"message": serialize_complex_value(SolutionInboxMessageTO.fromModel(message, sln_settings, sln_i_settings, True), SolutionInboxMessageTO, False)})
send_message(service_user, sm_data, service_identity=service_identity)
attachments = []
if picture_url:
att = AttachmentTO()
att.content_type = AttachmentTO.CONTENT_TYPE_IMG_JPG
att.download_url = picture_url
att.name = common_translate(sln_settings.main_language, SOLUTION_COMMON, u'picture')
att.size = 0
attachments = [att]
app_user = user_details[0].toAppUser()
send_inbox_forwarders_message(service_user, service_identity, app_user, msg, {
'if_name': user_details[0].name,
'if_email':user_details[0].email
}, message_key=message.solution_inbox_message_key, attachments=attachments, reply_enabled=message.reply_enabled)
def _resolve_voucher(service_user, service_identity, url):
'''Lookup the provided URL. Can be a city voucher. Else it will be treated as a custom loyalty card.'''
# 1/ Check if a custom loyalty card already exists for this URL
custom_loyalty_card = CustomLoyaltyCard.get_by_url(url)
if custom_loyalty_card and custom_loyalty_card.app_user:
human_user, app_id = get_app_user_tuple(custom_loyalty_card.app_user)
return _create_resolve_result(CustomLoyaltyCard.TYPE, url,
human_user.email(), app_id)
# 2/ Check if it's a city voucher
si = system.get_identity(service_identity)
poke_information, city_service_user = _find_voucher(url, si.app_ids)
if not poke_information or not poke_information.tag.startswith(
POKE_TAG_CITY_VOUCHER_QR):
# 2.1/ Not a city voucher
logging.debug(
'Unknown QR code scanned: %s. Loyalty device will create custom paper loyalty card.',
url)
user_info = GetUserInfoResponseTO()
user_info.app_id = user_info.email = user_info.name = user_info.qualifiedIdentifier = u'dummy'
return _create_resolve_result(u'unknown', url, u'dummy', u'dummy')
# 2.2/ It is a city voucher
data = json.loads(poke_information.tag[len(POKE_TAG_CITY_VOUCHER_QR):])
ancestor_key = SolutionCityVoucher.create_parent_key(data["app_id"])
sln_city_voucher = SolutionCityVoucher.get_by_id(data["voucher_id"],
ancestor_key)
if not sln_city_voucher:
logging.debug("Could not find city voucher for data: %s", data)
raise Exception("Could not find city voucher")
sln_settings = get_solution_settings(service_user)
r_dict = dict()
r_dict["type"] = SolutionCityVoucher.TYPE
r_dict["app_id"] = sln_city_voucher.app_id
r_dict["voucher_id"] = sln_city_voucher.key().id()
r_dict["uid"] = sln_city_voucher.uid
if sln_city_voucher.activated:
if sln_city_voucher.expired:
raise BusinessException(
common_translate(sln_settings.main_language, SOLUTION_COMMON,
'Voucher has expired'))
r_dict["status"] = 1
r_dict["value"] = sln_city_voucher.value
r_dict["redeemed_value"] = sln_city_voucher.redeemed_value
elif service_user == city_service_user:
r_dict["status"] = 2
else:
raise BusinessException(
common_translate(sln_settings.main_language, SOLUTION_COMMON,
'Voucher not activated'))
return r_dict
def _send_denied_signup_email(city_customer, signup, lang, reason):
subject = common_translate(city_customer.language,
SOLUTION_COMMON,
u'signup_request_denied_by_city',
city=city_customer.name)
message = common_translate(city_customer.language,
SOLUTION_COMMON,
u'signup_request_denial_reason',
reason=reason)
city_from = '%s <%s>' % (city_customer.name, city_customer.user_email)
send_mail(city_from, signup.customer_email, subject, message)
def get(self):
data_dict, app_user = self.get_user_info()
if not data_dict or not app_user:
language = self.request.get("language", DEFAULT_LANGUAGE)
title = common_translate(language, SOLUTION_COMMON, u'Error')
text = common_translate(language, SOLUTION_COMMON, u"error-occured-unknown-try-again")
else:
azzert(data_dict['a'] == "loyalty_no_mobiles_lottery_winner")
service_email = data_dict['e']
service_identity_user = users.User(service_email)
service_user, service_identity = get_service_identity_tuple(service_identity_user)
user_profile = db.get(UserProfile.createKey(app_user))
if user_profile:
language = self.request.get("language", user_profile.language)
if redeem_lottery_winner(service_user, service_identity, data_dict['mk'], app_user, user_profile.name):
title = common_translate(language, SOLUTION_COMMON, u'Success')
text = common_translate(language, SOLUTION_COMMON, u'loyalty-lottery-loot-receive')
else:
title = common_translate(language, SOLUTION_COMMON, u'Error')
text = common_translate(language, SOLUTION_COMMON, u'Unfortunately you have not confirmed on time and lost your chance')
else:
language = self.request.get("language", DEFAULT_LANGUAGE)
title = common_translate(language, SOLUTION_COMMON, u'Error')
text = common_translate(language, SOLUTION_COMMON, u"error-occured-unknown-try-again")
params = {
'title': title,
'text': text
}
jinja_template = JINJA_ENVIRONMENT.get_template('pages/loyalty_title_text.html')
self.response.out.write(jinja_template.render(params))
def solution_voucher_pin_activate(service_user, email, method, params, tag,
service_identity, user_details):
logging.debug("Received voucher pin activate call with params: %s", params)
sln_settings = get_solution_settings(service_user)
r = SendApiCallCallbackResultTO()
r.result = None
r.error = None
try:
jsondata = json.loads(params)
city_service_users = get_service_users_for_city(jsondata["app_id"])
if not city_service_users:
raise Exception(u"No city_service_users")
if service_user not in city_service_users:
raise Exception(u"Normal service tried activating voucher")
ancestor_key = SolutionCityVoucher.create_parent_key(
jsondata["app_id"])
sln_city_voucher = SolutionCityVoucher.get_by_id(
jsondata["voucher_id"], ancestor_key)
if not sln_city_voucher:
raise Exception(u"sln_city_voucher was None")
if sln_city_voucher.activated:
raise Exception(u"sln_city_voucher was already activated")
sln_city_voucher_settings = get_city_vouchers_settings(
jsondata["app_id"])
if not sln_city_voucher_settings:
raise Exception(u"sln_city_voucher_settings was None")
if jsondata["pin"] not in sln_city_voucher_settings.pincodes:
r.error = common_translate(sln_settings.main_language,
SOLUTION_COMMON, 'Pincode invalid')
return r
index = sln_city_voucher_settings.pincodes.index(jsondata["pin"])
r_dict = dict()
r_dict["username"] = sln_city_voucher_settings.usernames[index]
result = json.dumps(r_dict)
r.result = result if isinstance(result,
unicode) else result.decode("utf8")
except:
logging.error("solutions.voucher.activate.pin exception occurred",
exc_info=True)
r.error = common_translate(sln_settings.main_language, SOLUTION_COMMON,
'error-occured-unknown')
return r
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 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 set_default_broadcast_types(sln_settings, solution=SOLUTION_COMMON):
if not sln_settings.broadcast_types:
sln_settings.broadcast_types = []
for broadcast_type in DEFAULT_BROADCAST_TYPES:
translated = common_translate(sln_settings.main_language, solution,
broadcast_type)
sln_settings.broadcast_types.append(translated)
def trans():
sln_i_settings_key = SolutionIdentitySettings.create_key(
service_user, service_identity)
sln_i_settings = SolutionIdentitySettings(key=sln_i_settings_key)
sln_i_settings.name = name
sln_i_settings.phone_number = sln_settings.phone_number
sln_i_settings.qualified_identifier = sln_settings.qualified_identifier
sln_i_settings.description = sln_settings.description
sln_i_settings.opening_hours = sln_settings.opening_hours
sln_i_settings.address = sln_settings.address
sln_i_settings.location = sln_settings.location
sln_i_settings.search_keywords = sln_settings.search_keywords
sln_i_settings.inbox_forwarders = []
sln_i_settings.inbox_connector_qrcode = None
sln_i_settings.inbox_mail_forwarders = []
sln_i_settings.inbox_email_reminders_enabled = False
sln_i_settings.holidays = []
sln_i_settings.holiday_out_of_office_message = common_translate(
sln_settings.main_language, SOLUTION_COMMON,
'holiday-out-of-office')
sln_i_settings.put()
if not sln_settings.identities:
sln_settings.identities = []
sln_settings.identities.append(service_identity)
sln_settings.put()
on_trans_committed(_create_service_identity, service_user,
sln_i_settings, broadcast_to_users)
def send_expired_voucher_message(voucher_key, sln_settings, days):
voucher = SolutionCityVoucher.get(voucher_key)
if not voucher or days in voucher.expiration_reminders_sent:
return
language = sln_settings.main_language
service_user = sln_settings.service_user
branding = get_solution_main_branding(service_user).branding_key
if voucher.owner:
activation_date = format_timestamp(voucher.activation_date,
sln_settings,
format='medium')
message = common_translate(language,
SOLUTION_COMMON,
u'voucher_expiration_message',
days=days,
date=activation_date)
with users.set_user(sln_settings.service_user):
member = MemberTO()
member.alert_flags = Message.ALERT_FLAG_VIBRATE
member.member = voucher.owner.email()
member.app_id = voucher.app_id
messaging.send(parent_key=None,
parent_message_key=None,
message=message,
answers=[],
flags=Message.FLAG_ALLOW_DISMISS,
members=[member],
branding=branding,
tag=None)
voucher.expiration_reminders_sent.append(days)
db.put(voucher)
def order_sandwich_received(service_user, message_flow_run_id, member, steps, end_id, end_message_flow_id, parent_message_key,
tag, result_key, flush_id, flush_message_flow_id, service_identity, user_details):
type_ = get_first_fmr_step_result_value(steps, u'message_type')
topping = get_first_fmr_step_result_value(steps, u'message_topping')
customizations = get_first_fmr_step_result_value(steps, u'message_customize')
remark = get_first_fmr_step_result_value(steps, u'message_remark')
takeaway_time = get_first_fmr_step_result_value(steps, u'message_takeaway_time')
deferred.defer(process_sandwich_order, service_user, service_identity, user_details, type_, topping, customizations,
remark, takeaway_time, parent_message_key)
sln_settings = get_solution_settings(service_user)
main_branding = get_solution_main_branding(service_user)
result = FlowMemberResultCallbackResultTO()
result.type = TYPE_MESSAGE
result.value = MessageCallbackResultTypeTO()
result.value.flags = Message.FLAG_ALLOW_DISMISS | Message.FLAG_AUTO_LOCK
result.value.answers = []
result.value.alert_flags = Message.ALERT_FLAG_SILENT
result.value.attachments = []
result.value.branding = main_branding.branding_key
result.value.dismiss_button_ui_flags = 0
result.value.tag = None
result.value.message = common_translate(sln_settings.main_language, SOLUTION_COMMON, u'order-sandwich-received')
result.value.step_id = u'message_sandwich_ordered'
return result
def 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 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 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 try_to_translate(key, language):
try:
return common_translate(language,
SOLUTION_COMMON,
key,
suppress_warning=True)
except:
return key
def _send_signup_status_inbox_reply(sln_settings, parent_chat_key, approved,
reason):
lang = sln_settings.main_language
if approved:
message = common_translate(lang, SOLUTION_COMMON, u'approved')
else:
message = common_translate(lang,
SOLUTION_COMMON,
u'signup_request_denial_reason',
reason=reason)
inbox_message = new_inbox_message(sln_settings,
message,
parent_chat_key,
mark_as_read=not approved,
mark_as_trashed=approved)
return inbox_message
def create_qr():
return qr.create(common_translate(
get_solution_settings(service_user).main_language,
SOLUTION_COMMON,
u'upload_menu_item_image',
item_name=item.name),
json.dumps(tag),
qr_template_id,
flow=u'Upload image')
def restapi_add_city_postal_code(app_id, postal_code):
try:
sln_settings = can_edit_city_postal_codes()
add_city_postal_code(app_id, postal_code)
return RETURNSTATUS_TO_SUCCESS
except ValueError:
return ReturnStatusTO.create(False, common_translate(sln_settings.main_language,
SOLUTION_COMMON, u'invlid_postal_code'))
except BusinessException as e:
return ReturnStatusTO.create(False, e.message)
def trans():
sln_settings = get_solution_settings(service_user)
menu = get_restaurant_menu(service_user, sln_settings.solution)
category = menu.categories[category_id]
if not category:
return create_error(
common_translate(sln_settings.main_language,
SOLUTION_COMMON,
u'category_not_found',
name=category_name))
for item in category.items:
if item.id == item_id:
break
else:
return create_error(
common_translate(sln_settings.main_language,
SOLUTION_COMMON,
u'item_not_found',
name=item_name))
if item.image_id:
delete_file_blob(service_user, item.image_id)
response = download_image()
if response.status_code != 200:
return create_error(
common_translate(sln_settings.main_language, SOLUTION_COMMON,
u'error-occured-unknown-try-again'))
item.image_id = create_file_blob(service_user,
response.content).key().id()
menu.put()
on_trans_committed(channel.send_message,
service_user,
'solutions.common.menu.item_image_configured',
category=serialize_complex_value(
category, MenuCategory, False),
item=serialize_complex_value(item, MenuItem, False))
return None
def trans():
sln_settings = get_solution_settings(service_user)
m = get_restaurant_menu(service_user, sln_settings.solution)
if not m:
m = RestaurantMenu(key=RestaurantMenu.create_key(
service_user, sln_settings.solution))
m.is_default = False
m.predescription = menu.predescription
m.postdescription = menu.postdescription
m.categories = MenuCategories()
category_names = list()
for c in menu.categories:
if c.name in category_names:
raise BusinessException(
common_translate(sln_settings.main_language,
SOLUTION_COMMON,
"category_duplicate_name",
name=c.name))
if c.id == MISSING:
c.id = str(uuid.uuid4()).decode('UTF-8')
category_names.append(c.name)
item_names = list()
for i in c.items:
if i.name in item_names:
raise BusinessException(
common_translate(sln_settings.main_language,
SOLUTION_COMMON,
"product_duplicate_name",
name=i.name))
if i.id == MISSING:
i.id = str(uuid.uuid4()).decode('UTF-8')
item_names.append(i.name)
m.categories.add(c)
sln_settings.updates_pending = True
put_and_invalidate_cache(m, sln_settings)
return sln_settings
def get(self):
data_dict, app_user = self.get_user_info()
if not data_dict or not app_user:
language = self.request.get("language", DEFAULT_LANGUAGE)
title = common_translate(language, SOLUTION_COMMON, u'Error')
text = common_translate(language, SOLUTION_COMMON, u"error-occured-unknown-try-again")
else:
azzert(data_dict['a'] == "loyalty_no_mobiles_unsubscribe")
service_name = data_dict['n']
service_identity_user_email = data_dict['e']
suls_key = SolutionUserLoyaltySettings.createKey(app_user)
suls = SolutionUserLoyaltySettings.get(suls_key)
if not suls:
suls = SolutionUserLoyaltySettings(key=suls_key)
suls.reminders_disabled = False
suls.reminders_disabled_for = []
if service_identity_user_email not in suls.reminders_disabled_for:
suls.reminders_disabled_for.append(service_identity_user_email)
suls.put()
user_profile = db.get(UserProfile.createKey(app_user))
if user_profile:
language = self.request.get("language", user_profile.language)
else:
language = self.request.get("language", DEFAULT_LANGUAGE)
title = common_translate(language, SOLUTION_COMMON, u'You have been unsubscribed')
text = common_translate(language, SOLUTION_COMMON, u'You will not receive any loyalty updates from "%(name)s" anymore', name=service_name)
params = {
'title': title,
'text': text
}
jinja_template = JINJA_ENVIRONMENT.get_template('pages/loyalty_title_text.html')
self.response.out.write(jinja_template.render(params))
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 put_order_weekday_timeframe(service_user, timeframe_id, day, time_from,
time_until):
sln_settings = get_solution_settings(service_user)
if time_from == time_until:
raise BusinessException(
common_translate(sln_settings.main_language, SOLUTION_COMMON,
'time-start-end-equal'))
if time_from >= time_until:
raise BusinessException(
common_translate(sln_settings.main_language, SOLUTION_COMMON,
'time-start-end-smaller'))
sln_settings = get_solution_settings(service_user)
if timeframe_id:
sawt = SolutionOrderWeekdayTimeframe.get_by_id(
timeframe_id, parent_key(service_user, sln_settings.solution))
if not sawt:
# Already deleted before channel update went through
send_message(service_user,
u"solutions.common.order.settings.timeframe.update")
return
sawt.day = day
sawt.time_from = time_from
sawt.time_until = time_until
else:
sawt = SolutionOrderWeekdayTimeframe.get_or_create(
parent_key(service_user, sln_settings.solution), day, time_from,
time_until)
sawt.put()
sln_settings = get_solution_settings(service_user)
sln_settings.updates_pending = True
put_and_invalidate_cache(sln_settings)
broadcast_updates_pending(sln_settings)
send_message(service_user,
u"solutions.common.order.settings.timeframe.update")
def validate_sandwiches(language, sandwich_types, sandwich_toppings, sandwich_options):
"""
Args:
language (unicode)
sandwich_types (list of SandwichType)
sandwich_toppings (list of SandwichToppings)
sandwich_options (list of SandwichOptions)
Raises:
InvalidSandwichSettingsException
"""
errors = set()
type_labels = []
topping_lables = []
option_labels = []
for sandwich_type in sandwich_types:
if sandwich_type.description in type_labels:
msg = common_translate(language, SOLUTION_COMMON, 'duplicate_sandwich_type',
label=sandwich_type.description)
errors.add(msg)
else:
type_labels.append(sandwich_type.description)
for sandwich_topping in sandwich_toppings:
if sandwich_topping.description in topping_lables:
msg = common_translate(language, SOLUTION_COMMON, 'duplicate_sandwich_topping',
label=sandwich_topping.description)
errors.add(msg)
else:
topping_lables.append(sandwich_topping.description)
for sandwich_option in sandwich_options:
if sandwich_option.description in option_labels:
msg = common_translate(language, SOLUTION_COMMON, 'duplicate_sandwich_option',
label=sandwich_option.description)
errors.add(msg)
else:
option_labels.append(sandwich_option.description)
if errors:
raise InvalidSandwichSettingsException('\n'.join(errors))
def put_appointment_weekday_timeframe(service_user, appointment_id, day, time_from, time_until):
sln_settings = get_solution_settings(service_user)
if time_from == time_until:
raise BusinessException(common_translate(sln_settings.main_language, SOLUTION_COMMON, 'time-start-end-equal'))
if time_from >= time_until:
raise BusinessException(common_translate(sln_settings.main_language, SOLUTION_COMMON, 'time-start-end-smaller'))
sln_settings = get_solution_settings(service_user)
if appointment_id:
sawt = SolutionAppointmentWeekdayTimeframe.get_by_id(appointment_id, parent_key(service_user, sln_settings.solution))
sawt.day = day
sawt.time_from = time_from
sawt.time_until = time_until
else:
sawt = SolutionAppointmentWeekdayTimeframe.get_or_create(parent_key(service_user, sln_settings.solution), day,
time_from, time_until)
sawt.put()
sln_settings = get_solution_settings(service_user)
sln_settings.updates_pending = True
put_and_invalidate_cache(sln_settings)
broadcast_updates_pending(sln_settings)
send_message(service_user, u"solutions.common.appointment.settings.timeframe.update")
def close_city_wide_lottery_info(key):
service_user = users.get_current_user()
try:
ll_info = SolutionCityWideLottery.get(key)
if ll_info and not ll_info.pending and not ll_info.deleted:
ll_info.deleted = True
ll_info.put()
send_message(service_user, u"solutions.common.loyalty.lottery.update",
service_identity=ll_info.service_identity)
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 bulk_invite_result(service_user, service_identity, tag, email, result, user_details):
if not tag:
logging.exception("Expected tag in bulk_invite_result")
return
if tag in (SERVICE_AUTOCONNECT_INVITE_TAG, APP_BROADCAST_TAG):
return
try:
key = db.Key(tag)
except db.BadKeyError:
logging.info('Tag is no db.Key: %s. Ignoring...', tag)
return
def trans():
invite = db.get(reconstruct_key(key))
if not invite:
logging.error("Invite object not found in datastore")
return
save_message = False
if "accepted" == result:
invite.status = RestaurantInvite.STATUS_ACCEPTED
save_message = True
else:
invite.status = RestaurantInvite.STATUS_REJECTED
invite.put()
return save_message
save_message = run_in_xg_transaction(trans)
if save_message:
now_ = now()
sln_settings = get_solution_settings(service_user)
msg = common_translate(sln_settings.main_language, SOLUTION_COMMON, 'if-accepted-invitation',
if_name=user_details[0].name,
if_email=user_details[0].email)
message = create_solution_inbox_message(
service_user, service_identity, SolutionInboxMessage.CATEGORY_BULK_INVITE, None, False, user_details, now_, msg, False)
app_user = create_app_user_by_email(user_details[0].email, user_details[0].app_id)
send_inbox_forwarders_message(service_user, service_identity, app_user, msg, {
'if_name': user_details[0].name,
'if_email': user_details[0].email
}, message_key=message.solution_inbox_message_key, reply_enabled=message.reply_enabled, send_reminder=False)
sln_i_settings = get_solution_settings_or_identity_settings(sln_settings, service_identity)
send_message(service_user, u"solutions.common.messaging.update",
service_identity=service_identity,
message=serialize_complex_value(SolutionInboxMessageTO.fromModel(message, sln_settings, sln_i_settings, True), SolutionInboxMessageTO, False))
def solution_voucher_redeem(service_user, email, method, params, tag,
service_identity, user_details):
logging.debug("Received voucher redeem call with params: %s", params)
sln_settings = get_solution_settings(service_user)
r = SendApiCallCallbackResultTO()
r.result = None
r.error = None
try:
jsondata = json.loads(params)
ancestor_key = SolutionCityVoucher.create_parent_key(
jsondata["app_id"])
sln_city_voucher = SolutionCityVoucher.get_by_id(
jsondata["voucher_id"], ancestor_key)
if not sln_city_voucher:
raise Exception(u"sln_city_voucher was None")
value = long(jsondata["value"])
if (sln_city_voucher.value - sln_city_voucher.redeemed_value) < value:
raise Exception(u"insufficient funds")
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
sln_city_voucher_rt = SolutionCityVoucherRedeemTransaction(
parent=parent_key_unsafe(service_identity_user, SOLUTION_COMMON))
sln_city_voucher_rt.created = now()
sln_city_voucher_rt.confirmed = False
sln_city_voucher_rt.value = value
sln_city_voucher_rt.voucher_key = unicode(sln_city_voucher.key())
sln_city_voucher_rt.signature = sln_city_voucher.signature()
sln_city_voucher_rt.put()
r_dict = dict()
r_dict["uid"] = sln_city_voucher.uid
r_dict["voucher_redeem_key"] = unicode(sln_city_voucher_rt.key())
r_dict["value"] = sln_city_voucher_rt.value
result = json.dumps(r_dict)
r.result = result if isinstance(result,
unicode) else result.decode("utf8")
except:
logging.error("solutions.voucher.redeem exception occurred",
exc_info=True)
r.error = common_translate(sln_settings.main_language, SOLUTION_COMMON,
'error-occured-unknown')
return r
def delete_city_wide_lottery_info(key):
ll_info_delete = SolutionCityWideLottery.get(key)
if not ll_info_delete:
return RETURNSTATUS_TO_SUCCESS
service_user = users.get_current_user()
sln_settings = get_solution_settings(service_user)
try:
ll_info = SolutionCityWideLottery.load_pending(ll_info_delete.app_id)
if ll_info_delete.key() == ll_info.key():
raise RETURNSTATUS_TO_SUCCESS
if ll_info_delete.schedule_loot_time > 0:
ll_info_delete.delete()
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))
