This is similar to the product adjustments ticket. We need some simple models to track products which have been blacklisted. This functionality will be used by projects that have a processing tier and need to filter out products before they are imported into the main DB.

We should probably create a special package for all these "procesing" type apps: oscar.apps.processing....

I was trying to override oscar.apps.checkout.views.OrderPlacementMixin but as far as I can see, there is no way that this can be done on the actual code - please tell me that I'm wrong! :)

What I've came up is to push mixins to the seaprate module, and then call get_class from the main module.

Let me know what do you think, is so will anybody will be intersted in such a patch?

Extend the oscar.order_management app to support an advanced search for orders,
where you can search by:

• Order number
• Shipping address
• Billing address
• Customer name

See the BAU customer services for a guide.

at http://tangentlabs.github.com/django-oscar/#takeapeek

everything is ok during installation

but when i run server, i have an django error page with the message :

Template error

In template /root/python_pj/oscarnew/django-oscar/oscar/templates/partials/brand.html, error at line 16
Caught Error while rendering: unsupported locale setting
6

error is here >>> 16

17

any help would be appreciated, thx

Probably a more long-term idea, but it would potentially benefit most users of Oscar.

There are a number of price comparison sites which retailers can register their catalogue with, they usually operate on a cost-per-click basis, but google's one is free.

They can use a number of mechanisms, the most common being a feed or a programmatic API. I envisage a number of backends being available that build on one of these core mechanisms.

To understand the potential complexity, here's how it would work for Google via their API:

• Google removes any products after 30 days, this is presumably to prevent their search results becoming stale. To get around this, all active products would need to be resynced at least once every 30 days.
• Any time a product changes it would need to be resynced. This could be done as a periodic task (eg daily), or perhaps asynchronously using a message queue. In the past I've used a twice-daily cron task.
• Assuming we go with a cron task and because of the previous two points, for each product we'd need to keep track of the last-modified and last-syndicated dates of each product.
• The task runs, finds all the products that need to be synced and generates the required API calls. These calls can be quite slow, so it's best to sync batches of products in one call. There may be issues with large batches timing out, which would prevent syncing all products with just one call. In the past i've used batches of 50.
• We'd also need to keep track of any products that need to be removed (before their natural 30 day expiry), this may be because they've been physically deleted or because they're out of stock. Whilst Google is free, other providers charge per click, so paying for a customer who can't buy the product isn't ideal. With Google these products can be removed via the API.

The feed approach works similarly, but with hosting an XML feed of the changes at a URL rather than generating an API call. The catch is that there's no confirmation of a successful sync, so we wouldn't be able to accurately update the last-syndicated field. Because of this the feed may have to show ALL products, which isn't a good solution with a large catalogue.

Assuming Google is just one backend of many, we'd also need support for multiple backends running in tandem, possibly with each having their own models and cron tasks.

Other providers to investigate include Kelkoo, Pricerunner and Ciao.

If there's interest I can investigate this further.

file oscar/apps/partner/utils.py line 156:

cat = create_from_breadcrumbs('Books > Fiction')

./manage.py loaddata countries.json fixtures/pages.json

in http://tangentlabs.github.com/django-oscar/#takeapeek requires the user to install debug_toolbar and django_extensions -- this is not installed via python setup.py develop!

I think we need to discuss what details we store on anonymous checkout, where to store them and how to deal with registration using the same details at a later date.

Any views?

The product record class in oscar.analytics has a field for a score. We need a simple manage.py command that calculates this score as a weighted average of the data within the user-record class.

Reqs:

• Make the weights configurable via settings.py
• The command should be part of the oscar.analytics package
• It should be extensible within a project to add fields to the calculation

We should have an autodiscovery script for reporting that works like the admin or Haystack autodiscovery.

It will need to loop through all the installled apps and looks for a file called reports.py, then register each reporting class. This will allow the reporting dashboard to automatically show the available reports.

