def globalmenu(request): Category = get_model('catalogue', 'Category') Product = get_model('catalogue', 'Product') return{ 'bicicletas' : Category.objects.get(id=3), 'caminadoras' : Category.objects.get(id=4), 'elipticas' : Category.objects.get(id=5), 'gimnasios' : Category.objects.get(id=6), 'fitness' : Category.objects.get(id=7), 'refacciones' : Category.objects.get(id=8), 'golds_gym' : Category.objects.get(id=1), 'golds_gym_caminadoras' : Category.objects.get(id=19), 'golds_gym_fitness' : Category.objects.get(id=2), 'pro_form' : Category.objects.get(id=10), 'pro_form_elipticas' : Category.objects.get(id=23), 'pro_form_caminadoras' : Category.objects.get(id=20), 'pro_form_bicicletas' : Category.objects.get(id=17), 'freemotion' : Category.objects.get(id=11), 'freemotion_gimnasios' : Category.objects.get(id=24), 'freemotion_elipticas' : Category.objects.get(id=22), 'freemotion_caminadoras' : Category.objects.get(id=18), 'freemotion_bicicletas' : Category.objects.get(id=16), 'weslo' : Category.objects.get(id=12), 'weslo_caminadoras' : Category.objects.get(id=21), 'weider' : Category.objects.get(id=13), 'nordi_trak' : Category.objects.get(id=9), 'epic' : Category.objects.get(id=14), 'epic_bicicletas' : Category.objects.get(id=15), 'products' : Product.objects.all().order_by('?')[0:12], }
def save_value(self, product, value): try: value_obj = product.attribute_values.get(attribute=self) except get_model('catalogue', 'ProductAttributeValue').DoesNotExist: # FileField uses False for anouncing deletion of the file # not creating a new value delete_file = self.is_file and value is False if value is None or value == '' or delete_file: return model = get_model('catalogue', 'ProductAttributeValue') value_obj = model.objects.create(product=product, attribute=self) if self.is_file: # File fields in Django are treated differently, see # django.db.models.fields.FileField and method save_form_data if value is None: # No change return elif value is False: # Delete file value_obj.delete() else: # New uploaded file value_obj.value = value value_obj.save() else: if value is None or value == '': value_obj.delete() return if value != value_obj.value: value_obj.value = value value_obj.save()
def _get_buy_price(self): SystemConfig = get_model('commission', 'SystemConfig') system_config = SystemConfig.objects.first() buy_price_rate = system_config.buy_price_rate StockTicker = get_model('commission', 'StockTicker') try: current_stockticker = StockTicker.objects.filter(product=self).order_by('-created_datetime').first() if current_stockticker and current_stockticker.closing_price: buy_price = float(current_stockticker.closing_price)*float(buy_price_rate) else: TradeComplete = get_model('commission', 'TradeComplete') StockProductConfig = get_model('commission', 'StockProductConfig') last_trade_complete = TradeComplete.objects.filter(product=self).order_by('-created_datetime') current_product_config = StockProductConfig.objects.get(product=self) if last_trade_complete: buy_price = float(last_trade_complete[0].unit_price)*float(buy_price_rate) else: try: buy_price = float(current_product_config.opening_price)*float(buy_price_rate) except: buy_price = 99999999 except: traceback.print_exc() buy_price = 99999999 return float("%.2f"%buy_price)
def _lazy_get_models(): # This avoids various import conflicts between apps that may # import the Facade before any other models. global Order global SourceType if Order is None: Order = get_model('order', 'Order') SourceType = get_model('payment', 'SourceType')
def get_default_review_status(): ProductReview = get_model('reviews', 'ProductReview') if settings.OSCAR_MODERATE_REVIEWS: return ProductReview.FOR_MODERATION return ProductReview.APPROVED
def remove_product(self, product): """ Remove product from range. To save on queries, this function does not check if the product is in fact in the range. """ RangeProduct = get_model('offer', 'RangeProduct') RangeProduct.objects.filter(range=self, product=product).delete()
def _validate_entity(self, value): if not isinstance(value, get_model("catalogue", "AttributeEntity")): raise ValidationError(_("Must be an AttributeEntity model object instance")) if not value.pk: raise ValidationError(_("Model has not been saved yet")) if value.type != self.entity_type: raise ValidationError(_("Entity must be of type %s" % self.entity_type.name))
def process(self): """ Process the file upload and add products to the range """ all_ids = set(self.extract_ids()) products = self.range.all_products() existing_skus = products.values_list( 'stockrecords__partner_sku', flat=True) existing_skus = set(filter(bool, existing_skus)) existing_upcs = products.values_list('upc', flat=True) existing_upcs = set(filter(bool, existing_upcs)) existing_ids = existing_skus.union(existing_upcs) new_ids = all_ids - existing_ids Product = get_model('catalogue', 'Product') products = Product._default_manager.filter( models.Q(stockrecords__partner_sku__in=new_ids) | models.Q(upc__in=new_ids)) for product in products: self.range.add_product(product) # Processing stats found_skus = products.values_list( 'stockrecords__partner_sku', flat=True) found_skus = set(filter(bool, found_skus)) found_upcs = set(filter(bool, products.values_list('upc', flat=True))) found_ids = found_skus.union(found_upcs) missing_ids = new_ids - found_ids dupes = set(all_ids).intersection(existing_ids) self.mark_as_processed(products.count(), len(missing_ids), len(dupes)) return products
def get_user_model(): """ Return the User model. Doesn't require the app cache to be fully initialised. This used to live in compat to support both Django 1.4's fixed User model and custom user models introduced thereafter. Support for Django 1.4 has since been dropped in Oscar, but our get_user_model remains because code relies on us annotating the _meta class with the additional fields, and other code might rely on it as well. """ try: model = get_model(AUTH_USER_APP_LABEL, AUTH_USER_MODEL_NAME) except LookupError: # Convert exception to an ImproperlyConfigured exception for # backwards compatibility with previous Oscar versions and the # original get_user_model method in Django. raise ImproperlyConfigured( "AUTH_USER_MODEL refers to model '%s' that has not been installed" % settings.AUTH_USER_MODEL) # Test if user model has any custom fields and add attributes to the _meta # class core_fields = set([f.name for f in User._meta.fields]) model_fields = set([f.name for f in model._meta.fields]) new_fields = model_fields.difference(core_fields) model._meta.has_additional_fields = len(new_fields) > 0 model._meta.additional_fields = new_fields return model
def batchInsertProducts(self,product_qset): GoogleProduct = get_model('gmerchant','GoogleProduct') def product_inserted(unused_request_id, response, exception): if exception is not None: # Do something with the exception. print 'There was an error: ' + str(exception) else: offer_id = smart_text(response['offerId'].encode('ascii', 'ignore')) gp = GoogleProduct.objects.get(google_shopping_id=offer_id) if not gp.google_shopping_created: gp.google_shopping_created = datetime.now() else: gp.google_shopping_updated = datetime.now() gp.save() print ('Product with offerId "%s" and title "%s" was created.' % (offer_id, smart_text(response['title'].encode('ascii', 'ignore')))) for block in chunks(product_qset,BATCH_SIZE): #Build a new batch request for this block of products batch = BatchHttpRequest(callback=product_inserted) for i in block: product = self.buildProduct(i) # Add product to the batch. batch.add(self.service.products().insert(merchantId=self.merchant_id, body=product)) try: #Let's send this batch off to the Goog. batch.execute() except client.AccessTokenRefreshError: warn_exp_token()
def add_product(self, product, display_order=None): """ Add product to the range When adding product that is already in the range, prevent re-adding it. If display_order is specified, update it. Default display_order for a new product in the range is 0; this puts the product at the top of the list. """ initial_order = display_order or 0 RangeProduct = get_model('offer', 'RangeProduct') relation, __ = RangeProduct.objects.get_or_create( range=self, product=product, defaults={'display_order': initial_order}) if (display_order is not None and relation.display_order != display_order): relation.display_order = display_order relation.save() # Remove product from excluded products if it was removed earlier and # re-added again, thus it returns back to the range product list. if product.id in self._excluded_product_ids(): self.excluded_products.remove(product) self.invalidate_cached_ids()
def _category_comparison_fields(self): # Overwritten Category models could contain a lot of data, e.g CMS # content. Hence, this avoids fetching unneeded data in the costly # range comparison queries. Note that using .only() with an empty list # is a no-op essentially, so nothing breaks when the field is missing. Category = get_model('catalogue', 'Category') return getattr(Category, 'COMPARISON_FIELDS', ())
def test_filters(self): f = DashboardStoreSearchForm() Store = get_model('stores', 'Store') location = '{"type": "Point", "coordinates": [144.917908,-37.815751]}' store1 = StoreFactory(name='store1', location=location) store2 = StoreFactory(name='store2', location=location) StoreAddressFactory( store=store1, line1='Great Portland st., London') StoreAddressFactory( store=store2, line1='Sturt Street, Melbourne') f.cleaned_data = {'address': 'portland st, london'} qs = f.apply_filters(Store.objects.all()) self.assertEqual(list(qs), [store1]) f.cleaned_data = {'name': 'store2'} qs = f.apply_filters(Store.objects.all()) self.assertEqual(list(qs), [store2]) f.cleaned_data = {'name': 'store2', 'address': 'london'} qs = f.apply_filters(Store.objects.all()) self.assertEqual(list(qs), [])
def formset_valid(self, formset): # Store offers before any changes are made so we can inform the user of # any changes offers_before = self.request.basket.applied_offers() save_for_later = False # Keep a list of messages - we don't immediately call # django.contrib.messages as we may be returning an AJAX response in # which case we pass the messages back in a JSON payload. flash_messages = ajax.FlashMessages() for form in formset: if hasattr(form, "cleaned_data") and form.cleaned_data["save_for_later"]: line = form.instance if self.request.user.is_authenticated(): self.move_line_to_saved_basket(line) msg = render_to_string("basket/messages/line_saved.html", {"line": line}) flash_messages.info(msg) save_for_later = True else: msg = _("You can't save an item for later if you're " "not logged in!") flash_messages.error(msg) return redirect(self.get_success_url()) if save_for_later: # No need to call super if we're moving lines to the saved basket response = redirect(self.get_success_url()) else: # Save changes to basket as per normal response = super(BasketView, self).formset_valid(formset) # If AJAX submission, don't redirect but reload the basket content HTML if self.request.is_ajax(): # Reload basket and apply offers again self.request.basket = get_model("basket", "Basket").objects.get(id=self.request.basket.id) self.request.basket.strategy = self.request.strategy Applicator().apply(self.request.basket, self.request.user, self.request) offers_after = self.request.basket.applied_offers() for level, msg in get_messages(self.request.basket, offers_before, offers_after, include_buttons=False): flash_messages.add_message(level, msg) # Reload formset - we have to remove the POST fields from the # kwargs as, if they are left in, the formset won't construct # correctly as there will be a state mismatch between the # management form and the database. kwargs = self.get_formset_kwargs() del kwargs["data"] del kwargs["files"] if "queryset" in kwargs: del kwargs["queryset"] formset = self.get_formset()(queryset=self.get_queryset(), **kwargs) ctx = self.get_context_data(formset=formset, basket=self.request.basket) return self.json_response(ctx, flash_messages) apply_messages(self.request, offers_before) return response
def products(self, create, extracted, **kwargs): if not create or not extracted: return RangeProduct = get_model('offer', 'RangeProduct') for product in extracted: RangeProduct.objects.create(product=product, range=self)
def _validate_option(self, value): if not isinstance(value, get_model("catalogue", "AttributeOption")): raise ValidationError(_("Must be an AttributeOption model object instance")) if not value.pk: raise ValidationError(_("AttributeOption has not been saved yet")) valid_values = self.option_group.options.values_list("option", flat=True) if value.option not in valid_values: raise ValidationError(_("%(enum)s is not a valid choice for %(attr)s") % {"enum": value, "attr": self})
def _get_up_up_range(self): StockProductConfig = get_model("commission", "StockProductConfig") try: current_product_config = StockProductConfig.objects.filter(product=self)[0] up_up_range = current_product_config.up_up_range except: up_up_range = 0 return up_up_range
def _get_pickup_price(self): StockProductConfig = get_model("commission", "StockProductConfig") try: current_product_config = StockProductConfig.objects.filter(product=self)[0] pickup_price = current_product_config.pickup_price except: pickup_price = 0 return pickup_price
def _get_opening_price(self): StockProductConfig = get_model("commission", "StockProductConfig") try: current_product_config = StockProductConfig.objects.filter(product=self)[0] opening_price = current_product_config.opening_price except: opening_price = 0 return opening_price
def _get_max_buy_num(self): StockProductConfig = get_model("commission", "StockProductConfig") try: current_product_config = StockProductConfig.objects.filter(product=self)[0] max_buy_num = current_product_config.max_buy_num except: max_buy_num = 0 return max_buy_num
def _get_express_price(self): StockProductConfig = get_model("commission", "StockProductConfig") try: current_product_config = StockProductConfig.objects.filter(product=self)[0] express_price = current_product_config.express_price except: express_price = 0 return express_price
def _get_sale_num(self): StockProductConfig = get_model('commission', 'StockProductConfig') try: current_product_config = StockProductConfig.objects.filter(product=self)[0] sale_num = current_product_config.sale_num except: sale_num = 0 return sale_num
def _get_quote(self): StockProductConfig = get_model('commission', 'StockProductConfig') try: current_product_config = StockProductConfig.objects.filter(product=self)[0] quote = current_product_config.quote except: quote = 0 return quote
def _get_max_deal_num(self): StockProductConfig = get_model('commission', 'StockProductConfig') try: current_product_config = StockProductConfig.objects.filter(product=self)[0] max_deal_num = current_product_config.max_deal_num except: max_deal_num = 0 return max_deal_num
def get(self, request, *args, **kwargs): pk = kwargs['pk'] ln = Line.objects.get(id=pk) WishList = get_model('wishlists', 'WishList') WishList.objects.get_or_create(owner=request.user)[0].add(ln.product) ln.delete() return redirect('basket:summary')
def get(self, request, *args, **kwargs): pk = kwargs["pk"] ln = Line.objects.get(id=pk) WishList = get_model("wishlists", "WishList") WishList.objects.get_or_create(owner=request.user)[0].add(ln.product) ln.delete() return redirect("basket:summary")
def _get_volume(self): TradeComplete = get_model('commission', 'TradeComplete') try: volume = TradeComplete.objects.filter(product=self).aggregate(Sum('quantity')).get('quantity__sum') if not volume: volume = 0 except: traceback.print_exc() volume = 0 return volume
def get_site_offers(self): """ Return site offers that are available to all users """ ConditionalOffer = get_model('offer', 'ConditionalOffer') qs = ConditionalOffer.active.filter(offer_type=ConditionalOffer.SITE) # Using select_related with the condition/benefit ranges doesn't seem # to work. I think this is because both the related objects have the # FK to range with the same name. return qs.select_related('condition', 'benefit')
def _can_pickup(self): can_pickup = True try: StockProductConfig = get_model("commission", "StockProductConfig") current_product_config = StockProductConfig.objects.get(product=self) if current_product_config.self_pick_or_express == 2: can_pickup = False except: can_pickup = True return can_pickup
def products(self): """ Return a queryset of products in this offer """ Product = get_model('catalogue', 'Product') if not self.has_products: return Product.objects.none() queryset = self.condition.range.all_products() return queryset.filter(is_discountable=True).exclude( structure=Product.CHILD)
class Meta: model = get_model("oscar_support", "Ticket") fields = ['message_text']
from django.utils.http import is_safe_url from oscar.apps.basket.views import (BasketView as CoreBasketView, BasketAddView as CoreBasketAddView) from oscar.apps.customer.history import extract from oscar.core.loading import get_model from oscar.core.utils import safe_referrer from rest_framework.views import APIView from stars.apps.address.models import ReceivingAddress from stars.apps.basket.forms import BasketLineFormSet, BasketLineForm from stars.apps.catalogue.utils import open_close_date from stars.apps.commission.models import UserPickupAddr, PickupAddr, ProductOrder, OrderInfo from stars.apps.commission.views import new_commission_buy, DealException, order_commission from stars.apps.tradingcenter.views import is_market_opening Line = get_model('basket', 'Line') Product = get_model('catalogue', 'Product') Category = get_model('catalogue', 'Category') Partner = get_model('partner', 'Partner') UserBalance = get_model('commission', 'UserBalance') UserMoneyChange = get_model('commission', 'UserMoneyChange') SystemConfig = get_model('commission', 'SystemConfig') PickupList = get_model('commission', 'PickupList') PickupDetail = get_model('commission', 'PickupDetail') class BasketView(CoreBasketView): formset_class = BasketLineFormSet form_class = BasketLineForm def get_success_url(self):
from ecommerce.core.tests import toggle_switch from ecommerce.core.tests.decorators import mock_course_catalog_api_client, mock_enterprise_api_client from ecommerce.coupons.tests.mixins import CouponMixin, CourseCatalogMockMixin from ecommerce.courses.tests.factories import CourseFactory from ecommerce.courses.tests.mixins import CourseCatalogServiceMockMixin from ecommerce.enterprise.entitlements import ( get_course_entitlements_for_learner, get_course_vouchers_for_learner, get_entitlement_voucher, is_course_in_enterprise_catalog) from ecommerce.enterprise.tests.mixins import EnterpriseServiceMockMixin from ecommerce.extensions.catalogue.tests.mixins import CourseCatalogTestMixin from ecommerce.extensions.partner.strategy import DefaultStrategy from ecommerce.tests.testcases import TestCase COURSE_CATALOG_API_URL = 'https://catalog.example.com/api/v1/' Catalog = get_model('catalogue', 'Catalog') StockRecord = get_model('partner', 'StockRecord') @ddt.ddt @httpretty.activate class EntitlementsTests(EnterpriseServiceMockMixin, CourseCatalogServiceMockMixin, CourseCatalogTestMixin, CourseCatalogMockMixin, CouponMixin, TestCase): def setUp(self): super(EntitlementsTests, self).setUp() self.learner = self.create_user(is_staff=True) self.client.login(username=self.learner.username, password=self.password) # Enable enterprise functionality
import django_filters from django.db.models import Q from oscar.core.loading import get_model Order = get_model('order', 'Order') Product = get_model('catalogue', 'Product') class ProductFilter(django_filters.FilterSet): """ Filter products via query string parameters. """ product_class = django_filters.CharFilter(method='filter_product_class') structure = django_filters.CharFilter(field_name='structure', lookup_expr='iexact') def filter_product_class(self, queryset, name, value): # pylint: disable=unused-argument return queryset.filter( Q(product_class__name__iexact=value) | Q(parent__product_class__name__iexact=value)) class Meta: model = Product fields = ( 'product_class', 'structure', ) class OrderFilter(django_filters.FilterSet): """ Filter orders via query string parameter.""" username = django_filters.CharFilter(field_name='user__username')
# NOTE (CCB): These functions are copied from oscar.apps.offer.custom due to a bug # detailed at https://github.com/django-oscar/django-oscar/issues/2345. This file # should be removed after the fix for the bug is released. from oscar.core.loading import get_model Condition = get_model('offer', 'Condition') def class_path(klass): return '%s.%s' % (klass.__module__, klass.__name__) def create_condition(condition_class, **kwargs): """ Create a custom condition instance """ return Condition.objects.create(proxy_class=class_path(condition_class), **kwargs)
from django.http import HttpResponseRedirect from django.urls import reverse from edx_django_utils.cache import TieredCache from oscar.core.loading import get_model from requests.exceptions import ConnectionError, Timeout from slumber.exceptions import SlumberBaseException from ecommerce.core.constants import COUPON_PRODUCT_CLASS_NAME from ecommerce.core.utils import get_cache_key from ecommerce.coupons.views import voucher_is_valid from ecommerce.enterprise import api as enterprise_api from ecommerce.enterprise.utils import CONSENT_FAILED_PARAM, is_enterprise_feature_enabled from ecommerce.extensions.api.serializers import retrieve_all_vouchers logger = logging.getLogger(__name__) Product = get_model('catalogue', 'Product') Voucher = get_model('voucher', 'Voucher') def get_entitlement_voucher(request, product): """ Returns entitlement voucher for the given product against an enterprise learner. Arguments: product (Product): A product that has course_id as attribute (seat or bulk enrollment coupon) request (HttpRequest): request with voucher data """ if not is_enterprise_feature_enabled():
# -*- coding: utf-8 -*- from __future__ import absolute_import, unicode_literals from django.db import migrations from oscar.core.loading import get_model from ecommerce.core.constants import COUPON_PRODUCT_CLASS_NAME ProductAttribute = get_model("catalogue", "ProductAttribute") ProductClass = get_model("catalogue", "ProductClass") def create_enterprise_id_attribute(apps, schema_editor): """Create coupon enterprise_customer_uuid attribute.""" ProductAttribute.skip_history_when_saving = True coupon = ProductClass.objects.get(name=COUPON_PRODUCT_CLASS_NAME) pa = ProductAttribute(product_class=coupon, name='Enterprise Customer UUID', code='enterprise_customer_uuid', type='text', required=False) pa.save() def remove_enterprise_id_attribute(apps, schema_editor): """Remove coupon enterprise_customer_uuid attribute.""" coupon = ProductClass.objects.get(name=COUPON_PRODUCT_CLASS_NAME) ProductAttribute.skip_history_when_saving = True ProductAttribute.objects.get(product_class=coupon, code='enterprise_customer_uuid').delete()
class Meta: model = get_model("oscar_support", "Ticket") fields = ['type', 'subject', 'body']
from oscar.test.utils import RequestFactory from rest_framework import status from ecommerce.core.url_utils import get_lms_url from ecommerce.coupons.tests.mixins import CouponMixin from ecommerce.coupons.views import voucher_is_valid from ecommerce.courses.tests.factories import CourseFactory from ecommerce.extensions.api import exceptions from ecommerce.extensions.catalogue.tests.mixins import CourseCatalogTestMixin from ecommerce.extensions.test.factories import prepare_voucher from ecommerce.extensions.voucher.utils import get_voucher_and_products_from_code from ecommerce.tests.mixins import ApiMockMixin, LmsApiMockMixin from ecommerce.tests.testcases import TestCase Applicator = get_class('offer.utils', 'Applicator') Basket = get_model('basket', 'Basket') Benefit = get_model('offer', 'Benefit') Catalog = get_model('catalogue', 'Catalog') Course = get_model('courses', 'Course') Product = get_model('catalogue', 'Product') OrderLineVouchers = get_model('voucher', 'OrderLineVouchers') StockRecord = get_model('partner', 'StockRecord') Voucher = get_model('voucher', 'Voucher') VoucherApplication = get_model('voucher', 'VoucherApplication') CONTENT_TYPE = 'application/json' COUPON_CODE = 'COUPONTEST' class CouponAppViewTests(TestCase): path = reverse('coupons:app', args=[''])
from django.utils import timezone from oscar.core.loading import get_model from oscarapi.tests.utils import APITest Basket = get_model('basket', 'Basket') ConditionalOffer = get_model('offer', 'ConditionalOffer') Voucher = get_model('voucher', 'Voucher') class VoucherTest(APITest): fixtures = [ 'product', 'productcategory', 'productattribute', 'productclass', 'productattributevalue', 'category', 'attributeoptiongroup', 'attributeoption', 'stockrecord', 'partner', 'voucher' ] def setUp(self): # Adjust offer dates so it's valid offer = ConditionalOffer.objects.get( name="Offer for voucher 'testvoucher'") offer.start_datetime = timezone.now() offer.end_datetime = timezone.now() + timezone.timedelta(days=1) offer.save() # adjust voucher dates for testing the view voucher = Voucher.objects.get(name="testvoucher") voucher.start_datetime = timezone.now() voucher.end_datetime = timezone.now() + timezone.timedelta(days=1)
from django.forms.models import inlineformset_factory from oscar.core.loading import get_class, get_model HandPickedProductList = get_model('oscar_promotions', 'HandPickedProductList') OrderedProduct = get_model('oscar_promotions', 'OrderedProduct') OrderedProductForm = get_class( 'oscar_promotions.dashboard.forms', 'OrderedProductForm', module_prefix='oscar_promotions' ) OrderedProductFormSet = inlineformset_factory( HandPickedProductList, OrderedProduct, form=OrderedProductForm, extra=2)
import logging from django.db.models import Q from oscar.apps.partner import strategy from oscar.core.loading import get_class, get_model from ecommerce.extensions.checkout.mixins import EdxOrderPlacementMixin from ecommerce.extensions.payment.constants import CYBERSOURCE_CARD_TYPE_MAP from ecommerce.extensions.payment.helpers import get_processor_class_by_name from ecommerce.extensions.payment.processors import HandledProcessorResponse logger = logging.getLogger(__name__) Applicator = get_class('offer.applicator', 'Applicator') Basket = get_model('basket', 'Basket') EventHandler = get_class('order.processing', 'EventHandler') NoShippingRequired = get_class('shipping.methods', 'NoShippingRequired') Order = get_model('order', 'Order') OrderTotalCalculator = get_class('checkout.calculators', 'OrderTotalCalculator') ShippingEventType = get_model('order', 'ShippingEventType') SHIPPING_EVENT_NAME = 'Shipped' _payment_processors = {} def _get_payment_processor(site, name): key = ( site, name,
from django import forms from django.utils.translation import gettext_lazy as _ from oscar.core.loading import get_model Account = get_model('oscar_accounts', 'Account') class AccountForm(forms.Form): code = forms.CharField(label=_("Account code")) def clean_code(self): code = self.cleaned_data['code'].strip() try: self.account = Account.objects.get(code=code) except Account.DoesNotExist: raise forms.ValidationError(_("No account found with this code")) return code
import ddt import httpretty import mock from oscar.core.loading import get_model from requests import Timeout from slumber.exceptions import HttpNotFoundError, SlumberBaseException from ecommerce.courses.models import Course from ecommerce.extensions.test import factories from ecommerce.programs.tests.mixins import ProgramTestMixin from ecommerce.tests.factories import ProductFactory, SiteConfigurationFactory from ecommerce.tests.testcases import TestCase Product = get_model('catalogue', 'Product') LOGGER_NAME = 'ecommerce.programs.conditions' @ddt.ddt class ProgramCourseRunSeatsConditionTests(ProgramTestMixin, TestCase): def setUp(self): super(ProgramCourseRunSeatsConditionTests, self).setUp() self.condition = factories.ProgramCourseRunSeatsConditionFactory() self.test_product = ProductFactory(stockrecords__price_excl_tax=10) self.site.siteconfiguration.enable_partial_program = True def test_name(self): """ The name should contain the program's UUID. """ condition = factories.ProgramCourseRunSeatsConditionFactory() expected = 'Basket contains a seat for every course in program {}'.format( condition.program_uuid) self.assertEqual(condition.name, expected)
# TODO: Refactor this to consolidate it with `ecommerce.programs.views`. import logging from django.contrib import messages from django.urls import reverse from django.utils.translation import ugettext_lazy as _ from django.views.generic import CreateView, ListView, TemplateView, UpdateView from oscar.core.loading import get_model from ecommerce.core.views import StaffOnlyMixin from ecommerce.enterprise.forms import EnterpriseOfferForm from ecommerce.enterprise.utils import get_enterprise_customer Benefit = get_model('offer', 'Benefit') ConditionalOffer = get_model('offer', 'ConditionalOffer') logger = logging.getLogger(__name__) class EnterpriseOfferViewMixin(StaffOnlyMixin): model = ConditionalOffer def get_context_data(self, **kwargs): context = super(EnterpriseOfferViewMixin, self).get_context_data(**kwargs) context['admin'] = 'enterprise_offers' return context def get_queryset(self): return super(EnterpriseOfferViewMixin, self).get_queryset().filter( partner=self.request.site.siteconfiguration.partner,
get_profile_class) from oscar.core.utils import safe_referrer from oscar.views.generic import PostActionMixin from . import signals PageTitleMixin, RegisterUserMixin = get_classes( 'customer.mixins', ['PageTitleMixin', 'RegisterUserMixin']) Dispatcher = get_class('customer.utils', 'Dispatcher') EmailAuthenticationForm, EmailUserCreationForm, OrderSearchForm = get_classes( 'customer.forms', ['EmailAuthenticationForm', 'EmailUserCreationForm', 'OrderSearchForm']) ProfileForm, ConfirmPasswordForm = get_classes( 'customer.forms', ['ProfileForm', 'ConfirmPasswordForm']) UserAddressForm = get_class('address.forms', 'UserAddressForm') Order = get_model('order', 'Order') Line = get_model('basket', 'Line') Basket = get_model('basket', 'Basket') UserAddress = get_model('address', 'UserAddress') Email = get_model('customer', 'Email') CommunicationEventType = get_model('customer', 'CommunicationEventType') User = get_user_model() # ======= # Account # ======= class AccountSummaryView(generic.RedirectView): """
from oscar.apps.order.utils import OrderCreator as CoreOrderCreator from django.conf import settings from oscar.core.loading import get_model from django.db import transaction from oscar.apps.order.signals import order_placed Order = get_model('order', 'Order') class OrderCreator(CoreOrderCreator): def place_order(self, basket, total, # noqa (too complex (12)) shipping_method, shipping_charge, user=None, shipping_address=None, billing_address=None, order_number=None, status=None, request=None, **kwargs): """ Placing an order involves creating all the relevant models based on the basket and session data. """ if basket.is_empty: raise ValueError(_("Empty baskets cannot be submitted")) if not order_number: generator = OrderNumberGenerator() order_number = generator.order_number(basket) if not status and hasattr(settings, 'OSCAR_INITIAL_ORDER_STATUS'): status = getattr(settings, 'OSCAR_INITIAL_ORDER_STATUS') if Order._default_manager.filter(number=order_number).exists(): raise ValueError(_("There is already an order with number %s") % order_number)
from django.conf import settings from django.db import models, transaction from django.db.models import Count, Q from django.utils.timezone import now, timedelta from django.utils.translation import ugettext from django.utils.translation import ugettext_lazy as _ from oscar.core.loading import get_class, get_model from ecommerce.core.constants import (ENROLLMENT_CODE_PRODUCT_CLASS_NAME, ENROLLMENT_CODE_SEAT_TYPES, SEAT_PRODUCT_CLASS_NAME) from ecommerce.courses.publishers import LMSPublisher from ecommerce.extensions.catalogue.utils import generate_sku logger = logging.getLogger(__name__) Category = get_model('catalogue', 'Category') Partner = get_model('partner', 'Partner') Product = get_model('catalogue', 'Product') ProductCategory = get_model('catalogue', 'ProductCategory') ProductClass = get_model('catalogue', 'ProductClass') Selector = get_class('partner.strategy', 'Selector') StockRecord = get_model('partner', 'StockRecord') class Course(models.Model): site = models.ForeignKey('sites.Site', verbose_name=_('Site'), null=True, blank=True, on_delete=models.PROTECT) partner = models.ForeignKey('partner.Partner',
from django.http import Http404 from django.views import generic from oscar.core.loading import get_model from django.shortcuts import get_object_or_404 from django.contrib import messages from django.utils.translation import ugettext_lazy as _ from django import http from oscar.core.loading import get_class from oscar.apps.customer.alerts import utils from oscar.apps.customer.mixins import PageTitleMixin Product = get_model('catalogue', 'Product') ProductAlert = get_model('customer', 'ProductAlert') ProductAlertForm = get_class('customer.forms', 'ProductAlertForm') class ProductAlertListView(PageTitleMixin, generic.ListView): model = ProductAlert template_name = 'customer/alerts/alert_list.html' context_object_name = 'alerts' page_title = _('Product Alerts') active_tab = 'alerts' def get_queryset(self): return ProductAlert.objects.select_related().filter( user=self.request.user, date_closed=None, )
from django.conf import settings from django.contrib.auth.models import AnonymousUser from django.test.client import RequestFactory from oscar.core.loading import get_model from oscar.test.factories import BasketFactory from ecommerce.extensions.basket import middleware from ecommerce.tests.testcases import TestCase Basket = get_model('basket', 'Basket') class BasketMiddlewareTests(TestCase): def setUp(self): super(BasketMiddlewareTests, self).setUp() self.middleware = middleware.BasketMiddleware() self.request = RequestFactory().get('/') self.request.user = AnonymousUser() self.request.site = self.site self.middleware.process_request(self.request) def test_basket_is_attached_to_request(self): self.assertTrue(hasattr(self.request, 'basket')) def test_strategy_is_attached_to_basket(self): self.assertTrue(hasattr(self.request.basket, 'strategy')) def test_strategy_is_attached_to_request(self): self.assertTrue(hasattr(self.request, 'strategy')) def test_get_cookie_basket_handles_invalid_signatures(self):
from django.contrib import admin from treebeard.admin import TreeAdmin from treebeard.forms import movenodeform_factory from oscar.core.loading import get_model AttributeOption = get_model('catalogue', 'AttributeOption') AttributeOptionGroup = get_model('catalogue', 'AttributeOptionGroup') Category = get_model('catalogue', 'Category') Option = get_model('catalogue', 'Option') Product = get_model('catalogue', 'Product') ProductAttribute = get_model('catalogue', 'ProductAttribute') ProductAttributeValue = get_model('catalogue', 'ProductAttributeValue') ProductCategory = get_model('catalogue', 'ProductCategory') ProductClass = get_model('catalogue', 'ProductClass') ProductImage = get_model('catalogue', 'ProductImage') ProductRecommendation = get_model('catalogue', 'ProductRecommendation') class AttributeInline(admin.TabularInline): model = ProductAttributeValue class ProductRecommendationInline(admin.TabularInline): model = ProductRecommendation fk_name = 'primary' class CategoryInline(admin.TabularInline): model = ProductCategory extra = 1
""" Add 'Partner No Rev' categories to the list of default coupon categories""" from __future__ import unicode_literals from django.db import migrations from oscar.apps.catalogue.categories import create_from_breadcrumbs from oscar.core.loading import get_model Category = get_model('catalogue', 'Category') COUPON_CATEGORY_NAME = 'Coupons' DEFAULT_CATEGORIES = [ 'Partner No Rev - Prepay', 'Partner No Rev - Upon Redemption', ] def create_default_categories(apps, schema_editor): """Create default coupon categories.""" Category.skip_history_when_saving = True for category in DEFAULT_CATEGORIES: create_from_breadcrumbs('{} > {}'.format(COUPON_CATEGORY_NAME, category)) def remove_default_categories(apps, schema_editor): """Remove default coupon categories.""" Category.skip_history_when_saving = True Category.objects.get(name=COUPON_CATEGORY_NAME).get_children().filter( name__in=DEFAULT_CATEGORIES ).delete()
from ecommerce.core.tests.decorators import mock_course_catalog_api_client from ecommerce.core.url_utils import get_lms_url from ecommerce.coupons.tests.mixins import CourseCatalogMockMixin, CouponMixin from ecommerce.courses.tests.factories import CourseFactory from ecommerce.extensions.api import serializers from ecommerce.extensions.api.v2.views.vouchers import VoucherViewSet from ecommerce.extensions.catalogue.tests.mixins import CourseCatalogTestMixin from ecommerce.extensions.partner.strategy import DefaultStrategy from ecommerce.extensions.test.factories import ConditionalOfferFactory, VoucherFactory, prepare_voucher from ecommerce.extensions.voucher.models import CouponVouchers from ecommerce.tests.factories import PartnerFactory from ecommerce.tests.mixins import Catalog, LmsApiMockMixin from ecommerce.tests.testcases import TestCase Product = get_model('catalogue', 'Product') Range = get_model('offer', 'Range') StockRecord = get_model('partner', 'StockRecord') Voucher = get_model('voucher', 'Voucher') @ddt.ddt class VoucherViewSetTests(CourseCatalogMockMixin, CourseCatalogTestMixin, LmsApiMockMixin, TestCase): """ Tests for the VoucherViewSet view set. """ path = reverse('api:v2:vouchers-list') def setUp(self): super(VoucherViewSetTests, self).setUp() self.user = self.create_user(is_staff=True) self.client.login(username=self.user.username, password=self.password)
from oscar.core.loading import get_class, get_model from oscar.core.exceptions import (AppNotFoundError, ClassNotFoundError, ModuleNotFoundError) try: UserSessionData = get_class('user.session', 'UserSessionData') except (ImportError, AppNotFoundError, ClassNotFoundError, ModuleNotFoundError): from .checkout.session import FictaSessionData as UserSessionData Person = get_model('oscar_ficta', 'Person') def current_person(request): ctx = {} if getattr(request, 'user', None) and request.user.is_authenticated(): user = request.user user_session = UserSessionData(request) person_id = user_session.get_person_id() if person_id == -1: person = -1 # current_person is None when no linked persons found else: person = None if user.related_persons and len( user.related_persons.values_list()) > 0: try: person = user.related_persons.get(pk=person_id) except Person.DoesNotExist: # set current person to -1 that points to user themselves person = -1
# -*- coding: utf-8 -*- from django.contrib import messages from django.core.exceptions import (MultipleObjectsReturned, ObjectDoesNotExist, PermissionDenied) from django.core.urlresolvers import reverse from django.http import Http404 from django.shortcuts import get_object_or_404, redirect from django.utils.translation import ugettext_lazy as _ from django.views.generic import (CreateView, DeleteView, FormView, ListView, UpdateView, View) from oscar.core.loading import get_class, get_model from oscar.core.utils import redirect_to_referrer, safe_referrer WishList = get_model('wishlists', 'WishList') Line = get_model('wishlists', 'Line') Product = get_model('catalogue', 'Product') WishListForm = get_class('wishlists.forms', 'WishListForm') LineFormset = get_class('wishlists.formsets', 'LineFormset') PageTitleMixin = get_class('customer.mixins', 'PageTitleMixin') class WishListListView(PageTitleMixin, ListView): context_object_name = active_tab = "wishlists" template_name = 'customer/wishlists/wishlists_list.html' page_title = _('Wish Lists') def get_queryset(self): return self.request.user.wishlists.all()
from uuid import uuid4 import ddt import mock from oscar.core.loading import get_model from oscar.test import factories from testfixtures import LogCapture from waffle.testutils import override_flag from ecommerce.core.constants import SYSTEM_ENTERPRISE_LEARNER_ROLE from ecommerce.extensions.offer.applicator import CustomApplicator from ecommerce.extensions.offer.constants import CUSTOM_APPLICATOR_LOG_FLAG from ecommerce.extensions.test.factories import ConditionalOfferFactory, ConditionFactory, ProgramOfferFactory from ecommerce.tests.testcases import TestCase BasketAttribute = get_model('basket', 'BasketAttribute') BasketAttributeType = get_model('basket', 'BasketAttributeType') BUNDLE = 'bundle_identifier' LOGGER_NAME = 'ecommerce.extensions.offer.applicator' @ddt.ddt class CustomApplicatorTests(TestCase): """ Tests for the Program Applicator. """ def setUp(self): self.applicator = CustomApplicator() self.basket = factories.create_basket(empty=True) self.user = factories.UserFactory() def create_bundle_attribute(self, bundle_id): """ Helper to add a bundle attribute to a basket. """
from django.utils.translation import ugettext_lazy as _ from oscar.core.loading import get_model from oscar.apps.dashboard.orders.forms import * Country = get_model('address', 'Country') class ShippingAddressForm(ShippingAddressForm): class Meta(ShippingAddressForm.Meta): fields = ['full_name', 'full_address', 'sub_districts', 'city' ] + ShippingAddressForm.Meta.fields def __init__(self, *args, **kwargs): super(ShippingAddressForm, self).__init__(*args, **kwargs) for field in [ 'title', 'first_name', 'last_name', 'line1', 'line2', 'line3', 'line4' ]: self.fields.pop(field) self.fields['phone_number'].label = _('Phone number') self.fields['full_address'].widget.attrs['rows'] = 3 self.adjust_country_field() def adjust_country_field(self): countries = Country._default_manager.filter(is_shipping_country=True) # No need to show country dropdown if there is only one option if len(countries) == 1: self.fields.pop('country', None) self.instance.country = countries[0] else:
from django.db import transaction from django.template.defaultfilters import slugify from rest_framework import serializers from rest_framework.exceptions import APIException from oscar.core.loading import get_model from oscarapi.serializers.utils import OscarHyperlinkedModelSerializer from oscarapi.utils.categories import create_from_full_slug from oscarapi.utils.loading import get_api_classes, get_api_class from oscarapi.utils.models import fake_autocreated Product = get_model("catalogue", "Product") ProductClass = get_model("catalogue", "ProductClass") ProductAttributeValue = get_model("catalogue", "ProductAttributeValue") Option = get_model("catalogue", "Option") AdminStockRecordSerializer = get_api_class("serializers.admin.partner", "AdminStockRecordSerializer") ( BaseProductSerializer, BaseCategorySerializer, ProductImageSerializer, ProductAttributeSerializer, OptionSerializer, ) = get_api_classes( "serializers.product", [ "BaseProductSerializer", "BaseCategorySerializer", "ProductImageSerializer",
'ProductImageFormSet', 'ProductRecommendationFormSet', 'ProductAttributesFormSet', 'AttributeOptionFormSet')) ProductTable, CategoryTable, AttributeOptionGroupTable \ = get_classes('dashboard.catalogue.tables', ('ProductTable', 'CategoryTable', 'AttributeOptionGroupTable')) (PopUpWindowCreateMixin, PopUpWindowUpdateMixin, PopUpWindowDeleteMixin) \ = get_classes('dashboard.views', ('PopUpWindowCreateMixin', 'PopUpWindowUpdateMixin', 'PopUpWindowDeleteMixin')) Product = get_model('catalogue', 'Product') Category = get_model('catalogue', 'Category') ProductImage = get_model('catalogue', 'ProductImage') ProductCategory = get_model('catalogue', 'ProductCategory') ProductClass = get_model('catalogue', 'ProductClass') StockRecord = get_model('partner', 'StockRecord') StockAlert = get_model('partner', 'StockAlert') Partner = get_model('partner', 'Partner') AttributeOptionGroup = get_model('catalogue', 'AttributeOptionGroup') def filter_products(queryset, user): """ Restrict the queryset to products the given user has access to. A staff user is allowed to access all Products. A non-staff user is only allowed access to a product if they are in at
from django import forms from django.utils.translation import ugettext_lazy as _ from oscar.core.loading import get_model from .. import utils Attachment = get_model('oscar_support', 'Attachment') Order = get_model('order', 'Order') RelatedOrder = get_model("oscar_support", "RelatedOrder") RelatedOrderLine = get_model("oscar_support", "RelatedOrderLine") RelatedProduct = get_model("oscar_support", "RelatedProduct") class AttachmentForm(forms.ModelForm): def __init__(self, user, *args, **kwargs): self.user = user super(AttachmentForm, self).__init__(*args, **kwargs) class Meta: model = Attachment fields = [ 'ticket', 'file', ] def save(self, *args, **kwargs): kwargs['commit'] = False obj = super(AttachmentForm, self).save(*args, **kwargs) obj.user = self.user obj.save()