def validate_sms_users(self): for sms_user in iterate_over_api_objects(self.endpoint.get_smsusers): description = "" user = CommCareUser.get_by_username(self.get_username(sms_user)[0]) if not user: description = "Not exists" EWSMigrationProblem.objects.create( domain=self.domain, external_id=sms_user.id, object_type='smsuser', description=description ) continue phone_numbers = { apply_leniency(connection.phone_number) for connection in sms_user.phone_numbers } if phone_numbers - set(user.phone_numbers): description += "Invalid phone numbers, " phone_to_backend = { connection.phone_number: connection.backend for connection in sms_user.phone_numbers } default_phone_number = [ connection.phone_number for connection in sms_user.phone_numbers if connection.default ] default_phone_number = default_phone_number[0] if default_phone_number else None if default_phone_number and (apply_leniency(default_phone_number) != user.default_phone_number): description += "Invalid default phone number, " for phone_number in user.phone_numbers: vn = VerifiedNumber.by_phone(phone_number) if not vn or vn.owner_id != user.get_id: description += "Phone number not verified, " else: backend = phone_to_backend.get(phone_number) if backend == 'message_tester' and vn.backend_id != 'MOBILE_BACKEND_TEST' \ or (backend != 'message_tester' and vn.backend_id): description += "Invalid backend, " if description: migration_problem, _ = EWSMigrationProblem.objects.get_or_create( domain=self.domain, object_id=user.get_id, object_type='smsuser' ) migration_problem.external_id = sms_user.id migration_problem.description = description.rstrip(' ,') migration_problem.save() else: EWSMigrationProblem.objects.filter( domain=self.domain, external_id=sms_user.id, object_type='smsuser' ).delete()
def add_language_to_user(self, logistics_sms_user): domain_part = "%s.commcarehq.org" % self.domain username_part = "%s%d" % (logistics_sms_user.name.strip().replace(' ', '.').lower(), logistics_sms_user.id) username = "******" % (username_part[:(128 - (len(domain_part) + 1))], domain_part) user = CouchUser.get_by_username(username) if not user: return if user.language != logistics_sms_user.language: user.language = logistics_sms_user.language user.save() logistics_numbers = {apply_leniency(phone_number) for phone_number in logistics_sms_user.phone_numbers} if set(user.phone_numbers) == logistics_numbers: return for phone_number in user.phone_numbers: user.delete_phone_number(phone_number) if logistics_sms_user.phone_numbers: phone_number = apply_leniency(logistics_sms_user.phone_numbers[0]) if not phone_number: return user.set_default_phone_number(phone_number) self._save_verified_number(user, phone_number)
def add_phone_numbers(self, ilsgateway_smsuser, user): if ilsgateway_smsuser.phone_numbers: cleaned_number = apply_leniency(ilsgateway_smsuser.phone_numbers[0]) if cleaned_number: user.set_default_phone_number(cleaned_number) user.user_data["backend"] = ilsgateway_smsuser.backend self._save_verified_number(user, cleaned_number)
def _sync_user_phone_numbers(couch_user_id): couch_user = CouchUser.get_by_user_id(couch_user_id) if not isinstance(couch_user, CommCareUser): # It isn't necessary to sync WebUser's phone numbers right now # and we need to think through how to support entries when a user # can belong to multiple domains return with CriticalSection([couch_user.phone_sync_key], timeout=5 * 60): phone_entries = couch_user.get_phone_entries() if ( couch_user.is_deleted() or (not couch_user.is_active and not USE_SMS_WITH_INACTIVE_CONTACTS.enabled(couch_user.domain)) ): for phone_number in phone_entries.values(): phone_number.delete() return numbers_that_should_exist = [apply_leniency(phone_number) for phone_number in couch_user.phone_numbers] # Delete entries that should not exist for phone_number in phone_entries.keys(): if phone_number not in numbers_that_should_exist: phone_entries[phone_number].delete() # Create entries that should exist but do not exist for phone_number in numbers_that_should_exist: if phone_number not in phone_entries: try: couch_user.create_phone_entry(phone_number) except InvalidFormatException: pass
def add_phone_numbers(self, ilsgateway_smsuser, user): if ilsgateway_smsuser.phone_numbers: cleaned_number = apply_leniency(ilsgateway_smsuser.phone_numbers[0]) if cleaned_number: user.phone_numbers = [cleaned_number] user.user_data['backend'] = ilsgateway_smsuser.backend user.save() self._save_verified_number(user, cleaned_number)
def _reassign_number(self, user, connection): v = VerifiedNumber.by_phone(apply_leniency(connection.phone_number), include_pending=True) if v.domain in self._get_logistics_domains(): v.domain = self.domain v.owner_doc_type = user.doc_type v.owner_id = user.get_id backend_id = None if connection.backend == 'message_tester': backend_id = 'MOBILE_BACKEND_TEST' v.backend_id = backend_id v.verified = True v.save()
def get_one_way_number_for_recipient(recipient): if isinstance(recipient, CouchUser): return recipient.phone_number elif is_commcarecase(recipient): one_way_number = recipient.get_case_property('contact_phone_number') one_way_number = apply_leniency(one_way_number) if one_way_number: try: CommCareMobileContactMixin.validate_number_format(one_way_number) return one_way_number except InvalidFormatException: return None return None
def edit_phone_numbers(self, ilsgateway_smsuser, user): verified_number = user.get_verified_number() phone_number = verified_number.phone_number if verified_number else None if ilsgateway_smsuser.phone_numbers: new_phone_number = apply_leniency(ilsgateway_smsuser.phone_numbers[0]) if new_phone_number != phone_number: if phone_number: user.delete_verified_number(phone_number) user.phone_numbers = [] self._save_verified_number(user, new_phone_number) user.set_default_phone_number(new_phone_number) elif phone_number: user.phone_numbers = [] user.delete_verified_number(phone_number)
def _reassign_number(self, user, connection): from custom.ilsgateway import SLAB_DOMAIN v = VerifiedNumber.by_phone(apply_leniency(connection.phone_number), include_pending=True) if v.domain in self._get_logistics_domains() or v.domain == SLAB_DOMAIN: v.domain = self.domain v.owner_doc_type = user.doc_type v.owner_id = user.get_id backend_id = None if connection.backend != 'push_backend': backend_id = 'MOBILE_BACKEND_TEST' v.backend_id = backend_id v.verified = True v.save()
def edit_phone_numbers(self, ewsghana_smsuser, user): phone_numbers = {phone_number for phone_number in user.phone_numbers} saved_numbers = [] for connection in ewsghana_smsuser.phone_numbers: phone_number = apply_leniency(connection.phone_number) if phone_number not in phone_numbers: self._save_verified_number(user, connection) if connection.default: saved_numbers = [phone_number] + saved_numbers else: saved_numbers.append(phone_number) for phone_number in phone_numbers - set(saved_numbers): user.delete_verified_number(phone_number) user.phone_numbers = saved_numbers
def add_phone_numbers(self, ilsgateway_smsuser, user): phone_numbers = ilsgateway_smsuser.phone_numbers if not phone_numbers: return saved_numbers = [] for connection in phone_numbers: phone_number = apply_leniency(connection.phone_number) if connection.default: saved_numbers = [phone_number] + saved_numbers else: saved_numbers.append(phone_number) user.phone_numbers = saved_numbers user.save() for connection in phone_numbers: self._save_verified_number(user, connection)
def get_unverified_number_for_recipient(recipient): if isinstance(recipient, CouchUser): try: return recipient.phone_number except Exception: # todo: catch more specific error return None elif isinstance(recipient, CommCareCase): unverified_number = recipient.get_case_property("contact_phone_number") unverified_number = apply_leniency(unverified_number) if unverified_number: try: CommCareMobileContactMixin.validate_number_format(unverified_number) return unverified_number except InvalidFormatException: return None return None
def add_phone_numbers(self, ewsghana_smsuser, user): phone_numbers = ewsghana_smsuser.phone_numbers if not phone_numbers: return default_phone_number = None saved_numbers = [] for connection in phone_numbers: connection.phone_number = apply_leniency(connection.phone_number) self._save_verified_number(user, connection) saved_numbers.append(connection.phone_number) if connection.default: default_phone_number = connection.phone_number user.phone_numbers = saved_numbers if default_phone_number: user.set_default_phone_number(default_phone_number)
def edit_phone_numbers(self, ilsgateway_smsuser, user): phone_numbers = set(user.phone_numbers) saved_numbers = [] for connection in ilsgateway_smsuser.phone_numbers: phone_number = apply_leniency(connection.phone_number) if phone_number not in phone_numbers: self._save_verified_number(user, connection) if connection.default: saved_numbers = [phone_number] + saved_numbers else: saved_numbers.append(phone_number) for phone_number in phone_numbers - set(saved_numbers): user.delete_verified_number(phone_number) user.phone_numbers = saved_numbers user.save()
def _validate_users(self, user_data): phone_numbers = set() for user_info in user_data: if not isinstance(user_info, dict): raise SelfRegistrationValidationException( {'users': 'Expected a list of dictionaries'} ) self._validate_toplevel_fields(user_info, [ FieldDefinition('phone_number', True, basestring), FieldDefinition('custom_user_data', False, dict), ]) phone_number = apply_leniency(user_info['phone_number']) if phone_number in phone_numbers: raise SelfRegistrationValidationException( {'users': 'phone_number cannot be reused within a request: {}'.format(phone_number)} ) phone_numbers.add(phone_number)
def _validate_users(self, user_data): phone_numbers = set() for user_info in user_data: if not isinstance(user_info, dict): raise SelfRegistrationValidationException( {'users': 'Expected a list of dictionaries'}) self._validate_toplevel_fields(user_info, [ FieldDefinition('phone_number', True, six.string_types), FieldDefinition('custom_user_data', False, dict), ]) phone_number = apply_leniency(user_info['phone_number']) if phone_number in phone_numbers: raise SelfRegistrationValidationException({ 'users': 'phone_number cannot be reused within a request: {}'. format(phone_number) }) phone_numbers.add(phone_number)
def initiate_sms_verification_workflow(contact, phone_number): # For now this is only applicable to mobile workers assert isinstance(contact, CommCareUser) phone_number = apply_leniency(phone_number) logged_event = MessagingEvent.get_current_verification_event( contact.domain, contact.get_id, phone_number) p = PhoneNumber.get_reserved_number(phone_number) if p: if p.owner_id != contact.get_id: return VERIFICATION__ALREADY_IN_USE if p.verified: return VERIFICATION__ALREADY_VERIFIED else: result = VERIFICATION__RESENT_PENDING else: entry = contact.get_or_create_phone_entry(phone_number) try: entry.set_pending_verification() except PhoneNumberInUseException: # On the off chance that the phone number was reserved between # the check above and now return VERIFICATION__ALREADY_IN_USE result = VERIFICATION__WORKFLOW_STARTED # Always create a new event when the workflow starts if logged_event: logged_event.status = MessagingEvent.STATUS_NOT_COMPLETED logged_event.save() logged_event = MessagingEvent.create_verification_event( contact.domain, contact) if not logged_event: logged_event = MessagingEvent.create_verification_event( contact.domain, contact) send_verification(contact.domain, contact, phone_number, logged_event) return result
def get_recipient_phone_number(reminder, recipient, verified_numbers): verified_number = verified_numbers.get(recipient.get_id, None) unverified_number = None if verified_number is None: if isinstance(recipient, CouchUser): try: unverified_number = recipient.phone_number except Exception: unverified_number = None elif isinstance(recipient, CommCareCase): unverified_number = recipient.get_case_property("contact_phone_number") unverified_number = apply_leniency(unverified_number) if unverified_number: try: CommCareMobileContactMixin.validate_number_format(unverified_number) except InvalidFormatException: unverified_number = None else: unverified_number = None return (verified_number, unverified_number)
def initiate_sms_verification_workflow(contact, phone_number): # For now this is only applicable to mobile workers assert isinstance(contact, CommCareUser) phone_number = apply_leniency(phone_number) logged_event = MessagingEvent.get_current_verification_event( contact.domain, contact.get_id, phone_number) p = PhoneNumber.get_reserved_number(phone_number) if p: if p.owner_id != contact.get_id: return VERIFICATION__ALREADY_IN_USE if p.verified: return VERIFICATION__ALREADY_VERIFIED else: result = VERIFICATION__RESENT_PENDING else: entry = contact.get_or_create_phone_entry(phone_number) try: entry.set_pending_verification() except PhoneNumberInUseException: # On the off chance that the phone number was reserved between # the check above and now return VERIFICATION__ALREADY_IN_USE result = VERIFICATION__WORKFLOW_STARTED # Always create a new event when the workflow starts if logged_event: logged_event.status = MessagingEvent.STATUS_NOT_COMPLETED logged_event.save() logged_event = MessagingEvent.create_verification_event(contact.domain, contact) if not logged_event: logged_event = MessagingEvent.create_verification_event(contact.domain, contact) send_verification(contact.domain, contact, phone_number, logged_event) return result
def _sync_user_phone_numbers(couch_user_id): couch_user = CouchUser.get_by_user_id(couch_user_id) if not isinstance(couch_user, CommCareUser): # It isn't necessary to sync WebUser's phone numbers right now # and we need to think through how to support entries when a user # can belong to multiple domains return with CriticalSection([couch_user.phone_sync_key], timeout=5 * 60): phone_entries = couch_user.get_phone_entries() if (couch_user.is_deleted() or (not couch_user.is_active and not USE_SMS_WITH_INACTIVE_CONTACTS.enabled(couch_user.domain))): for phone_number in phone_entries.values(): phone_number.delete() return numbers_that_should_exist = [ apply_leniency(phone_number) for phone_number in couch_user.phone_numbers ] # Delete entries that should not exist for phone_number in phone_entries.keys(): if phone_number not in numbers_that_should_exist: phone_entries[phone_number].delete() # Create entries that should exist but do not exist for phone_number in numbers_that_should_exist: if phone_number not in phone_entries: try: couch_user.create_phone_entry(phone_number) except InvalidFormatException: pass
def get_recipient_phone_number(reminder, recipient, verified_numbers): verified_number = verified_numbers.get(recipient.get_id, None) unverified_number = None if verified_number is None: if isinstance(recipient, CouchUser): try: unverified_number = recipient.phone_number except Exception: unverified_number = None elif isinstance(recipient, CommCareCase): unverified_number = recipient.get_case_property( "contact_phone_number") unverified_number = apply_leniency(unverified_number) if unverified_number: try: CommCareMobileContactMixin.validate_number_format( unverified_number) except InvalidFormatException: unverified_number = None else: unverified_number = None return (verified_number, unverified_number)
def test_apply_leniency(self): self.assertEqual('16175551234', apply_leniency(' 1 (617) 555-1234 ')) self.assertEqual('16175551234', apply_leniency(' 1.617.555.1234 ')) self.assertEqual('16175551234', apply_leniency(' +1 617 555 1234 '))
def test_apply_leniency(self): self.assertEqual("16175551234", apply_leniency(" 1 (617) 555-1234 ")) self.assertEqual("16175551234", apply_leniency(" 1.617.555.1234 ")) self.assertEqual("16175551234", apply_leniency(" +1 617 555 1234 "))
def clean_test_phone_number(self): value = self.cleaned_data.get('test_phone_number') value = apply_leniency(value) validate_phone_number(value, error_message=_("Please enter digits only, in international format (country code and phone number).")) return value
def sms_user_sync(self, ilsgateway_smsuser, username_part=None, password=None, first_name='', last_name=''): domain_part = "%s.commcarehq.org" % self.domain if not username_part: username_part = "%s%d" % (ilsgateway_smsuser.name.strip().replace(' ', '.').lower(), ilsgateway_smsuser.id) username = "******" % (username_part[:(128 - (len(domain_part) + 1))], domain_part) # sanity check assert len(username) <= 128 user = CouchUser.get_by_username(username) splitted_value = ilsgateway_smsuser.name.split(' ', 1) if not first_name: first_name = splitted_value[0][:30] if splitted_value else '' if not last_name: last_name = splitted_value[1][:30] if len(splitted_value) > 1 else '' language = ilsgateway_smsuser.language user_dict = { 'first_name': first_name, 'last_name': last_name, 'is_active': bool(ilsgateway_smsuser.is_active), 'email': ilsgateway_smsuser.email, 'user_data': {} } if ilsgateway_smsuser.role: user_dict['user_data']['role'] = ilsgateway_smsuser.role if ilsgateway_smsuser.phone_numbers: cleaned_number = apply_leniency(ilsgateway_smsuser.phone_numbers[0]) if cleaned_number: user_dict['phone_numbers'] = [cleaned_number] user_dict['user_data']['backend'] = ilsgateway_smsuser.backend if user is None and username_part: try: user_password = password or User.objects.make_random_password() user = CommCareUser.create(domain=self.domain, username=username, password=user_password, email=ilsgateway_smsuser.email, commit=False, password_hashed=bool(password)) user.first_name = first_name user.last_name = last_name user.language = language user.is_active = bool(ilsgateway_smsuser.is_active) user.user_data = user_dict["user_data"] if "phone_numbers" in user_dict: user.set_default_phone_number(user_dict["phone_numbers"][0]) try: user.save_verified_number(self.domain, user_dict["phone_numbers"][0], True) except PhoneNumberInUseException as e: self._reassign_number(user, user_dict["phone_numbers"][0]) except InvalidFormatException: pass except Exception as e: logging.error(e) else: verified_number = user.get_verified_number() phone_number = verified_number.phone_number if verified_number else None if apply_updates(user, user_dict): if user_dict.get('phone_numbers'): new_phone_number = user_dict['phone_numbers'][0] if new_phone_number != phone_number: if phone_number: user.delete_verified_number(phone_number) self._save_verified_number(user, new_phone_number) elif phone_number: user.phone_numbers = [] user.delete_verified_number(phone_number) user.save() return user
def web_user_sync(self, ews_webuser): username = ews_webuser.email.lower() if not username: try: validate_email(ews_webuser.username) username = ews_webuser.username except ValidationError: return None user = WebUser.get_by_username(username) user_dict = { 'first_name': ews_webuser.first_name, 'last_name': ews_webuser.last_name, 'is_active': ews_webuser.is_active, 'last_login': force_to_datetime(ews_webuser.last_login), 'date_joined': force_to_datetime(ews_webuser.date_joined), 'password_hashed': True, } location_id = None if ews_webuser.location: try: sql_location = SQLLocation.objects.get(domain=self.domain, external_id=ews_webuser.location) location_id = sql_location.location_id except SQLLocation.DoesNotExist: pass if user is None: try: user = WebUser.create(domain=None, username=username, password=ews_webuser.password, email=ews_webuser.email.lower(), **user_dict) user.add_domain_membership(self.domain, location_id=location_id) except Exception as e: logging.error(e) else: if self.domain not in user.get_domains(): user.add_domain_membership(self.domain, location_id=location_id) ews_webuser_extension(user, ews_webuser) dm = user.get_domain_membership(self.domain) if dm.location_id != location_id: dm.location_id = location_id if ews_webuser.program: self._set_program(user, ews_webuser.program) self._set_extension(user, ews_webuser.supply_point, ews_webuser.sms_notifications) if ews_webuser.is_superuser: dm.role_id = UserRole.by_domain_and_name(self.domain, 'Administrator')[0].get_id elif ews_webuser.groups and ews_webuser.groups[0].name == 'facility_manager': dm.role_id = UserRole.by_domain_and_name(self.domain, 'Facility manager')[0].get_id else: if ews_webuser.supply_point: supply_point = get_supply_point_case_by_domain_external_id(self.domain, ews_webuser.supply_point) if supply_point: dm.role_id = UserRole.by_domain_and_name(self.domain, 'Web Reporter')[0].get_id else: dm.role_id = UserRole.get_read_only_role_by_domain(self.domain).get_id else: dm.role_id = UserRole.get_read_only_role_by_domain(self.domain).get_id if ews_webuser.contact: user.phone_numbers = [] default_phone_number = None for connection in ews_webuser.contact.phone_numbers: phone_number = apply_leniency(connection.phone_number) user.phone_numbers.append(phone_number) if connection.default: default_phone_number = phone_number if default_phone_number: user.set_default_phone_number(default_phone_number) user.save() return user
def validate_sms_users(self): for sms_user in iterate_over_api_objects(self.endpoint.get_smsusers, {'is_active': True}): description = "" user = CommCareUser.get_by_username(self.get_username(sms_user)[0]) if not user: description = "Not exists" ILSMigrationProblem.objects.create( domain=self.domain, external_id=sms_user.id, object_type='smsuser', description=description ) continue if user.domain != self.domain: description += "domain isn't correct" phone_numbers = { apply_leniency(connection.phone_number) for connection in sms_user.phone_numbers } if phone_numbers - set(user.phone_numbers): description += "Invalid phone numbers, " phone_to_backend = { apply_leniency(connection.phone_number): connection.backend for connection in sms_user.phone_numbers } default_phone_number = [ connection.phone_number for connection in sms_user.phone_numbers if connection.default ] default_phone_number = default_phone_number[0] if default_phone_number else None if default_phone_number and (apply_leniency(default_phone_number) != user.default_phone_number): description += "Invalid default phone number, " for phone_number in user.phone_numbers: vn = VerifiedNumber.by_phone(phone_number) if vn and vn.owner_id != user.get_id and vn.domain == self.domain: description += "Phone number already assigned to user({}) from this domain, "\ .format(vn.owner_id) elif vn and vn.domain != self.domain: description += "Phone number already assigned on domain {}, ".format(vn.domain) elif not vn or not vn.verified: description += "Phone number not verified, " else: backend = phone_to_backend.get(phone_number) if backend != 'push_backend' and vn.backend_id != 'MOBILE_BACKEND_TEST' \ or (backend == 'push_backend' and vn.backend_id): description += "Invalid backend, " if description: migration_problem, _ = ILSMigrationProblem.objects.get_or_create( domain=self.domain, object_id=user.get_id, object_type='smsuser' ) migration_problem.external_id = sms_user.id migration_problem.description = description.rstrip(' ,') migration_problem.save() else: ILSMigrationProblem.objects.filter( domain=self.domain, external_id=sms_user.id, object_type='smsuser' ).delete()
def validate_web_users(self, date=None): unique_usernames = set() for web_user in iterate_over_api_objects( self.endpoint.get_webusers, filters=dict(date_joined__gte=date) ): description = "" if web_user.email: username = web_user.email.lower() else: username = web_user.username.lower() try: validate_email(username) except ValidationError: # We are not migrating users without valid email in v1 continue unique_usernames.add(username) couch_web_user = WebUser.get_by_username(username) if not couch_web_user or self.domain not in couch_web_user.get_domains(): description = "Not exists" EWSMigrationProblem.objects.create( domain=self.domain, object_type='webuser', description=description, external_id=web_user.email or web_user.username ) continue user_contact = web_user.contact if not user_contact: continue phone_numbers = { apply_leniency(connection.phone_number) for connection in user_contact.phone_numbers } if set(phone_numbers) - set(couch_web_user.phone_numbers): description = "Invalid phone numbers, " default_phone_number = [ connection.phone_number for connection in user_contact.phone_numbers if connection.default ] default_phone_number = default_phone_number[0] if default_phone_number else None if default_phone_number and \ (apply_leniency(default_phone_number) != couch_web_user.default_phone_number): description += "Invalid default phone number, " try: extension = EWSExtension.objects.get(user_id=couch_web_user.get_id, domain=self.domain) supply_point = extension.supply_point.external_id if extension.supply_point else None sms_notifications = extension.sms_notifications except EWSExtension.DoesNotExist: supply_point = None sms_notifications = False if str(supply_point) != str(web_user.supply_point): active = True if not supply_point and web_user.supply_point: active = self.endpoint.get_supply_point(web_user.supply_point).active if active: description += 'Invalid supply point, ' if sms_notifications != web_user.sms_notifications: description += 'Invalid value of sms_notifications field' if description: migration_problem, _ = EWSMigrationProblem.objects.get_or_create( domain=self.domain, object_id=couch_web_user.get_id, object_type='webuser' ) migration_problem.external_id = web_user.email or web_user.username migration_problem.description = description.rstrip(' ,') migration_problem.save() else: EWSMigrationProblem.objects.filter( domain=self.domain, external_id=web_user.email or web_user.username, object_type='webuser' ).delete() migration_stats = EWSMigrationStats.objects.get(domain=self.domain) migration_stats.web_users_count = len(unique_usernames) migration_stats.save()
def sms_user_sync(self, ilsgateway_smsuser, username_part=None, password=None, first_name='', last_name=''): domain_part = "%s.commcarehq.org" % self.domain if not username_part: username_part = "%s%d" % (ilsgateway_smsuser.name.strip().replace( ' ', '.').lower(), ilsgateway_smsuser.id) username = "******" % (username_part[:(128 - (len(domain_part) + 1))], domain_part) # sanity check assert len(username) <= 128 user = CouchUser.get_by_username(username) splitted_value = ilsgateway_smsuser.name.split(' ', 1) if not first_name: first_name = splitted_value[0][:30] if splitted_value else '' if not last_name: last_name = splitted_value[1][:30] if len( splitted_value) > 1 else '' language = ilsgateway_smsuser.language user_dict = { 'first_name': first_name, 'last_name': last_name, 'is_active': bool(ilsgateway_smsuser.is_active), 'email': ilsgateway_smsuser.email, 'user_data': {} } if ilsgateway_smsuser.role: user_dict['user_data']['role'] = ilsgateway_smsuser.role if ilsgateway_smsuser.phone_numbers: cleaned_number = apply_leniency( ilsgateway_smsuser.phone_numbers[0]) if cleaned_number: user_dict['phone_numbers'] = [cleaned_number] user_dict['user_data']['backend'] = ilsgateway_smsuser.backend if user is None and username_part: try: user_password = password or User.objects.make_random_password() user = CommCareUser.create(domain=self.domain, username=username, password=user_password, email=ilsgateway_smsuser.email, commit=False, password_hashed=bool(password)) user.first_name = first_name user.last_name = last_name user.language = language user.is_active = bool(ilsgateway_smsuser.is_active) user.user_data = user_dict["user_data"] if "phone_numbers" in user_dict: user.set_default_phone_number( user_dict["phone_numbers"][0]) try: user.save_verified_number( self.domain, user_dict["phone_numbers"][0], True) except PhoneNumberInUseException as e: self._reassign_number(user, user_dict["phone_numbers"][0]) except InvalidFormatException: pass except Exception as e: logging.error(e) else: verified_number = user.get_verified_number() phone_number = verified_number.phone_number if verified_number else None if apply_updates(user, user_dict): if user_dict.get('phone_numbers'): new_phone_number = user_dict['phone_numbers'][0] if new_phone_number != phone_number: if phone_number: user.delete_verified_number(phone_number) self._save_verified_number(user, new_phone_number) elif phone_number: user.phone_numbers = [] user.delete_verified_number(phone_number) user.save() return user
def phone_number_filter(self): value = self._filter['phone_number_filter'] if isinstance(value, basestring): return apply_leniency(value.strip()) return None
def phone_number_filter(self): value = RequiredPhoneNumberFilter.get_value(self.request, domain=None) if isinstance(value, str): return apply_leniency(value.strip()) return None