def test_manager_save_plugin_configuration(plugin_configuration):
plugins = ["tests.plugins.sample_plugins.PluginSample"]
manager = PluginsManager(plugins=plugins)
manager.save_plugin_configuration(PluginSample.PLUGIN_ID,
{"active": False})
plugin_configuration.refresh_from_db()
assert not plugin_configuration.active
def test_manager_calculates_checkout_total(
checkout_with_item, discount_info, plugins, total_amount
):
currency = checkout_with_item.currency
expected_total = Money(total_amount, currency)
manager = PluginsManager(plugins=plugins)
taxed_total = manager.calculate_checkout_total(checkout_with_item, [discount_info])
assert TaxedMoney(expected_total, expected_total) == taxed_total
def test_manager_get_plugin_configuration(plugin_configuration):
plugins = [
"tests.plugins.sample_plugins.PluginSample",
"tests.plugins.sample_plugins.PluginInactive",
]
manager = PluginsManager(plugins=plugins)
plugin = manager.get_plugin("PluginSample")
configuration_from_db = PluginConfiguration.objects.get(name="PluginSample")
assert plugin.DEFAULT_CONFIGURATION == configuration_from_db.configuration
def test_manager_get_plugin_configuration(plugin_configuration):
plugins = [
"saleor.plugins.tests.sample_plugins.PluginSample",
"saleor.plugins.tests.sample_plugins.PluginInactive",
]
manager = PluginsManager(plugins=plugins)
plugin = manager.get_plugin(PluginSample.PLUGIN_ID)
configuration_from_db = PluginConfiguration.objects.get(
identifier=PluginSample.PLUGIN_ID
)
assert plugin.DEFAULT_CONFIGURATION == configuration_from_db.configuration
def test_manager_serve_list_of_payment_gateways():
expected_gateway = {
"name": ActivePaymentGateway.PLUGIN_NAME,
"config": ActivePaymentGateway.CLIENT_CONFIG,
}
plugins = [
"tests.plugins.sample_plugins.PluginSample",
"tests.plugins.sample_plugins.ActivePaymentGateway",
"tests.plugins.sample_plugins.InactivePaymentGateway",
]
manager = PluginsManager(plugins=plugins)
assert manager.list_payment_gateways() == [expected_gateway]
def synchronize_allegro_offers_task():
manage = PluginsManager(plugins=["saleor.plugins.allegro.plugin.AllegroPlugin"])
plugin_configs = manage.get_plugin(AllegroPlugin.PLUGIN_ID)
conf = {item["name"]: item["value"] for item in plugin_configs.configuration}
token = conf.get('token_value')
env = conf.get('env')
allegro_api = AllegroAPI(token, env)
params = {'publication.status': ['ACTIVE'], 'limit': '1', 'offset': 0}
response = allegro_api.get_request('sale/offers', params)
total_count = json.loads(response.text).get('totalCount')
if total_count is None:
return
limit = 1000
errors = []
updated_amount = 0
for i in range(int(int(total_count) / limit) + 1):
offset = i * limit
params = {'publication.status': ['ACTIVE'], 'limit': limit, 'offset': offset}
response = allegro_api.get_request('sale/offers', params)
logger.info(
f'Fetching 1000 offers status: {response.status_code}, offset: {offset}')
offers = json.loads(response.text).get('offers')
if offers:
skus = [offer.get('external').get('id') for offer in offers]
product_variants = list(
ProductVariant.objects.select_related('product').filter(sku__in=skus))
products_to_update = []
for offer in offers:
product_errors = []
sku = offer.get('external').get('id')
offer_id = offer.get('id')
variant = next((x for x in product_variants if x.sku == sku), None)
if variant:
product = variant.product
product_errors = valid_product(product)
if product.private_metadata.get('publish.allegro.id') != offer_id:
product.private_metadata['publish.allegro.id'] = offer_id
products_to_update.append(product)
else:
product_errors.append('nie znaleziono produktu o podanym SKU')
if product_errors:
errors.append({'sku': sku, 'errors': product_errors})
if products_to_update:
Product.objects.bulk_update(products_to_update, ['private_metadata'])
updated_amount += len(products_to_update)
html_errors_list = plugin_configs.create_table(errors)
send_mail(html_errors_list, updated_amount)
def test_plugin_add_new_configuration(
new_config, new_config_structure, monkeypatch,
):
monkeypatch.setattr(PluginInactive, "DEFAULT_ACTIVE", True)
monkeypatch.setattr(
PluginInactive, "DEFAULT_CONFIGURATION", [new_config],
)
config_structure = {"Foo": new_config_structure}
monkeypatch.setattr(PluginInactive, "CONFIG_STRUCTURE", config_structure)
manager = PluginsManager(plugins=["tests.plugins.sample_plugins.PluginInactive"])
plugin = manager.get_plugin("PluginInactive")
assert len(plugin.configuration) == 1
assert plugin.configuration[0] == {**new_config, **new_config_structure}
def test_manager_serve_list_all_payment_gateways():
expected_gateways = [
{
"name": ActivePaymentGateway.PLUGIN_NAME,
"config": ActivePaymentGateway.CLIENT_CONFIG,
},
{"name": InactivePaymentGateway.PLUGIN_NAME, "config": []},
]
plugins = [
"tests.plugins.sample_plugins.ActivePaymentGateway",
"tests.plugins.sample_plugins.InactivePaymentGateway",
]
manager = PluginsManager(plugins=plugins)
assert manager.list_payment_gateways(active_only=False) == expected_gateways
def test_create_wmsdocument(staff_api_client, permission_manage_wmsdocument,
staff_user, customer_user, warehouse,
wms_deliverer, setup_wms):
query = MUTATION_CREATE_WMSDOCUMENT
manager = PluginsManager(plugins=setup_wms.PLUGINS)
warehouse_id = graphene.Node.to_global_id("Warehouse", warehouse.pk)
createdby_id = graphene.Node.to_global_id("User", staff_user.pk)
customer_user_id = graphene.Node.to_global_id("User", customer_user.pk)
deliverer_id = graphene.Node.to_global_id("WmsDeliverer", wms_deliverer.pk)
location = "location100"
variables = {
"input": {
"createdBy": createdby_id,
"recipient": customer_user_id,
"deliverer": deliverer_id,
"documentType": "GRN",
"warehouse": warehouse_id,
"location": location
}
}
staff_api_client.user.user_permissions.add(permission_manage_wmsdocument)
response = staff_api_client.post_graphql(query, variables)
content = get_graphql_content(response)
data = content["data"]["wmsDocumentCreate"]
assert data["errors"] == []
assert data["wmsDocument"]["status"] == "DRAFT"
assert data["wmsDocument"]["createdBy"]["id"] == createdby_id
assert data["wmsDocument"]["recipient"]["id"] == customer_user_id
assert data["wmsDocument"]["documentType"] == "GRN"
assert data["wmsDocument"]["warehouse"]["id"] == warehouse_id
assert data["wmsDocument"]["deliverer"]["id"] == deliverer_id
assert data["wmsDocument"]["location"] == location
def test_manager_apply_taxes_to_product(product, plugins, price):
country = Country("PL")
variant = product.variants.all()[0]
currency = variant.get_price().currency
expected_price = Money(price, currency)
taxed_price = PluginsManager(plugins=plugins).apply_taxes_to_product(
product, variant.get_price(), country)
assert TaxedMoney(expected_price, expected_price) == taxed_price
def test_manager_apply_taxes_to_shipping(
shipping_method, address, plugins, price_amount
):
expected_price = Money(price_amount, "USD")
taxed_price = PluginsManager(plugins=plugins).apply_taxes_to_shipping(
shipping_method.price, address
)
assert TaxedMoney(expected_price, expected_price) == taxed_price
def test_manager_calculates_checkout_line_total(checkout_with_item,
discount_info, plugins,
amount):
line = checkout_with_item.lines.all()[0]
currency = checkout_with_item.currency
expected_total = Money(amount, currency)
taxed_total = PluginsManager(
plugins=plugins).calculate_checkout_line_total(line, [discount_info])
assert TaxedMoney(expected_total, expected_total) == taxed_total
def test_manager_calculates_order_shipping(order_with_lines, plugins,
shipping_amount):
currency = order_with_lines.total.currency
expected_shipping_price = Money(shipping_amount, currency)
taxed_shipping_price = PluginsManager(
plugins=plugins).calculate_order_shipping(order_with_lines)
assert (TaxedMoney(expected_shipping_price,
expected_shipping_price) == taxed_shipping_price)
def test_manager_get_plugin_configurations(plugin_configuration):
plugins = [
"tests.plugins.sample_plugins.PluginSample",
"tests.plugins.sample_plugins.PluginInactive",
]
manager = PluginsManager(plugins=plugins)
plugin_configs = manager._plugin_configs.values()
assert len(plugin_configs) == 1
assert set(plugin_configs) == set(list(PluginConfiguration.objects.all()))
def test_manager_calculates_checkout_subtotal(
checkout_with_item, discount_info, plugins, subtotal_amount
):
currency = checkout_with_item.currency
expected_subtotal = Money(subtotal_amount, currency)
taxed_subtotal = PluginsManager(plugins=plugins).calculate_checkout_subtotal(
checkout_with_item, list(checkout_with_item), [discount_info]
)
assert TaxedMoney(expected_subtotal, expected_subtotal) == taxed_subtotal
def test_plugin_updates_configuration_shape(
new_config, new_config_structure, plugin_configuration, monkeypatch,
):
config_structure = PluginSample.CONFIG_STRUCTURE.copy()
config_structure["Foo"] = new_config_structure
monkeypatch.setattr(PluginSample, "CONFIG_STRUCTURE", config_structure)
monkeypatch.setattr(
PluginSample,
"DEFAULT_CONFIGURATION",
plugin_configuration.configuration + [new_config],
)
manager = PluginsManager(plugins=["tests.plugins.sample_plugins.PluginSample"])
plugin = manager.get_plugin("PluginSample")
assert len(plugin.configuration) == 5
assert plugin.configuration[-1] == {**new_config, **new_config_structure}
def test_manager_calculates_checkout_shipping(checkout_with_item,
discount_info, plugins,
shipping_amount):
currency = checkout_with_item.currency
expected_shipping_price = Money(shipping_amount, currency)
taxed_shipping_price = PluginsManager(
plugins=plugins).calculate_checkout_shipping(checkout_with_item,
list(checkout_with_item),
[discount_info])
assert (TaxedMoney(expected_shipping_price,
expected_shipping_price) == taxed_shipping_price)
def test_update_wmsdocument(staff_api_client, wms_document,
permission_manage_wmsdocument, setup_wms):
query = MUTATION_UPDATE_WMSDOCUMENT
manager = PluginsManager(plugins=setup_wms.PLUGINS)
wms_document_id = graphene.Node.to_global_id("WmsDocument",
wms_document.pk)
wms_document_type = "GIN"
variables = {
"id": wms_document_id,
"input": {
"documentType": wms_document_type
}
}
staff_api_client.user.user_permissions.add(permission_manage_wmsdocument)
response = staff_api_client.post_graphql(query, variables)
content = get_graphql_content(response)
data = content["data"]["wmsDocumentUpdate"]
assert data["errors"] == []
assert data["wmsDocument"]["number"] == 'GIN1'
assert data["wmsDocument"]["documentType"] == wms_document_type
def test_manager_get_tax_rate_percentage_value(plugins, amount, product):
country = Country("PL")
tax_rate_value = PluginsManager(
plugins=plugins).get_tax_rate_percentage_value(product, country)
assert tax_rate_value == Decimal(amount)
def test_manager_show_taxes_on_storefront(plugins, show_taxes):
assert show_taxes == PluginsManager(
plugins=plugins).show_taxes_on_storefront()
def test_manager_uses_get_tax_rate_choices(plugins, tax_rate_list):
assert tax_rate_list == PluginsManager(
plugins=plugins).get_tax_rate_type_choices()
def test_manager_calculates_order_line(order_line, plugins, amount):
currency = order_line.unit_price.currency
expected_price = Money(amount, currency)
unit_price = PluginsManager(
plugins=plugins).calculate_order_line_unit(order_line)
assert expected_price == unit_price.gross
def remove_null_values_from_allegro_offers(self, options):
manage = PluginsManager(
plugins=["saleor.plugins.allegro.plugin.AllegroPlugin"])
plugin_configs = manage.get_plugin(AllegroPlugin.PLUGIN_ID)
conf = {
item["name"]: item["value"]
for item in plugin_configs.configuration
}
token = conf.get('token_value')
self.allegro_api = AllegroAPI(token)
data = self.read_csv(options['path'])
skus = data['sku']
product_variants = list(ProductVariant.objects.filter(sku__in=skus))
sku_errors = []
for product_variant in product_variants:
self.product = {}
errors = []
if product_variant:
saleor_product = product_variant.product
allegro_id = saleor_product.private_metadata.get(
'publish.allegro.id')
if allegro_id is not None:
category_id = saleor_product.product_type.metadata.get(
'allegro.mapping.categoryId')
require_parameters = self.allegro_api.get_require_parameters(
category_id)
parameters_mapper = ParametersMapperFactory().get_mapper()
parameters = parameters_mapper.set_product(
saleor_product).set_require_parameters(
require_parameters).run_mapper()
product_mapper = ProductMapperFactory().get_mapper()
try:
product = product_mapper.set_saleor_product(saleor_product) \
.set_saleor_images(self.allegro_api.upload_images(saleor_product)) \
.set_saleor_parameters(parameters).set_category(
category_id).set_obj_publication_starting_at('2020-10-10 10:10').\
set_offer_type('AUCTION').run_mapper()
except:
pass
offer = self.allegro_api.update_allegro_offer(
allegro_product=product, allegro_id=allegro_id)
if 'error' in offer:
errors.append(offer.get('error_description'))
elif 'errors' in offer:
errors += offer['errors']
elif offer['validation'].get('errors') is not None:
if len(offer['validation'].get('errors')) > 0:
for error in offer['validation'].get('errors'):
errors.append(error['message'])
else:
errors.append('produkt nie ma allegro id')
sku_errors.append({
'sku': product_variant.sku,
'errors': errors
})
html_errors_list = plugin_configs.create_table(sku_errors)
return self.send_mail(html_errors_list, options)
def handle(self, *args, **options):
manage = PluginsManager(
plugins=["saleor.plugins.allegroSync.plugin.AllegroSyncPlugin"])
plugin = manage.get_plugin(AllegroSyncPlugin.PLUGIN_ID)
plugin.type = options['type']
plugin.synchronize_allegro_offers()