• Need a basic integration with Solr.
• Needs to be extensible so new fields can be added within specific projects.

We should make sure the docs give a simple guide to getting set up.

comparing Oscar to leading e-commerce solutions it loks like they all go with the one screen checkout.

I suppose in a long-run this should be a better fit, as an lot of e-commerce studies show that simple and faster checkouts a better customer experience and have less drop-outs.

areas that need to be discussed:

• how to reduce number of steps to the bare minimum
• implementing multiple choices for addresses (selection)/shipping/payment methods
• how checkout can work with ajax and without it
• how additional (external) methods can be called during checkout (e.g. UPS price calculation)
• how to implement multiple payment methods with their selection

We need a flexible system for generating stock messaging. This is always partner dependent, and we need a way of loading a per-partner message generator, but falling back to a default.

The generator should take the stock record as an input and be able to return the availability message as well as the estimated dispatch date.

compilation of dashboard.less failing (less v. 1.3.0), there are basically two issues:

• line 155 - missing mixin for .box-sizing(border-box); - definition is later on, so this code should be moved down a bit
• line 515 #grid - there are severral lines similiar to: (~".span@{index}") { .span(@index); } which cause error

Following the instructions at http://tangentlabs.github.com/django-oscar/#takeapeek, i ran into a problem with this line:

./manage.py oscar_import_catalogue_images data/books-images.tar.gz --settings=settings_simple

  File "/home/.../django-oscar/oscar/apps/catalogue/utils.py", line 7, in <module>
    from PIL import Image as PImage
ImportError: No module named PIL

Changed that line to import Image as PImage and it worked.

Hi,
first of all, sorry for my english; i'm italian :-)
When i try to delete an order in the admin site i've got this error:

DjangoUnicodeDecodeError at /admin/order/order/
'ascii' codec can't decode byte 0xe2 in position 21: ordinal not in range(128). You passed in <ShippingEventQuantity: [Bad Unicode data]> (<class 'oscar.apps.order.abstract_models.ShippingEventQuantity'>)

The solution is very simple; add an 'u' in the unicode function of ShippingEventQuantity model in oscar.apps.order.abstract_models.py

I saw an old issue about the unicode functions. Maybe is a little forgetfulness. :-)
Bye,
Marco

This should be available on the page for the product. There is a Django app for creating RSS feeds so make sure you use that.

Need a new app oscar.apps.rest.inventory which provides a simple REST webservice so a partner can update their stock.

Requirements:

• Use HTTP Basic auth to authenticate each request
• Is only for writing information, not reading (for this ticket anyway)
• Each partner has their own authentication credentials, stored separately from the normal users table
• A partner can use the service to update stock levels and prices, or just one of these
• The API should be easily extensible so that partner with extra inventory information can post this too

The end URL should just be /rest/inventory/ and it should support the following API:

POST /rest/inventory/ with body

    <?xml ...?>
    <products>
        <product sku="123456">
            <num_in_stock>100</num_in_stock>
            <cost_price currency="GBP">12.99</cost_price>
        </product>
        <product sku="123453">
            <num_in_stock>0</num_in_stock>
        </product>
    </products>

to update the stock levels and prices of a range of products.

The stock.Partner model will need to be extended to support the authentication credentials for the Basic Auth.

We need a management command for import CSV data in to product models.

Should ship with a "simple" object mapper and a more complex one, with instructions on how to create and use custom mappers.

I wonder if django-oscar would support i18n support in templates and code ... Yes, some people do not speak english :) #frenchtouchinside

Installed by hand by this guide: http://django-oscar.readthedocs.org/en/latest/getting_started.html
database backend is postgresql 8.4 via psycopg2

Environment:

Request Method: GET
Request URL: http://oobchod.progredior.yac/admin/

