Пример #1
0
    def save(self):
        title = self.cleaned_data['title']
        iarticle = self.cleaned_data['iarticle']
        article = self.cleaned_data['article']
        name = self.cleaned_data['name']
        description = self.cleaned_data['description']
        comment = self.cleaned_data['comment']
        url = self.cleaned_data['url']
        code = self.cleaned_data['code']
        cat = self.cleaned_data['category']
        vend = self.cleaned_data['vendor']
        distr = self.cleaned_data['distr']
        number = Product.set_number(self)
        #print(number)
        prod = Product(type=1,
                       number=number,
                       iarticle=iarticle,
                       article=article,
                       title=title,
                       name=name,
                       alias='',
                       description=description,
                       comment=comment,
                       url=url,
                       img='',
                       category=cat,
                       vendor=vend)
        prod.save()
        if code:
            dc = Code(type=0, code=code, distr=distr, product_id=prod.id)
            dc.save()

        return "Товар " + title + " добавлен!"
Пример #2
0
def process_request(request, p: m.Product):
    if request.user.is_superuser:
        p.status = 2
        p.save()
        return HttpResponseRedirect('/manager/')
    else:
        return HttpResponseRedirect('/index/')
def new_product(request):
    noForwardedsInfo(request)
    context = {}

    if request.method == 'GET':
        form = ProductForm()
        context['form'] = form
        return render(request, 'dashboard_admin/new_product.html', context)
    else:
        form = ProductForm(request.POST, request.FILES)
        if form.is_valid():
            value = Utils.convertStringForNumber(request.POST.get('value'))
            product = Product()
            product.name = form.cleaned_data['name']
            product.description = form.cleaned_data['description']
            product.image = form.cleaned_data['image']
            product.value = value
            product.brand = form.cleaned_data['brand']
            product.category = form.cleaned_data['category']
            product.save()
            messages.success(request, "Novo Produto salvo com sucesso!")
        else:
            messages.warning(request,
                             "Por favor, preencha os campos corretamente!")
        context['form'] = form

        return HttpResponseRedirect(
            reverse('dashboard_admin:show_all_products'))
Пример #4
0
 def setUp(self):
     """Setup."""
     self.client = Client()
     self.user = User(username='******',
                      email='*****@*****.**')
     self.user.set_password('COOKIE')
     self.user.is_active = True
     self.user.save()
     self.account = Account.objects.get(user=self.user)
     self.account.has_address_delete = True
     self.account.save()
     self.addresses = []
     self.products = []
     self.services = []
     for i in range(2):
         address = ShippingInfo(name='test_name{}'.format(i),
                                address1='1234 Test Ave S',
                                zip_code='11111',
                                city='testville',
                                state='testington',
                                resident=self.account)
         address.save()
         product = Product(image=test_image,
                           name=('test' + str(i)),
                           price=50.00)
         product.save()
         service = Service(image=test_image,
                           name=('test' + str(i)))
         service.save()
         self.addresses.append(address)
         self.products.append(product)
         self.services.append(service)
     self.account.main_address = ShippingInfo.objects.last().id
     self.account.save()
Пример #5
0
 def get_context_data(self, **kwargs):
     return {
         'seo': views.get_seo(),
         'banner_products': Product.get_banner(),
         'other_products': Product.get_other(),
         'other_stock': Category.get_other(),
     }
Пример #6
0
    def handle(self, *fixture_labels, **options):

        if len(fixture_labels) > 0:
            path = fixture_labels[0]
            if not os.path.exists(path):
                print "Path does not exist:", path
                return

            fields = fields_for_model(Product)
            print "fields:", fields.keys()
            reader = csv.reader(open(path), delimiter=";")
            self.header = reader.next()
            print "header", self.header
            columns = list(set(fields.keys()) & set(self.header))
            print "columns:", columns
            for row in reader:
                id = self.get_value("id", row)
                data = dict([(c, getattr(self, "resolve_" + c, self.get_value)(c, row)) for c in columns])
                prod = None
                try:
                    prod = Product.objects.get(id=id)
                except Product.DoesNotExist:
                    data["id"] = id
                    pl = Placeholder(slot="product_description")
                    pl.save()
                    data["description"] = pl
                    prod = Product(**data)
                else:
                    Product.objects.filter(id=id).update(**data)
                    prod = Product.objects.get(id=id)

                if prod:
                    prod.save()
                    self.post_create(prod, row)
