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()