Django Version: 1.4
Python Version: 2.6.6
Installed Applications:
['django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.messages',
'django.contrib.staticfiles',
'django.contrib.admin',
'south',
'oscar',
'oscar.apps.analytics',
'oscar.apps.order',
'oscar.apps.checkout',
'oscar.apps.shipping',
'oscar.apps.catalogue',
'oscar.apps.catalogue.reviews',
'oscar.apps.basket',
'oscar.apps.payment',
'oscar.apps.offer',
'oscar.apps.address',
'oscar.apps.partner',
'oscar.apps.customer',
'oscar.apps.promotions',
'oscar.apps.search',
'oscar.apps.voucher',
'oscar.apps.dashboard',
'oscar.apps.dashboard.reports',
'oscar.apps.dashboard.users',
'oscar.apps.dashboard.orders',
'oscar.apps.dashboard.promotions',
'oscar.apps.dashboard.catalogue',
'oscar.apps.dashboard.offers',
'oscar.apps.dashboard.ranges',
'oscar.apps.dashboard.vouchers',
'debug_toolbar']
Installed Middleware:
('django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'oscar.apps.basket.middleware.BasketMiddleware',
'debug_toolbar.middleware.DebugToolbarMiddleware')

Traceback:
File "/home/yac/.local/share/virtualenvs/oscar/pk-eshop/lib/python2.6/site-packages/django/core/handlers/base.py" in get_response

1.             response = middleware_method(request, response)
   

   File "/home/yac/.local/share/virtualenvs/oscar/pk-eshop/lib/python2.6/site-packages/debug_toolbar/panels/template.py" in process_response

2.                 pformat(k(self.request))) for k in get_standard_processors()
   

   File "/home/yac/.local/share/virtualenvs/oscar/pk-eshop/lib/python2.6/site-packages/oscar/apps/promotions/context_processors.py" in promotions

3. split_by_position(promotions, context)
   

   File "/home/yac/.local/share/virtualenvs/oscar/pk-eshop/lib/python2.6/site-packages/oscar/apps/promotions/context_processors.py" in split_by_position

4. for linked_promotion in linked_promotions:
   

   File "/home/yac/.local/share/virtualenvs/oscar/pk-eshop/lib/python2.6/site-packages/django/db/models/query.py" in _result_iter

5.             self._fill_cache()
   

   File "/home/yac/.local/share/virtualenvs/oscar/pk-eshop/lib/python2.6/site-packages/django/db/models/query.py" in _fill_cache

6.                 self._result_cache.append(self._iter.next())
   

   File "/home/yac/.local/share/virtualenvs/oscar/pk-eshop/lib/python2.6/site-packages/django/db/models/query.py" in iterator

7.     for row in compiler.results_iter():
   

   File "/home/yac/.local/share/virtualenvs/oscar/pk-eshop/lib/python2.6/site-packages/django/db/models/sql/compiler.py" in results_iter

8.     for rows in self.execute_sql(MULTI):
   

   File "/home/yac/.local/share/virtualenvs/oscar/pk-eshop/lib/python2.6/site-packages/django/db/models/sql/compiler.py" in execute_sql

9.     cursor.execute(sql, params)
   

   File "/home/yac/.local/share/virtualenvs/oscar/pk-eshop/lib/python2.6/site-packages/django/db/backends/util.py" in execute

10.         return self.cursor.execute(sql, params)
    

    File "/home/yac/.local/share/virtualenvs/oscar/pk-eshop/lib/python2.6/site-packages/django/db/backends/postgresql_psycopg2/base.py" in execute

11.         return self.cursor.execute(query, args)
    

Exception Type: DatabaseError at /admin/
Exception Value: current transaction is aborted, commands ignored until end of transaction block

Create functionality for a user's recently viewed items to be recorded. I think this is in one of the Django ecommerce books, so check there first.

This basically involves using cookies to store a fixed-size queue of product IDs. Create a simple template tag that renders the list onto the page, you'll need to allow a custom tempalte to be specified as part of this.

Make the number of products in the history configurable from settings.py