Пример #7
0
def process_request(request, deactivatedProduct: cmod.Product):

    context = {}
    # deactivatedProduct = cmod.Product.objects.get(id=productID)
    deactivatedProduct.Status = 'I'
    deactivatedProduct.save()

    return redirect('/manager/')
Пример #8
0
    def get(self, request):
        featured_products = Product.featured_products()
        recent_products = Product.recent_products(
            self.get_max_recent_arrivals())

        return super(IndexView, self).get(request,
                                          featured_products=featured_products,
                                          recent_products=recent_products)
Пример #9
0
def process_request(request, Product: cmod.Product = None):

    Product.status = 'I'
    Product.save()

    return HttpResponseRedirect('/manager/index/')
    context = {}
    return request.dmp.render('index.html', context)
Пример #10
0
def process_request(request, productid: cmod.Product):

    if not request.user.has_perm('auth.manager_view'):
        return HttpResponseRedirect('/homepage/index')

    productid.status = 'I'
    productid.save()

    return HttpResponseRedirect('/manager/ProductList')
Пример #11
0
    def __init__(self, **kwargs):
        super(StatisticModule, self).__init__(**kwargs)
        self.template = 'admin/statistic_block.html'
        self.css_classes.append('big-block')
        self.column = 3
        self.collapsible = False
        self.total_1 = "NONE1"
        self.total_2 = "NONE2"
        self.total_3 = "NONE2-NONE1"
        self.total_4 = Product.get_sales_count()
        self.total_5 = Product.get_in_stoke_count()

        request = kwargs.get('context').get('request')
Пример #12
0
def process_request(request, product:cmod.Product):

    #p = cmod.Product.objects.get(id=request.urlparams[0])

    product.status = 'I'
    product.save()

    return HttpResponseRedirect('/manager/product')

    context = {

    }
    return request.dmp.render('delete.html', context)
Пример #13
0
def process_request(request, product: amod.Product):
    #set the product status to Inactive
    product.status = 'I'
    #save the status change
    product.save()

    #get all active products
    products = amod.Product.objects.filter(status='A')

    #render the product list template
    return request.dmp.render('product.html', {
        'products': products,
    })
Пример #14
0
def process_request(request, product: cmod.Product):
    # try:
    #     product = cmod.Product.objects.get(id=request.urlparams[0])
    # except cmod.Product.DoesNotExist:
    #     return HttpResponseRedirect('/')

    product.status = 'I'
    product.save()

    productList = cmod.Product.objects.filter(status='A')

    context = {'productList': productList}

    return request.dmp.render('products.html', context)
Пример #15
0
    def get(self, request, page_num):
        form = AdvancedSearchForm(request.GET)
        query = '?' + request.GET.urlencode()
        products = None
        keyword = request.GET.get('keyword', None)
        page_title = 'Search: ' + keyword
        breadcrumbs = ({
            'name': 'Search: ' + keyword,
            'url': reverse('catalog_search') + query
        }, )

        if form.is_valid():
            data = form.cleaned_data

            products = paginate(Product.search_advance_products(
                data['keyword'], data['category'], data['manufacturer'],
                data['price_from'], data['price_to'], self.categories),
                                self.get_page_size(),
                                page_num,
                                'catalog_search',
                                qs=query)

        return super(SearchProductsView, self).get(request,
                                                   form=form,
                                                   keyword=keyword,
                                                   products=products,
                                                   page_title=page_title,
                                                   breadcrumbs=breadcrumbs)
def process_request(request, product:cmod.Product=None):
    prodict = {}
    prodict['pid'] = product.id
    prodict['max'] = product.get_quantity()
    if product.__class__.__name__ == 'BulkProduct':
        prodict['bulk'] = True
    else:
        prodict['bulk'] = False
    products = cmod.Product.objects.all()
    if product in request.last_five:
        request.last_five.remove(product)
    request.last_five.insert(0, product)
    if len(request.last_five) > 6:
        del request.last_five[-1]
    form = AddToCart(request, initial=prodict)
    form.submit_text = form.buy_now_text
    if form.is_valid():
        if request.user.is_authenticated:
            form.commit()
            cart = request.user.get_shopping_cart()
            cart.recalculate()
            return HttpResponseRedirect('/catalog/cart/')
        else:
            return HttpResponseRedirect('/account/signup/')

    context = {
        'product': product,
        'form': form,
    }
    return request.dmp.render('detail.html', context)
