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))