def test_accept_offer_invalid_status(user_api_client, is_accepted,
initial_status):
customer = CustomerProfileFactory()
due_date = date.today() + relativedelta(days=14)
berth_switch_offer = BerthSwitchOfferFactory(
customer=customer,
due_date=due_date,
status=initial_status,
lease=BerthLeaseFactory(
customer=customer,
start_date=calculate_berth_lease_start_date(),
end_date=calculate_berth_lease_end_date(),
status=LeaseStatus.PAID,
),
)
variables = {
# "offerId": to_global_id(BerthSwitchOfferNode, berth_switch_offer.id),
"offerNumber": berth_switch_offer.offer_number,
"isAccepted": is_accepted,
}
user_api_client.execute(ACCEPT_BERTH_SWITCH_OFFER_MUTATION,
input=variables)
berth_switch_offer.refresh_from_db()
berth_switch_offer.lease.refresh_from_db()
assert berth_switch_offer.status == initial_status
assert berth_switch_offer.lease.status == LeaseStatus.PAID
new_lease = BerthLease.objects.exclude(
id=berth_switch_offer.lease_id).first()
assert new_lease is None
def test_reject_offer(user_api_client):
customer = CustomerProfileFactory()
due_date = date.today() + relativedelta(days=14)
berth_switch_offer = BerthSwitchOfferFactory(
customer=customer,
due_date=due_date,
status=OfferStatus.OFFERED,
lease=BerthLeaseFactory(
customer=customer,
start_date=calculate_berth_lease_start_date(),
end_date=calculate_berth_lease_end_date(),
status=LeaseStatus.PAID,
),
)
variables = {
# "offerId": to_global_id(BerthSwitchOfferNode, berth_switch_offer.id),
"offerNumber": berth_switch_offer.offer_number,
"isAccepted": False,
}
user_api_client.execute(ACCEPT_BERTH_SWITCH_OFFER_MUTATION,
input=variables)
berth_switch_offer.refresh_from_db()
berth_switch_offer.lease.refresh_from_db()
assert berth_switch_offer.status == OfferStatus.REJECTED
assert berth_switch_offer.lease.status == LeaseStatus.PAID
assert berth_switch_offer.application.status == ApplicationStatus.REJECTED
assert BerthLease.objects.all().count() == 1
def _get_berth_order_context(subject: str = "Berth order"):
customer = CustomerProfileFactory.build()
order = OrderFactory.build(
customer=customer,
product=BerthProductFactory.build(),
lease=BerthLeaseFactory.build(
customer=customer,
# Fixed to a harbor with a real image
berth__pier__harbor__image_file="/img/helsinki_harbors/41189.jpg",
),
price=Decimal("100"),
tax_percentage=Decimal("24.00"),
)
optional_services = [
OrderLineFactory.build(
order=order,
product__service=ProductServiceType.OPTIONAL_SERVICES()[0],
price=random_price(),
),
OrderLineFactory.build(
order=order,
product__service=ProductServiceType.OPTIONAL_SERVICES()[1],
price=random_price(),
),
]
return _get_order_context(subject, order, optional_services)
def test_berth_lease_update_application_different_customer(berth_lease):
first_application = BerthApplicationFactory(
customer=CustomerProfileFactory())
second_application = BerthApplicationFactory(
customer=CustomerProfileFactory())
berth_lease.application = first_application
berth_lease.save()
assert BerthLease.objects.get(
id=berth_lease.id).application == first_application
with pytest.raises(ValidationError) as exception:
berth_lease.application = second_application
berth_lease.save()
assert (
"Cannot change the application to one which belongs to another customer"
in str(exception.value))
def get_customer_profile_dict() -> dict:
faker = Faker()
profile = CustomerProfileFactory()
return {
"id": to_global_id(ProfileNode, profile.id),
"first_name": profile.user.first_name,
"last_name": profile.user.last_name,
"primary_email": {"email": profile.user.email},
"primary_phone": {"phone": faker.phone_number()},
"primary_address": MOCK_HKI_PROFILE_ADDRESS,
}
def test_winter_storage_lease_application_different_customer(
winter_storage_lease):
first_application = WinterStorageApplicationFactory(
customer=CustomerProfileFactory())
second_application = WinterStorageApplicationFactory(
customer=CustomerProfileFactory())
winter_storage_lease.application = first_application
winter_storage_lease.save()
assert (WinterStorageLease.objects.get(
id=winter_storage_lease.id).application == first_application)
with pytest.raises(ValidationError) as exception:
winter_storage_lease.application = second_application
winter_storage_lease.save()
assert (
"Cannot change the application to one which belongs to another customer"
in str(exception.value))
def _get_berth_switch_offer_context(subject: str = "Berth offer"):
customer = CustomerProfileFactory.build()
offer = BerthSwitchOfferFactory.build(
customer=customer,
application=BerthApplicationFactory.build(customer=customer),
berth=BerthFactory.build(),
lease=BerthLeaseFactory.build(
customer=customer,
# Fixed to a harbor with a real image
berth__pier__harbor__image_file="/img/helsinki_harbors/41189.jpg",
),
)
return _get_offer_context(subject, offer)
def test_delete_profile(rest_api_client, requests_mock, settings):
customer_profile = CustomerProfileFactory()
auth_header = get_api_token_for_user_with_scopes(
customer_profile.user, [settings.GDPR_API_DELETE_SCOPE], requests_mock
)
rest_api_client.credentials(HTTP_AUTHORIZATION=auth_header)
response = rest_api_client.delete(
reverse("helsinki_gdpr:gdpr_v1", kwargs={"pk": customer_profile.id})
)
assert response.status_code == 204
assert CustomerProfile.objects.count() == 0
assert User.objects.count() == 0
def test_delete_profile_with_lease(rest_api_client, requests_mock, settings):
"""For now, if the profile has resources connected to it, they will prevent
the deletion of the profile
"""
customer_profile = CustomerProfileFactory()
BerthLeaseFactory(customer=customer_profile)
auth_header = get_api_token_for_user_with_scopes(
customer_profile.user, [settings.GDPR_API_DELETE_SCOPE], requests_mock
)
rest_api_client.credentials(HTTP_AUTHORIZATION=auth_header)
response = rest_api_client.delete(
reverse("helsinki_gdpr:gdpr_v1", kwargs={"pk": customer_profile.id})
)
assert response.status_code == 403
assert CustomerProfile.objects.count() == 1
assert User.objects.count() == 1
def _get_cancelled_order_context(subject: str = "Order cancelled"):
customer = CustomerProfileFactory.build()
return {
"subject": subject,
"order": {
**factory.build(
dict,
FACTORY_CLASS=OrderFactory,
customer=customer,
status=OrderStatus.CANCELLED,
product=BerthProductFactory.build(),
lease=BerthLeaseFactory.build(customer=customer),
price=Decimal("100"),
tax_percentage=Decimal("24.00"),
),
},
"rejected_at": str(datetime.date.today(
)), # language not known at this point, default to ISO format
}
def test_get_profile_information_from_gdpr_api(
rest_api_client, requests_mock, settings
):
customer_profile = CustomerProfileFactory()
auth_header = get_api_token_for_user_with_scopes(
customer_profile.user, [settings.GDPR_API_QUERY_SCOPE], requests_mock
)
rest_api_client.credentials(HTTP_AUTHORIZATION=auth_header)
response = rest_api_client.get(
reverse("helsinki_gdpr:gdpr_v1", kwargs={"pk": customer_profile.id})
)
resp = json.loads(response.content)
assert response.status_code == 200
assert resp == {
"key": "CUSTOMERPROFILE",
"children": [
{
"key": "INVOICING_TYPE",
"value": dict(InvoicingType.choices)[customer_profile.invoicing_type],
},
{"key": "COMMENT", "value": customer_profile.comment},
{
"key": "CREATED_AT",
"value": customer_profile.created_at.strftime("%d-%m-%Y %H:%M:%S"),
},
{
"key": "MODIFIED_AT",
"value": customer_profile.modified_at.strftime("%d-%m-%Y %H:%M:%S"),
},
{"key": "BERTH_APPLICATIONS", "children": []},
{"key": "BERTH_LEASES", "children": []},
{"key": "BOATS", "children": []},
{"key": "OFFERS", "children": []},
{"key": "ORDERS", "children": []},
{"key": "WINTER_STORAGE_APPLICATIONS", "children": []},
{"key": "WINTER_STORAGE_LEASES", "children": []},
],
}
def _get_refunded_order_context(subject: str = "Order refunded"):
customer = CustomerProfileFactory.build()
return {
"subject": get_email_subject(NotificationType.ORDER_REFUNDED),
"order": {
**factory.build(
dict,
FACTORY_CLASS=OrderFactory,
customer=customer,
status=OrderStatus.REFUNDED,
product=BerthProductFactory.build(),
lease=BerthLeaseFactory.build(customer=customer),
price=Decimal("100"),
tax_percentage=Decimal("24.00"),
order_number="1234567abc",
),
},
"refund": {
"amount": Decimal("100")
},
}
def test_update_berth_application_by_owner_invalid_status(
berth_customer_api_client, customer_profile, status):
berth_application = BerthApplicationFactory(status=status)
berth_application_id = to_global_id(BerthApplicationNode,
berth_application.id)
other_customer = CustomerProfileFactory()
customer_profile.user = berth_customer_api_client.user
customer_profile.save()
berth_application.customer = customer_profile
berth_application.save()
variables = {
"id": berth_application_id,
"customerId": to_global_id(ProfileNode, other_customer.id),
}
executed = berth_customer_api_client.execute(
UPDATE_BERTH_APPLICATION_OWNER_MUTATION, input=variables)
assert_in_errors(
"Cannot modify the application once it has been processed", executed)
def test_update_berth_application_by_owner_cant_update_customer(
berth_customer_api_client, berth_application, customer_profile):
berth_application_id = to_global_id(BerthApplicationNode,
berth_application.id)
other_customer = CustomerProfileFactory()
customer_profile.user = berth_customer_api_client.user
customer_profile.save()
berth_application.customer = customer_profile
berth_application.save()
variables = {
"id": berth_application_id,
"customerId": to_global_id(ProfileNode, other_customer.id),
}
executed = berth_customer_api_client.execute(
UPDATE_BERTH_APPLICATION_OWNER_MUTATION, input=variables)
assert_in_errors(
"A customer cannot modify the customer connected to the application",
executed)
def test_update_winter_storage_application_by_owner_cant_update_customer(
berth_customer_api_client, winter_storage_application,
customer_profile):
winter_storage_application_id = to_global_id(WinterStorageApplicationNode,
winter_storage_application.id)
other_customer = CustomerProfileFactory()
customer_profile.user = berth_customer_api_client.user
customer_profile.save()
winter_storage_application.customer = customer_profile
winter_storage_application.save()
variables = {
"id": winter_storage_application_id,
"customerId": to_global_id(ProfileNode, other_customer.id),
}
executed = berth_customer_api_client.execute(
UPDATE_WINTER_STORAGE_APPLICATION_OWNER_MUTATION, input=variables)
assert_in_errors(
"A customer cannot modify the customer connected to the application",
executed)
def _get_winter_storage_order_context(subject: str = "Winter storage order"):
customer = CustomerProfileFactory.build()
order = OrderFactory.build(
customer=customer,
product=WinterStorageProductFactory.build(),
lease=WinterStorageLeaseFactory.build(customer=customer),
price=Decimal("100"),
tax_percentage=Decimal("24.00"),
)
optional_services = [
OrderLineFactory.build(
order=order,
product__service=ProductServiceType.OPTIONAL_SERVICES()[0],
price=random_price(),
),
OrderLineFactory.build(
order=order,
product__service=ProductServiceType.OPTIONAL_SERVICES()[1],
price=random_price(),
),
]
return _get_order_context(subject, order, optional_services)
def test_user_can_have_only_one_profile(customer_profile):
with pytest.raises(IntegrityError):
CustomerProfileFactory(user=customer_profile.user)
def winter_storage_application_with_customer(winter_storage_application):
winter_storage_application.customer = CustomerProfileFactory()
winter_storage_application.save()
return winter_storage_application
def berth_application_with_customer(berth_application):
berth_application.customer = CustomerProfileFactory()
berth_application.save()
return berth_application
def test_resend_order(
api_client,
order: Order,
order_has_contact_info,
request_has_profile_token,
notification_template_orders_approved,
berth_product,
winter_storage_product,
payment_provider,
order_status,
):
order.status = order_status
order.order_type = OrderType.LEASE_ORDER.value
initial_price = decimal.Decimal(
"00.42") # a price that is different from the price in BerthProduct
order.price = initial_price
order_original_email = "*****@*****.**"
if order_has_contact_info:
order.customer_phone = "+358505658789"
order.customer_email = order_original_email
else:
order.customer_phone = "" # trigger update from profile service
order.customer_email = ""
order.save()
order.lease.status = LeaseStatus.OFFERED
order.lease.save()
orders = [order]
if isinstance(order.lease, WinterStorageLease):
winter_storage_product.winter_storage_area = (
order.lease.get_winter_storage_area())
berth_product.min_width = decimal.Decimal("0.0")
berth_product.max_width = decimal.Decimal("999.0")
berth_product.tier_1_price = decimal.Decimal("100.0")
berth_product.tier_2_price = decimal.Decimal("200.0")
berth_product.tier_3_price = decimal.Decimal("300.0")
berth_product.pricing_category = get_berth_product_pricing_category(order)
berth_product.save()
variables = {
"orders": [to_global_id(OrderNode, o.id) for o in orders],
"dueDate": "2020-01-31",
}
if request_has_profile_token:
variables["profileToken"] = "token"
customer_profile = CustomerProfileFactory()
profile_data = {
"id": to_global_id(ProfileNode, customer_profile.id),
"first_name": order.lease.application.first_name,
"last_name": order.lease.application.last_name,
"primary_email": {
"email": order.lease.application.email
},
"primary_phone": {
"phone": order.lease.application.phone_number
},
}
with mock.patch(
"requests.post",
side_effect=mocked_response_profile(count=0,
data=profile_data,
use_edges=False),
), mock.patch.object(SMSNotificationService, "send",
return_value=None) as mock_send_sms:
executed = api_client.execute(RESEND_ORDER_MUTATION, input=variables)
if request_has_profile_token or order_has_contact_info:
# there was sufficient customer info available for invoicing
assert executed["data"]["resendOrder"]["failedOrders"] == []
assert executed["data"]["resendOrder"]["sentOrders"] == [str(order.id)]
order.refresh_from_db()
assert order.price != initial_price
order.lease.refresh_from_db()
assert order.status == OrderStatus.OFFERED
assert order.lease.status == LeaseStatus.OFFERED
assert len(mail.outbox) == 1
assert (mail.outbox[0].subject ==
f"test order approved subject, event: {order.order_number}!")
assert order.order_number in mail.outbox[0].body
if request_has_profile_token:
# always when profile_token is supplied, fetch customer info from profile
assert mail.outbox[0].to == [order.lease.application.email]
else:
assert mail.outbox[0].to == [order_original_email]
assert order.order_number in mail.outbox[0].alternatives[0][0]
assert mail.outbox[0].alternatives[0][1] == "text/html"
# Assert that the SMS is being sent
payment_url = payment_provider.get_payment_email_url(
order, lang=order.lease.application.language)
sms_context = {
"product_name":
order.product.name,
"due_date":
format_date(order.due_date,
locale=order.lease.application.language),
"payment_url":
payment_url,
}
mock_send_sms.assert_called_with(
NotificationType.SMS_INVOICE_NOTICE,
sms_context,
order.customer_phone,
language=order.lease.application.language,
)
else:
# no profile_token and no contact info
assert len(executed["data"]["resendOrder"]["failedOrders"]) == 1
assert ("Profile token is required"
in executed["data"]["resendOrder"]["failedOrders"][0]["error"])
assert executed["data"]["resendOrder"]["sentOrders"] == []
# Assert that the SMS is not sent
mock_send_sms.assert_not_called()
def customer(self):
if hasattr(self, "lease") and self.lease is not None:
return self.lease.customer
return CustomerProfileFactory()
def test_get_full_profile_information_from_gdpr_api(
rest_api_client, requests_mock, settings
):
customer_profile = CustomerProfileFactory()
boat = BoatFactory(owner=customer_profile)
berth_application = BerthApplicationFactory(customer=customer_profile)
berth_lease = BerthLeaseFactory(
customer=customer_profile, boat=boat, status=LeaseStatus.PAID
)
winter_storage_application = WinterStorageApplicationFactory(
customer=customer_profile
)
winter_storage_lease = WinterStorageLeaseFactory(
customer=customer_profile, boat=boat
)
order = OrderFactory(lease=berth_lease)
berth_switch_offer = BerthSwitchOfferFactory(
customer=customer_profile, lease=berth_lease
)
organization = OrganizationFactory(customer=customer_profile)
auth_header = get_api_token_for_user_with_scopes(
customer_profile.user, [settings.GDPR_API_QUERY_SCOPE], requests_mock
)
rest_api_client.credentials(HTTP_AUTHORIZATION=auth_header)
response = rest_api_client.get(
reverse("helsinki_gdpr:gdpr_v1", kwargs={"pk": customer_profile.id})
)
resp = json.loads(response.content)
assert response.status_code == 200
assert {
"key": "INVOICING_TYPE",
"value": dict(InvoicingType.choices)[customer_profile.invoicing_type],
} in resp["children"]
assert {"key": "COMMENT", "value": customer_profile.comment} in resp["children"]
assert {
"key": "CREATED_AT",
"value": customer_profile.created_at.strftime("%d-%m-%Y %H:%M:%S"),
} in resp["children"]
assert {
"key": "MODIFIED_AT",
"value": customer_profile.modified_at.strftime("%d-%m-%Y %H:%M:%S"),
} in resp["children"]
berth_applications_dict = {}
berth_leases_dict = {}
boats_dict = {}
offers_dict = {}
orders_dict = {}
organization_dict = {}
winter_storage_applications_dict = {}
winter_storage_leases_dict = {}
for child_dict in resp["children"]:
if child_dict["key"] == "BERTH_APPLICATIONS":
berth_applications_dict = child_dict
elif child_dict["key"] == "BERTH_LEASES":
berth_leases_dict = child_dict
elif child_dict["key"] == "BOATS":
boats_dict = child_dict
elif child_dict["key"] == "OFFERS":
offers_dict = child_dict
elif child_dict["key"] == "ORDERS":
orders_dict = child_dict
elif child_dict["key"] == "ORGANIZATION":
organization_dict = child_dict
elif child_dict["key"] == "WINTER_STORAGE_APPLICATIONS":
winter_storage_applications_dict = child_dict
elif child_dict["key"] == "WINTER_STORAGE_LEASES":
winter_storage_leases_dict = child_dict
# Using a TestCase here since assertDictEqual is better for comparing dicts
test_case = TestCase()
test_case.assertDictEqual(
{
"key": "BERTH_APPLICATIONS",
"children": [
{
"key": "BERTHAPPLICATION",
"children": [
{"key": "ID", "value": berth_application.id},
{
"key": "CREATED_AT",
"value": berth_application.created_at.strftime(
"%d-%m-%Y %H:%M:%S"
),
},
{
"key": "STATUS",
"value": dict(ApplicationStatus.choices)[
berth_application.status
],
},
{"key": "LANGUAGE", "value": berth_application.language},
{"key": "FIRST_NAME", "value": berth_application.first_name},
{"key": "LAST_NAME", "value": berth_application.last_name},
{"key": "EMAIL", "value": berth_application.email},
{
"key": "PHONE_NUMBER",
"value": berth_application.phone_number,
},
{"key": "ADDRESS", "value": berth_application.address},
{"key": "ZIP_CODE", "value": berth_application.zip_code},
{
"key": "MUNICIPALITY",
"value": berth_application.municipality,
},
{
"key": "COMPANY_NAME",
"value": berth_application.company_name,
},
{"key": "BUSINESS_ID", "value": berth_application.business_id},
{"key": "BOAT_TYPE", "value": berth_application.boat_type.name},
{
"key": "BOAT_REGISTRATION_NUMBER",
"value": berth_application.boat_registration_number,
},
{"key": "BOAT_NAME", "value": berth_application.boat_name},
{"key": "BOAT_MODEL", "value": berth_application.boat_model},
{
"key": "BOAT_LENGTH",
"value": float(berth_application.boat_length),
},
{
"key": "BOAT_WIDTH",
"value": float(berth_application.boat_width),
},
{
"key": "ACCEPT_BOATING_NEWSLETTER",
"value": berth_application.accept_boating_newsletter,
},
{
"key": "ACCEPT_FITNESS_NEWS",
"value": berth_application.accept_fitness_news,
},
{
"key": "ACCEPT_LIBRARY_NEWS",
"value": berth_application.accept_library_news,
},
{
"key": "ACCEPT_OTHER_CULTURE_NEWS",
"value": berth_application.accept_other_culture_news,
},
{
"key": "INFORMATION_ACCURACY_CONFIRMED",
"value": berth_application.information_accuracy_confirmed,
},
{
"key": "APPLICATION_CODE",
"value": berth_application.application_code,
},
{"key": "HARBORCHOICE_SET", "value": []},
{
"key": "BERTH_SWITCH",
"value": berth_application.berth_switch,
},
{
"key": "BOAT_DRAUGHT",
"value": berth_application.boat_draught,
},
{"key": "BOAT_WEIGHT", "value": berth_application.boat_weight},
{
"key": "ACCESSIBILITY_REQUIRED",
"value": berth_application.accessibility_required,
},
{
"key": "BOAT_PROPULSION",
"value": berth_application.boat_propulsion,
},
{
"key": "BOAT_HULL_MATERIAL",
"value": berth_application.boat_hull_material,
},
{
"key": "BOAT_INTENDED_USE",
"value": berth_application.boat_intended_use,
},
{
"key": "RENTING_PERIOD",
"value": berth_application.renting_period,
},
{"key": "RENT_FROM", "value": berth_application.rent_from},
{"key": "RENT_TILL", "value": berth_application.rent_till},
{
"key": "BOAT_IS_INSPECTED",
"value": berth_application.boat_is_inspected,
},
{
"key": "BOAT_IS_INSURED",
"value": berth_application.boat_is_insured,
},
{
"key": "AGREE_TO_TERMS",
"value": berth_application.agree_to_terms,
},
],
}
],
},
berth_applications_dict,
)
test_case.assertDictEqual(
{
"key": "BERTH_LEASES",
"children": [
{
"key": "BERTHLEASE",
"children": [
{"key": "ID", "value": str(berth_lease.id)},
{"key": "BOAT", "value": str(boat.id)},
{
"key": "STATUS",
"value": dict(LeaseStatus.choices)[berth_lease.status],
},
{"key": "ORDERS", "value": [str(order.id)]},
{"key": "COMMENT", "value": berth_lease.comment},
{
"key": "BERTH",
"value": {
"key": "BERTH",
"children": [
{
"key": "NUMBER",
"value": berth_lease.berth.number,
},
{
"key": "PIER",
"value": {
"key": "PIER",
"children": [
{
"key": "IDENTIFIER",
"value": berth_lease.berth.pier.identifier,
}
],
},
},
],
},
},
{"key": "APPLICATION", "value": None},
{
"key": "START_DATE",
"value": berth_lease.start_date.strftime("%d-%m-%Y"),
},
{
"key": "END_DATE",
"value": berth_lease.end_date.strftime("%d-%m-%Y"),
},
],
}
],
},
berth_leases_dict,
)
test_case.assertDictEqual(
{
"key": "BOATS",
"children": [
{
"key": "BOAT",
"children": [
{"key": "ID", "value": str(boat.id)},
{"key": "CERTIFICATES", "children": []},
{
"key": "REGISTRATION_NUMBER",
"value": boat.registration_number,
},
{"key": "LENGTH", "value": float(boat.length)},
{"key": "WIDTH", "value": float(boat.width)},
{"key": "DRAUGHT", "value": boat.draught},
],
}
],
},
boats_dict,
)
test_case.assertDictEqual(
{
"key": "OFFERS",
"children": [
{
"key": "BERTHSWITCHOFFER",
"children": [
{"key": "ID", "value": str(berth_switch_offer.id)},
{
"key": "STATUS",
"value": dict(OfferStatus.choices)[
berth_switch_offer.status
],
},
{
"key": "DUE_DATE",
"value": berth_switch_offer.due_date.strftime("%d-%m-%Y")
if berth_switch_offer.due_date
else None,
},
{
"key": "CUSTOMER_FIRST_NAME",
"value": berth_switch_offer.customer_first_name,
},
{
"key": "CUSTOMER_LAST_NAME",
"value": berth_switch_offer.customer_last_name,
},
{
"key": "CUSTOMER_EMAIL",
"value": berth_switch_offer.customer_email,
},
{
"key": "CUSTOMER_PHONE",
"value": berth_switch_offer.customer_phone,
},
{
"key": "APPLICATION",
"value": berth_switch_offer.application.id,
},
{"key": "LEASE", "value": str(berth_switch_offer.lease.id)},
{"key": "BERTH", "value": str(berth_switch_offer.berth.id)},
],
}
],
},
offers_dict,
)
test_case.assertDictEqual(
{
"key": "ORDERS",
"children": [
{
"key": "ORDER",
"children": [
{"key": "ID", "value": str(order.id)},
{
"key": "PRODUCT",
"value": {
"key": "BERTHPRODUCT",
"children": [
{
"key": "MIN_WIDTH",
"value": float(order.product.min_width),
},
{
"key": "MAX_WIDTH",
"value": float(order.product.max_width),
},
{
"key": "TIER_1_PRICE",
"value": float(order.product.tier_1_price),
},
{
"key": "TIER_2_PRICE",
"value": float(order.product.tier_2_price),
},
{
"key": "TIER_3_PRICE",
"value": float(order.product.tier_3_price),
},
{
"key": "PRICE_UNIT",
"value": order.product.price_unit,
},
{
"key": "TAX_PERCENTAGE",
"value": float(order.product.tax_percentage),
},
],
},
},
{"key": "LEASE", "value": str(order.lease.id)},
{
"key": "STATUS",
"value": dict(OrderStatus.choices)[order.status],
},
{"key": "COMMENT", "value": order.comment},
{"key": "PRICE", "value": float(order.price)},
{"key": "TAX_PERCENTAGE", "value": float(order.tax_percentage)},
{"key": "PRETAX_PRICE", "value": float(order.pretax_price)},
{"key": "TOTAL_PRICE", "value": float(order.total_price)},
{
"key": "TOTAL_PRETAX_PRICE",
"value": float(order.total_pretax_price),
},
{
"key": "TOTAL_TAX_PERCENTAGE",
"value": float(order.total_tax_percentage),
},
{
"key": "DUE_DATE",
"value": order.due_date.strftime("%d-%m-%Y"),
},
{"key": "ORDER_LINES", "children": []},
{"key": "LOG_ENTRIES", "children": []},
{"key": "PAID_AT", "value": None},
{"key": "CANCELLED_AT", "value": None},
{"key": "REJECTED_AT", "value": None},
],
}
],
},
orders_dict,
)
test_case.assertDictEqual(
{
"key": "ORGANIZATION",
"children": [
{"key": "ID", "value": str(organization.id)},
{"key": "BUSINESS_ID", "value": organization.business_id},
{"key": "NAME", "value": organization.name},
{"key": "ADDRESS", "value": organization.address},
{"key": "POSTAL_CODE", "value": organization.postal_code},
{"key": "CITY", "value": organization.city},
],
},
organization_dict,
)
test_case.assertDictEqual(
{
"key": "WINTER_STORAGE_APPLICATIONS",
"children": [
{
"key": "WINTERSTORAGEAPPLICATION",
"children": [
{"key": "ID", "value": winter_storage_application.id},
{
"key": "CREATED_AT",
"value": winter_storage_application.created_at.strftime(
"%d-%m-%Y %H:%M:%S"
),
},
{
"key": "STATUS",
"value": dict(ApplicationStatus.choices)[
winter_storage_application.status
],
},
{
"key": "LANGUAGE",
"value": winter_storage_application.language,
},
{
"key": "FIRST_NAME",
"value": winter_storage_application.first_name,
},
{
"key": "LAST_NAME",
"value": winter_storage_application.last_name,
},
{"key": "EMAIL", "value": winter_storage_application.email},
{
"key": "PHONE_NUMBER",
"value": winter_storage_application.phone_number,
},
{"key": "ADDRESS", "value": winter_storage_application.address},
{
"key": "ZIP_CODE",
"value": winter_storage_application.zip_code,
},
{
"key": "MUNICIPALITY",
"value": winter_storage_application.municipality,
},
{"key": "COMPANY_NAME", "value": ""},
{"key": "BUSINESS_ID", "value": ""},
{
"key": "BOAT_TYPE",
"value": winter_storage_application.boat_type.name,
},
{"key": "BOAT_REGISTRATION_NUMBER", "value": ""},
{"key": "BOAT_NAME", "value": ""},
{"key": "BOAT_MODEL", "value": ""},
{
"key": "BOAT_LENGTH",
"value": float(winter_storage_application.boat_length),
},
{
"key": "BOAT_WIDTH",
"value": float(winter_storage_application.boat_width),
},
{"key": "ACCEPT_BOATING_NEWSLETTER", "value": False},
{"key": "ACCEPT_FITNESS_NEWS", "value": False},
{"key": "ACCEPT_LIBRARY_NEWS", "value": False},
{"key": "ACCEPT_OTHER_CULTURE_NEWS", "value": False},
{"key": "INFORMATION_ACCURACY_CONFIRMED", "value": False},
{"key": "APPLICATION_CODE", "value": ""},
{"key": "AREA_TYPE", "value": None},
{"key": "WINTERSTORAGEAREACHOICE_SET", "value": []},
{
"key": "STORAGE_METHOD",
"value": dict(WinterStorageMethod.choices)[
winter_storage_application.storage_method
],
},
{"key": "TRAILER_REGISTRATION_NUMBER", "value": ""},
],
}
],
},
winter_storage_applications_dict,
)
test_case.assertDictEqual(
{
"key": "WINTER_STORAGE_LEASES",
"children": [
{
"key": "WINTERSTORAGELEASE",
"children": [
{"key": "ID", "value": str(winter_storage_lease.id)},
{"key": "BOAT", "value": str(boat.id)},
{
"key": "STATUS",
"value": dict(LeaseStatus.choices)[
winter_storage_lease.status
],
},
{"key": "ORDERS", "value": []},
{"key": "COMMENT", "value": winter_storage_lease.comment},
{
"key": "PLACE",
"value": {
"key": "WINTERSTORAGEPLACE",
"children": [
{
"key": "NUMBER",
"value": winter_storage_lease.place.number,
},
{
"key": "WINTER_STORAGE_SECTION",
"value": {
"key": "WINTERSTORAGESECTION",
"children": [
{
"key": "IDENTIFIER",
"value": (
winter_storage_lease.place.winter_storage_section.identifier
),
}
],
},
},
],
},
},
{"key": "SECTION", "value": None},
{"key": "APPLICATION", "value": None},
{
"key": "START_DATE",
"value": winter_storage_lease.start_date.strftime(
"%d-%m-%Y"
),
},
{
"key": "END_DATE",
"value": winter_storage_lease.end_date.strftime("%d-%m-%Y"),
},
{"key": "STICKER_NUMBER", "value": None},
{"key": "STICKER_POSTED", "value": None},
],
}
],
},
winter_storage_leases_dict,
)