Пример #17
0
def search(request):
    company = request.user.account.company
    results = OrderTransferItem.objects.filter(Q(order__order__supplier=company) | Q(order__order__customer=company))

    contact_id = request.GET.get('contact_id', None)
    if contact_id:
        results = results.filter(Q(order__order__customer__id=contact_id) | Q(order__order__supplier__id=contact_id))

    customer_id = request.GET.get('customer_id', None)
    if customer_id:
        results = results.filter(order__order__customer__id=customer_id)
    
    supplier_id = request.GET.get('supplier_id', None)
    if supplier_id:
        results = results.filter(order__order__supplier__id=supplier_id)

    product_id = request.GET.get('product_id', None)
    if product_id:
        results = results.filter(order__info_id=product_id, order__info_type=Product.content_type())
    
    date = request.GET.get('date', None)
    if date:
        date = datetime.strptime(date, settings.DATE_FORMAT)
        
    sort = request.GET.get('sort', 'dsc')
    if sort == 'dsc':
        if date: results = results.filter(transfer__date__lte=date)
        results = results.order_by('-transfer__date')
    else:        
        if date: results = results.filter(transfer__date__gte=date)
        results = results.order_by('transfer__date')
    
    return results
Пример #18
0
def process_request(request, product: pmod.Product):

    plist = product.image_urls()
    if request.method == 'POST':
        form = PurchaseForm(request.POST)
        form.user = request.user
        form.product = product
        form.sale = request.user.get_shopping_cart()

        if form.is_valid():
            form.commit(product)
            PurchaseForm(request, form.user)

            return HttpResponseRedirect(
                f'/catalog/cart/{request.user.get_shopping_cart().id}')

    else:
        form = PurchaseForm()

    context = {
        'form': form,
        'product': product,
        'plist': plist,
    }

    return request.dmp.render('product.html', context)
Пример #19
0
    def handle_noargs(self, **options):
        admin = User.objects.get(username='******')
        primary = admin.account.company

        # list of zero stock products
        no_stock_ids = set(
            Product.objects.exclude(stocks__quantity__gt=0).values_list(
                'id', flat=True))

        # list of products with sales
        sale_ids = set(
            OrderItem.objects.filter(
                info_type=Product.content_type).values_list('info_id',
                                                            flat=True))

        excluded_ids = no_stock_ids.difference(sale_ids)
        print excluded_ids
        raw_input("Press to continue...")

        items = ItemAccount.objects.filter(
            cost=0, owner=primary,
            item_type=Product.content_type()).exclude(item_id__in=excluded_ids)

        fname = "{} {}".format('for_costing', '.csv')
        with open(fname, 'wb') as f:
            writer = csv.writer(f)
            writer.writerow(['ID', 'Name', 'Summary', 'Cost'])
            for i in items:
                print '{} {} {} {}'.format(i.id, i.item.name(), i.item.summary,
                                           i.cost)
                writer.writerow([i.id, i.item.name(), i.item.summary, i.cost])
 def setUp(self):
     p = Product()
     p.name = 'lays'
     p.slug = 'lays'
     p.price = 10.00
     p.quantity= 1
     p.save();