At the moment, they stick around after logging out, which is wrong.

I wonder if we would be able to modify the status of a product, e.g.

• Draft
• Published
• Unpublished

whatever its availability is.

The field exists in the product model but is not exploited.

Need models to capture an adjustment to a product which will override the data coming
from a feed, or add an additional attribute to a product.

• An adjustment links to a product and sets a new value for a field.
• The adjustment has a start and end date for when it is applicable
• It should be possible to add an attribute to a product

Core oscar needs a way of handling different size images. I think something like sorl is the answer here. At the moment, we have an images app but the images are just rendered in their original size.

A template tag like:

{% thumbnail item 200 100 %}

or something like that would be useful to give dynamic image size.

The ultimate need is for templates to be able to specify a size of image to be loaded in the template.

[We should rename the app to just "imports" or something similar.]

Create a custom command for importing a CSV of stock records. The CSV should take the format:

partner_ref, price_excl_tax, num_in_stock

The partner should be specified as part of the command, which would look something like:

./manage.py stock_import --partner=Gardners /tmp/stock.csv

Have a look at the existing catalogue import code to see what can be reused for this.

At the final step of http://tangentlabs.github.com/django-oscar/#takeapeek, where you run Django's server:

./manage.py runserver --settings=settings_simple

The server starts but the pages return:

AppNotFoundError: No app found matching 'dashboard.offers.forms'.

In settings_simple.py, add 'oscar.apps.dashboard.offers' and 'oscar.apps.dashboard.ranges' ro INSTALLED_APPS and this is resolved.

When choosing a report, you should be able to choose a output format, either HTML or CSV. If HTML is chosen, then the report is rendered as a table within the page.

This will require creating some kind of "formatter" class which gets passed to the report class. The report class will just write to this object and it will handle whether the output is going to screen or to a file.

Oscar core needs a simple registration system that can be customised to suit the domain of a shop.

We should try django-registration to see if this works.

at the moment default admin for the Category model (in apps.catalogue) is not working.

I suppose there should be at least something:

from treebeard.admin import TreeAdmin


class CategoryAdmin(TreeAdmin):
    pass

admin.site.register(product_models.Category, CategoryAdmin)

and of course treebeard should be added to the INSTALLED_APPS

Create a new oscar.wishlist app similar to the basket app.

• A wishlist is simply a list of products
• Wishlist products do not have quantities
• Only signed in users can have wishlists
• A user can only have one wishlist (for now)
• A wishlist can either be public or private
• A user can add a product to their wishlist from a product page - after adding they are redirected
  to their wishlist management page but with a link back to the page they just came from.
• The wishlist management should have URL /wishlist
• On the wishlist management page:
  • you can add the item to your normal basket or remove it from your wishlist
  • you can make your list public or private
  • you can empty your whole wishlist

The view functions for this app should be v similar to the basket ones. Also have a look at Amazons for
guidance.

The import_images management command should be extended to work with a compressed archive of images. It should detect the type of source file from the file extension.

Once it's working, we should convert the folder examples/book-images/ into a zip file to be neater.

Sample usage:

cd examples/vanilla/
./manage.py import_images ../sample-data/book-images.zip

The current testing-reqs.txt causes tests to fail, this is fixed with a pull request to follow:

One thing that may possibly need a review is the haystack version, as I wasn't sure what that preferred version was, but 1.2.7 causes all test to pass, so I went with that.

I've tried to install on window xp, it fail because ptrace package because there is no fork on window.

Just use price and product class to start with, but make sure it is easy to extend and add new facets within projects.

Will require a little research into Haystack. Basic search is already working, you just need to install solr locally and put your schema.xml in place. Faceting is required on loads of projects so we need a flexible way of implementing it.

Can be part of the catalogue/stock import app. Usage should be:

./manage.py import_images /path/to/folder

The folder should contain images named "{{ upc }}.jpg". The command should iterate through and create the appropriate image models. It should be able to handle both jpg and png files.

