def process_login():
form = LoginForm()
next_url = request.args.get('next')
if form.validate_on_submit():
user_json = data_api_client.authenticate_user(form.email_address.data,
form.password.data)
if not user_json:
current_app.logger.info(
"login.fail: failed to log in {email_hash}",
extra={'email_hash': hash_string(form.email_address.data)})
flash(NO_ACCOUNT_MESSAGE, "error")
return render_template("auth/login.html",
form=form,
errors=get_errors_from_wtform(form),
next=next_url), 403
user = User.from_json(user_json)
login_user(user)
current_app.logger.info("login.success: role={role} user={email_hash}",
extra={
'role':
user.role,
'email_hash':
hash_string(form.email_address.data)
})
return redirect_logged_in_user(next_url)
else:
errors = get_errors_from_wtform(form)
return render_template("auth/login.html",
form=form,
errors=errors,
next=next_url), 400
def edit_supplier_registered_name(supplier_id):
supplier = data_api_client.get_supplier(supplier_id)['suppliers']
company_details = get_company_details_from_supplier(supplier)
form = EditSupplierRegisteredNameForm(
data={"registered_company_name": company_details.get('registered_name')}
)
if form.validate_on_submit():
data_api_client.update_supplier(
supplier_id,
{'registeredName': form.registered_company_name.data},
current_user.email_address
)
flash(SUPPLIER_DETAILS_UPDATED_MESSAGE.format(supplier_name=supplier['name']))
return redirect(url_for('.supplier_details', supplier_id=supplier_id))
errors = get_errors_from_wtform(form)
return render_template(
"suppliers/edit_registered_name.html",
supplier=supplier,
form=form,
errors=errors,
), 200 if not errors else 400
def edit_supplier_organisation_size():
form = CompanyOrganisationSizeForm()
if request.method == 'POST':
if form.validate_on_submit():
data_api_client.update_supplier(
supplier_id=current_user.supplier_id,
supplier={"organisationSize": form.organisation_size.data},
user=current_user.email_address)
return redirect(url_for('.supplier_details'))
# TODO: see if we can remove this
current_app.logger.warning(
"supplieredit.fail: organisation-size:{osize}, errors:{osize_errors}",
extra={
'osize': form.organisation_size.data,
'osize_errors': ",".join(form.organisation_size.errors)
})
supplier = data_api_client.get_supplier(
current_user.supplier_id)['suppliers']
form.organisation_size.data = supplier.get('organisationSize', None)
errors = get_errors_from_wtform(form)
return render_template('suppliers/edit_supplier_organisation_size.html',
form=form,
errors=errors), 200 if not errors else 400
def ask_brief_clarification_question(brief_id):
brief = get_brief(data_api_client, brief_id, allowed_statuses=['live'])
if brief['clarificationQuestionsAreClosed']:
abort(404)
if not is_supplier_eligible_for_brief(data_api_client,
current_user.supplier_id, brief):
return _render_not_eligible_for_brief_error_page(
brief, clarification_question=True)
form = AskClarificationQuestionForm(brief)
if form.validate_on_submit():
send_brief_clarification_question(data_api_client, brief,
form.clarification_question.data)
flash(CLARIFICATION_QUESTION_SENT_MESSAGE.format(brief=brief),
"success")
errors = govuk_errors(get_errors_from_wtform(form))
return render_template(
"briefs/clarification_question.html",
brief=brief,
form=form,
errors=errors,
), 200 if not errors else 400
def update_password(token):
form = PasswordResetForm()
decoded = decode_password_reset_token(token, data_api_client)
if 'error' in decoded:
flash(EXPIRED_PASSWORD_RESET_TOKEN_MESSAGE, "error")
return redirect(url_for('.request_password_reset'))
user_id = decoded["user"]
email_address = decoded["email"]
password = form.password.data
if form.validate_on_submit():
if data_api_client.update_user_password(user_id, password,
email_address):
current_app.logger.info(
"User {user_id} successfully changed their password",
extra={'user_id': user_id})
flash(PASSWORD_UPDATED_MESSAGE, "success")
else:
flash(PASSWORD_NOT_UPDATED_MESSAGE, "error")
return redirect(url_for('.render_login'))
else:
return render_template("auth/reset-password.html",
email_address=email_address,
form=form,
errors=get_errors_from_wtform(form),
token=token), 400
def edit_supplier_trading_status():
prefill_data = {}
if request.method == "GET":
supplier = data_api_client.get_supplier(
current_user.supplier_id)['suppliers']
prefill_data = {"trading_status": supplier.get("tradingStatus")}
form = CompanyTradingStatusForm(data=prefill_data)
if request.method == 'POST':
if form.validate_on_submit():
data_api_client.update_supplier(
supplier_id=current_user.supplier_id,
supplier={"tradingStatus": form.trading_status.data},
user=current_user.email_address)
return redirect(url_for('.supplier_details'))
current_app.logger.warning(
"supplieredit.fail: trading-status:{tstatus}, errors:{tstatus_errors}",
extra={
'tstatus': form.trading_status.data,
'tstatus_errors': ",".join(form.trading_status.errors)
})
errors = get_errors_from_wtform(form)
return render_template('suppliers/edit_supplier_trading_status.html',
form=form,
errors=errors), 200 if not errors else 400
def invite_admin_user():
notify_template_id = '08ab7791-6038-4ad2-9560-740bbcb675b7'
form = InviteAdminForm()
if request.method == 'POST' and form.validate_on_submit():
email_address = form.data.get('email_address')
role = form.data.get('role')
send_user_account_email(
role,
email_address,
notify_template_id,
personalisation={'name': current_user.name}
)
flash(INVITATION_SENT_MESSAGE.format(email_address=email_address))
return redirect(url_for('main.manage_admin_users'))
errors = get_errors_from_wtform(form)
return render_template(
"invite_admin_user.html",
form=form,
errors=errors,
), 200 if not errors else 400
def invite_user():
form = EmailAddressForm()
if form.validate_on_submit():
send_user_account_email(
'supplier',
form.email_address.data,
current_app.config['NOTIFY_TEMPLATES']['invite_contributor'],
extra_token_data={
'supplier_id': current_user.supplier_id,
'supplier_name': current_user.supplier_name
},
personalisation={
'user': current_user.name,
'supplier': current_user.supplier_name
})
data_api_client.create_audit_event(
audit_type=AuditTypes.invite_user,
user=current_user.email_address,
object_type='suppliers',
object_id=current_user.supplier_id,
data={'invitedEmail': form.email_address.data},
)
flash(USER_INVITED_FLASH_MESSAGE, "success")
return redirect(url_for('.list_users'))
errors = get_errors_from_wtform(form)
return render_template("auth/submit_email_address.html",
form=form,
errors=errors), 200 if not errors else 400
def submit_create_buyer_account():
current_app.logger.info("buyercreate: post create-buyer-account")
form = EmailAddressForm()
if form.validate_on_submit():
email_address = form.email_address.data
if not data_api_client.is_email_address_with_valid_buyer_domain(
email_address):
return render_template("create_buyer/create_buyer_user_error.html",
support_email_address=current_app.
config['SUPPORT_EMAIL_ADDRESS'],
error='invalid_buyer_domain'), 400
else:
send_user_account_email(
'buyer', email_address,
current_app.config['NOTIFY_TEMPLATES']['create_user_account'])
data_api_client.create_audit_event(
audit_type=AuditTypes.invite_user,
data={'invitedEmail': email_address})
return redirect(url_for('.create_your_account_complete'), 302)
else:
return render_template(
"create_buyer/create_buyer_account.html",
form=form,
errors=get_errors_from_wtform(form),
), 400
def join_open_framework_notification_mailing_list():
status = 200
form = EmailAddressForm()
if form.validate_on_submit():
dmmc_client = DMMailChimpClient(
current_app.config["DM_MAILCHIMP_USERNAME"],
current_app.config["DM_MAILCHIMP_API_KEY"],
current_app.logger,
)
mc_response = dmmc_client.subscribe_new_email_to_list(
current_app.config["DM_MAILCHIMP_OPEN_FRAMEWORK_NOTIFICATION_MAILING_LIST_ID"],
form.data["email_address"],
)
if mc_response.get('status') == 'success':
data_api_client.create_audit_event(
audit_type=AuditTypes.mailing_list_subscription,
data={
"subscribedEmail": form.data["email_address"],
"mailchimp": {k: mc_response.get(k) for k in (
"id",
"unique_email_id",
"timestamp_opt",
"last_changed",
"list_id",
)},
},
)
flash(JOIN_OPEN_FRAMEWORK_NOTIFICATION_MAILING_LIST_SUCCESS_MESSAGE.format(
email_address=form.data["email_address"],
), "success")
return redirect("/")
else:
if mc_response.get('error_type') == 'already_subscribed':
flash(JOIN_OPEN_FRAMEWORK_NOTIFICATION_MAILING_LIST_ALREADY_SUBSCRIBED_MESSAGE.format(
support_email_address=current_app.config['SUPPORT_EMAIL_ADDRESS']
), "error")
elif mc_response.get('error_type') in ['deleted_user', 'invalid_email']:
flash(JOIN_OPEN_FRAMEWORK_NOTIFICATION_MAILING_LIST_UNSUBSCRIBED_MESSAGE.format(
support_email_address=current_app.config['SUPPORT_EMAIL_ADDRESS']
), "error")
else:
flash(JOIN_OPEN_FRAMEWORK_NOTIFICATION_MAILING_LIST_ERROR_MESSAGE.format(
support_email_address=current_app.config['SUPPORT_EMAIL_ADDRESS']
), "error")
# If no status code supplied, something has probably gone wrong
status = mc_response.get('status_code', 503)
# fall through to re-display form with error
elif request.method == "POST":
status = 400
# fall through to re-display form with errors
return render_template(
"suppliers/join_open_framework_notification_mailing_list.html",
form=form,
errors=get_errors_from_wtform(form),
), status
def edit_supplier_registration_number():
form = AddCompanyRegistrationNumberForm()
supplier = data_api_client.get_supplier(current_user.supplier_id)['suppliers']
if (supplier.get("companiesHouseNumber") or supplier.get("otherCompanyRegistrationNumber")) \
and supplier.get('companyDetailsConfirmed'):
return (
render_template(
"suppliers/already_completed.html",
completed_data_description="registration number",
company_details_change_email=current_app.config['DM_COMPANY_DETAILS_CHANGE_EMAIL'],
),
200 if request.method == 'GET' else 400
)
if request.method == 'POST':
if form.validate_on_submit():
if form.has_companies_house_number.data == "Yes":
data_api_client.update_supplier(
supplier_id=current_user.supplier_id,
supplier={"companiesHouseNumber": form.companies_house_number.data.upper(),
"otherCompanyRegistrationNumber": None},
user=current_user.email_address
)
else:
data_api_client.update_supplier(
supplier_id=current_user.supplier_id,
supplier={"companiesHouseNumber": None,
"otherCompanyRegistrationNumber": form.other_company_registration_number.data},
user=current_user.email_address
)
return redirect(url_for('.supplier_details'))
else:
current_app.logger.warning(
"supplieredit.fail: has-companies-house-number:{hasnum}, companies-house-number:{chnum}, "
"other-registered-company-number:{rnumber}, errors:{rnumber_errors}",
extra={
'hasnum': form.has_companies_house_number.data,
'chnum': form.companies_house_number.data,
'rnumber': form.other_company_registration_number.data,
'rnumber_errors': ",".join(form.errors)
})
else:
if supplier.get('companiesHouseNumber'):
form.has_companies_house_number.data = "Yes"
form.companies_house_number.data = supplier.get('companiesHouseNumber')
elif supplier.get('otherCompanyRegistrationNumber'):
form.has_companies_house_number.data = "No"
form.other_company_registration_number.data = supplier.get('otherCompanyRegistrationNumber')
errors = get_errors_from_wtform(form)
return render_template(
'suppliers/edit_company_registration_number.html',
form=form,
errors=errors,
), 200 if not errors else 400
def duns_number():
form = DunsNumberForm()
if request.method == 'GET':
if request.args.get('retry', None) == 'true':
# When redirected back from the confirm_company page
form.duns_number.errors = ["Enter a different DUNS number"]
elif form.duns_number.name in session:
# Likely a back click or unexpected navigation, refill form data
form.duns_number.data = session[form.duns_number.name]
if form.validate_on_submit():
# Valid duns number
# Fail on existing account with this duns number first
if len(
data_api_client.find_suppliers(
duns_number=form.duns_number.data)['suppliers']) > 0:
form.duns_number.errors = ["DUNS number already used"]
else:
# Check for number in Direct Plus API
# If we cannot contact the API then skip this step
# If the client doesn't return an organization then there is not a record for that DUNs
# Otherwise the number is good, add the 'primaryName' to the session and continue
try:
organization = direct_plus_client.get_organization_by_duns_number(
form.duns_number.data)
if organization is not None:
company_name = organization['primaryName']
except KeyError:
# An unexpected error. Something other than supplier data in the response.
# Allow the user to proceed with the entered duns numer and skip this part of sign up.
session[form.duns_number.name] = form.duns_number.data
return redirect(url_for(".company_details"))
if organization is None:
form.duns_number.errors = ["DUNS number not found"]
else:
# Success
session[form.duns_number.name] = form.duns_number.data
session['company_name'] = company_name
return redirect(url_for(".confirm_company"))
current_app.logger.warning(
"suppliercreate.fail: duns:{duns} {duns_errors}",
extra={
'duns': form.duns_number.data,
'duns_errors': ",".join(form.duns_number.errors)
})
errors = get_errors_from_wtform(form)
return render_template(
"suppliers/create_duns_number.html",
form=form,
errors=errors,
support_email_address=current_app.config['SUPPORT_EMAIL_ADDRESS']
), 200 if not errors else 400
def award_brief(framework_slug, lot_slug, brief_id):
get_framework_and_lot(
framework_slug,
lot_slug,
data_api_client,
allowed_statuses=['live', 'expired'],
must_allow_brief=True,
)
brief = data_api_client.get_brief(brief_id)["briefs"]
if not is_brief_correct(brief,
framework_slug,
lot_slug,
current_user.id,
allowed_statuses=['closed']):
abort(404)
brief_responses = data_api_client.find_brief_responses(
brief['id'], status="submitted,pending-awarded")['briefResponses']
if not brief_responses:
return redirect(
url_for(".view_brief_responses",
framework_slug=brief['frameworkSlug'],
lot_slug=brief['lotSlug'],
brief_id=brief['id']))
form = AwardedBriefResponseForm(brief_responses)
form_options = form.brief_response.govuk_options
if form.validate_on_submit():
try:
data_api_client.update_brief_award_brief_response(
brief_id, form.data['brief_response'],
current_user.email_address)
except HTTPError:
abort(500, "Unexpected API error when awarding brief response")
return redirect(
url_for(".award_brief_details",
framework_slug=brief['frameworkSlug'],
lot_slug=brief['lotSlug'],
brief_id=brief['id'],
brief_response_id=form.data['brief_response']))
pending_brief_responses = list(
filter(lambda x: x.get('awardDetails', {}).get('pending'),
brief_responses))
form['brief_response'].data = pending_brief_responses[0][
"id"] if pending_brief_responses else None
errors = get_errors_from_wtform(form)
return render_template("buyers/award.html",
brief=brief,
form=form,
form_options=form_options,
errors=errors), 200 if not errors else 400
def award_or_cancel_brief(framework_slug, lot_slug, brief_id):
get_framework_and_lot(
framework_slug,
lot_slug,
data_api_client,
allowed_statuses=['live', 'expired'],
must_allow_brief=True,
)
brief = data_api_client.get_brief(brief_id)["briefs"]
if not is_brief_correct(brief,
framework_slug,
lot_slug,
current_user.id,
allowed_statuses=[
"awarded", "cancelled", "unsuccessful",
"closed"
]):
abort(404)
form = AwardOrCancelBriefForm(brief)
already_awarded = brief['status'] in [
"awarded", "cancelled", "unsuccessful"
]
if already_awarded is False and form.validate_on_submit():
answer = form.data.get('award_or_cancel_decision')
if answer == 'back':
flash(BRIEF_UPDATED_MESSAGE.format(brief=brief), "success")
return redirect(url_for('.buyer_dos_requirements'))
elif answer == 'yes':
return redirect(
url_for('.award_brief',
framework_slug=framework_slug,
lot_slug=lot_slug,
brief_id=brief_id))
elif answer == 'no':
return redirect(
url_for('.cancel_award_brief',
framework_slug=framework_slug,
lot_slug=lot_slug,
brief_id=brief_id))
else:
# We should never get here as the form validates the answers against the available choices.
abort(500, "Unexpected answer to award or cancel brief")
errors = get_errors_from_wtform(form)
return render_template(
"buyers/award_or_cancel_brief.html",
brief=brief,
form=form,
errors=errors,
already_awarded=already_awarded,
), 200 if not errors else 400
def test_empty_list_if_no_errors(self, app):
with app.app_context():
form = EmailFieldFormatTestForm(
formdata=ImmutableMultiDict((
("test_email", '*****@*****.**',),
)),
meta={'csrf': False},
)
assert form.validate() is True
assert not form.errors
assert get_errors_from_wtform(form) == OrderedDict()
def render_login():
next_url = request.args.get('next')
if current_user.is_authenticated and not get_flashed_messages():
return redirect_logged_in_user(next_url)
form = LoginForm()
errors = get_errors_from_wtform(form)
return render_template("auth/login.html",
form=form,
errors=errors,
next=next_url), 200
def user_research_consent():
"""Page where users can opt into/ out of the user research mailing lists."""
# Set defaults
form = UserResearchOptInForm(request.form)
status_code = 200
errors = {}
dashboard_url = get_user_dashboard_url(current_user)
if request.method == "POST":
if form.validate_on_submit():
# If the form is valid then set the new value.
user_research_opt_in = form.data.get('user_research_opt_in')
data_api_client.update_user(
current_user.id,
user_research_opted_in=user_research_opt_in,
updater=current_user.email_address)
flash("Your preference has been saved", 'success')
return redirect(dashboard_url)
else:
# If the form is not valid set the status code and parse the errors into an acceptable format.
status_code = 400
errors = get_errors_from_wtform(form)
else:
# Update the form with the existing value if this is not a POST
user = data_api_client.get_user(current_user.id)
form = UserResearchOptInForm(
user_research_opt_in=user['users']['userResearchOptedIn'])
# Set the seen_user_research_message cookie if it does not exist.
# This ensures the user research banner is no longer shown.
additional_headers = []
# Changing cookie name will require an update to the following files:
# digitalmarketplace-frontend-toolkit/toolkit/templates/user-research-consent-banner.html
# digitalmarketplace-frontend-toolkit/toolkit/javascripts/user-research-consent-banner.js
cookie_name = 'seen_user_research_message'
if cookie_name not in request.cookies:
expiry_date = datetime.datetime.now() + datetime.timedelta(90)
expiry_date = expiry_date.strftime("%a, %d-%b-%Y %H:%M:%S GMT")
additional_headers = {
'Set-Cookie':
"{}=yes; Path=/; Expires={}".format(cookie_name, expiry_date)
}
return render_template(
"notifications/user-research-consent.html",
form=form,
errors=errors,
dashboard_url=dashboard_url), status_code, additional_headers
def reset_password(token):
decoded = decode_password_reset_token(token, data_api_client)
if 'error' in decoded:
flash(EXPIRED_PASSWORD_RESET_TOKEN_MESSAGE, "error")
return redirect(url_for('.request_password_reset'))
email_address = decoded['email']
form = PasswordResetForm()
errors = get_errors_from_wtform(form)
return render_template("auth/reset-password.html",
email_address=email_address,
form=form,
errors=errors,
token=token), 200
def create_user(encoded_token):
token = decode_invitation_token(encoded_token)
if token.get('error') == 'token_invalid':
current_app.logger.warning("createuser.token_invalid: {encoded_token}",
extra={'encoded_token': encoded_token})
# Replace this with a proper dedicated template.
return render_error_page(
status_code=400,
error_message=INVALID_TOKEN_MESSAGE.format(
support_email=current_app.config['SUPPORT_EMAIL_ADDRESS']),
)
role = token["role"]
if token.get('error') == 'token_expired':
current_app.logger.warning("createuser.token_expired: {encoded_token}",
extra={'encoded_token': encoded_token})
return render_template(
"auth/create-user-error.html",
error=None,
support_email_address=current_app.config['SUPPORT_EMAIL_ADDRESS'],
role=role,
token=None,
user=None), 400
form = CreateUserForm()
user_json = data_api_client.get_user(email_address=token["email_address"])
if not user_json:
return render_template("auth/create-user.html",
email_address=token['email_address'],
form=form,
errors=get_errors_from_wtform(form),
role=role,
supplier_name=token.get('supplier_name'),
token=encoded_token), 200
user = User.from_json(user_json)
return render_template(
"auth/create-user-error.html",
error=None,
support_email_address=current_app.config['SUPPORT_EMAIL_ADDRESS'],
role=role,
token=token,
user=user), 400
def test_errors_include_href_and_text_for_govuk_frontend_error_summary(
self, app, email_address):
with app.app_context():
form = EmailFieldFormatTestForm(
formdata=ImmutableMultiDict(((
"test_email",
email_address,
), )),
meta={'csrf': False},
)
assert form.validate() is False
assert form.errors
errors = get_errors_from_wtform(form)["test_email"]
assert errors["href"] == "#input-test_email"
assert errors["text"] == "Please enter a valid email address."
def edit_supplier_registered_address(supplier_id):
supplier = data_api_client.get_supplier(supplier_id)['suppliers']
contact = supplier["contactInformation"][0]
company_details = get_company_details_from_supplier(supplier)
prefill_data = {
"street": company_details['address'].get('street_address_line_1'),
"city": company_details['address'].get('locality'),
"postcode": company_details['address'].get('postcode'),
"country": company_details['address']['country']
}
form = EditSupplierRegisteredAddressForm(data=prefill_data)
if form.validate_on_submit():
# Will update declarations for open frameworks
data_api_client.update_supplier(
supplier_id,
{'registrationCountry': form.country.data},
current_user.email_address
)
# Will update declarations for open frameworks
data_api_client.update_contact_information(
supplier_id,
contact['id'],
{
'country': form.country.data,
'address1': form.street.data,
'city': form.city.data,
'postcode': form.postcode.data,
},
current_user.email_address
)
flash(SUPPLIER_DETAILS_UPDATED_MESSAGE.format(supplier_name=supplier['name']))
return redirect(url_for('.supplier_details', supplier_id=supplier_id))
errors = get_errors_from_wtform(form)
return render_template(
"suppliers/edit_registered_address.html",
supplier=supplier,
form=form,
countries=COUNTRY_TUPLE,
errors=errors,
), 200 if not errors else 400
def edit_what_buyers_will_see():
supplier = data_api_client.get_supplier(
current_user.supplier_id
)['suppliers']
contact = supplier["contactInformation"][0]
prefill_data = {
"contactName": contact.get("contactName"),
"phoneNumber": contact.get("phoneNumber"),
"email": contact.get("email"),
"description": supplier.get("description"),
}
form = EditSupplierInformationForm(data=prefill_data)
if form.validate_on_submit():
data_api_client.update_supplier(
current_user.supplier_id,
{
"description": form.description.data,
},
current_user.email_address
)
data_api_client.update_contact_information(
current_user.supplier_id,
contact["id"],
{
"contactName": form.contactName.data,
"phoneNumber": form.phoneNumber.data,
"email": form.email.data,
},
current_user.email_address
)
return redirect(url_for(".supplier_details"))
errors = get_errors_from_wtform(form)
return render_template(
"suppliers/edit_what_buyers_will_see.html",
form=form,
errors=errors,
), 200 if not errors else 400
def create_your_account():
current_app.logger.info(
"suppliercreate: {} create-your-account supplier_id:{}".format(
request.method, session.get('email_supplier_id', 'unknown')))
form = EmailAddressForm()
if form.validate_on_submit():
session['account_email_address'] = form.email_address.data
return redirect(url_for(".company_summary"))
errors = get_errors_from_wtform(form)
return render_template(
"suppliers/create_your_account.html",
form=form,
errors=errors,
email_address=form.email_address.data if form.email_address.data else
session.get('account_email_address', '')), 200 if not errors else 400
def test_errors_include_error_message_for_govuk_frontend_error_message(
self, app, email_address):
with app.app_context():
form = EmailFieldFormatTestForm(
formdata=ImmutableMultiDict(((
"test_email",
email_address,
), )),
meta={'csrf': False},
)
assert form.validate() is False
assert form.errors
error_message = get_errors_from_wtform(
form)["test_email"]["errorMessage"]
assert error_message[
"text"] == "Please enter a valid email address."
def test_errors_include_input_name_and_question_and_message(
self, app, email_address):
with app.app_context():
form = EmailFieldFormatTestForm(
formdata=ImmutableMultiDict(((
"test_email",
email_address,
), )),
meta={'csrf': False},
)
assert form.validate() is False
assert form.errors
errors = get_errors_from_wtform(form)["test_email"]
assert errors["input_name"] == "test_email"
assert errors["question"] == "An Electronic Mailing Address"
assert errors["message"] == "Please enter a valid email address."
def edit_registered_address():
supplier = data_api_client.get_supplier(current_user.supplier_id)["suppliers"]
contact = supplier["contactInformation"][0]
prefill_data = {
"street": contact.get("address1"),
"city": contact.get("city"),
"postcode": contact.get("postcode"),
"country": supplier.get("registrationCountry"),
}
registered_address_form = EditRegisteredAddressForm(data=prefill_data)
if registered_address_form.validate_on_submit():
data_api_client.update_supplier(
current_user.supplier_id,
{
"registrationCountry": registered_address_form.country.data,
},
current_user.email_address,
)
data_api_client.update_contact_information(
current_user.supplier_id,
contact["id"],
{
"address1": registered_address_form.street.data,
"city": registered_address_form.city.data,
"postcode": registered_address_form.postcode.data,
},
current_user.email_address
)
return redirect(url_for(".supplier_details"))
errors = get_errors_from_wtform(registered_address_form)
return render_template(
"suppliers/registered_address.html",
supplier=supplier,
countries=COUNTRY_TUPLE,
form=registered_address_form,
errors=errors,
), 200 if not errors else 400
def test_errors_are_formatted(self, app, email_address):
with app.app_context():
form = EmailFieldFormatTestForm(
formdata=ImmutableMultiDict((
("test_email", email_address,),
)),
meta={'csrf': False},
)
assert form.validate() is False
assert form.errors
assert get_errors_from_wtform(form) == OrderedDict([(
'test_email',
{
'input_name': 'test_email',
'question': "An Electronic Mailing Address",
'message': 'Please enter a valid email address.'
}
)])
def company_details():
form = CompanyPublicContactInformationForm()
if request.method == "POST":
if form.validate_on_submit():
session[form.company_name.name] = form.company_name.data
session[form.email_address.name] = form.email_address.data
session[form.phone_number.name] = form.phone_number.data
session[form.contact_name.name] = form.contact_name.data
return redirect(url_for(".create_your_account"))
else:
current_app.logger.warning(
"suppliercreate.fail: duns:{duns} {form_errors}",
extra={
'duns':
session.get('duns_number'),
'form_errors':
",".join(chain.from_iterable(form.errors.values()))
})
else:
if form.company_name.name in session:
form.company_name.data = session[form.company_name.name]
if form.contact_name.name in session:
form.contact_name.data = session[form.contact_name.name]
if form.email_address.name in session:
form.email_address.data = session[form.email_address.name]
if form.phone_number.name in session:
form.phone_number.data = session[form.phone_number.name]
errors = get_errors_from_wtform(form)
return render_template(
"suppliers/create_company_details.html",
form=form,
errors=errors,
), 200 if not errors else 400
def edit_supplier_registered_name():
form = AddCompanyRegisteredNameForm()
supplier = data_api_client.get_supplier(
current_user.supplier_id)['suppliers']
if supplier.get("registeredName") and supplier.get(
'companyDetailsConfirmed'):
return (render_template(
"suppliers/already_completed.html",
completed_data_description="registered company name",
company_details_change_email=current_app.
config['DM_COMPANY_DETAILS_CHANGE_EMAIL'],
), 200 if request.method == 'GET' else 400)
if request.method == 'POST':
if form.validate_on_submit():
data_api_client.update_supplier(
supplier_id=current_user.supplier_id,
supplier={"registeredName": form.registered_company_name.data},
user=current_user.email_address)
return redirect(url_for('.supplier_details'))
else:
current_app.logger.warning(
"supplieredit.fail: registered-name:{rname}, errors:{rname_errors}",
extra={
'rname': form.registered_company_name.data,
'rname_errors':
",".join(form.registered_company_name.errors)
})
else:
form.registered_company_name.data = supplier.get("registeredName")
errors = get_errors_from_wtform(form)
return render_template(
'suppliers/edit_registered_name.html',
form=form,
errors=errors,
company_details_change_email=current_app.
config['DM_COMPANY_DETAILS_CHANGE_EMAIL']), 200 if not errors else 400
def test_errors_retain_ordering(self, app):
with app.app_context():
form = MultipleFieldFormatTestForm(
formdata=ImmutableMultiDict((
(
'test_email',
'my bad email',
),
('test_two', 'some text, good'),
('test_three', 'not enough text'),
('test_four', ''),
)),
meta={'csrf': False},
)
assert form.validate() is False
assert form.errors
assert list(get_errors_from_wtform(form).keys()) == [
"test_one",
"test_three",
"test_four",
]