Пример #21
0
    def bookkeep_adjustments(self):
        physicals = Physical.objects.filter(
            date__lte=self.end_date,
            date__gte=self.start_date,
            stock__location__owner=self.primary)
        adjustments = AdjustmentItem.objects.filter(
            adjustment__date__lte=self.end_date,
            adjustment__date__gte=self.start_date,
            adjustment__location__owner=self.primary,
            adjustment__labels__name=Adjustment.VALID)

        delta_map = {}
        count = len(physicals)
        for i, p in enumerate(physicals):
            sys.stdout.write("Calculating physicals... {} of {}\r".format(
                i + 1, count))
            sys.stdout.flush()
            delta_map[p.stock.product.id] = delta_map.get(
                p.stock.product.id, 0) + p.delta

        count = len(adjustments)
        for i, a in enumerate(adjustments):
            sys.stdout.write("Calculating adjustments... {} of {}\r".format(
                i + 1, count))
            sys.stdout.flush()
            delta_map[a.product.id] = delta_map.get(a.product.id, 0) + a.delta

        total = 0
        accounts = ItemAccount.objects.filter(item_type=Product.content_type(),
                                              owner=self.primary)
        count = len(accounts)
        for i, account in enumerate(accounts):
            sys.stdout.write("Writing out adjustments... {} of {}\r".format(
                i + 1, count))
            sys.stdout.flush()
            key = account.item_id
            adjustment = delta_map.get(key, 0) * self.context.estimate(
                account.item)
            total += adjustment
            account.data(ItemAccount.YEAR_ADJUSTMENTS, self.cutoff, adjustment)

        self.primary.account.data(CompanyAccount.YEAR_ADJUSTMENTS, self.cutoff,
                                  total)

        # Calculate bad debts
        writeoffs = Bill.objects.filter(supplier=self.primary,
                                        labels__date__gte=self.start_date,
                                        labels__date__lte=self.end_date,
                                        labels__name=Bill.BAD)
        bad_debts = 0
        for w in writeoffs:
            bad_debts += w.outstanding()

        self.primary.account.data(CompanyAccount.YEAR_BAD_DEBTS, self.cutoff,
                                  bad_debts)

        print "\nDone."
Пример #22
0
    def setUp(self):
        self.noprod = Product()
        self.lg3 = Product()
        self.loafer = Product()

        self.noprod.activ = False
        self.noprod.quantity = 10
        self.noprod.pk = 19
        self.noprod.name = 'No product'

        # LG3 Product
        self.lg3.pk = 3
        self.lg3.quantity = 1
        self.lg3.name = 'LG 3'

        # Loafer Product
        self.loafer.pk = 1
        self.loafer.quantity = 6
        self.loafer.name = 'Loafer'