The command should support an option to specify how the files are named. Eg

./manage.py import_images --filename=partner_ref /path/to/folder

In this case the partner_reference field would be used to link filename to products.

They will need a specific URL to open the tab of each promotion.

For now, the currency filter format is currency-amount, e.g. $20 but this is not appropriate for some european countries where the correct syntax is 20€

It would be nice to override a template for currency formatting.

Add OptParse controls for passing dialect to CSV reader but also add auto-detection capabilities.

Dialect passed through CMD should override auto-detected dialect.

Create a new oscar.reviews app which provides reviews and voting functionality.

• Each product can have reviews attached to it. Each review has a title, a body and a score from 1-5.
• Signed in users can always submit reviews, anonymous users can only submit reviews if a setting
  OSCAR_ALLOW_ANON_REVIEWS is set to true - it should default to false.
• If anon users can submit reviews, then we require their name, email address and an (optional) URL.
• By default, reviews must be approved before they are live. However, if a setting OSCAR_MODERATE_REVIEWS
  is set to false, then they don't need moderation.
• The product page should have a review form on it, any errors in the submission will be shown on the same product page
• The product page will show the most recent 5 reviews with a link to browse all reviews for that product.
• The URL for browsing a products offers should be the normal product URL with /reviews appended at the end
• The product page should show the average score based on the reviews
• The review browsing page should allow reviews to be sorted by score, or recency.
• Each review should have a permalink, ie it has its own page.
• Each reviews can be voted up or down by other users
• Only signed in users can vote
• A user can only vote once on each product once

It might be possible to use the Django comments framework for this.

Create a view in the offers app that allows all products in an offer's range to be browsed. If the condition and benefit have different ranges, then allow products from both ranges to be browsed.

in __unicode__ method there is a refference to non-existing property item

return '%s <- %s - %s' % (self.item, self.role, self.contributor)

I suppose it should be a product

return '%s <- %s - %s' % (self.product, self.role, self.contributor)    

Does nobody use MySQL anymore?

Problem:

These 2 lines in the AbstractCategory model in apps/catalogue/models.py:

slug = models.SlugField(max_length=1024, db_index=True, editable=False)
full_name = models.CharField(max_length=1024, db_index=True, editable=False)    

Using a MySQL database backend with a unicode charset results in this error during schema migrate:

"Warning: Specified key was too long; max key length is 1000 bytes"

This is a long-standing limitation in MySQL. As unicode characters will use up to 3 bytes per char, the max field length is ~300 chars for an indexed char field.

Solution:

Changing max_length to 255 characters will fix the issue.

slug = models.SlugField(max_length=255, db_index=True, editable=False)
full_name = models.CharField(max_length=255, db_index=True, editable=False)    

NOTE: This needs to be changed right through all existing migrations as the initial migration won't even work. Pain in the @#$!

Specifically, the import_images and import_catalogue. These should respect the verbosity argument and show extended details when verbosity is turned out, showing only stats otherwise.

We need a flexible category system as part of the core. We should try using django-mptt for this.

It needs to support products existing in multiple categories at the same time.

Pods, banners and merchandising blocks need to link to either an external URL or an internal
one (eg /fiction-books/). The current URLField only supports external ones. Write a new type
of field class that allows internal URLs too.

Lots of models have a currency field but the field attributes are duplicated each time. This could be
simplified if we had a currency field class.

• This should set the correct decimal settings and support a default value

Write a manage.py command that populates the product recommendation models
based on the data within order history. Just follow the rules for "customers who
bought x, bought y"

Create a service that takes in a basket, and returns the a set of recommended products

Hello guys! I'm in love with django-oscar and using it and you know, I'm give advice to other ppl for using it. And will be much better if you'll add screenshots in repo readme aswell as screenshots at official site. Demo is even better.
I'm really deployed more than 13 times django-oscar just to let ppl see how it's look like.
Sorry for my english tho.