def post(self): user = users.get_current_user() data = json.loads(self.request.POST["data"]) if data['general']: settings = Settings.get() updateMobile = lambda s:None else: mobile = get_mobile_by_id(data['mobile_id']) azzert(mobile.user == user) settings = MobileSettings.get(mobile) settings.color = data['color'] mobile.description = data['description'] if settings.version: settings.version += 1 mobile.put() request = UpdateSettingsRequestTO() def updateMobile(s): request.settings = SettingsTO.fromDBSettings(s, get_app_settings(App.APP_ID_ROGERTHAT)) logging.info("Updating mobile " + mobile.description) updateSettings(update_settings_response_handler, logError, mobile.user, request=request) settingsTO = parse_complex_value(SettingsTO, data, False) if settingsTO.geoLocationSamplingIntervalBattery < Settings.MINIMUM_INTERVAL: return if settingsTO.geoLocationSamplingIntervalCharging < Settings.MINIMUM_INTERVAL: return if settingsTO.xmppReconnectInterval < Settings.MINIMUM_INTERVAL: return settingsTO.apply(settings) settings.put() updateMobile(settings)
def __init__(self, configuration): super(TffBackendPlugin, self).__init__(configuration) self.configuration = parse_complex_value( TffConfiguration, configuration, False) # type: TffConfiguration rogerthat_api_plugin = get_plugin('rogerthat_api') assert (isinstance(rogerthat_api_plugin, RogerthatApiPlugin)) rogerthat_api_plugin.subscribe('messaging.flow_member_result', rogerthat_callbacks.flow_member_result) rogerthat_api_plugin.subscribe('messaging.form_update', rogerthat_callbacks.form_update) rogerthat_api_plugin.subscribe('messaging.update', rogerthat_callbacks.messaging_update) rogerthat_api_plugin.subscribe('messaging.poke', rogerthat_callbacks.messaging_poke) rogerthat_api_plugin.subscribe('friend.is_in_roles', rogerthat_callbacks.friend_is_in_roles) rogerthat_api_plugin.subscribe('friend.update', rogerthat_callbacks.friend_update) rogerthat_api_plugin.subscribe('friend.invited', rogerthat_callbacks.friend_invited) rogerthat_api_plugin.subscribe('friend.register', rogerthat_callbacks.friend_register, trigger_only=True) rogerthat_api_plugin.subscribe( 'friend.invite_result', rogerthat_callbacks.friend_invite_result, trigger_only=True) rogerthat_api_plugin.subscribe('system.api_call', rogerthat_callbacks.system_api_call) patch_onfido_lib()
def _execute_flow(service_identity_user, message_flow_design, message_flow_run_record, members, message_parent_key, context=None, resultKey=None, force_language=None, broadcast_type=None, broadcast_guid=None, tag=None): logging.info("Executing message flow for %s with force_language %s" % (service_identity_user.email(), force_language)) xml_doc = _create_message_flow_run_xml_doc(service_identity_user, message_flow_design, message_flow_run_record, members, force_language) logging.info(xml_doc.toxml()) xml = xml_doc.toxml("utf-8") settings = get_server_settings() headers = { 'X-Nuntiuz-Service-Identifier-Key': get_mfr_sik(service_identity_user).sik, 'X-Nuntiuz-Service-Identity': base64.b64encode(get_identity_from_service_identity_user(service_identity_user)), 'X-Nuntiuz-Service-API-Key': get_mfr_api_key(service_identity_user).key().name(), 'X-Nuntiuz-Shared-Secret': settings.secret, 'X-Nuntiuz-MessageFlowRunId': message_flow_run_record.messageFlowRunId, 'X-Nuntiuz-MessageParentKey': message_parent_key if message_parent_key else "", 'X-Nuntiuz-Context': context if context else "", 'X-Nuntiuz-ResultKey': resultKey, 'Content-type': 'text/xml' } if broadcast_guid: headers['X-Nuntiuz-BroadcastGuid'] = broadcast_guid if tag: headers['X-Nuntiuz-Tag'] = tag.encode('utf') logging.debug('Executing flow with run id %s for members %s', message_flow_run_record.messageFlowRunId, members) result = urlfetch.fetch( "%s/api" % settings.messageFlowRunnerAddress, xml, "POST", headers, False, False, deadline=10 * 60) if result.status_code != 200: error_message = "MFR returned status code %d" % result.status_code if result.status_code == 400: logging.error(error_message, _suppress=False) raise deferred.PermanentTaskFailure(error_message) raise Exception(error_message) logging.debug('MFR response: %s', result.content) if len(members) == 1 and result.content: try: flow_start_result = parse_complex_value(FlowStartResultCallbackResultTO, json.loads(result.content), False) if isinstance(flow_start_result.value, MessageCallbackResultTypeTO): sendMessage(service_identity_user, [UserMemberTO(members[0], flow_start_result.value.alert_flags)], flow_start_result.value.flags, 0, message_parent_key, flow_start_result.value.message, flow_start_result.value.answers, None, flow_start_result.value.branding, flow_start_result.value.tag, flow_start_result.value.dismiss_button_ui_flags, context, key=resultKey, is_mfr=True, broadcast_type=broadcast_type, broadcast_guid=broadcast_guid, attachments=flow_start_result.value.attachments, step_id=None if flow_start_result.value.step_id is MISSING else flow_start_result.value.step_id) elif isinstance(flow_start_result.value, FormCallbackResultTypeTO): sendForm(service_identity_user, message_parent_key, members[0], flow_start_result.value.message, flow_start_result.value.form, flow_start_result.value.flags, flow_start_result.value.branding, flow_start_result.value.tag, flow_start_result.value.alert_flags, context, key=resultKey, is_mfr=True, broadcast_type=broadcast_type, attachments=flow_start_result.value.attachments, broadcast_guid=broadcast_guid, step_id=None if flow_start_result.value.step_id is MISSING else flow_start_result.value.step_id) except: logging.exception("Failed to parse result from message flow runner.")
def get_payment_assets(app_user, currency=None): args = dict() args["app_user"] = app_user.email() result = _execute_payment_request(u'assets', args) if not result: return [] return parse_complex_value(PaymentProviderAssetTO, result, True)
def update_presence(params, user_detail): presence = parse_complex_value(BasePresenceTO, params, False) iyo_username = get_iyo_username(user_detail) participant = EventParticipant.get_or_create_participant(presence.event_id, iyo_username) participant.status = presence.status participant.wants_recording = presence.wants_recording participant.put() return participant.to_dict()
def merge_steps(flow_run, new_steps): # In case of sub flows, new_steps won't contain steps from the previous flow. steps = parse_complex_value(object_factory('step_type', FLOW_STEP_MAPPING), flow_run.steps, True) saved_step_ids = [step.step_id for step in steps] for step in new_steps: if step.step_id not in saved_step_ids: steps.append(step) return steps
def _get_transactions_by_type(asset_id, transaction_type, cursor): args = dict() args["asset_id"] = asset_id args["transaction_type"] = transaction_type if cursor: args["cursor"] = cursor result = _execute_payment_request(u'transactions', args) if not result: return [], None to = parse_complex_value(GetPaymentTransactionsResponseTO, result, False) return to.transactions, to.cursor
def get_oauth_identity(identity_url, access_token, response_type, identity_url_parameters=None): if identity_url_parameters is None: identity_url_parameters = {} headers = {"Authorization": access_token, 'Accept': "application/json"} response = urlfetch.fetch(identity_url % identity_url_parameters, method=urlfetch.GET, headers=headers, deadline=20) logging.debug(response.content) if response.status_code == httplib.OK: return parse_complex_value(response_type, json.loads(response.content), False) else: logging.error('%s responded with status code %s.\n%s', identity_url, response.status_code, response.content) raise BusinessException('Could not get oauth identity')
def put(self, *args, **kwargs): GenericRESTRequestHandler.setCurrent(self.request, self.response) f = self.get_handler('put', self.request.route) if not f: return self.update_kwargs(f, kwargs) post_data_type = f.meta['kwarg_types'].get('data') if post_data_type: is_list = type(post_data_type) is list if is_list: post_data_type = post_data_type[0] post_data = json.loads(self.request.body) if self.request.body else {} kwargs['data'] = parse_complex_value(post_data_type, post_data, is_list) self.write_result(self.run(f, args, kwargs))
def get_bank_details(iban): """ Args: iban (unicode) Returns: OpenIbanResultTO """ response = urlfetch.fetch('https://openiban.com/validate/%s?getBIC=true' % iban) if response.status_code != httplib.OK: raise BusinessException('Could not fetch bank details.\'Status: %s\'Content: %s', response.status_code, response.content) json_result = json.loads(response.content) logging.debug('Bank details for iban %s: %s', iban, json_result) return parse_complex_value(OpenIbanResultTO, json_result, False)
def __init__(self, configuration): super(RogerthatApiPlugin, self).__init__(configuration) self.configuration = parse_complex_value(RogerthatApiPluginConfiguration, configuration if configuration is not MISSING else {}, False) # type: RogerthatApiPluginConfiguration if self.configuration.rogerthat_server_url is MISSING \ or not self.configuration.rogerthat_server_url \ or self.configuration.rogerthat_server_url == 'https://rogerth.at': logging.warn('[RogerthatApiPlugin]: Set the \'rogerthat_server_url\' in the configuration file' 'to an appengine application url (<project-id>.appspot.com) to decrease the latency of the' ' requests to rogerthat.') self.configuration.rogerthat_server_url = 'https://rogerth.at' elif 'localhost' in self.configuration.rogerthat_server_url and not DEBUG: logging.error('Invalid rogerthat_server_url %s', self.configuration.rogerthat_server_url)
def form_update(rt_settings, request_id, status, form_result, answer_id, member, message_key, tag, received_timestamp, acked_timestamp, parent_message_key, result_key, service_identity, user_details, **kwargs): if not is_flag_set(Message.STATUS_ACKED, status): return None user_details = log_and_parse_user_details(user_details) form_result = parse_complex_value(FormResultTO, form_result, False) f = FMR_TAG_MAPPING.get(parse_to_human_readable_tag(tag)) if not f: return None result = f(status, form_result, answer_id, member, message_key, tag, received_timestamp, acked_timestamp, parent_message_key, result_key, service_identity, user_details) return result and serialize_complex_value(result, FormAcknowledgedCallbackResultTO, False, skip_missing=True)
def import_service_data(service_user, zip_file): zip_file = zipfile.ZipFile(StringIO(zip_file)) brandings = [] menu = None roles = [] # list of tuples (branding_id, branding_content) branding_contents = [] # type: tuple(unicode, unicode) message_flows = [] try: for file_name in set(zip_file.namelist()): if file_name == 'brandings.json': brandings = parse_complex_value(BrandingTO, json.loads(zip_file.read(file_name)), True) elif file_name == 'menu.json': menu = parse_complex_value(WebServiceMenuTO, json.loads(zip_file.read(file_name)), False) elif file_name == 'roles.json': roles = parse_complex_value(RoleTO, json.loads(zip_file.read(file_name)), True) # type:list[RoleTO] elif '/' in file_name: folder = file_name.split('/')[0] if folder == 'message_flows': message_flows.append( parse_complex_value(ExportMessageFlowDesignTO, json.loads(zip_file.read(file_name)), False)) elif folder == 'brandings': branding_hash = file_name.split('/')[1].replace('.zip', '') branding_contents.append((branding_hash, zip_file.read(file_name))) finally: zip_file.close() import_brandings_result = _import_brandings(service_user, brandings, branding_contents) _import_flows(service_user, message_flows, import_brandings_result) new_roles = _import_roles(service_user, roles) role_mapping = {} for old_role in roles: for new_role in new_roles: if old_role.name == new_role.name: role_mapping[old_role.id] = new_role.role_id if menu: _import_menu(service_user, menu, role_mapping)
def put(self, *args, **kwargs): GenericRESTRequestHandler.setCurrent(self.request, self.response) f = self.get_handler('put', self.request.route) if not f: return self.update_kwargs(f, kwargs) post_data_type = f.meta['kwarg_types'].get('data') if post_data_type: is_list = type(post_data_type) is list if is_list: post_data_type = post_data_type[0] post_data = json.loads( self.request.body) if self.request.body else {} kwargs['data'] = parse_complex_value(post_data_type, post_data, is_list) self.write_result(self.run(f, args, kwargs))
def post(self): app_id = self.request.POST.get("app_id", None) azzert(app_id is not None, "app_id is not found") azzert(app_id is not "com.mobicage.osa.launcher", "app_id is invalid") mobileInfo = self.request.POST.get("mobileInfo", None) logging.debug("GetOSALaucherAppsHandler mobileInfo: %s" % mobileInfo) azzert(mobileInfo is not None, "mobileInfo is not found") mobileInfoJSON = json.loads(mobileInfo) mobileInfo = parse_complex_value(MobileInfoTO, mobileInfoJSON, False) result = [] for a in OSALauncherApp.all(): result.append({"app_id": a.app_id, "version_code": a.version_code}) r = json.dumps(dict(result=result)) self.response.out.write(r)
def get_oauth_access_token(access_token_url, client_id, client_secret, code, redirect_url, state, grant_type=None): params = urllib.urlencode({ 'client_id': client_id, 'client_secret': client_secret, 'code': code, 'redirect_uri': redirect_url, 'state': state, 'grant_type': grant_type if grant_type else "" }) headers = {'Accept': "application/json"} response = urlfetch.fetch(access_token_url, payload=params, method=urlfetch.POST, headers=headers, deadline=20, validate_certificate=not DEBUG) logging.debug(response.content) if response.status_code == httplib.OK: return parse_complex_value(OauthAccessTokenTO, json.loads(response.content), False) else: logging.error('%s responded with status code %s.\n%s\n%s', access_token_url, response.status_code, params, response.content) raise BusinessException('Could not get oauth access token')
def flow_member_result(rt_settings, request_id, 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, flow_params, **kwargs): user_details = log_and_parse_user_details(user_details) steps = parse_complex_value(object_factory("step_type", FLOW_STEP_MAPPING), steps, True) f = FMR_TAG_MAPPING.get(parse_to_human_readable_tag(tag)) if not f: logging.info('[tff] Ignoring flow_member_result with tag %s', tag) return None result = f(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, flow_params) return result and serialize_complex_value( result, FlowMemberResultCallbackResultTO, False, skip_missing=True)
def flow_member_result(rt_settings, request_id, 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, flow_params, timestamp, **kwargs): user_details = log_and_parse_user_details(user_details) steps = parse_complex_value(object_factory("step_type", FLOW_STEP_MAPPING), steps, True) f = FMR_TAG_MAPPING.get(parse_to_human_readable_tag(tag)) should_process_flush = f and not flush_id.startswith('flush_monitoring') result = None try: if should_process_flush: logging.info('Processing flow_member_result with tag %s and flush_id %s', tag, flush_id) result = f(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, flow_params) return result and serialize_complex_value(result, FlowMemberResultCallbackResultTO, False, skip_missing=True) else: logging.info('[tff] Ignoring flow_member_result with tag %s and flush_id %s', tag, flush_id) finally: deferred.defer(save_flow_statistics, parent_message_key, steps, end_id, tag, flush_id, flush_message_flow_id, user_details[0], timestamp, result)
def __init__(self, configuration): super(ItsYouOnlineAuthPlugin, self).__init__(configuration) self.configuration = parse_complex_value(ItsYouOnlineConfiguration, configuration, False) # type: ItsYouOnlineConfiguration if self.configuration.api_domain is MISSING: self.configuration.api_domain = u'itsyou.online' if self.configuration.iyo_public_key is MISSING: # key from https://itsyou.online by default self.configuration.iyo_public_key = """-----BEGIN PUBLIC KEY----- MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAES5X8XrfKdx9gYayFITc89wad4usrk0n2 7MjiGYvqalizeSWTHEpnd7oea9IQ8T5oJjMVH5cc0H5tFSKilFFeh//wngxIyny6 6+Vq5t5B0V0Ehy01+2ceEon2Y0XDkIKv -----END PUBLIC KEY-----""" if self.configuration.fetch_information is MISSING: self.configuration.fetch_information = False rogerthat_api_plugin = get_plugin('rogerthat_api') assert isinstance(rogerthat_api_plugin, RogerthatApiPlugin) rogerthat_api_plugin.subscribe('friend.register', friend_register) self.base_uri = u'https://%s/' % self.configuration.api_domain self.api_uri = u'%sapi' % self.base_uri self.oauth_base_url = '%sv1/oauth' % self.base_uri HTTPClient._handle_data = _new_handle_data
def broadcast(api_key, broadcast_type, message, answers, flags, branding, tag, service_identity=None, alert_flags=Message.ALERT_FLAG_VIBRATE, dismiss_button_ui_flags=0, target_audience=None, attachments=None, timeout=0, json_rpc_id=None): method = 'messaging.broadcast' if not attachments: attachments = list() params = dict( broadcast_type=broadcast_type, message=message, answers=serialize_complex_value(answers, AnswerTO, True, skip_missing=True), flags=flags, branding=branding, tag=tag, service_identity=service_identity, alert_flags=alert_flags, dismiss_button_ui_flags=dismiss_button_ui_flags, target_audience=serialize_complex_value(target_audience, BroadcastTargetAudienceTO, False, skip_missing=True), attachments=serialize_complex_value(attachments, AttachmentTO, True, skip_missing=True), timeout=timeout ) result = call_rogerthat(api_key, method, params, json_rpc_id) return parse_complex_value(BroadcastResultTO, result, False)
def test_mix_type_property(self): class MyLittleTO(object): name = unicode_property('name') age = long_property('age') def __str__(self): return u"%s is %s years old" % (self.name, self.age) def __eq__(self, other): return self.name == other.name and self.age == other.age class MyPetTO(object): person = typed_property('person', (unicode, MyLittleTO)) crew = typed_property('crew', (unicode, MyLittleTO), True) felix = MyPetTO() felix.person = u"nice" felix.crew = [u"bart", u"donatello"] ceaser = MyPetTO() ceaser.person = MyLittleTO() ceaser.person.name = u"ceaser" ceaser.person.age = 35 ceaser.crew = [u"bart", MyLittleTO()] ceaser.crew[1].name = u"donatello" ceaser.crew[1].age = 34 for person in ceaser.crew: print person serialized = serialize_complex_value(ceaser, MyPetTO, False) print serialized ceaser2 = parse_complex_value(MyPetTO, serialized, False) self.assertEquals(ceaser.person.name, ceaser2.person.name) self.assertEquals(ceaser.person.age, ceaser2.person.age) self.assertEquals(ceaser.crew[0], ceaser2.crew[0]) self.assertEquals(ceaser.crew[1], ceaser2.crew[1])
def from_dict(cls, data): # type: (Type[TO_TYPE], dict) -> TO_TYPE return parse_complex_value(cls, data, False)
def attachments(self): return parse_complex_value(AttachmentTO, json.loads(self.json_attachments), True)
def from_dict(cls, data): return parse_complex_value(cls, data, False)
def from_list(cls, data): # type: (Type[TO_TYPE], list[dict]) -> list[TO_TYPE] return parse_complex_value(cls, data, True)
def post(self): from rogerthat.bizz.registration import finish_registration account = self.request.POST['account'] password = self.request.POST['password'] accounts = self.request.POST.get('accounts', u"[]") if not users.set_json_rpc_user(account, password, True): self.response.set_status(401, "could not authenticate") return app_id = self.request.POST.get("app_id", App.APP_ID_ROGERTHAT) app = _verify_app_id(app_id) azzert(app is not None, "app_id is not found") mobileInfoJSON = json.loads(self.request.POST["mobileInfo"]) if mobileInfoJSON.get('version', 1) == 1: oldMobileInfo = parse_complex_value(DeprecatedMobileInfoTO, mobileInfoJSON, False) mobileInfo = MobileInfoTO.fromDeprecatedMobileInfoTO(oldMobileInfo) else: mobileInfo = parse_complex_value(MobileInfoTO, mobileInfoJSON, False) invitor_code = self.request.POST.get('invitor_code') invitor_secret = self.request.POST.get('invitor_secret') beaconsString = self.request.POST.get('beacons') if beaconsString: beacons = json.loads(beaconsString) else: beacons = mobileInfoJSON.get('beacons') # Beacons where places inside mobile info in 1.0.161.I ipaddress = os.environ.get('HTTP_X_FORWARDED_FOR', None) if not ipaddress: server_settings = get_server_settings() xmpp.send_message(server_settings.xmppInfoMembers, "Received finish registration request without origin ipaddress!") else: ipaddress = unicode(ipaddress) mobile = finish_registration(account, mobileInfo, accounts, invitor_code, invitor_secret, ipaddress) discoveredBeacons = dict() if beacons: logging.info("User discovered the following beacons during registration: %s", beacons) for b in beacons: beacon_discovered_request_to = parse_complex_value(BeaconDiscoveredRequestTO, b, False) beacon_uuid = beacon_discovered_request_to.uuid.lower() beacon = get_beacon(beacon_uuid, beacon_discovered_request_to.name) if not beacon: logging.warn("Beacon not found uuid: %s name: %s" % (beacon_uuid, beacon_discovered_request_to.name)) else: friend_map = get_friends_map(mobile.user) if remove_slash_default(beacon.service_identity_user) not in friend_map.friends: si = get_service_identity(beacon.service_identity_user) if si.beacon_auto_invite: if app_id in si.appIds: translator = get_translator(si.service_user, [ServiceTranslation.IDENTITY_TEXT], mobile.localeLanguage) discoveredBeacons[beacon.service_identity_user] = dict(name=translator.translate(ServiceTranslation.IDENTITY_TEXT, si.name, mobile.localeLanguage), avatar_url=si.avatarUrl, friend_email=remove_slash_default(beacon.service_identity_user).email()) else: logging.info("Beacon detected but %s does not contain app_id %s: {uuid: %s, name: %s}", beacon.service_identity_user, app_id, beacon_uuid, beacon_discovered_request_to.name) else: logging.info("Beacon detected but %s does not allow auto invite {app_id %s, uuid: %s, name: %s}", beacon.service_identity_user, app_id, beacon_uuid, beacon_discovered_request_to.name) r = json.dumps(dict(discovered_beacons=sorted(discoveredBeacons.values(), key=lambda x: x['name']))) logging.info("User discovered the following new beacons during registration: %s", r) self.response.out.write(r)
def from_list(cls, data): return parse_complex_value(cls, data, True)
def get_payment_asset(app_user, asset_id): result = _execute_payment_request(u'assets/%s' % urllib.quote(asset_id), dict()) if not result: return None return parse_complex_value(PaymentProviderAssetTO, result, False)
def __init__(self, configuration): super(RogerthatControlCenterPlugin, self).__init__(configuration) self.configuration = parse_complex_value(RogerthatControlCenterConfiguration, configuration, False) # type: RogerthatControlCenterConfiguration JINJA_ENVIRONMENT.add_extension(CopyrightExtension)
def log_and_parse_user_details(user_details): # type: (dict) -> UserDetailsTO user_detail = user_details[0] if isinstance(user_details, list) else user_details logging.debug('Current user: %(email)s:%(app_id)s', user_detail) return parse_complex_value(UserDetailsTO, user_detail, False)
def post(self): success = False app_id = self.request.POST.get("app_id_hidden", 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)) has_core_branding = self.request.POST.get("has_core_branding", None) auto_connected_services_string = self.request.POST.get("auto_connected_services", "[]") logging.debug("auto_connected_services = %s", auto_connected_services_string) auto_connected_services = parse_complex_value(AutoConnectedService, json.loads(auto_connected_services_string), True) admin_services = json.loads(self.request.POST.get('admin_services', '[]')) qr_templates_to_delete = json.loads(self.request.POST.get("qr_templates_to_delete", "[]")) beacon_regions = json.loads(self.request.POST.get("beacon_regions", "[]")) 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) try: has_core_branding = None if not has_core_branding else int(has_core_branding) except Exception: has_core_branding = None 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 = "BUG!!! Failed to update app (app_id was empty)!" if not name: result = "Failed to update app (name was empty)!" elif app_type is None: result = "Failed to update app (app_type was empty)!" elif not ios_app_id: result = "Failed to update app (ios_app_id was empty)!" elif not android_app_id: result = "Failed to update app (android_app_id was empty)!" elif not dashboard_email_address: result = "Failed to update app (dashboard_email_address was empty)!" else: app = get_app_by_id(app_id) if app: try: if user_regex: validate_user_regex(user_regex) to_be_put = [app] app.name = name app.type = app_type if has_core_branding: 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.core_branding_hash = branding.hash for qr_template_key_name in qr_templates_to_delete: app.qrtemplate_keys.remove(qr_template_key_name) for i in xrange(qr_templates_count): description = self.request.POST.get("qr_template_description_%s" % i) key_name = create_qr_template_key_name(app_id, description) if self.request.POST.get('qr_template_new_%s' % i) == "1": file_ = self.request.POST.get('qr_template_%s' % i) color = self.request.POST.get("qr_template_color_%s" % i) file_ = file_.file.getvalue() if isinstance(file_, FieldStorage) else None 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) else: if default_qr_template_index == i: app.qrtemplate_keys.remove(key_name) app.qrtemplate_keys.insert(0, key_name) 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.demo = demo app.beta = beta app.mdp_client_id = mdp_client_id or None app.mdp_client_secret = mdp_client_secret or None old_auto_connected_services = {acs.service_identity_email for acs in app.auto_connected_services} 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 old_beacon_regions = list(app.beacon_regions(keys_only=True)) new_beacon_regions = list() should_update_beacon_regions = False for beacon_region in beacon_regions: uuid = beacon_region.get("uuid") major = beacon_region.get("major") minor = beacon_region.get("minor") br_key = BeaconRegion.create_key(app.key(), uuid, major, minor) new_beacon_regions.append(br_key) if br_key not in old_beacon_regions: should_update_beacon_regions = True br = BeaconRegion(key=br_key) br.uuid = uuid.lower() br.major = major br.minor = minor br.creation_time = now() to_be_put.append(br) to_be_deleted = [] for beacon_region_key in old_beacon_regions: if beacon_region_key not in new_beacon_regions: should_update_beacon_regions = True to_be_deleted.append(beacon_region_key) app.beacon_major = beacon_major app.beacon_last_minor = app.beacon_last_minor if app.beacon_last_minor else 0 put_and_invalidate_cache(*to_be_put) if to_be_deleted: db.delete(db.get(to_be_deleted)) for acs in app.auto_connected_services: if acs.service_identity_email not in old_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]) if should_update_beacon_regions: schedule_update_beacon_regions_for_all_users(app_id) result = "Updated app!" success = True except BusinessException, e: logging.info("BusinessException: %s", e, exc_info=1) result = e.message except Exception, e: logging.exception(str(e), exc_info=1) result = "Unknown error has occurred."
def log_and_parse_user_details(user_details): # type: (dict) -> UserDetailsTO is_list = isinstance(user_details, list) user_detail = user_details[0] if is_list else user_details logging.debug('Current user: %(email)s:%(app_id)s', user_detail) return parse_complex_value(UserDetailsTO, user_details, is_list)
def friend_is_in_roles(rt_settings, request_id, service_identity, user_details, roles, **kwargs): user_details = log_and_parse_user_details(user_details) roles = parse_complex_value(RoleTO, roles, True) return is_user_in_roles(user_details[0], roles)
def finish_registration(mobile_account, mobileInfo, invitor_code, invitor_secret, ipaddress, anonymous_account=None): from rogerthat.service.api import friends as service_api_friends m = get_mobile_by_account(mobile_account) mobile_key = m.key() ms_key = get_mobile_settings_cached(m).key() profile_key = get_user_profile_key(m.user) def trans(): mobile, ms, my_profile = db.get((mobile_key, ms_key, profile_key)) mobile.status = mobile.status | Mobile.STATUS_REGISTERED mobile.type = mobileInfo.app_type mobile.simCountry = mobileInfo.sim_country if mobileInfo.sim_country != MISSING else None mobile.simCountryCode = mobileInfo.sim_country_code if mobileInfo.sim_country_code != MISSING else None mobile.simCarrierCode = mobileInfo.sim_carrier_code if mobileInfo.sim_carrier_code != MISSING else None mobile.simCarrierName = mobileInfo.sim_carrier_name if mobileInfo.sim_carrier_name != MISSING else None mobile.netCountry = mobileInfo.net_country if mobileInfo.net_country != MISSING else None mobile.netCountryCode = mobileInfo.net_country_code if mobileInfo.net_country_code != MISSING else None mobile.netCarrierCode = mobileInfo.net_carrier_code if mobileInfo.net_carrier_code != MISSING else None mobile.netCarrierName = mobileInfo.net_carrier_name if mobileInfo.net_carrier_name != MISSING else None mobile.hardwareModel = mobileInfo.device_model_name mobile.osVersion = mobileInfo.device_os_version if mobileInfo.device_os_version != MISSING else None mobile.localeLanguage = mobileInfo.locale_language if mobileInfo.locale_language and mobileInfo.locale_language != MISSING else DEFAULT_LANGUAGE mobile.localeCountry = mobileInfo.locale_country mobile.timezone = mobileInfo.timezone if mobileInfo.timezone != MISSING else None mobile.timezoneDeltaGMT = mobileInfo.timezone_delta_gmt if mobileInfo.timezone_delta_gmt != MISSING else None if mobileInfo.app_major_version != MISSING and mobileInfo.app_minor_version != MISSING: ms.majorVersion = mobileInfo.app_major_version ms.minorVersion = mobileInfo.app_minor_version # This is the official place where we set the profile language my_profile.language = mobile.localeLanguage my_profile.country = mobile.netCountry or mobile.simCountry or mobile.localeCountry my_profile.timezone = mobile.timezone my_profile.timezoneDeltaGMT = mobile.timezoneDeltaGMT my_profile.mobiles = MobileDetails() my_profile.mobiles.addNew(mobile.account, mobile.type, mobile.pushId, mobile.app_id) put_and_invalidate_cache(mobile, ms, my_profile) deferred.defer(_finishup_mobile_registration, mobile, invitor_code, invitor_secret, ipaddress, ms_key, _transactional=True, _queue=FAST_QUEUE) return mobile, my_profile mobile, my_profile = run_in_transaction(trans, xg=True) channel.send_message(mobile.user, u'com.mobicage.registration.finished') registration = get_registration_by_mobile(mobile) if registration and registration.installation: save_successful_registration(registration, mobile, my_profile) if registration.installation.service_identity_user and (registration.installation.qr_url or registration.installation.oauth_state): service_identity_user = registration.installation.service_identity_user service_user, service_identity = get_service_identity_tuple(service_identity_user) svc_profile = get_service_profile(service_user) user_details = [UserDetailsTO.fromUserProfile(my_profile)] user_app_id = get_app_id_from_app_user(mobile.user) # auto_connected_services services_to_connect = set() if registration.installation.service_callback_result == ACCEPT_AND_CONNECT_ID: def trans_update_app_id(): si = get_service_identity(service_identity_user) bizz_check(si, "ServiceIdentity %s not found" % service_identity_user) if user_app_id not in si.appIds: si.appIds.append(user_app_id) put_and_invalidate_cache(si) run_in_transaction(trans_update_app_id) services_to_connect.add(service_identity_user) for autoconnect_service_email in registration.installation.auto_connected_services: if "/" in autoconnect_service_email: autoconnect_service_identity_user = users.User(autoconnect_service_email) else: autoconnect_service_identity_user = create_service_identity_user( users.User(autoconnect_service_email)) if autoconnect_service_identity_user in services_to_connect: continue si = get_service_identity(autoconnect_service_identity_user) if si and user_app_id in si.appIds: services_to_connect.add(autoconnect_service_identity_user) for service_to_connect in services_to_connect: try_or_defer(makeFriends, mobile.user, service_to_connect, original_invitee=None, servicetag=None, origin=None, notify_invitee=False, notify_invitor=False, user_data=None) # roles if registration.installation.roles: roles_to_add = defaultdict(set) for r in parse_complex_value(RegistrationResultRolesTO, json.loads(registration.installation.roles), True): for role_id in r.ids: roles_to_add[create_service_identity_user( users.User(r.service), r.identity or ServiceIdentity.DEFAULT)].add(role_id) for service_identity_email, role_ids in roles_to_add.iteritems(): service_user, identity = get_service_identity_tuple(users.User(service_identity_email)) grant_service_roles(service_user, identity, mobile.user, list(role_ids)) # callback if registration.installation.qr_url: service_api_friends.register_result(register_result_response_receiver, logServiceError, svc_profile, service_identity=service_identity, user_details=user_details, origin=REGISTRATION_ORIGIN_QR) elif registration.installation.oauth_state: service_api_friends.register_result(register_result_response_receiver, logServiceError, svc_profile, service_identity=service_identity, user_details=user_details, origin=REGISTRATION_ORIGIN_OAUTH) else: app = get_app_by_id(get_app_id_from_app_user(mobile.user)) if app.admin_services: service_profiles = filter(None, db.get((get_profile_key(users.User(e)) for e in app.admin_services))) if service_profiles: user_details = [UserDetailsTO.fromUserProfile(my_profile)] for service_profile in service_profiles: service_api_friends.register_result(register_result_response_receiver, logServiceError, service_profile, service_identity=ServiceIdentity.DEFAULT, user_details=user_details, origin=REGISTRATION_ORIGIN_DEFAULT) if anonymous_account: deferred.defer(migrate_anonymous_account, anonymous_account, mobile.user) return mobile
def post(self): if not self.set_user(): self.abort(401) return connect_rpc = None try: authorization_code = self.request.POST['authorization_code'] state = self.request.POST['state'] scopes = self.request.POST['scope'].split(' ') logging.debug('POST params: %s', dict(self.request.POST)) app_user = users.get_current_user() app_id = users.get_current_app_id() app = get_app_by_id(app_id) azzert(app and app.supports_mdp) mdp_state = MyDigiPassState.get(MyDigiPassState.create_key(app_user)) azzert(mdp_state.state == state) db.delete_async(mdp_state) mdp_result, connect_rpc = self.authorize_mdp(app_user, app, authorization_code, scopes) # mdp_result: dict with following keys: uuid, access_token, scope mdp_profile_pointer = MyDigiPassProfilePointer.create(app_user, mdp_result['uuid']) mdp_profile_pointer.put() endpoints = { self.SCOPE_TO_ENDPOINT_MAPPING[s] for s in scopes } rpcs = {endpoint: self.get_mdp_data_async(mdp_result['access_token'], endpoint) for endpoint in endpoints} result = MyDigiPassWidgetResultTO(initialize=True) for endpoint, rpc in rpcs.iteritems(): response = rpc.get_result() if response.status_code != 200: if endpoint in (MdpEndpoint.EID_DATA, MdpEndpoint.EID_PHOTO): try: error_dict = json.loads(response.content) except: pass else: if error_dict.get('error') == 'insufficient_permissions': raise BusinessException(localize(self.language(), u'mdp_missing_eid_data')) raise Exception('Failed to get %s data for MDP user %s: %s' % (endpoint, app_user.email(), response.content)) if endpoint == MdpEndpoint.EID_PHOTO: logging.debug('Got MDP %s for %s', endpoint, app_user.email()) photo = response.content if not photo: raise BusinessException(localize(self.language(), u'mdp_missing_eid_data')) result.eid_photo = base64.b64encode(photo).decode('utf-8') elif endpoint == MdpEndpoint.EID_DATA: response_dict = json.loads(response.content) logging.debug('Got MDP %s for %s:\n%s', endpoint, app_user.email(), response_dict) if not response_dict: raise BusinessException(localize(self.language(), u'mdp_missing_eid_data')) if MdpScope.EID_PROFILE in scopes: result.eid_profile = parse_complex_value(MyDigiPassEidProfile, response_dict, False) if MdpScope.EID_ADDRESS in scopes: result.eid_address = parse_complex_value(MyDigiPassEidAddress, response_dict, False) elif endpoint == MdpEndpoint.USER_DATA: response_dict = json.loads(response.content) logging.debug('Got MDP %s for %s:\n%s', endpoint, app_user.email(), response_dict) if MdpScope.EMAIL in scopes: result.email = response_dict['email'] if not result.email: raise BusinessException(localize(self.language(), u'mdp_missing_email')) if MdpScope.PHONE in scopes: result.phone = response_dict['phone_number'] if not result.phone: raise BusinessException(localize(self.language(), u'mdp_missing_phone')) if MdpScope.ADDRESS in scopes: result.address = parse_complex_value(MyDigiPassAddress, response_dict, False) if not all((result.address.address_1, result.address.zip, result.address.country)): raise BusinessException(localize(self.language(), u'mdp_missing_address')) if MdpScope.PROFILE in scopes: result.profile = parse_complex_value(MyDigiPassProfile, response_dict, False) if not all((result.profile.first_name, result.profile.last_name)): raise BusinessException(localize(self.language(), u'mdp_missing_profile')) else: azzert(False, 'Unexpected endpoint: %s' % endpoint) result_dict = serialize_complex_value(result, MyDigiPassWidgetResultTO, False, skip_missing=True) except BusinessException, e: result_dict = dict(error=e.message, mdp_update_required=isinstance(e, MissingScopesException))
def from_model(cls, model, reference_model=None): # type: (NdbModel, NdbModel) -> AuditLogDetailsTO props = model.to_dict() props['reference'] = reference_model.to_dict( ) if reference_model else None return parse_complex_value(cls, props, False)
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 messaging_flow_member_result(sik, id_, steps, user_details, tag, **kwargs): if tag == SUSPECT_TAG: try_or_defer(add_new_prospect_from_discovery, parse_complex_value(UserDetailsTO, user_details, True)[0], steps) return None
def urls(self): from solutions.common.to import UrlTO return parse_complex_value(UrlTO, json.loads(self.json_urls), True)
def _put_identity_json(self, json_dict): to = parse_complex_value(ServiceIdentityDetailsTO, json_dict, False) return put_identity(to)