def trans():
sln_settings = get_solution_settings(service_user)
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
if group_purchase.id:
sgp = SolutionGroupPurchase.get_by_id(
group_purchase.id,
parent_key_unsafe(service_identity_user,
sln_settings.solution))
if group_purchase.new_picture:
sgp.picture_version += 1
else:
sgp = SolutionGroupPurchase(parent=parent_key_unsafe(
service_identity_user, sln_settings.solution))
sgp.picture_version = 0
sgp.title = group_purchase.title
sgp.description = group_purchase.description
sgp.units = group_purchase.units
sgp.unit_description = group_purchase.unit_description
sgp.unit_price = group_purchase.unit_price
sgp.min_units_pp = group_purchase.min_units_pp
sgp.max_units_pp = group_purchase.max_units_pp
sgp.time_from = group_purchase.time_from
sgp.time_until = group_purchase.time_until
sgp.picture = picture
sln_settings.updates_pending = True
put_and_invalidate_cache(sgp, sln_settings)
return sln_settings
def create_key(cls, service_user, service_identity):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
return db.Key.from_path(cls.kind(),
service_user.email(),
parent=parent_key_unsafe(
service_identity_user, SOLUTION_COMMON))
def create_key(service_user, service_identity):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
return db.Key.from_path(SolutionLoyaltyIdentitySettings.kind(),
service_identity_user.email(),
parent=parent_key_unsafe(
service_identity_user, SOLUTION_COMMON))
def create_key(cls, name, service_user, service_identity, solution):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
return db.Key.from_path(cls.kind(),
name,
parent=parent_key_unsafe(
service_identity_user, solution))
def create_key(service_user, service_identity, invitee, solution):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
return db.Key.from_path(RestaurantInvite.kind(),
invitee,
parent=parent_key_unsafe(
service_identity_user, solution))
def load_all(cls, service_user, service_identity):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
qry = cls.all().ancestor(
parent_key_unsafe(service_identity_user, SOLUTION_COMMON))
qry.filter('deleted =', False)
return qry
def _delete_solution_models(service_user, service_identity, solutions,
delete_svc):
solution = solutions.pop(0)
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
key = parent_key_unsafe(service_identity_user, solution)
def trans():
keys = db.GqlQuery("SELECT __key__ WHERE ANCESTOR IS KEY('%s')" %
str(key)).fetch(1000)
if keys:
db.delete(keys)
return True
else:
if solutions:
deferred.defer(_delete_solution_models,
service_user,
service_identity,
solutions,
delete_svc,
_transactional=True)
elif delete_svc and service_identity is None:
deferred.defer(delete_service.job,
service_user,
service_user,
_transactional=True)
return False
while db.run_in_transaction(trans):
pass
def solution_group_purchcase_purchase(service_user, email, method, params, tag,
service_identity, user_details):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
jsondata = json.loads(params)
group_purchase_id = int(jsondata['groupPurchaseId'])
units = int(jsondata['units'])
r = SendApiCallCallbackResultTO()
sln_settings = get_solution_settings(service_user)
try:
sgp = new_group_purchase_subscription(service_user, service_identity,
group_purchase_id,
user_details[0].name,
user_details[0], units)
r.result = u"Successfully purchased %s units" % units
r.error = None
message = translate(sln_settings.main_language,
SOLUTION_COMMON,
'group-subscription-successful-title',
units=units,
title=sgp.title)
except BusinessException, e:
r.result = e.message
r.error = None
sgp = SolutionGroupPurchase.get_by_id(
group_purchase_id,
parent_key_unsafe(service_identity_user, sln_settings.solution))
message = translate(sln_settings.main_language,
SOLUTION_COMMON,
'group-subscription-failure-title-reason',
units=units,
title=sgp.title,
reason=e.message)
def broadcast_group_purchase(service_user, service_identity, group_purchase_id,
message):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
sln_settings = get_solution_settings(service_user)
sgp = SolutionGroupPurchase.get_by_id(
group_purchase_id,
parent_key_unsafe(service_identity_user, sln_settings.solution))
sln_main_branding = get_solution_main_branding(service_user)
branding = sln_main_branding.branding_key if sln_main_branding else None
members = dict()
for e in sgp.subscriptions:
if e.sender:
member = MemberTO()
member.alert_flags = Message.ALERT_FLAG_VIBRATE
member.member = e.sender.email
member.app_id = e.sender.app_id
members["%s:%s" % (member.member, member.app_id)] = member
if members:
messaging.send(parent_key=None,
parent_message_key=None,
message=message,
answers=[],
flags=Message.FLAG_ALLOW_DISMISS,
members=members.values(),
branding=branding,
tag=None,
service_identity=service_identity)
def create_key(cls, service_user, service_identity, year, month):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
return db.Key.from_path(cls.kind(),
'%s_%s' % (year, month),
parent=parent_key_unsafe(
service_identity_user, SOLUTION_COMMON))
def txn():
sln_settings = get_solution_settings(service_user)
m = SolutionGroupPurchase.get_by_id(
group_purchase_id,
parent_key_unsafe(service_identity_user, sln_settings.solution))
azzert(service_user == m.service_user)
m.deleted = True
m.put()
def get_solution_loyalty_visits_for_lottery(service_user, service_identity,
app_user):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
qry = SolutionLoyaltyVisitLottery.all().ancestor(
parent_key_unsafe(service_identity_user, SOLUTION_COMMON)).filter(
'redeemed =', False).filter('app_user =', app_user)
return generator(qry.run())
def get_for_time_period(cls, service_user, service_identity, first_day,
last_day):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
return cls.all() \
.ancestor(parent_key_unsafe(service_identity_user, SOLUTION_COMMON)) \
.filter('redeemed_timestamp >=', first_day) \
.filter('redeemed_timestamp <', last_day)
def get_by_service_user(cls, service_user, service_identity):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
return cls.all().ancestor(
parent_key_unsafe(service_identity_user, SOLUTION_COMMON)).filter(
"processed =",
False).filter("timestamp >",
now() - (60 * 60 * 24)).order("timestamp")
def load(cls, service_user, service_identity):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
qry = cls.all().ancestor(
parent_key_unsafe(service_identity_user, SOLUTION_COMMON))
qry.filter('redeemed', False)
qry.order('-timestamp')
return qry
def create_key(cls, service_user, service_identity, app_user,
timestamp_day):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
return db.Key.from_path(cls.kind(),
"%s|%s" % (timestamp_day, app_user.email()),
parent=parent_key_unsafe(
service_identity_user, SOLUTION_COMMON))
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 load_pending(cls, service_user, service_identity):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
qry = cls.all().ancestor(
parent_key_unsafe(service_identity_user, SOLUTION_COMMON))
qry.filter('deleted =', False)
qry.filter('pending =', True)
qry.order("end_timestamp")
return qry.get()
def get_all_by_service(cls, service_user, service_identity, start_date):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
ancestor = parent_key_unsafe(service_identity_user, SOLUTION_COMMON)
return cls.all().ancestor(ancestor) \
.filter('parent_message_key', None) \
.filter('deleted =', False) \
.filter('last_timestamp >', start_date) \
.order('-last_timestamp')
def get_solution_loyalty_slides(service_user, service_identity):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
qry = SolutionLoyaltySlide.gql(
"WHERE ANCESTOR IS :ancestor AND deleted=False ORDER BY timestamp DESC"
)
qry.bind(
ancestor=parent_key_unsafe(service_identity_user, SOLUTION_COMMON))
return generator(qry.run())
def get_for_time_period(cls, service_user, service_identity, first_day,
last_day):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
return cls.all() \
.ancestor(parent_key_unsafe(service_identity_user, SOLUTION_COMMON)) \
.filter('winner_timestamp >', first_day) \
.filter('winner_timestamp <', last_day) \
.filter('deleted =', False) \
.filter('claimed', True)
def get_solution_pharmacy_orders(service_user, service_identity):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
qry = SolutionPharmacyOrder.gql(
"WHERE ANCESTOR IS :ancestor AND deleted = :deleted ORDER BY timestamp DESC"
)
qry.bind(ancestor=parent_key_unsafe(service_identity_user,
SOLUTION_COMMON),
deleted=False)
return generator(qry.run())
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 count_unread_solution_inbox_messages(service_user, service_identity):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
ancestor = parent_key_unsafe(service_identity_user, SOLUTION_COMMON)
qry = SolutionInboxMessage.all(keys_only=True).ancestor(ancestor).filter(
'parent_message_key =', None)
qry.filter('deleted =', False)
qry.filter('trashed =', False)
qry.filter('read =', False)
qry.filter('starred =', False)
return qry.count(None)
def get_solution_repair_orders(service_user,
service_identity,
solution,
cursor=None):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
qry = SolutionRepairOrder.gql(
"WHERE ANCESTOR IS :ancestor AND deleted=False ORDER BY timestamp DESC"
)
qry.with_cursor(cursor)
qry.bind(ancestor=parent_key_unsafe(service_identity_user, solution))
return generator(qry.run())
def get_solution_loyalty_visits_for_revenue_discount(service_user,
service_identity,
app_user,
max_visits=None):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
qry = SolutionLoyaltyVisitRevenueDiscount.all() \
.ancestor(parent_key_unsafe(service_identity_user, SOLUTION_COMMON)) \
.filter('redeemed =', False) \
.filter('app_user ='******'timestamp')
return qry.fetch(max_visits)
else:
qry.order('-timestamp')
return generator(qry.run())
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 get_solution_loyalty_visits_for_stamps(service_user,
service_identity,
app_user,
max_stamps=None,
return_qry=False):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
qry = SolutionLoyaltyVisitStamps.all() \
.ancestor(parent_key_unsafe(service_identity_user, SOLUTION_COMMON)) \
.filter('redeemed =', False) \
.filter('app_user ='******'timestamp')
if return_qry:
return qry
return qry.fetch(max_stamps)
else:
return generator(qry.run())
def _handle_invitation_with_secret(self, entry_point, code, su, user_agent, secret, profile_info, language, version):
# There is a secret!
logging.info("There is a secret!")
supported_platform = determine_if_platform_supports_rogerthat_by_user_agent(user_agent)
if (version and version == "web") or not supported_platform:
# Unsupported platform ===> Show sorry page with install instructions for android & iphone
logging.info("Unsupported platform ===> Show sorry page with install instructions for android & iphone")
context = {'profile': profile_info,
'payload': urllib.urlencode([("chl", "%s/S/%s?s=%s" % (get_server_settings().baseUrl, code, secret))]),
'app_name': get_app_name_by_id(profile_info.app_id)}
self.response.out.write(render('sorry_step2', language, context, 'web'))
else:
# It's a supported platform ===> redirect into the app
logging.info("It's a supported platform ===> redirect into the app!")
uis = UserInvitationSecret.get_by_id(base65.decode_int(secret),
parent=parent_key_unsafe(remove_slash_default(profile_info.user)))
if uis:
deferred.defer(_set_redirect_timestamp_of_user_invitation_secret, uis.key(), now(), _transactional=db.is_in_transaction())
full_url = "%s?%s" % (su.full, urllib.urlencode((("s", secret), ("u", profile_info.name.encode('utf8')))))
fallback_url = "%s/%s/%s?v=web" % (get_server_settings().baseUrl, entry_point, code)
redirect_to_app(self, user_agent.lower(), profile_info.app_id, full_url, fallback_url)
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_solution_inbox_messages(service_user,
service_identity,
count,
name,
cursor=None):
service_identity_user = create_service_identity_user_wo_default(
service_user, service_identity)
ancestor = parent_key_unsafe(service_identity_user, SOLUTION_COMMON)
qry = SolutionInboxMessage.all().with_cursor(cursor).ancestor(
ancestor).filter('parent_message_key =', None)
qry.filter('deleted =', False)
if name == SolutionInboxMessage.INBOX_NAME_UNREAD:
qry.filter('trashed =', False)
qry.filter('read =', False)
qry.filter('starred =', False)
elif name == SolutionInboxMessage.INBOX_NAME_STARRED:
qry.filter('trashed =', False)
qry.filter('starred =', True)
elif name == SolutionInboxMessage.INBOX_NAME_READ:
qry.filter('trashed =', False)
qry.filter('read =', True)
qry.filter('starred =', False)
elif name == SolutionInboxMessage.INBOX_NAME_TRASH:
qry.filter('trashed =', True)
else:
return None
qry.order('-last_timestamp')
messages = qry.fetch(count)
cursor_ = qry.cursor()
has_more = False
if len(messages) != 0:
qry.with_cursor(cursor_)
if len(qry.fetch(1)) > 0:
has_more = True
return unicode(cursor_), messages, has_more
def get_friend_invitation_history(user, friend):
return FriendInvitationHistory.get_by_key_name(friend.email(), parent_key_unsafe(user))
