def trans(): beacon = Beacon.all().ancestor(parent_key(si.service_user)).get() if beacon: return beacon.uuid, beacon.name app = App.get(App.create_key(si.app_id)) app.beacon_last_minor = app.beacon_last_minor + 1 name = "%s|%s" % (app.beacon_major, app.beacon_last_minor) logging.info("add_new_beacon: %s", name) if not add_new_beacon(app.beacon_uuid, name, u'Autoconnect', si.service_identity_user): raise Exception("Beacon already exists") app.put() return app.beacon_uuid, name
def get(self): url_app_id = self.request.get('id') if url_app_id: app = get_app_by_id(url_app_id) if app: self.write_app_details(app) return url_new_app = self.request.get('new_app') if url_new_app: self.write_app_details(None) return rogerthat_app = get_app_by_id(App.APP_ID_ROGERTHAT) if rogerthat_app is None: rogerthat_app = App(key=App.create_key(App.APP_ID_ROGERTHAT)) rogerthat_app.name = "Rogerthat" rogerthat_app.type = App.APP_TYPE_ROGERTHAT rogerthat_app.creation_time = now() rogerthat_app.visible = False rogerthat_app.put() template = JINJA_ENVIRONMENT.get_template('apps.html') context = self.get_request_params() context['apps'] = sorted(get_visible_apps(), key=lambda app: (app.is_default, app.name)) self.response.out.write(template.render(context))
def test_static_flex_service(self): self.set_datastore_hr_probability(1) print 'Test service creation with static modules' email = u'test1.flex.foo.com' r = create_flex_service(email, name="test", address="Antwerpsesteenweg 19\n9080 Lochristi", phone_number="+32 9 324 25 64", languages=["en", "nl"], currency=u"€", modules=list(SolutionModule.STATIC_MODULES), broadcast_types=['test1', 'test2', 'test3'], apps=[a.app_id for a in App.all()], allow_redeploy=False, organization_type=random.choice([ x for x in OrganizationType.all() if x > 0 ])) service_user = users.User(r.login) set_current_user(service_user) print 'Test provisioning of static modules' common_provision(service_user) print 'Test rendering the home page' FlexHomeHandler({}, webapp2.Response()).get()
def run(self, bucket_name, key, current_date): # type: (str, str, long) -> GeneratorType shards = max(2, int(App.all(keys_only=True).count() / 100)) # A maximum of 100 apps will be logged per shard logging.info('Starting ServiceStatsPipeline with %d shards', shards) params = { 'mapper_spec': 'rogerthat.bizz.job.service_stats.mapper', 'mapper_params': { 'bucket_name': bucket_name, 'entity_kind': 'rogerthat.models.ServiceIdentity', 'filters': [] }, 'combiner_spec': 'rogerthat.bizz.job.service_stats.combiner', 'reducer_spec': 'rogerthat.bizz.job.service_stats.reducer', 'reducer_params': { 'output_writer': { 'bucket_name': bucket_name } }, 'input_reader_spec': 'mapreduce.input_readers.DatastoreInputReader', 'output_writer_spec': 'mapreduce.output_writers.GoogleCloudStorageConsistentOutputWriter', 'shards': shards } output = yield mapreduce_pipeline.MapreducePipeline(key, **params) process_output_pipeline = yield ProcessOutputPipeline(output, current_date) with pipeline.After(process_output_pipeline): yield CleanupGoogleCloudStorageFiles(output)
def get_available_apps_for_customer(customer, demo_only=False): if not customer: return [] app_ids = (a for a in customer.sorted_app_ids if a != App.APP_ID_OSA_LOYALTY) available_apps = list(App.get(map(App.create_key, app_ids))) azzert(all(available_apps)) if available_apps[0].orderable_app_ids: extra_app_ids = set(available_apps[0].orderable_app_ids).difference( customer.sorted_app_ids) if extra_app_ids: available_apps += App.get(map(App.create_key, extra_app_ids)) if demo_only: available_apps = filter(lambda x: x.demo, available_apps) available_apps.sort(key=lambda app: app.name.upper()) return available_apps
def get(self, app_id): template = JINJA_ENVIRONMENT.get_template('app_translations.html') js_template = JINJA_ENVIRONMENT.get_template('app_translations_part.html').render() app = App.get(App.create_key(app_id)) if not app: self.response.out.write('app %s does not exist' % app_id) return app_translations_key = AppTranslations.create_key(app_id) translations = AppTranslations.get_or_insert(app_translations_key.name(), parent=app_translations_key.parent()) parameters = { 'templates': json.dumps({'app_translations_part': js_template}), 'translations': json.dumps( zlib.decompress(translations.translations) if translations.translations else None), 'app': json.dumps(serialize_complex_value(AppTO.fromModel(app), AppTO, False)) } self.response.out.write(template.render(parameters))
def test_association_creation(self): self.set_datastore_hr_probability(1) apps = [a.app_id for a in App.all()] r = create_flex_service(email=u'*****@*****.**', name=u"test", address=u"Antwerpsesteenweg 19\n9080 Lochristi", phone_number=u"+32 9 324 25 64", languages=[u"en", u"nl"], currency=u"€", modules=[SolutionModule.CITY_APP, SolutionModule.BROADCAST, SolutionModule.ASK_QUESTION, SolutionModule.WHEN_WHERE], broadcast_types=['News', 'test'], apps=apps, allow_redeploy=False, organization_type=OrganizationType.CITY) # Create city customer shop_user = users.User(u'*****@*****.**') customer_id = None vat = u'' name = u'Town Lochristi' address1 = u'Dorp - West 52' address2 = u'' zip_code = u'9080' city = u'Lochristi' country = u'BE' language = u'nl' organization_type = OrganizationType.CITY prospect_id = None city_customer = create_or_update_customer(shop_user, customer_id, vat, name, address1, address2, zip_code, city, country, language, organization_type, prospect_id, team_id=RegioManagerTeam.all().get().id) city_customer.service_email = city_customer.user_email = r.login city_customer.default_app_id = apps[0] city_customer.app_ids = apps city_customer.put() # Create city contact first_name = u'Firstname' last_name = u'Lastname' email_address = u'*****@*****.**' phone_number = u'+3293268806' create_contact(city_customer, first_name, last_name, email_address, phone_number) name = u'test-Test association' address1 = u'Antwerpsesteenweg 19' address2 = u'' zip_code = u'9080' city = u'Lochristi' user_email = u'*****@*****.**' telephone = u'+32 9 324 25 64' language = u'nl' modules = [u'agenda', u'bulk_invite', u'static_content', u'ask_question', u'broadcast'] broadcast_types = [u'Evenementen', u'Nieuws'] set_current_user(users.User(r.login), set_google_user=False) output = rest_put_service(name, address1, address2, zip_code, city, user_email, telephone, language, modules, broadcast_types) self.assertTrue(output.success, output.errormsg) self.assertFalse(output.errormsg)
def setup_qr_templates(self, app_id): app = App.get(App.create_key(app_id)) app.qrtemplate_keys = list() description = u"DEFAULT" key_name = create_qr_template_key_name(app_id, description) store_template(None, DEFAULT_QR_CODE_OVERLAY, description, u"".join(("%X" % c).rjust(2, '0') for c in DEFAULT_QR_CODE_COLOR), key_name) app.qrtemplate_keys.append(key_name) description = u"HAND" key_name = create_qr_template_key_name(app_id, description) store_template(None, HAND_ONLY_QR_CODE_OVERLAY, description, u"".join(("%X" % c).rjust(2, '0') for c in DEFAULT_QR_CODE_COLOR), key_name) app.qrtemplate_keys.append(key_name) put_and_invalidate_cache(app)
def migrate(): for app in App.all(): settings_key = AppSettings.create_key(app.app_id) new_settings = AppSettings(key=settings_key, background_fetch_timestamps=[21600] if app.type == App.APP_TYPE_CITY_APP else []) settings = AppSettings.get(settings_key) or new_settings settings.put() get_app_settings.invalidate_cache(app.app_id) # @UndefinedVariable
def trans(create_app_to): app_key = App.create_key(create_app_to.app_id) if App.get(app_key): raise DuplicateAppIdException(create_app_to.app_id) app = App( key=app_key, type=data.type, name=create_app_to.name, is_default=False, android_app_id=u'com.mobicage.rogerthat.%s' % create_app_to.app_id.replace('-', '.'), dashboard_email_address=data.dashboard_email_address, creation_time=now(), ) app_settings = AppSettings(key=AppSettings.create_key(app.app_id), background_fetch_timestamps=[21600] if app.type == App.APP_TYPE_CITY_APP else []) db.put((app, app_settings)) return app
def validate_delete_service(service_user): # type: (users.User) -> None all_app_ids = set() for service_identity in get_service_identities(service_user): all_app_ids.update(service_identity.appIds) apps = get_apps_by_keys([App.create_key(app_id) for app_id in all_app_ids]) for app in apps: if app.main_service == service_user.email(): raise BusinessException('Cannot delete main service of app %s' % app.app_id)
def generate_all_stats(): apps = App.all().fetch(None) app_ids = [a.app_id for a in apps] d = datetime.now() date = datetime(year=d.year, month=d.month, day=d.day) results = [ generate_created_app_stats(apps), generate_released_app_stats(apps), generate_users_per_app_stats(app_ids) ] for type_, result in results: log_offload.create_log(None, type_, result, None, timestamp=time.mktime(date.timetuple()))
def _test_dynamic_flex_service(self, language): self.set_datastore_hr_probability(1) print 'Test %s service creation with all modules' % language email = u'*****@*****.**' r = create_flex_service(email, name="test", address="Antwerpsesteenweg 19\n9080 Lochristi", phone_number="+32 9 324 25 64", languages=[language], currency=u"€", modules=SolutionModule.visible_modules(), broadcast_types=['test1', 'test2', 'test3'], apps=[a.app_id for a in App.all()], allow_redeploy=False, organization_type=random.choice([ x for x in OrganizationType.all() if x > 0 ])) service_user = users.User(r.login) set_current_user(service_user) print 'Setting order type to advanced' _put_default_menu(service_user) sln_settings = get_solution_settings(service_user) sln_order_settings = SolutionOrderSettings( key=SolutionOrderSettings.create_key(service_user)) sln_order_settings.text_1 = 'text_1' sln_order_settings.order_type = SolutionOrderSettings.TYPE_ADVANCED sln_order_settings.leap_time = 1 sln_order_settings.leap_time_type = 86400 sln_order_settings.put() SolutionOrderWeekdayTimeframe.create_default_timeframes_if_nessecary( service_user, sln_settings.solution) print 'Test provisioning of all modules' common_provision(service_user) print 'Test rendering the home page' FlexHomeHandler({}, webapp2.Response()).get() print 'Test deletion of all modules' solution_settings = get_solution_settings(service_user) solution_settings.modules = [] solution_settings.put() common_provision(service_user) print 'Test rendering the home page' FlexHomeHandler({}, webapp2.Response()).get()
def get(self): expired_apps = [(app.app_id, time.ctime(app.apple_push_cert_valid_until)) for app in App.all() \ .filter('apple_push_cert_valid_until !=', None) \ .filter('apple_push_cert_valid_until <', now() + 60 * 86400) \ .order('apple_push_cert_valid_until')] if expired_apps: expired_apps_str = pprint.pformat(expired_apps) settings = get_server_settings() send_mail(settings.dashboardEmail, settings.supportWorkers, "There are APN certs that are about to expire", "The following APN certs are about to expire:\n%s" % expired_apps_str) logging.error("The following APN certs are about to expire:\n%s" % expired_apps_str)
def get(self): data_dict, app_user = self.get_user_info() if not data_dict or not app_user: return azzert(data_dict['a'] == "unsubscribe deactivate") app, user_profile = db.get([App.create_key(get_app_id_from_app_user(app_user)), UserProfile.createKey(app_user)]) if not user_profile: self.redirect("/") return mobiles = list(get_user_active_mobiles(app_user)) if mobiles: mobile = mobiles[0] if mobile.type in Mobile.ANDROID_TYPES: page_type = "android" elif mobile.type in Mobile.IOS_TYPES: page_type = "ios" else: return self.return_error() else: mobile = None page_type = "web" page_type = self.request.get("page_type", page_type) language = self.request.get("language", user_profile.language) ActivationLog(timestamp=now(), email=app_user.email(), mobile=mobile, description="Visit unsubscribe page %s %s" % (page_type, user_profile.language)).put() jinja_template = self.get_jinja_environment().get_template('unsubscribe_deactivate.html') params = { 'name': data_dict['n'], 'app_name': get_app_by_user(app_user).name, 'hide_header': True, 'data': self.request.get("data"), 'app_email': app_user.email(), 'email': get_human_user_from_app_user(app_user).email(), 'action': data_dict['a'], 'page_type': page_type, 'language': language, 'is_city_app': app.type == App.APP_TYPE_CITY_APP } self.response.out.write(jinja_template.render(params))
def trans(old_default_app_key): new_default_app = get_app_by_id(app_id) if new_default_app.key() == old_default_app_key: return new_default_app.is_default = True if old_default_app_key: old_default_app = App.get(old_default_app_key) old_default_app.is_default = False put_and_invalidate_cache(new_default_app, old_default_app) on_trans_committed(logging.info, "Default app updated from %s (%s) to %s (%s)", old_default_app.app_id, old_default_app.name, new_default_app.app_id, new_default_app.name) else: put_and_invalidate_cache(new_default_app)
def generate_app_stats_history(log_type): if log_type == 'rogerthat.created_apps': stats_func = _generate_created_app_stats elif log_type == 'rogerthat.released_apps': stats_func = _generate_released_app_stats else: raise Exception('Invalid log type') d = datetime.utcfromtimestamp(1410963082) date = datetime(year=d.year, month=d.month, day=d.day) all_apps = App.all().fetch(None) now = datetime.now() while date < now: ts = time.mktime(date.timetuple()) result = stats_func([app for app in all_apps if app.creation_time <= ts]) log_offload.create_log(None, log_type, result, None, timestamp=ts) date = date + relativedelta(days=1)
def delete_app(app_id): app = get_app(app_id) validate_can_delete_app(app) to_delete = [ AppSettings.create_key(app_id), app.key() ] to_put = [] for profile_key in UserProfile.all(keys_only=True).filter('app_id', app_id): delete_account(users.User(profile_key.parent().name())) for other_app in App.all(): if app_id in other_app.orderable_app_ids: other_app.orderable_app_ids.remove(app_id) to_put.append(other_app) db.delete(to_delete) if to_put: put_and_invalidate_cache(to_put)
def get_all_signup_enabled_apps(): signup_enabled_app_keys = ShopApp.all(keys_only=True).filter( 'signup_enabled', True) signup_enabled_apps = filter( lambda app: app.main_service, db.get([ App.create_key(app_key.name()) for app_key in signup_enabled_app_keys ])) for app in reversed(signup_enabled_apps): # TODO: cache Customer.get_by_service_email(app.main_service) customer = Customer.get_by_service_email(app.main_service) if not customer: signup_enabled_apps.remove(app) continue app.customer_id = customer.id app.country = customer.country return signup_enabled_apps
def _validate_job(from_service_user, to_service_user): # FROM != TO bizz_check(from_service_user.email() != to_service_user.email(), 'FROM and TO should not be equal') # FROM should exist and be a ServiceProfile from_service_profile = _get_profile_not_cached(from_service_user) bizz_check(from_service_profile, 'ServiceProfile %s not found' % from_service_user) bizz_check(isinstance(from_service_profile, ServiceProfile), 'Profile %s is not of expected type ServiceProfile, but of type %s' % (from_service_user, from_service_profile.kind())) # TO should not exist to_profile = _get_profile_not_cached(to_service_user) if to_profile: raise BusinessException('%s %s already exists' % (to_profile.kind(), to_service_user)) # FROM should not be an auto_connected_service in an App for app in App.all(): if from_service_user.email() in app.admin_services: raise BusinessException('FROM should not be an app admin service (found in app %s)' % app.app_id) for acs in app.auto_connected_services: acs_si_user = users.User(acs.service_identity_email) if get_service_user_from_service_identity_user(acs_si_user).email() == from_service_user.email(): raise BusinessException('FROM should not be an AutoConnectedService (found %s in app %s)' % (acs_si_user, app.app_id)) # Validate that there are no running jobs for <from_service> or <to_service> def get_base_query(): return MigrateServiceJob.all().filter('phase !=', MigrateServiceJob.PHASE_DONE) for service_user in (from_service_user, to_service_user): for prop in ('from_service_user', 'to_service_user'): job = get_base_query().filter(prop, service_user).get() if job: raise BusinessException('There already is a MigrateServiceJob with %s=%s\n%s' % (prop, service_user, db.to_dict(job))) return from_service_profile
def _send_export_email(result_path, human_user_email, app_id, data_export_email, download_url): logging.info(download_url) app_user = create_app_user_by_email(human_user_email, app_id) user_profile, app = db.get([get_profile_key(app_user), App.create_key(app_id)]) subject = localize(user_profile.language, "user_data_download_ready_summary") variables = dict(name=user_profile.name, link=download_url, app=app) body = render("data_download_ready_email", [user_profile.language], variables) html = render("data_download_ready_email_html", [user_profile.language], variables) server_settings = get_server_settings() email_receivers = [data_export_email] if app.is_default: email_sender = server_settings.senderEmail else: email_sender = ("%s <%s>" % (app.name, app.dashboard_email_address)) send_mail(email_sender, email_receivers, subject, body, html=html) deferred.defer(_cleanup_export, result_path, _countdown=4 * DAY, _queue=DATA_EXPORT_QUEUE)
def _get_all_apps(): return App.all(keys_only=True)
def get_apps_by_type(app_type): # type: (list[int]) -> list[App] qry = App.all(keys_only=True).filter('type', app_type) return get_apps_by_keys(qry.fetch(None))
def get_all_apps(): return App.all()
def _get_all_apps_keys_query(): return App.all(keys_only=True)
def get_apps_by_id(app_ids): # type: (list[unicode]) -> list[App] return get_cached_models([App.create_key(app_id) for app_id in app_ids])
def get_visible_apps(): return App.all().filter("visible =", True)
def get_extra_apps(): return App.all().filter("demo =", False).filter("visible =", True)
def post(self): success = False app_id = self.request.POST.get("app_id", None) name = self.request.POST.get("name", None) app_type = self.request.POST.get("app_type", None) fb_app_id = self.request.POST.get("fb_app_id", None) ios_app_id = self.request.POST.get("ios_app_id", None) android_app_id = self.request.POST.get("android_app_id", None) dashboard_email_address = self.request.POST.get('dashboard_email_address', None) contact_email_address = self.request.POST.get("contact_email_address", None) user_regex = self.request.POST.get("user_regex", None) qr_templates_count = int(self.request.POST.get("qr_templates_count", 0)) default_qr_template_index = int(self.request.POST.get("default_qr_template_index", 0)) auto_connected_services_string = self.request.POST.get("auto_connected_services", "[]") logging.debug("auto_connected_services = %s", auto_connected_services_string) beacon_major_str = self.request.POST.get("beacon_major", 0) beacon_major = int(beacon_major_str) if beacon_major_str else 0 demo = bool(self.request.POST.get("demo", '')) beta = bool(self.request.POST.get("beta", '')) mdp_client_id = self.request.POST.get('mdp_client_id', None) mdp_client_secret = self.request.POST.get('mdp_client_secret', None) orderable_apps = self.request.get_all('orderable_apps') auto_connected_services = parse_complex_value(AutoConnectedService, json.loads(auto_connected_services_string), True) admin_services = json.loads(self.request.POST.get('admin_services', '[]')) beacon_regions = json.loads(self.request.POST.get("beacon_regions", "[]")) try: app_type = None if not app_type else int(app_type) except Exception: app_type = None try: fb_app_id = None if not fb_app_id else int(fb_app_id) except Exception: fb_app_id = None if not app_id: result = "Failed to create new app (app_id was empty)!" elif [c for c in app_id if c not in '-abcdefghijklmnopqrstuvwxyz0123456789']: result = "App ids should only contain (-, lower case alphabet characters and numbers)" elif not name: result = "Failed to create new app (name was empty)!" elif app_type is None: result = "Failed to create new app (app_type was empty)!" elif not ios_app_id: result = "Failed to create new app (ios_app_id was empty)!" elif not android_app_id: result = "Failed to create new app (android_app_id was empty)!" elif not dashboard_email_address: result = "Failed to create new app (dashboard_email_address was empty)!" else: try: if user_regex: validate_user_regex(user_regex) zip_stream = self.request.POST.get('core_branding').file zip_stream.seek(0) try: zip_ = ZipFile(zip_stream) except BadZipfile, e: raise BrandingValidationException(e.message) branding = store_branding_zip(None, zip_, u"Core branding of %s" % app_id) app = App(key=App.create_key(app_id)) to_be_put = [] app.qrtemplate_keys = [] for i in xrange(qr_templates_count): file_ = self.request.POST.get('qr_template_%s' % i) description = self.request.POST.get("qr_template_description_%s" % i) color = self.request.POST.get("qr_template_color_%s" % i) file_ = file_.file.getvalue() if isinstance(file_, FieldStorage) else None key_name = create_qr_template_key_name(app_id, description) store_template(None, file_, description, color, key_name) if default_qr_template_index == i: app.qrtemplate_keys.insert(0, key_name) else: app.qrtemplate_keys.append(key_name) app.name = name app.type = app_type app.core_branding_hash = branding.hash app.facebook_app_id = fb_app_id app.ios_app_id = ios_app_id app.android_app_id = android_app_id app.dashboard_email_address = dashboard_email_address app.contact_email_address = contact_email_address app.user_regex = user_regex app.creation_time = now() app.is_default = get_default_app_key() is None app.demo = demo app.beta = beta app.mdp_client_id = mdp_client_id or None app.mdp_client_secret = mdp_client_secret or None app.auto_connected_services = AutoConnectedServices() for acs in auto_connected_services: service_identity_user = add_slash_default(users.User(acs.service_identity_email)) si = get_service_identity(service_identity_user) bizz_check(si, "ServiceIdentity %s not found" % service_identity_user) if app_id not in si.appIds: si.appIds.append(app_id) to_be_put.append(si) acs.service_identity_email = service_identity_user.email() app.auto_connected_services.add(acs) admin_profiles = db.get([get_profile_key(u) for u in map(users.User, admin_services)]) non_existing = list() for admin_email, admin_profile in zip(admin_services, admin_profiles): if not admin_profile: non_existing.append(admin_email) bizz_check(not non_existing, "Non existing services specified: %s" % non_existing) app.admin_services = admin_services app.beacon_major = beacon_major app.beacon_last_minor = 0 put_and_invalidate_cache(*to_be_put) to_be_put = [] for beacon_region in beacon_regions: uuid = beacon_region.get("uuid") major = beacon_region.get("major") minor = beacon_region.get("minor") br = BeaconRegion(key=BeaconRegion.create_key(app.key(), uuid, major, minor)) br.uuid = uuid.lower() br.major = major br.minor = minor br.creation_time = now() to_be_put.append(br) app.orderable_app_ids = list(orderable_apps) apps = db.get(map(App.create_key, app.orderable_app_ids)) for a in apps: a.orderable_app_ids.append(app_id) to_be_put.append(a) to_be_put.append(app) put_and_invalidate_cache(*to_be_put) for acs in app.auto_connected_services: logging.info("There is a new auto-connected service: %s", acs.service_identity_email) run_job(get_user_profile_keys_by_app_id, [app_id], hookup_with_default_services.run_for_auto_connected_service, [acs, None]) result = "Created new app!" success = True except BusinessException, e: logging.info("BusinessException: %s", e, exc_info=1) result = e.message
def trans(): app = App.get(App.create_key(app_id)) if not app: raise AppDoesNotExistException(app_id) return app
def re_index_all_vouchers_all_apps(queue=HIGH_LOAD_WORKER_QUEUE): for app_key in App.all(keys_only=True): _re_index_all_vouchers(app_key.name(), queue)
def f(): return App.all().filter('is_default =', True).get()
def create_and_pay_news_order(service_user, news_item_id, order_items_to): """ Creates an order, orderitems, charge and executes the charge. Should be executed in a transaction. Args: service_user (users.User) news_item_id (long) order_items_to (ist of OrderItemTO) Raises: NoCreditCardException ProductNotFoundException """ @db.non_transactional def _get_customer(): return get_customer(service_user) @db.non_transactional def _get_contact(): return Contact.get_one(customer) customer = _get_customer() azzert(customer) contact = _get_contact() azzert(contact) if not customer.stripe_valid: raise NoCreditCardException(customer) extra_city_product_key = Product.create_key(Product.PRODUCT_EXTRA_CITY) news_product_key = Product.create_key(Product.PRODUCT_NEWS_PROMOTION) rmt_key = RegioManagerTeam.create_key(customer.team_id) extra_city_product, news_promotion_product, team = db.get( (extra_city_product_key, news_product_key, rmt_key)) azzert(extra_city_product) azzert(news_promotion_product) azzert(team) new_order_key = Order.create_key(customer.id, OrderNumber.next(team.legal_entity_key)) vat_pct = get_vat_pct(customer, team) total_amount = 0 added_app_ids = [] for order_item in order_items_to: if order_item.product == Product.PRODUCT_EXTRA_CITY: total_amount += extra_city_product.price * order_item.count added_app_ids.append(order_item.app_id) order_item.price = extra_city_product.price elif order_item.product == Product.PRODUCT_NEWS_PROMOTION: total_amount += news_promotion_product.price * order_item.count order_item.price = news_promotion_product.price else: raise BusinessException('Invalid product \'%s\'' % order_item.product) si = get_default_service_identity(users.User(customer.service_email)) if added_app_ids: keys = [App.create_key(app_id) for app_id in added_app_ids] apps = db.get(keys) for app_id, app in zip(added_app_ids, apps): if not app: raise AppNotFoundException(app_id) if app_id in si.appIds: raise BusinessException('Customer %s already has app_id %s' % (customer.id, app_id)) vat = int(round(vat_pct * total_amount / 100)) total_amount_vat_incl = int(round(total_amount + vat)) now_ = now() to_put = [] order = Order(key=new_order_key, date=now_, amount=total_amount, vat_pct=vat_pct, vat=vat, total_amount=total_amount_vat_incl, contact_id=contact.id, status=Order.STATUS_SIGNED, is_subscription_order=False, is_subscription_extension_order=False, date_signed=now_, manager=STORE_MANAGER, team_id=team.id) to_put.append(order) azzert(order.total_amount >= 0) for item in order_items_to: order_item = OrderItem(parent=new_order_key, number=item.number, product_code=item.product, count=item.count, comment=item.comment, price=item.price) order_item.app_id = item.app_id if order_item.product_code == Product.PRODUCT_NEWS_PROMOTION: order_item.news_item_id = news_item_id to_put.append(order_item) db.put(to_put) # Not sure if this is necessary deferred.defer(generate_and_put_order_pdf_and_send_mail, customer, new_order_key, service_user, _transactional=True) # No need for signing here, immediately create a charge. to_put = [] charge = Charge(parent=new_order_key) charge.date = now() charge.type = Charge.TYPE_ORDER_DELIVERY charge.amount = order.amount charge.vat_pct = order.vat_pct charge.vat = order.vat charge.total_amount = order.total_amount charge.manager = order.manager charge.team_id = order.team_id charge.status = Charge.STATUS_PENDING charge.date_executed = now() charge.currency_code = team.legal_entity.currency_code to_put.append(charge) # Update the regiomanager statistics so these kind of orders show up in the monthly statistics deferred.defer(update_regiomanager_statistic, gained_value=order.amount / 100, manager=order.manager, _transactional=True) # Update the customer service si.appIds.extend(added_app_ids) to_put.append(si) # Update the customer object so the newly added apps are added. customer.app_ids.extend(added_app_ids) customer.extra_apps_count += len(added_app_ids) to_put.append(customer) db.put(to_put) deferred.defer(re_index, si.user) # charge the credit card if charge.total_amount > 0: get_payed(customer.id, order, charge) server_settings = get_server_settings() send_to = server_settings.supportWorkers send_to.append(MC_DASHBOARD.email()) channel_data = { 'customer': customer.name, 'no_manager': True, 'amount': charge.amount / 100, 'currency': charge.currency } channel.send_message(map(users.User, send_to), 'shop.monitoring.signed_order', info=channel_data) else: charge.status = Charge.STATUS_EXECUTED charge.date_executed = now() charge.put() channel.send_message(service_user, 'common.billing.orders.update')
def prepare_app_statistics_cache(): for app_key in list(App.all(keys_only=True)): app_id = app_key.name() invalidate_cache(get_user_count_in_app, app_id) get_user_count_in_app(app_id)
def trans(): to_put = list() customer_store_order_key = Order.create_key( customer.id, Order.CUSTOMER_STORE_ORDER_NUMBER) subscription_order_key = Order.create_key( customer.id, customer.subscription_order_number) team_key = RegioManagerTeam.create_key(customer.team_id) product_key = Product.create_key(item.code) if item.app_id is not MISSING: app_key = App.create_key(item.app_id) product, customer_store_order, sub_order, app, team = db.get([ product_key, customer_store_order_key, subscription_order_key, app_key, team_key ]) if sub_order.status != Order.STATUS_SIGNED: raise BusinessException( translate(lang, SOLUTION_COMMON, u'no_unsigned_order')) # check if the provided app does exist azzert(app) else: product, customer_store_order, team = db.get( [product_key, customer_store_order_key, team_key]) # Check if the item has a correct count. # Should never happen unless the user manually recreates the ajax request.. azzert( not product.possible_counts or item.count in product.possible_counts or item.code == Product.PRODUCT_EXTRA_CITY, u'Invalid amount of items supplied') number = 0 existing_order_items = list() vat_pct = get_vat_pct(customer, team) item_already_added = False if not customer_store_order: # create new order customer_store_order = Order(key=customer_store_order_key) customer_store_order.contact_id = contact.key().id() customer_store_order.date = now() customer_store_order.vat_pct = 0 customer_store_order.amount = 0 customer_store_order.vat = 0 customer_store_order.vat_pct = vat_pct customer_store_order.total_amount = 0 customer_store_order.is_subscription_order = False customer_store_order.manager = STORE_MANAGER customer_store_order.team_id = None else: order_items = OrderItem.list_by_order(customer_store_order.key()) for i in order_items: number = i.number if i.number > number else number existing_order_items.append(i) # Check if this city isn't already in the possible pending order. if hasattr(i, 'app_id') and (i.app_id == item.app_id or item.app_id in customer.app_ids): raise BusinessException( translate(lang, SOLUTION_COMMON, u'item_already_added')) else: # Check if there already is an orderitem with the same product code. # If so, add the count of this new item to the existing item. for it in order_items: if it.product_code == item.code and it.product_code not in ( Product.PRODUCT_EXTRA_CITY, Product.PRODUCT_NEWS_PROMOTION): if ( it.count + item.count ) in product.possible_counts or not product.possible_counts: it.count += item.count item_already_added = True to_put.append(it) order_item = it elif len(product.possible_counts) != 0: raise BusinessException( translate( lang, SOLUTION_COMMON, u'cant_order_more_than_specified', allowed_items=max( product.possible_counts))) if item.app_id is not MISSING: remaining_length, _ = get_subscription_order_remaining_length( customer.id, customer.subscription_order_number) subscription_order_charge_date = format_date( datetime.datetime.utcfromtimestamp(sub_order.next_charge_date), locale=lang) total = remaining_length * product.price else: total = product.price * item.count vat = total * vat_pct / 100 total_price = total + vat customer_store_order.amount += total customer_store_order.vat += vat azzert(customer_store_order.total_amount >= 0) customer_store_order.total_amount += total_price service_visible_in_translation = None if not item_already_added: order_item = OrderItem(parent=customer_store_order.key()) order_item.number = number order_item.comment = product.default_comment(customer.language) order_item.product_code = product.code if item.app_id is not MISSING: order_item.count = remaining_length service_visible_in_translation = translate( lang, SOLUTION_COMMON, 'service_visible_in_app', subscription_expiration_date=subscription_order_charge_date, amount_of_months=remaining_length, extra_city_price=product.price_in_euro, app_name=app.name) else: order_item.count = item.count order_item.price = product.price if item.app_id is not MISSING: order_item.app_id = item.app_id to_put.append(order_item) to_put.append(customer_store_order) db.put(to_put) return order_item, service_visible_in_translation
def send_email(app_user_email, stats, dry_run=True): # stats: (index, {(sender_user, message_content, broadcast_type, timestamp), ...}) app_user = users.User(app_user_email) app_id = get_app_id_from_app_user(app_user) user_profile, app = db.get([get_profile_key(app_user), App.create_key(app_id)]) if app.type in (App.APP_TYPE_YSAAA, App.APP_TYPE_OSA_LOYALTY): logging.debug("App type was %s: %s", app.type_str, app_user.email()) return if not user_profile: logging.info("User was deactivated: %s" , app_user.email()) return if user_profile.unsubscribed_from_reminder_email: logging.info("User unsubscribed from email reminders: %s" , app_user.email()) return language = convert_web_lang_to_iso_lang(user_profile.language or DEFAULT_LANGUAGE) try: Locale.parse(language) except UnknownLocaleError: language = DEFAULT_LANGUAGE human_user, app_id = get_app_user_tuple_by_email(app_user_email) human_user_email = human_user.email() app = get_app_by_id(app_id) server_settings = get_server_settings() text_params, html_params, avatars = _get_template_params(stats, language, server_settings, user_profile, human_user_email, app) jinja_template = JINJA_ENVIRONMENT.get_template('generic/unread_messages_notification_email.tmpl') body = jinja_template.render(text_params) jinja_template = JINJA_ENVIRONMENT.get_template('generic/unread_messages_notification_email_html.tmpl') html = jinja_template.render(html_params) logging.info("%sSending mail to %s\n%s", 'DRY RUN!\n\n' if dry_run else '', human_user_email, body) email_receivers = server_settings.supportWorkers if dry_run else [human_user_email] if app.is_default: email_sender = server_settings.senderEmail else: email_sender = ("%s <%s>" % (app.name, app.dashboard_email_address)) rel_mime = MIMEMultipart('related') rel_mime['Subject'] = text_params['title'] rel_mime['From'] = email_sender rel_mime['To'] = ', '.join(email_receivers) msg = MIMEMultipart('alternative') msg.attach(MIMEText(body.encode('utf-8'), 'plain', 'utf-8')) msg.attach(MIMEText(html.encode('utf-8'), 'html', 'utf-8')) rel_mime.attach(msg) for avatar_id, avatar_data in avatars.iteritems(): mime_img = MIMEImage(avatar_data, 'png') mime_img.add_header('Content-Id', '<%s>' % avatar_id) mime_img.add_header("Content-Disposition", "inline", filename="%s.png" % avatar_id) rel_mime.attach(mime_img) send_mail_via_mime(email_sender, email_receivers, rel_mime) if DEBUG and dry_run: return html
def get_apps(app_types, only_visible=True): # type: (list[int], bool) -> list[App] qry = App.all().filter('type IN', app_types) if only_visible: qry.filter("visible =", True) return qry
def run(): apps = list(App.all()) for app in apps: app.demo = 'demo' in app.app_id put_and_invalidate_cache(*apps)
def get_app_by_id(app_id): # type: (unicode) -> App return get_cached_model(App.create_key(app_id))
def get_apps_that_use_embedded_app(name): app_ids = [] for k in App.all(keys_only=True).filter('embedded_apps =', name): app_ids.append(k.name()) return app_ids
def setUp(self, datastore_hr_probability=0): from rogerthat.bizz.profile import create_user_profile from rogerthat.settings import get_server_settings from rogerthat.rpc import users from google.appengine.datastore import datastore_stub_util from google.appengine.ext import testbed from rogerthat_tests import register_tst_mobile from rogerthat.to.payment import PaymentProviderTO from rogerthat.bizz.payment import create_payment_provider os.environ['HTTP_HOST'] = 'rt.dev:8080' self.testbed = testbed.Testbed() self.testbed.activate() self.datastore_hr_policy = datastore_stub_util.PseudoRandomHRConsistencyPolicy( probability=datastore_hr_probability) self.testbed.init_datastore_v3_stub(consistency_policy=self.datastore_hr_policy) self.testbed.init_taskqueue_stub(root_path=os.path.join(os.path.dirname(__file__), '..', 'src')) self.task_queue_stub = self.testbed.get_stub(testbed.TASKQUEUE_SERVICE_NAME) self.testbed.init_channel_stub() self.testbed.init_search_stub() self.testbed.init_blobstore_stub() ss = get_server_settings() ss.baseUrl = "http://*****:*****@example.com" ss.supportEmail = u"*****@*****.**" ss.supportWorkers = ["*****@*****.**"] ss.serviceCreators = ["djmatic", "*****@*****.**", "", "*****@*****.**"] ss.staticPinCodes = ["0666", "*****@*****.**"] ss.userEncryptCipherPart1 = base64.b64encode(u'userEncryptCipherPart1') ss.userEncryptCipherPart2 = base64.b64encode(u'userEncryptCipherPart2') rogerthat_app = App(key=App.create_key(u"rogerthat")) rogerthat_app.name = u"Rogerthat" rogerthat_app.type = App.APP_TYPE_ROGERTHAT rogerthat_app.core_branding_hash = None rogerthat_app.facebook_app_id = 188033791211994 rogerthat_app.ios_app_id = u"id446796149" rogerthat_app.android_app_id = u"com.mobicage.rogerth.at" rogerthat_app.secure = True rogerthat_app.is_default = True rogerthat_app.visible = True rogerthat_app.creation_time = now() rogerthat_app.admin_services = [u'*****@*****.**'] rogerthat_app.mdp_client_id = str(uuid.uuid4()) rogerthat_app.mdp_client_secret = str(uuid.uuid4()) be_loc_app = App(key=App.create_key(u"be-loc")) be_loc_app.name = u"Lochristi" be_loc_app.type = App.APP_TYPE_CITY_APP be_loc_app.core_branding_hash = None be_loc_app.facebook_app_id = 188033791211994 be_loc_app.ios_app_id = u"com.mobicage.cityapp.lochristi" be_loc_app.android_app_id = u"com.mobicage.cityapp.lochristi" be_loc_app.creation_time = now() be_loc_app.secure = False be_loc_app.is_default = False be_loc_app.visible = True be_loc_app.mdp_client_id = str(uuid.uuid4()) be_loc_app.mdp_client_secret = str(uuid.uuid4()) be_berlare_app = App(key=App.create_key(u"be-berlare")) be_berlare_app.name = u"Berlare" be_berlare_app.type = App.APP_TYPE_CITY_APP be_berlare_app.core_branding_hash = None be_berlare_app.facebook_app_id = None be_berlare_app.ios_app_id = u"com.mobicage.cityapp.berlare" be_berlare_app.android_app_id = u"com.mobicage.cityapp.berlare" be_berlare_app.creation_time = now() be_berlare_app.secure = False be_berlare_app.is_default = False be_berlare_app.visible = True be_berlare_app.mdp_client_id = str(uuid.uuid4()) be_berlare_app.mdp_client_secret = str(uuid.uuid4()) osa_loyalty_app = App(key=App.create_key(u"osa-loyalty")) osa_loyalty_app.name = u"OSA Loyalty" osa_loyalty_app.type = App.APP_TYPE_CONTENT_BRANDING osa_loyalty_app.core_branding_hash = None osa_loyalty_app.facebook_app_id = 188033791211994 osa_loyalty_app.ios_app_id = u"com.mobicage.rogerthat.osa.loyalty" osa_loyalty_app.android_app_id = u"com.mobicage.rogerthat.osa.loyalty" osa_loyalty_app.creation_time = now() osa_loyalty_app.is_default = False osa_loyalty_app.visible = True put_and_invalidate_cache(ss, rogerthat_app, be_loc_app, be_berlare_app, osa_loyalty_app) create_payment_provider(PaymentProviderTO(id=u"payconiq", name=u"Payconiq", logo=None, version=1, description=u"payconiq descripion is markdown", oauth_settings=None, background_color=None, text_color=None, button_color=None, black_white_logo=None, asset_types=[], currencies=[u'EUR'], settings=u"{'a': 1}", embedded_application=None, app_ids=[])) self.setup_qr_templates(u"rogerthat") self.setup_qr_templates(u"be-loc") self.setup_qr_templates(u"be-berlare") app.get_default_app = lambda: rogerthat_app users.get_current_user = lambda: users.User(u'*****@*****.**') user = users.get_current_user() create_user_profile(user, u"Geert test", language='nl') m = register_tst_mobile(user.email()) users.get_current_mobile = lambda: m