def create_beneficiary_from_application(application_detail: dict,
user: Optional[User] = None) -> User:
if not user:
beneficiary = User()
beneficiary.password = random_password()
beneficiary.email = application_detail["email"]
beneficiary.dateOfBirth = application_detail["birth_date"]
else:
beneficiary = user
beneficiary.lastName = application_detail["last_name"]
beneficiary.firstName = application_detail["first_name"]
beneficiary.publicName = "%s %s" % (application_detail["first_name"],
application_detail["last_name"])
beneficiary.phoneNumber = application_detail["phone"]
beneficiary.departementCode = application_detail["department"]
beneficiary.postalCode = application_detail["postal_code"]
beneficiary.civility = application_detail["civility"]
beneficiary.activity = application_detail["activity"]
beneficiary.isAdmin = False
beneficiary.hasSeenTutorials = False
generate_reset_token(beneficiary,
validity_duration_hours=THIRTY_DAYS_IN_HOURS)
beneficiary.isBeneficiary = True
application_id = application_detail["application_id"]
deposit = payments_api.create_deposit(
beneficiary, f"démarches simplifiées dossier [{application_id}]")
beneficiary.deposits = [deposit]
return beneficiary
def on_model_change(self, form: Form, model: User, is_created: bool) -> None:
if is_created:
model.password = random_password()
model.publicName = f"{model.firstName} {model.lastName}"
model.isBeneficiary = False
model.isAdmin = False
def to_model(beneficiary_pre_subscription: BeneficiaryPreSubscription) -> User:
beneficiary = User()
beneficiary.activity = beneficiary_pre_subscription.activity
beneficiary.address = beneficiary_pre_subscription.address
beneficiary.city = beneficiary_pre_subscription.city
beneficiary.civility = beneficiary_pre_subscription.civility
beneficiary.dateOfBirth = beneficiary_pre_subscription.date_of_birth
beneficiary.departementCode = beneficiary_pre_subscription.department_code
beneficiary.email = beneficiary_pre_subscription.email
beneficiary.firstName = beneficiary_pre_subscription.first_name
beneficiary.hasSeenTutorials = False
beneficiary.isAdmin = False
beneficiary.lastName = beneficiary_pre_subscription.last_name
beneficiary.password = random_password()
beneficiary.phoneNumber = beneficiary_pre_subscription.phone_number
beneficiary.postalCode = beneficiary_pre_subscription.postal_code
beneficiary.publicName = beneficiary_pre_subscription.public_name
beneficiary.isBeneficiary = True
generate_reset_token(beneficiary,
validity_duration_hours=THIRTY_DAYS_IN_HOURS)
deposit = payments_api.create_deposit(
beneficiary, beneficiary_pre_subscription.deposit_source)
beneficiary.deposits = [deposit]
users_api.attach_beneficiary_import_details(beneficiary,
beneficiary_pre_subscription)
return beneficiary
def signup_pro():
objects_to_save = []
app_origin_url = request.headers.get("origin")
check_valid_signup_pro(request)
new_user = User(from_dict=request.json)
existing_offerer = Offerer.query.filter_by(siren=request.json["siren"]).first()
if existing_offerer:
user_offerer = _generate_user_offerer_when_existing_offerer(new_user, existing_offerer)
offerer = existing_offerer
else:
offerer = _generate_offerer(request.json)
user_offerer = offerer.give_rights(new_user, RightsType.editor)
digital_venue = create_digital_venue(offerer)
objects_to_save.extend([digital_venue, offerer])
objects_to_save.append(user_offerer)
new_user.isBeneficiary = False
new_user.isAdmin = False
new_user.needsToFillCulturalSurvey = False
new_user = _set_offerer_departement_code(new_user, offerer)
new_user.generate_validation_token()
objects_to_save.append(new_user)
repository.save(*objects_to_save)
try:
send_user_validation_email(new_user, send_raw_email, app_origin_url, is_webapp=False)
subscribe_newsletter(new_user)
except MailServiceException:
logger.exception("Mail service failure")
return jsonify(as_dict(new_user, includes=USER_INCLUDES)), 201
def create_pro_user(pro_user: ProUserCreationBodyModel) -> User:
objects_to_save = []
new_pro_user = User(from_dict=pro_user.dict(by_alias=True))
new_pro_user.hasAllowedRecommendations = pro_user.contact_ok
existing_offerer = Offerer.query.filter_by(siren=pro_user.siren).first()
if existing_offerer:
user_offerer = _generate_user_offerer_when_existing_offerer(new_pro_user, existing_offerer)
offerer = existing_offerer
else:
offerer = _generate_offerer(pro_user.dict(by_alias=True))
user_offerer = offerer.grant_access(new_pro_user)
digital_venue = create_digital_venue(offerer)
objects_to_save.extend([digital_venue, offerer])
objects_to_save.append(user_offerer)
new_pro_user.isBeneficiary = False
new_pro_user.isAdmin = False
new_pro_user.needsToFillCulturalSurvey = False
new_pro_user = _set_offerer_departement_code(new_pro_user, offerer)
new_pro_user.generate_validation_token()
objects_to_save.append(new_pro_user)
repository.save(*objects_to_save)
try:
user_emails.send_user_validation_email(new_pro_user)
except MailServiceException:
logger.exception("Could not send validation email when creating pro user=%s", new_pro_user.id)
return new_pro_user
def test_application_with_known_email_are_saved_as_rejected(self, process_beneficiary_application, app):
# given
get_all_application_ids = Mock(return_value=[123])
find_applications_ids_to_retry = Mock(return_value=[])
get_details = Mock(return_value=make_new_beneficiary_application_details(123, "closed"))
user = User()
user.email = "*****@*****.**"
user.isBeneficiary = True
has_already_been_imported = Mock(return_value=False)
has_already_been_created = Mock(return_value=user)
# when
remote_import.run(
ONE_WEEK_AGO,
get_all_applications_ids=get_all_application_ids,
get_applications_ids_to_retry=find_applications_ids_to_retry,
get_details=get_details,
already_imported=has_already_been_imported,
already_existing_user=has_already_been_created,
)
# then
beneficiary_import = BeneficiaryImport.query.first()
assert beneficiary_import.currentStatus == ImportStatus.REJECTED
assert beneficiary_import.applicationId == 123
assert beneficiary_import.detail == "Compte existant avec cet email"
process_beneficiary_application.assert_not_called()
def activate_beneficiary(user: User, deposit_source: str) -> User:
if not is_user_eligible(user):
raise exceptions.NotEligible()
user.isBeneficiary = True
deposit = payment_api.create_deposit(user, deposit_source=deposit_source)
db.session.add_all((user, deposit))
db.session.commit()
return user
def create_user(
activity: str = None,
civility: str = None,
cultural_survey_id: str = None,
cultural_survey_filled_date: datetime = None,
date_created: datetime = datetime.utcnow(),
date_of_birth: datetime = None,
departement_code: str = "93",
email: str = "*****@*****.**",
first_name: str = None,
has_seen_tutorials: bool = None,
idx: int = None,
is_admin: bool = False,
is_beneficiary: bool = True,
is_email_validated: bool = True,
last_connection_date: datetime = None,
last_name: str = None,
needs_to_fill_cultural_survey: bool = False,
password: str = None,
phone_number: str = None,
postal_code: str = None,
public_name: str = "John Doe",
reset_password_token: str = None,
reset_password_token_validity_limit: datetime = None,
validation_token: str = None,
) -> User:
user = User()
user.activity = activity
user.civility = civility
user.culturalSurveyId = cultural_survey_id
user.culturalSurveyFilledDate = cultural_survey_filled_date
user.dateCreated = date_created
user.dateOfBirth = date_of_birth
user.departementCode = departement_code
user.email = email
user.firstName = first_name
user.hasSeenTutorials = has_seen_tutorials
user.id = idx
user.isAdmin = is_admin
user.isBeneficiary = is_beneficiary
user.isEmailValidated = is_email_validated
user.lastConnectionDate = last_connection_date
user.lastName = last_name
user.needsToFillCulturalSurvey = needs_to_fill_cultural_survey
user.phoneNumber = phone_number
user.publicName = public_name
user.postalCode = postal_code
user.validationToken = validation_token
if password:
user.setPassword(password)
else:
user.setPassword(PLAIN_DEFAULT_TESTING_PASSWORD)
user.resetPasswordToken = reset_password_token
user.resetPasswordTokenValidityLimit = reset_password_token_validity_limit
return user
def fill_user_from(csv_row: List[str], user: User) -> User:
user.lastName = csv_row[USER_LAST_NAME_COLUMN_INDEX]
user.firstName = csv_row[USER_FIRST_NAME_COLUMN_INDEX].split(" ")[0]
user.publicName = "%s %s" % (user.firstName, user.lastName)
user.email = csv_row[USER_EMAIL_COLUMN_INDEX]
user.departementCode = csv_row[USER_DEPARTMENT_CODE_COLUMN_INDEX]
user.isBeneficiary = False
user.password = random_password()
generate_reset_token(user, validity_duration_hours=THIRTY_DAYS_IN_HOURS)
return user
def on_model_change(self, form: Form, model: User,
is_created: bool) -> None:
model.publicName = f"{model.firstName} {model.lastName}"
if is_created:
model.isBeneficiary = False
model.password = random_password()
generate_reset_token(model, 24 * 14)
offerer = create_offerer(form)
create_digital_venue(offerer)
user_offerer = create_user_offerer(user=model, offerer=offerer)
model.userOfferers = [user_offerer]
super().on_model_change(form, model, is_created)
def signup_webapp():
objects_to_save = []
check_valid_signup_webapp(request)
new_user = User(from_dict=request.json)
if request.json.get("contact_ok"):
new_user.hasAllowedRecommendations = True
if settings.IS_INTEGRATION:
new_user.departementCode = "00"
objects_to_save.append(payments_api.create_deposit(new_user, "test"))
else:
authorized_emails, departement_codes = get_authorized_emails_and_dept_codes()
departement_code = _get_departement_code_when_authorized_or_error(authorized_emails, departement_codes)
new_user.departementCode = departement_code
new_user.isBeneficiary = False
new_user.isAdmin = False
new_user.isEmailValidated = True
objects_to_save.append(new_user)
repository.save(*objects_to_save)
return jsonify(as_dict(new_user, includes=BENEFICIARY_INCLUDES)), 201
def activate_beneficiary(user: User, deposit_source: str) -> User:
user.isBeneficiary = True
deposit = payment_api.create_deposit(user, deposit_source=deposit_source)
db.session.add_all((user, deposit))
db.session.commit()
return user
