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 + " добавлен!"
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'))
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()
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'
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
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')
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
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()
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)))
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)
def test_userfavoritemodel(self):
product = Product(name='8 steaks hachés façon bouchère')
user = '******'
product_name = UserFavorite(user_name=User(username=user),
product=product)
self.assertEqual(str(product), str(product))
password='******',
email="*****@*****.**",
name="John Doe",
avatar="https://pbs.twimg.com/profile_images/2671170543/18debd69"
"4829ed78203a5a36dd364160_400x400.png",
telephone="+1-333-222-1111"
)
]
# Define some dummy products
seed_products = [
Product(
title="Nintendo 64 with games",
slug="nintendo-64-with-games",
description="Selling my Nintendo 64 with 4 games, the video game is"
" incredibly well polished and well cared",
category=seed_categories[3],
user=seed_users[0],
picture="dummy_product_1.jpg",
price=2399
),
Product(
title="Playstation One - Old school :D",
slug="playstation-one-old-school",
description="PsOne very well cared"
" nice to play some old school games",
category=seed_categories[6],
user=seed_users[0],
picture="dummy_product_2.jpg",
price=12999
),
Product(
def handle(self, *args, **options):
parser = ElementTree.XMLParser(encoding="utf-8")
productinorder = ProductInOrder.objects.all()
productinorder.delete()
productinbasket = ProductInBasket.objects.all()
productinbasket.delete()
product = Product.objects.all()
product.delete()
category = Category.objects.all()
category.delete()
manufacturer = Manufacturer.objects.all()
manufacturer.delete()
trans = str.maketrans(
"абвгдеёжзийклмнопрстуфхцчшщъыьэюяАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ",
"abvgdeejzijklmnoprstufhzcss_y_euaABVGDEEJZIJKLMNOPRSTUFHZCSS_Y_EUA"
)
tree = ElementTree.parse("./ImportExport/import.xml", parser=parser)
root = tree.getroot()
#print(root)
for element in root.iter(
"{urn:1C.ru:commerceml_210}Группа"): #Наименование категории
name = element[1].text
category = Category(name=name,
id1C=element[0].text,
url=slugify(name.translate(trans)))
category.save()
for element in root.iter("{urn:1C.ru:commerceml_210}Свойство"):
#print(element[1].text)
for elem in element.iter(
"{urn:1C.ru:commerceml_210}Справочник"): #Бренд
name = elem[1].text
manufact = Manufacturer(name=name,
id1C=elem[0].text,
slug=slugify(name.translate(trans)))
manufact.save()
for element in root.iter("{urn:1C.ru:commerceml_210}Товар"):
name = element.find("{urn:1C.ru:commerceml_210}Наименование").text
category = element.find("{urn:1C.ru:commerceml_210}Группы")
category_id = Category.objects.get(id1C=category[0].text)
brend = element.find("{urn:1C.ru:commerceml_210}ЗначенияСвойств")
if brend is not None:
brend_id = Manufacturer.objects.get(id1C=brend[0][1].text)
short_description = element.find(
"{urn:1C.ru:commerceml_210}Описание").text
country = element.find("{urn:1C.ru:commerceml_210}Страна")
if country is None:
country_text = ""
else:
country_text = country.text
weight = element.find("{urn:1C.ru:commerceml_210}Вес")
weight_float = 0
height = 0
width = 0
length = 0
if weight is not None:
weight_float = Decimal(weight.text)
for val_req in element.iter(
"{urn:1C.ru:commerceml_210}ЗначениеРеквизита"):
if val_req[0].text == 'Высота':
height = Decimal(val_req[1].text)
elif val_req[0].text == 'Ширина':
width = Decimal(val_req[1].text)
elif val_req[0].text == 'Длина':
length = Decimal(val_req[1].text)
#print(name, int(category_id.id), category_id.name, int(brend_id.id), brend_id.name)
product = Product(name=name,
id1C=element[0].text,
category=category_id,
short_description=short_description,
country=country_text,
weight=weight_float,
height=height,
width=width,
length=length,
manufacturer=brend_id,
url=slugify(name.translate(trans)))
product.save()
#print(element[0].text)
#print(name)
img = 1
is_main = True
if element.find("{urn:1C.ru:commerceml_210}Картинка") is not None:
for elem in element.iter("{urn:1C.ru:commerceml_210}Картинка"):
if elem is not None:
#product=Product.objects.get(id1C=element[0].text)
name_file = slugify(
product.name.translate(trans)) + str(img) + ".jpg"
shutil.copy("./ImportExport/" + elem.text,
"./product_images/" + name_file)
if img != 1:
is_main = False
prod_img = ProductImage(product=product,
image="product_images/" +
name_file,
is_main=is_main)
prod_img.save()
img = img + 1
else:
prod_img = ProductImage(product=product,
image="product_images/no_image.png",
is_main=is_main)
prod_img.save()
tree = ElementTree.parse("./ImportExport/offers.xml")
root = tree.getroot()
for element in root.iter("{urn:1C.ru:commerceml_210}Предложение"):
#rest_float=0
product = Product.objects.get(id1C=element[0].text)
for elem in element.iter("{urn:1C.ru:commerceml_210}Цена"):
price = elem.find("{urn:1C.ru:commerceml_210}ЦенаЗаЕдиницу")
if price is not None:
product.price = Decimal(price.text)
rest = element.find("{urn:1C.ru:commerceml_210}Количество")
if rest is not None:
product.rest = Decimal(rest.text)
product.save()
def add_model(request,model,template_name=""):
# show_model(request,model,template_name)
# print();
result = "";
if request.method == 'POST':
print('add')
if request.POST.get('mode')=='add_cart_item':
cart.add_to_cart(request)
cart_items_list = []
cart_items = cart.get_cart_items(request)
# serializers.serialize("json", )
cart_item_count = cart.cart_distinct_item_count(request)
# result = {'cart_items' : cart_items ,'cart_item_count' : cart_item_count}
# print(cart_item_count)
for c in cart_items:
# print(c)
item = {}
item.setdefault('image',c.image())
item.setdefault('name',c.name())
item.setdefault('quantity',c.quantity)
price = str(c.price())
item.setdefault('unit_price',price)
total = str(c.total())
item.setdefault('total_price',total)
item.setdefault('id',c.id)
# print(item)
cart_items_list.append(item)
# print(cart_items_list)
# cart_items = serializers.serialize("json", cart_items_list)
# print(cart_items)
result = {'cart_items' : cart_items_list ,'cart_item_count' : cart_item_count}
# print(json.dumps(result))
print('++++++++++++++++++++++++++++++')
return HttpResponse(json.dumps(result),content_type='application/javascript; charset=utf-8')
else:
if model == 'people':
name = request.POST.get('name')
islug = slug(name)
category = Category()
category.name = name
category.description = request.POST.get('description')
is_active = request.POST.get('is_active')
if is_active=="on":
category.is_active = True
else:
category.is_active = False
category.slug = islug
category.updated_at = datetime.datetime.now().strftime("%m/%d/%Y")
category.created_at = datetime.datetime.now().strftime("%m/%d/%Y")
category.save()
result = "saved"
print('add people')
elif model == 'subcategory':
subcategory = SubCategory()
subcategory.name = request.POST.get('name')
subcategory.description = request.POST.get('description')
subcategory.slug = slug(subcategory.name)
is_active = request.POST.get('is_active')
subcategory.updated_at = datetime.datetime.now().strftime("%m/%d/%Y")
subcategory.created_at = datetime.datetime.now().strftime("%m/%d/%Y")
if is_active=="on":
subcategory.is_active = True
else:
subcategory.is_active = False
subcategory.save()
selected_c = json.loads(request.POST.get('selected_categories'))
for s_c in selected_c:
c = get_object_or_404(Category, slug=s_c)
subcategory.categories.add(c)
subcategory.save()
print('add subcategory')
elif model == 'product':
p = Product()
postdata = request.POST.copy()
p.name = postdata.get('name','a')
product_name = postdata.get('name','a')
p.brand = postdata.get('brand')
p.sku = postdata.get('sku')
p.price = postdata.get('price')
p.old_price = postdata.get('old_price')
p.quantity = postdata.get('quantity')
p.description = postdata.get('description')
# print(postdata.get('user'))
user = get_object_or_404(MyUser, username=postdata.get('user'))
p.user = user
p.slug = slug(p.name)
is_active = request.POST.get('is_active')
if is_active=="on":
p.is_active = True
else:
p.is_active = False
p.updated_at = datetime.datetime.now().strftime("%m/%d/%Y")
p.created_at = datetime.datetime.now().strftime("%m/%d/%Y")
if request.FILES:
print('image_exist')
p_main_file=request.FILES['img']
file_extention = os.path.splitext(str(request.FILES['img']))[1]
# print(file_extention)
# file_name = str(request.FILES['img']).split('.')
# file_extention = file_name[len(file_name)-1]
image_name = str(user)+'_'+p.name+file_extention
p_thumbnail_file=request.FILES['img']
with open(MEDIA_ROOT+'images/products/thumbnails/'+image_name, 'wb+') as destination:
if p_thumbnail_file.multiple_chunks():
for chunk in p_thumbnail_file.chunks():
destination.write(chunk)
else:
destination.write(p_thumbnail_file.read())
with open(MEDIA_ROOT+'images/products/thumbnails/'+image_name, 'rb+') as destination:
image_file = destination.read()
with open(MEDIA_ROOT+'images/products/main/'+image_name, 'wb+') as destination:
destination.write(image_file)
p.image=image_name
else:
print('image_empty')
p.image='default'
p.save()
selected_subc = json.loads(request.POST.get('selected_subcategories'))
for p_subc in selected_subc:
subc = get_object_or_404(SubCategory, slug=p_subc)
p.subcategories.add(subc)
p.save()
print('add product')
elif model == 'myuser':
user = MyUser()
postdata = request.POST.copy()
user.username = postdata.get('name')
user.first_name = postdata.get('first_name')
user.last_name = postdata.get('last_name')
##########change date format###########YYYY-MM-DD
# date_of_birth = postdata.get('date_of_birth')
# date_list = date_of_birth.split('/')
# join_str = '-'
# user.date_of_birth = join_str.join(date_list)
user.date_of_birth = postdata.get('date_of_birth')
########################################
user.address = postdata.get('address','a')
user.telephone = postdata.get('telephone')
user.password = make_password(postdata.get('password'))
user.is_active = True
user.is_staff = True
user.save()
print('add myuser')
elif model == 'order':
order = Order()
postdata = request.POST.copy()
myuser = get_object_or_404(MyUser, username=postdata.get('user'))
print(postdata)
order.address = myuser.address
order.phone = myuser.telephone
order_status = get_object_or_404(OrderStatus, id=postdata.get('status'))
print(order_status.name)
order.status = order_status
order.ip_address = postdata.get('ip_address')
# user = get_object_or_404(MyUser, username=postdata.get('user'))
order.user = myuser
order.transaction_id = postdata.get('transaction_id')
order.last_updated = datetime.datetime.now().strftime("%m/%d/%Y")
order.save()
print(order.id);
cart_items = cart.get_cart_items(request)
for c in cart_items:
orderitem = OrderItem()
orderitem.product = c.product
orderitem.price = c.price()
orderitem.quantity = c.quantity
orderitem.order = order
orderitem.save()
print('add order')
elif model == 'orderitem':
orderitem = OrderItem()
postdata = request.POST.copy()
product = get_object_or_404(Product, slug=postdata.get('product'))
orderitem.product = product
orderitem.price = product.price
orderitem.quantity = postdata.get('quantity')
order = get_object_or_404(Order, id=postdata.get('order'))
orderitem.order = order
orderitem.save()
print('add orderitem')
# return show_model(request,model,'')
url = urlresolvers.reverse('model',kwargs = {'model':model})
return HttpResponseRedirect(url)
else:
app_list = permission_app(request)
# print('_________________addpermission_________________')
if check_permission(request,'add',model):
if model == 'people':
print('category')
elif model == 'subcategory':
category = Category.objects.all()
print('subcategory')
elif model == 'product':
user_list = MyUser.objects.all()
subcategory = SubCategory.objects.all()
print('product')
print(subcategory)
elif model == 'myuser':
print('myuser')
elif model == 'order':
cart.clean(request)
user_list = MyUser.objects.all()
product = Product.objects.all()
order_status = OrderStatus.objects.all()
# print(request.GET)
# print('-------------------------------')
# cart.add_to_cart(request)
# cart_items = serializers.serialize("json", cart.get_cart_items(request))
# cart_item_count = cart.cart_distinct_item_count(request)
# result = {'cart_items' : cart_items ,'cart_item_count' : cart_item_count}
# print(result)
# print('++++++++++++++++++++++++++++++=')
# return HttpResponse(json.dumps(result),content_type='application/javascript; charset=utf-8')
print('order')
elif model == 'orderitem':
product = Product.objects.all()
order_list = Order.objects.all()
print('orderitem')
# subcategories = SubCategory.objects.all()
template_name = 'myadmin/add/'+model+'.html'
return render_to_response(template_name, locals(),context_instance=RequestContext(request))
else:
template_name = 'myadmin/err.html'
return render_to_response(template_name, locals(),context_instance=RequestContext(request))
def product_add():
categories = Category.query.all()
product = Product()
form = ProductForm(obj=product)
# Set the categories to the form
form.category_id.choices = [(c.id, c.name) for c in
Category.query.order_by('name')]
if request.method == "POST":
if form.validate():
# populate Product obj with wtform data
form.populate_obj(product)
product.user_id = current_user.get_id()
product.slug = slugify(product.title)
f = form.picture.data
# renames the file to prevent duplicated names
filename = datetime.now().strftime(
'%Y%m%d%H%M%S') + secure_filename(f.filename)
filepath = os.path.join(
app.config["UPLOAD_FOLDER"], 'uploads', filename
)
f.save(filepath)
# @TODO Generate an image thumbnail
product.picture = filename
db_session.add(product)
try:
db_session.commit()
flash('Nice! You just added your product to sell :D', 'success')
redirect("/")
except exc.SQLAlchemyError:
db_session.rollback()
flash('Error! There was an error trying to save your product',
'danger')
else:
for field, errors in form.errors.items():
for error in errors:
flash(u"Error in the %s field - %s" % (
getattr(form, field).label.text,
error
))
return render_template(
'products/add.html',
categories=categories,
form=form
)
def test_productmodel(self):
product = Product(name='8 steaks hachés façon bouchère')
self.assertEqual(str(product), product.name)
def test_product_save(self):
product = Product(name='lyagushka',
img='lyagushka.jpg',
description='лягушка',
price=10000)
product.save()
def handle(self, *args, **option):
print('-' * 150)
with open('atmosfera.csv', 'r', encoding='utf-8') as file:
reader = csv.DictReader(file, delimiter=';')
index = 0
for row in reader:
if row['Название_позиции'] \
and row['Описание'] \
and row['Название_позиции'] != row['Описание']:
print(' ' * 50, index)
url = row['Ссылка_изображения'].split(',')[0]
product = Product()
product.title = row['Название_позиции']
product.slug = self.slugify(row['Название_позиции'])
product.meta_keywords = row['Ключевые_слова']
product.description = row['Описание']
product.active = True
product.save()
product.category.add(
Category.objects.get(
title='Альтернативная энергетика').pk)
if row.get('Атрибут_Гарантийный срок(мес.)'):
feature_1 = Feature(
title='Гарантия',
value=row['Атрибут_Гарантийный срок(мес.)'],
product=product,
)
feature_1.save()
if row.get('Атрибут_Вес(кг)'):
feature_2 = Feature(
title='Вес',
value=row['Атрибут_Вес(кг)'],
product=product,
)
feature_2.save()
if row.get('Страна_производитель'):
feature_3 = Feature(
title='Страна производитель',
value=row['Страна_производитель'],
product=product,
)
feature_3.save()
if url:
ext = self.get_file_ext(url)
filename = self.make_filename(product.pk, ext)
self.get_and_save_image(url, filename)
product.image = filename
product.save(update_fields=('image', ))
else:
product.delete()
index += 1
def do_import(self):
try:
rb = xlrd.open_workbook(self.xls_file.path)
sheet = rb.sheet_by_index(0)
self.log = ''
row_with_names = sheet.row_values(0)
row_with_identifiers = sheet.row_values(1)
cols_to_fields_map = {
col_num: col
for col_num, col in enumerate(row_with_identifiers)
}
reversed_product_types = {
type_str: type_value
for type_value, type_str in
settings.XLS_PRODUCT_TYPES_MAP.items()
}
id_col = None
for col, field in cols_to_fields_map.items():
if field == 'id':
id_col = col
break
else:
self.log = _('Id col missing')
self.save()
return
properties = {}
ppvs_to_create = []
if self.properties:
for col_num, col in enumerate(row_with_identifiers):
if cols_to_fields_map[col_num].startswith('prop_'):
property_uuid = cols_to_fields_map[col_num].split(
'prop_')[-1]
if not property_uuid:
index = 1
initial_slug = slugify(
row_with_names[col_num].split('###')[0])
slug = initial_slug
while Property.objects.filter(slug=slug).exists():
slug = f'{initial_slug}_{index}'
index += 1
prop_lang_names = \
row_with_names[col_num].split('###')
prop_names = {}
for lang_index, lang in enumerate(
settings.LANGUAGES):
try:
prop_names['name_%s' % lang[0]] = \
prop_lang_names[lang_index]
except IndexError:
pass
prop = Property.objects.create(slug=slug,
**prop_names)
else:
try:
prop = Property.objects.get(uuid=property_uuid)
except Property.DoesNotExist:
self.log += _(
f'Property {row_with_names[col_num]} does not exist, ignored\n'
).__str__()
continue
properties[col_num] = prop
# get product_type field col_num
product_type_col = None
for col_num, col in enumerate(row_with_identifiers):
if col == 'product_type':
product_type_col = col_num
break
else:
self.log = _('Product type col missing')
self.save()
return
rows_for_ptypes = defaultdict(list)
for rownum in range(2, sheet.nrows):
row = sheet.row_values(rownum)
ptype = reversed_product_types[row[product_type_col]]
rows_for_ptypes[ptype].append(row)
sorted_rows = []
for ptype in [PRODUCT_WITH_VARIANTS, VARIANT, STANDARD_PRODUCT]:
sorted_rows.extend(rows_for_ptypes[ptype])
for row in sorted_rows:
product_id = row[id_col]
if product_id:
product_id = int(product_id)
try:
product = Product.objects.get(id=product_id)
except Product.DoesNotExist:
self.log += _(
f'Product with ID:({product_id}) does not exist\n'
).__str__()
continue
except Product.MultipleObjectsReturned:
self.log += _(
f'Product with ID:({product_id}) repeats multiple times, skipped\n'
).__str__()
continue
else:
product = Product()
ppvs = {}
skip_product = False
for col_num, col in enumerate(row):
field = cols_to_fields_map[col_num]
value = self.get_converted_field_value(col)
if field.startswith('name_'):
value = str(value).replace('.0', '')
if field == 'id':
continue
elif field == 'status__name_ru':
try:
status = ProductStatus.objects.get(name_ru=value)
except ProductStatus.DoesNotExist:
self.log += _(
f'Product status {col} does not exist, product ID:({product_id}) skipped\n'
).__str__()
skip_product = True
break
product.status = status
elif field == 'product_type':
if value not in reversed_product_types:
self.log += _(
f'Invalid type {value} for product ID:({product_id}), product skipped\n'
).__str__()
skip_product = True
break
product.product_type = reversed_product_types[value]
elif field.startswith('prop_') and self.properties:
prop = properties.get(col_num)
if prop is None:
continue
ppvs[prop] = value
elif getattr(self, field, True):
if field == 'parent_id':
# parent_id is parent name
if value and isinstance(value, str):
try:
product.parent_id = Product.objects.get(
name=value).id
except Product.DoesNotExist:
self.log += _(
f'Parent product with Name:({value}) does not exist, product skipped\n'
).__str__()
skip_product = True
break
except Product.MultipleObjectsReturned:
self.log += _(
f'Parent product with Name:({value}) repeats multiple times, product skipped\n'
).__str__()
skip_product = True
break
continue
setattr(product, field, value)
if skip_product:
continue
if (product.product_type == VARIANT
and not product.parent_id) or\
(product.product_type in
[PRODUCT_WITH_VARIANTS, STANDARD_PRODUCT]
and product.parent_id):
self.log += _(
f'Invalid type for product ID:({product_id}), product skipped\n'
).__str__()
continue
if not product.name:
self.log += _(
f'Product name must be set for ID:({product_id}), skipped\n'
).__str__()
continue
if not product_id:
if Product.objects.filter(name=product.name).exists():
self.log += _(
f'Product with name {product.name} already exists, skipped\n'
).__str__()
continue
index = 1
initial_slug = slugify(product.name)
slug = initial_slug
while Product.objects.filter(slug=slug).exists():
slug = f'{initial_slug}_{index}'
index += 1
product.slug = slug
product.active = True
product.save()
if product_id:
ppvs_objects = ProductPropertyValue.objects.filter(
product_id=product.id,
property__in=ppvs.keys()).select_related('property')
for ppv in ppvs_objects:
if not ppvs.get(ppv.property):
ppv.delete()
continue
ppv_lang_values = ppvs[ppv.property].split('###')
update_fields = []
for lang_index, lang in enumerate(settings.LANGUAGES):
lang_value_field = 'value_%s' % lang[0]
try:
lang_value = ppv_lang_values[lang_index]
if getattr(ppv, lang_value_field) != \
lang_value:
setattr(ppv, lang_value_field, lang_value)
update_fields.append(lang_value_field)
except IndexError:
setattr(ppv, lang_value_field, '')
update_fields.append(lang_value_field)
ppv.save(update_fields=update_fields)
ppvs.pop(ppv.property)
for prop, ppv in ppvs.items():
if ppv:
lang_values = {}
ppv_lang_values = ppvs[prop].split('###')
for lang_index, lang in enumerate(settings.LANGUAGES):
try:
lang_values['value_%s' % lang[0]] = \
ppv_lang_values[lang_index]
except IndexError:
pass
ppvs_to_create.append(
ProductPropertyValue(product=product,
property=prop,
slug_value=slugify(
str(ppv_lang_values[0])),
**lang_values))
ProductPropertyValue.objects.bulk_create(ppvs_to_create)
except:
exc = traceback.format_exc()
self.log = exc
self.save()
def handle(self, *args, **options):
print("Add products")
file_name = os.path.join(settings.BASE_DIR, 'termos.xls')
book = xlrd.open_workbook(file_name)
sh = book.sheet_by_index(0)
print("{0} {1} {2}".format(sh.name, sh.nrows, sh.ncols))
print("Cell D30 is {0}".format(sh.cell_value(rowx=29, colx=5)))
_root, _ = Category.objects.get_or_create(name='_root',
slug='root',
parent=None)
categories = set()
products = []
artikuls = []
for rx in range(sh.nrows):
if rx == 0:
continue
curr_cat = sh.cell_value(rowx=rx, colx=5)
categories.add(curr_cat)
product_name = sh.cell_value(rowx=rx, colx=1)
product_artikul = sh.cell_value(rowx=rx, colx=0)
img_url = sh.cell_value(rowx=rx, colx=15)
price_opt = sh.cell_value(rowx=rx, colx=16)
price = sh.cell_value(rowx=rx, colx=17)
old_price = sh.cell_value(rowx=rx, colx=18)
products.append({
'name': product_name,
'artikul': product_artikul,
'img_url': img_url,
'price_opt': price_opt,
'price': price,
'old_price': old_price,
'category_name': curr_cat,
'category_slug': slugify(curr_cat),
})
for category in categories:
sl_curr_cat = slugify(category)
ext_cat = Category.objects.filter(slug=sl_curr_cat).first()
if not ext_cat:
new_cat = Category()
new_cat.name = category
new_cat.slug = sl_curr_cat
new_cat.parent = _root
new_cat.save()
for prod in products:
# print(prod.get('name'))
try:
artikul = prod.get('artikul')
ext_prod = Product.objects.filter(artikul=artikul).first()
if not ext_prod:
need_category = Category.objects.filter(
slug=prod.get('category_slug')).first()
# print(need_category)
new_prod = Product()
new_prod.name = prod.get('name')
new_prod.slug = slugify(prod.get('name'))
new_prod.artikul = artikul
new_prod.category = need_category
new_prod.save()
print(new_prod.pk)
else:
ext_prod.price_opt = prod.get('price_opt')
ext_prod.price = prod.get('price')
ext_prod.old_price = prod.get('old_price')
if not ext_prod.img:
ext_prod.img = self.add_image(prod.get('img_url'))
ext_prod.save()
except Exception as e:
print(str(e))
def add_product(request, template_name=""):
mode = 'user_products'
currency_symbol = request.session.get('currency_symbol', '$')
currency_rate = request.session.get('currency_rate', 1)
products = Product.objects.filter(user=request.user)
product_list = products
for p_item in products:
p_item.price /= Decimal(currency_rate)
p_item.price = math.floor(p_item.price * 100) / 100
active_category = 'user_products'
if request.method == 'POST':
if (request.GET.get('post_mode') != 'currency'):
p = Product()
postdata = request.POST.copy()
p.name = postdata.get('name', 'a')
product_name = postdata.get('name', 'a')
p.brand = postdata.get('brand')
p.sku = postdata.get('sku')
p.price = postdata.get('price')
p.quantity = postdata.get('quantity')
p.description = postdata.get('description')
p.user = request.user
######################make slug string###############
product_name = product_name.lower()
p_n_list = product_name.split(' ')
join_str = '-'
product_name = join_str.join(p_n_list)
slug = ""
count = 0
p_n = ''
while (count < len(product_name)):
p_n = product_name[count]
if p_n.isdigit() or p_n.isalpha() or p_n == '-':
slug += p_n
count += 1
p.slug = slug
#####################################################
if request.FILES:
p_main_file = request.FILES['img']
file_extention = os.path.splitext(str(request.FILES['img']))[1]
# print(file_extention)
# file_name = str(request.FILES['img']).split('.')
# file_extention = file_name[len(file_name)-1]
image_name = str(request.user) + '_' + p.name + file_extention
p_thumbnail_file = request.FILES['img']
with open(
MEDIA_ROOT + 'images/products/thumbnails/' +
image_name, 'wb+') as destination:
if p_thumbnail_file.multiple_chunks():
for chunk in p_thumbnail_file.chunks():
destination.write(chunk)
else:
destination.write(p_thumbnail_file.read())
with open(
MEDIA_ROOT + 'images/products/thumbnails/' +
image_name, 'rb+') as destination:
image_file = destination.read()
with open(MEDIA_ROOT + 'images/products/main/' + image_name,
'wb+') as destination:
destination.write(image_file)
p.image = image_name
else:
p.image = p.name
p.save()
print(p.subcategories)
subc = get_object_or_404(SubCategory, slug='personal-products')
p.subcategories.add(subc)
p.save()
url = urlresolvers.reverse('account_user_products')
return HttpResponseRedirect(url)
return render_to_response(template_name,
locals(),
context_instance=RequestContext(request))