Пример #23
0
def process_request(request, product: cmod.Product = None):
    print(product, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
    if product is None:
        return HttpResponseRedirect('/catalog/index')

    picList = product.image_urls().order_by('id')
    for p in picList:
        print(p.filename)
    type = product.TITLE
    quant = product.get_quantity()
    name = cmod.Category.objects.get(id=product.category_id).name
    user = request.user

    if product in request.last_five:
        request.last_five.remove(product)

    request.last_five.insert(0, product)

    if len(request.last_five) > 6:
        request.last_five.pop()

    form = BuyForm(request, prod=product)
    if form.is_valid():
        if request.user.is_authenticated != True:
            return HttpResponseRedirect('/account/login')

        form.commit(product)
        return HttpResponseRedirect('/catalog/cart')
    form.submit_text = 'Add to Cart'

    context = {
        # sent to index.html:
        'form': form,
        'quant': quant,
        'type': type,
        'product': product,
        'name': name if name is not None else "All Products",
        'catID': product.category,
        'pictures': picList,
        # sent to index.html and index.js:
    }
    return request.dmp.render('details.html', context)
Пример #24
0
    def handle(self, *args, **options):
        admin = User.objects.get(username__exact='admin')  # hack
        primary = admin.account.company
        cutoff = primary.account.current_cutoff_date()

        terms = ' '.join(args)
        product_ids = SearchQuerySet().auto_query(terms).models(
            Product).values_list('pk', flat=True)
        items = ItemAccount.objects.filter(item_id__in=product_ids,
                                           item_type=Product.content_type(),
                                           owner=primary)

        today = datetime.today()
        last_year = today - timedelta(days=365)
        transfers = OrderTransferItem.objects.filter(
            order__info_id__in=product_ids,
            order__info_type=Product.content_type(),
            transfer__date__lte=today,
            transfer__date__gte=last_year)
        sales = {}
        for t in transfers:
            if not t.transfer.labeled(OrderTransfer.CANCELED):
                sales[t.order.info_id] = sales.get(t.order.info_id,
                                                   0) + t.net_quantity

        fname = "{}{}".format(terms, '.csv')
        with open(fname, 'wb') as f:
            writer = csv.writer(f)
            writer.writerow([
                'Brand', 'Model', 'Summary', 'On Hand', '1 Year Sales',
                'Average Monthly Rate'
            ])
            for i in items:
                #data = i.data(ItemAccount.YEAR_SALES_QUANTITY, cutoff)
                item_sales = sales.get(i.item.id, 0)
                print '{} {} {} {} {}'.format(i.item.brand, i.item.model,
                                              i.item.summary, i.stock,
                                              item_sales, item_sales / 12)
                writer.writerow([
                    i.item.brand, i.item.model, i.item.summary, i.stock,
                    item_sales, item_sales / 12
                ])
Пример #25
0
    def get(self, request, product_id, slug):
        try:
            product = Product.get_detail(int(product_id))
        except Product.DoesNotExist:
            raise Http404()

        return super(ProductDetailView, self).get(
            request,
            product=product,
            breadcrumbs=product.get_breadcrumbs(self.categories),
            page_title=product.name)
Пример #26
0
 def submit_data(self):
     data_dict = self.get_data_dict()
     product = Product(
         title=data_dict['title'][0],
         track_stock=True if data_dict['track_stock'][0] == 2 else False,
         upc=data_dict['UPC_1'][0],
         upc_2=data_dict['UPC_2'][0],
         purchase_price=float(data_dict['purchase_price_ET'][0]),
         selling_price=float(data_dict['selling_price_ET'][0]),
         tax_rate=float(data_dict['tax_rate'][0]),
         category=ProductCategory.objects.get(pk=data_dict['category'][0]),
         dci=data_dict['dci'][0],
         lab=data_dict['manufacturer'][0],
         th_class=data_dict['th'][0],
         refundable=True if data_dict['refundable'][0] == 2 else False,
         prescription=True if data_dict['prescription'][0] == 2 else False,
         pharma_form=data_dict['pharma_form'][0],
         tableau=data_dict['tableau'][0])
     product.save()
     self.close()
Пример #27
0
def remove_wish_list(request):
    slug = request.POST.get('slug')
    product = Product()
    user_profile = profile.get_profile(request)
    try:
        product = user_profile.wish_list.get(slug=slug)
        user_profile.wish_list.remove(product)
        response = json.dumps({'success': 'True'})
    except product.DoesNotExist:
        response = json.dumps({'success': 'False'})
    return HttpResponse(response,
                        content_type='application/javascript; charset=utf-8')
Пример #28
0
def order(request):
    items = []
    terms = request.GET.get('terms', None)
    months = decimal.Decimal(request.GET.get('months', 6))
    if terms:
        terms = terms.strip()
        results = SearchQuerySet().auto_query(terms)
        results = results.models(Product)
        product_ids = results.values_list('pk', flat=True)

        primary = request.user.account.company
        accounts = ItemAccount.objects.filter(owner=primary,
                                              item_id__in=product_ids,
                                              item_type=Product.content_type())

        today = datetime.today()
        last_year = today - timedelta(days=365)
        transfers = OrderTransferItem.objects.filter(
            order__order__supplier=primary,
            order__info_id__in=product_ids,
            order__info_type=Product.content_type(),
            transfer__date__lte=today,
            transfer__date__gte=last_year,
            transfer__labels__name=OrderTransfer.VALID)
        sales = {}
        for t in transfers:
            sales[t.order.info_id] = sales.get(t.order.info_id,
                                               0) + t.net_quantity

        for a in accounts:
            a.sales = sales.get(a.item_id, 0)
            a.rate = a.sales / 12
            a.quantity = a.rate * months - a.stock
            if a.quantity < 0: a.quantity = 0
            items.append(a)

    return render_to_response('task/purchasing/order.html',
                              dict(items=items, terms=terms, months=months),
                              context_instance=RequestContext(request))
Пример #29
0
 def save(self, commit=False):
     try:
         product = Product.objects.get(
             name=self.cleaned_data.get('name').title(),
             color=self.cleaned_data.get('color'))
         return product
     except Product.DoesNotExist:
         product = Product()
     product.name = self.cleaned_data.get('name').title()
     product.color = self.cleaned_data.get('color')
     product.quantity_stocked = self.cleaned_data.get('quantity_stocked')
     product.personalization_limit = self.cleaned_data.get(
         'personalization_limit')
     product.price = self.cleaned_data.get('price')
     features = self.cleaned_data.get('features')
     product.save()
     for feature in features.splitlines():
         Feature(product_id=product, feature_desc=feature.strip()).save()
     return product
Пример #30
0
    def handle(self, *fixture_labels, **options):

        if len(fixture_labels) > 0:
            path = fixture_labels[0]
            if not os.path.exists(path):
                print 'Path does not exist:', path
                return

            fields = fields_for_model(Product)
            print 'fields:', fields.keys()
            reader = csv.reader(open(path), delimiter=";")
            self.header = reader.next()
            print 'header', self.header
            columns = list(set(fields.keys()) & set(self.header))
            print 'columns:', columns
            for row in reader:
                id = self.get_value('id', row)
                data = dict([(c, getattr(self, 'resolve_' + c,
                                         self.get_value)(c, row))
                             for c in columns])
                prod = None
                try:
                    prod = Product.objects.get(id=id)
                except Product.DoesNotExist:
                    data['id'] = id
                    pl = Placeholder(slot='product_description')
                    pl.save()
                    data['description'] = pl
                    prod = Product(**data)
                else:
                    Product.objects.filter(id=id).update(**data)
                    prod = Product.objects.get(id=id)

                if prod:
                    prod.save()
                    self.post_create(prod, row)
Пример #31
0
    def preload(self):
        purchases = OrderTransferItem.objects.filter(transfer__labels__name=OrderTransfer.VALID,
                                                     transfer__date__lte=self.end_date,
                                                     transfer__date__gte=self.start_date,
                                                     transfer__order__customer__id=self.primary_id).order_by('transfer__date')
        quantities = {}
        values = {}
        for item in purchases:
            key = (item.order.info_id, item.order.info_type.id)
            if item.net_quantity > 0:
                quantities[key] = quantities.get(key, 0) + item.net_quantity
                values[key] = values.get(key, 0) + (item.order.price * item.net_quantity)
        for key in quantities.keys():
            self.cache[key] = values[key] / quantities[key]

        orders = OrderItem.objects.filter(order__labels__name=Order.CLOSED,
                                          order__customer__id=self.primary_id,
                                          info_type=Product.content_type(),
                                          order__date__lte=self.end_date).order_by('order__date')
        for o in orders:
            self.last_known_cache[o.info.id] = o.price

        self.default_cache = dict(ItemAccount.objects.filter(item_type=Product.content_type(),
                                                             owner__id=self.primary_id).values_list('item_id', 'cost'))
Пример #32
0
def urgent(request):
    primary = request.user.account.company

    # get all sale and purchase items with non-zero balance
    order_items = OrderItem.objects.pending().filter(
        info_type=Product.content_type())
    products = {}
    for i in order_items:
        pid = i.info.id
        if pid not in products:
            products[pid] = i.info
            products[pid].stock = 0
            products[pid].incoming = 0
            products[pid].outgoing = 0
            products[pid].required = 0
        if i.order.supplier == primary:
            products[pid].outgoing = products[pid].outgoing + i.balance
        elif i.order.customer == primary:
            products[pid].incoming = products[pid].incoming + i.balance
    accounts = ItemAccount.objects.filter(owner=primary,
                                          item_type=Product.content_type(),
                                          item_id__in=products.keys())
    for account in accounts:
        products[account.item_id].stock = account.stock


#    stocks = Stock.objects.filter(product__id__in=products.keys())
#    for s in stocks:
#        pid = s.product.id
#        products[pid].stock = products[pid].stock + s.quantity
    urgent = []
    for pid, p in products.items():
        p.required = p.outgoing - p.stock - p.incoming
        if p.required > 0:
            urgent.append(p)
    return paginate(request, urgent, 'task/purchasing/urgent_results.html')
Пример #33
0
def process_request(request, product:cmod.Product):

    if product is None:
        return redirect('/catalog/index')

    #remove the current object from the last_five list, if it exists
    #this prevents it from showing up as the current object as well as in the last_five list
    if product in request.last_five:
        request.last_five.remove(product)

    #add the current object to the front of the last_five list
    request.last_five.insert(0, cmod.Product.objects.get(id = product.id))

    return request.dmp.render('detail.html', {
        'product': product,
        'product_images': product.image_urls(),
    })
Пример #34
0
 def task_product(self, grab, task):
     print 'Product title: %s' % grab.doc.select(self.xpath['product_title']).text().strip()
     products = Product.objects.filter(urls__contains=task.url)
     if not products:
         product = Product(name=grab.doc.select(self.xpath['product_title']).text().strip(), category=task.category)
         product.urls = task.url
     else:
         product = products[0]
     product.descr = grab.doc.select(self.xpath['product_descr']).node().text
     price_rub = grab.doc.select(self.xpath['product_price'])
     price_kop = price_rub.select(".//span").node().text
     price_rub = price_rub.node().text
     try:
         product.price = float("%s.%s" % (price_rub, price_kop))
     except:
         pass
     if not product.name == grab.doc.select(self.xpath['product_title']).text().strip():
         product.name = grab.doc.select(self.xpath['product_title']).text().strip()
     product.save()
Пример #35
0
    def handle(self, *args, **options):
        start_time = time.time()

        # going to disconnect categories counter update hook from Product
        Signal.disconnect(pre_save, sender=Product, receiver=counters_hook)

        # going to disconnect product medial hook
        Signal.disconnect(post_delete, sender=ProductMedia, receiver=product_image_delete)

        if options['delete']:
            Category.objects.all().delete();
            Product.objects.all().delete();

        for file in args:
            if file[0:4] == 'http':
                try:
                    request = urllib2.Request(file, headers={"Accept": "application/xml"})
                    file = urllib2.urlopen(request)

                    tree = ET.parse(file)

                except ET.ParseError:
                    raise CommandError('YML "%s" is not valid' % file)
            else:
                tree = ET.parse(file)

            root = tree.getroot()

            trans_dct = {}

            # copy categories into databases
            for child in root.find('shop').find('categories'):
                category = Category(name=child.text);
                category.save()
                trans_dct[child.get('id')] = category.id;

            # setting child-parent relations
            for child in root.find('shop').find('categories'):
                # only for child elements
                if child.get('parentId') is not None:
                    # search for child a category
                    try:
                        category = Category.objects.get(pk=trans_dct[child.get('id')])
                    except Category.DoesNotExist:
                        raise CommandError('Category ID "%s" was not found' % child.get('id'))
                    pass
                    # adding relation to parent category
                    try:
                        category.parent = Category.objects.get(pk=trans_dct[child.get('parentId')])
                        category.save()
                    except Category.DoesNotExist:
                        raise CommandError('Category ID "%s" was not found' % child.get('id'))
                    pass

            self.stdout.write('Categories imported' + '\n')

            # import offers (products)
            product_counter = 0
            for child in root.find('shop').find('offers'):

                if options['verbose']:
                    u = u'import products)  %s ' % child.find('name').text
                    print u.encode('ascii', 'ignore')

                description = child.find('description').text;
                if description is None:
                    description = ""

                product = Product(
                    name=child.find('name').text,
                    price=child.find('price').text,
                    description=description,
                    category=Category.objects.get(pk=trans_dct[child.find('categoryId').text])

                );

                product.save()
                product_counter += 1

                if options['images']:
                    # importing images from <picture>http://...</picture>
                    if child.find('picture') is not None:
                        try:
                            image_data = urllib2.urlopen(child.find('picture').text, timeout=5)
                        except urllib2.HTTPError:
                            print 'Could not download image: ' + child.find('picture').text
                        else:
                            filename = urlparse.urlparse(image_data.geturl()).path.split('/')[-1] + '.jpg'

                            product_media = ProductMedia(image=filename, is_main=True, product=product)
                            product_media.image.save(filename, ContentFile(image_data.read()), save=False)
                            product_media.save()

            self.stdout.write('Products imported - ' + str(product_counter) + '\n' + str(round(time.time() - start_time, 2)) + " seconds")

            # fix categories counters

            categories = Category.objects.all()

            for category in categories:
                category.count_products = Product.active.filter(
                    category__in=category.get_descendants(include_self=True)).count()

                # deactivate empty categories
                if category.count_products == 0:
                    category.is_active = False

                category.save()
Пример #36
0
def get_last_products(session):
    last_products_id = session.get('last_products', [])
    if not len(last_products_id): return []
    return Product.get_last_products(last_products_id)
Пример #37
0
    def create_master_product(self, data, sync, product=None, is_update=False):
        if not product:
            product = Product()
        product.title = data['cleaned_data']['title']
        product.description = data['cleaned_data']['detailed_desc'] or data['cleaned_data']['description']
        product.brand = data['cleaned_data']['brand']
        product.category = data['cleaned_data']['category']
        product.slug = slugify(product.title)[:150]
        product.model = data['cleaned_data']['model']
        product.moderate = True
        product.currency = data['cleaned_data'].get('currency','inr')
        product.type = data['cleaned_data'].get('product_type','normal')
        product.product_type = self.get_mapped_sku_type(data['cleaned_data'].get('sku_type',''))
        if data['cleaned_data'].get('video',''):
            product.video_embed = data['cleaned_data']['video']

        #If the category belongs to BLACKLIST_CATEGORIES, then set product.status = 'deactive'
        #else product.status = data['cleaned_data']['status']
        category = data['cleaned_data']['category']
        if str(category.ext_id) in getattr(settings, 'BLACKLIST_CATEGORIES', []):
            product.status = 'deactive'
        elif data['cleaned_data']['status'] in ['active','deactive','deleted']:
            product.status = data['cleaned_data']['status']

        product.save(using='default')
        product.productimage_set.using('default').all().delete()

        if self.download_images:
            # download the image
            for url in data['cleaned_data']['image_url']:
                try:
                    feedutils.attach_image_to_product(product,url)
                except Exception, e:
                    log.exception(
                            'Error adding image to product %s from %s: %s' % (
                                product.id, data['cleaned_data']['image_url'],
                                repr(e)))
Пример #38
0
def process_request(request):
  
  #process the form
  form = CreateProductForm()
  if request.method == 'POST':  # just submitted the form
    form = CreateProductForm(request.POST)
    if form.is_valid():
      pr = Product()
      pr.name = form.cleaned_data.get('name')
      pr.description = form.cleaned_data.get('description')
      pr.image = form.cleaned_data.get('image')
      pr.price = form.cleaned_data.get('price')
      pr.ptype = form.cleaned_data.get('ptype')
      pr.creator = form.cleaned_data.get('creator')
      pr.quantity = form.cleaned_data.get('quantity')
      pr.status = form.cleaned_data.get('status')
      pr.date_made = form.cleaned_data.get('date_made')

      pr.save()

      return HttpResponseRedirect('/manager/products/')
      
  template_vars = {
    'form': form,
  }
  return dmp_render_to_response(request, 'productscreate.html', template_vars)
Пример #39
0
    def get_or_create_rate_chart(self, listing_id):
        try:
            rate_chart_map = ListingRateChartMap.objects.get(
                    listing_id = listing_id)
            if rate_chart_map.rate_chart:
                return rate_chart_map.rate_chart
        except ListingRateChartMap.DoesNotExist:
            pass

        results = listing_solr_search('id:%s' % listing_id)
        if results and results.results and len(results.results) > 0:
            listing = results.results[0]
            product = Product()
            product.title = listing.get('title','')
            product.description = listing.get('description','')
            product.currency = listing.get('currency','inr')
            product.brand = self.get_other_brand('Other')
            product.model = ''
            product.category = self.get_other_category('Other')
            product.type = 'normal'
            product.status = 'unavailable'
            product.save()

            rate_chart = SellerRateChart()
            rate_chart.listing_id = listing_id
            rate_chart.product = product
            rate_chart.seller = self.get_seller(listing.get('userId',0))
            rate_chart.status = 'unavailable'
            rate_chart.sku = listing.get('sku', '')
            rate_chart.condition = 'new'
            rate_chart.is_prefered = True
            rate_chart.list_price = Decimal(str(listing.get('mrp',0)))
            rate_chart.offer_price = Decimal(str(listing.get('askingPrice',0)))
            if rate_chart.offer_price > rate_chart.list_price:
                rate_chart.list_price = rate_chart.offer_price
            rate_chart.warranty = listing.get('warranty','')
            rate_chart.gift_title = listing.get('gifts','')
            rate_chart.shipping_charges = Decimal(str(listing.get('shippingCharges','0.0')))
            rate_chart.shipping_duration = listing.get('shippingDuration','7-10 working days')
            rate_chart.availability = self.get_available_every_where()
            rate_chart.stock_status = 'notavailable'
            rate_chart.status = 'deleted'
            rate_chart.save()

            listing_rate_chart_map = ListingRateChartMap(listing_id=listing_id, rate_chart=rate_chart)
            listing_rate_chart_map.save()

            return rate_chart

        return None
Пример #40
0
    def get(self, request):
        last_products_id = request.session.get('last_products', [])
        if not len(last_products_id): return Response([])

        products = Product.get_last_products(last_products_id)
        return Response(ProductSerializer(products, many=True).data)