def post(self, product_id=None, **kwargs):
"""Handle submitted form data"""
# validate form
if self.form.validate():
name = self.form.name.data
description = self.form.description.data
price = self.form.price.data
unit = self.form.unit.data
live = self.form.live.data
tags = self.form.tags.data
language = self.form.language.data
if tags is not None:
tags = [tag.strip() for tag in tags.split(',') if tag != '']
# save edit form
if product_id:
product = Product.get_by_id(product_id)
product.name = name
product.description = description
product.price = price
product.unit = unit
product.live = live
product.tags = tags
product.language = language
# save new form
else:
product = Product(name=name,
description=description,
price=price,
unit=unit,
live=live,
tags=tags,
language=language)
if product.put():
return redirect('/admin/shop/products/')
return self.get(**kwargs)
def products_dates_json(request):
date1 = request.values.get("from_date")
date2 = request.values.get('to_date')
if date1 is None:
ApiException('Invalid request: parameter "from_date" not found.')
date1 = datetime.strptime(date1, '%Y-%m-%d')
if date2 is None:
date2 = datetime.now()
else:
date2 = datetime.strptime(date2, '%Y-%m-%d')
ApiException(date2)
is_new = request.values.get('only_new')
if is_new is None:
products_q = Product.query(
Product.timestamp_edit >= date1,
Product.timestamp_edit <= date2).fetch(keys_only=True)
else:
products_q = Product.query(
Product.timestamp_add >= date1,
Product.timestamp_add <= date2).fetch(keys_only=True)
res = {
'success': True,
'result': [key.id() for key in products_q]
}
return render_json_response(res)
def products(request):
categories = Category.query(Category.available == True, Category.only_end_products == True).order(Category.title).fetch()
if request.user and request.user.is_admin:
products_obj = Product.query().order(-Product.rating).fetch(20)
else:
products_obj = Product.query().filter(Product.available == True).order(-Product.rating).fetch(20)
return render_to_response('shop/products.html', {'products':products_obj, 'categories':categories})
def filter_value(request):
is_available = bool(request.values.get('available'))
value_key = request.values.get('value')
products = []
if value_key:
value_ = ProductPropertyValue.get_by_id(int(value_key))
if is_available:
products = value_.get_available_products()
else:
products = value_.get_not_available_products()
else:
if is_available:
products_tmp = Product.available_list()
products = []
for prop in products_tmp:
if not prop.properties_:
products.append(prop)
else:
products_tmp = Product.not_available_list()
products = []
for prop in products_tmp:
if not prop.properties_:
products.append(prop)
return render_to_response('shop/admin/product_filter.html', {
'products':products,
'available':is_available
})
def post(self, product_id=None, **kwargs):
"""Handle submitted form data"""
# validate form
if self.form.validate():
name = self.form.name.data
description = self.form.description.data
price = self.form.price.data
unit = self.form.unit.data
live = self.form.live.data
tags = self.form.tags.data
language = self.form.language.data
if tags is not None:
tags = [tag.strip() for tag in tags.split(',') if tag != '']
# save edit form
if product_id:
product = Product.get_by_id(product_id)
product.name = name
product.description = description
product.price = price
product.unit = unit
product.live = live
product.tags = tags
product.language = language
# save new form
else:
product = Product(name=name, description=description, price=price, unit=unit, live=live, tags=tags, language=language)
if product.put():
return redirect('/admin/shop/products/')
return self.get(**kwargs)
def get(self, tag=None, **kwargs):
language = self.get_locale()
if tag is None:
products = Product.get_latest_products(10, language=language)
else:
products = Product.get_products_by_tag(tag, language=language)
context = {'products': products, 'tag': tag}
return render_response('feed/product.xml', **context)
def create_product(request):
model = simplejson.loads(request.data)
try:
new_product = Product(title=model['title'])
new_product.put()
except Exception, e:
data = {'api_success':False, 'api_msg':str(e)}
return render_json_response(data, status=400)
def constructor(request):
categories = Category.query(Category.available == True, Category.only_end_products == False).order(Category.title)
products_obj = None
if categories.count():
if request.user and request.user.is_admin:
products_obj = Product.query(Product.category==categories.get().key).order(-Product.rating).fetch(20)
else:
products_obj = Product.query(Product.category==categories.get().key).filter(Product.available == True).order(-Product.rating).fetch(20)
return render_to_response('shop/constructor.html', {'products':products_obj, 'categories':categories.fetch()})
def get_category(request, id):
cat_obj = Category.get_by_id(id)
if not cat_obj:
return redirect(url_for('shop/index'))
categories = Category.query(Category.available == True, Category.only_end_products == True).fetch()
if request.user and request.user.is_admin:
products_obj = Product.query().filter(Product.category == cat_obj.key).order(-Product.rating).fetch()
else:
products_obj = Product.query().filter(Product.category == cat_obj.key).filter(Product.available == True).order(-Product.rating).fetch()
return render_to_response('shop/category.html', {'category':cat_obj, 'products':products_obj, 'categories':categories})
def get(self, tag=None, **kwargs):
language = self.get_locale()
if tag is None:
products = Product.get_latest_products(10, language=language)
else:
products = Product.get_products_by_tag(tag, language=language)
context = {
'products': products,
'tag': tag
}
return render_response('feed/product.xml', **context)
def on_update(self, instance: models.Product, new_validated_data: dict):
new_product_category = new_validated_data.get("category")
if new_product_category:
instance.increment_category()
new_product_subcategories = new_validated_data.get("subcategories")
if new_product_subcategories:
new_product_subcategory_names = [
product_subcategory["name"]
for product_subcategory in new_product_subcategories
]
instance.increment_subcategories(new_product_subcategory_names)
def filter_brand(request):
is_available = bool(request.values.get('available', False))
brand_key = request.values.get('brand')
if brand_key:
brand = Brand.get_by_id(int(brand_key))
products = Product.query().filter(Product.brand == brand.key).filter(Product.available == is_available)
else:
products = Product.query().filter(Product.brand == None).filter(Product.available == is_available)
return render_to_response('shop/admin/product_filter.html', {
'products':products,
'available':is_available
})
def products_count_json(request):
available = request.values.get('available', None)
if available is None:
count = Product.query().count()
else:
if available.lower() == 'true':
count = Product.query(Product.available == True).count()
else:
count = Product.query(Product.available == False).count()
return render_json_response({
'success': True,
'result': count
})
def get(self, product_id=None, **kwargs):
"""Return a product to edit or an empty form to create"""
template = 'admin/product/new.html'
files = get_files()
#print self.form.photo.choices
context = {
'files': files,
'form': self.form,
}
# render edit form
if product_id is not None:
product = Product.get_by_id(product_id)
if product:
self.form = ProductForm(obj=product)
self.form.tags.data = ', '.join(product.tags)
product_photo = ''
if product.photo:
product_photo = product.photo.key().id()
context.update({ 'form': self.form, 'product_photo': product_photo })
template = 'admin/product/edit.html'
else:
return redirect('/admin/shop/')
# render new form
return self.render_response(template, **context)
def product_json(request, product_id):
product = Product.get_by_id(product_id)
if not product:
return render_json_response({
'api':{
'success': False,
'msg': 'Product %s not found' % product_id
}
}, status=400)
if request.method == 'GET':
return get_product(product)
if request.method == 'DELETE':
return delete_product(request, product)
if request.method == 'PUT':
return put_product(request, product)
return render_json_response({
'api':{
'success':False,
'msg': 'Request method %s not supported' % request.method
}
}, status=400)
def add_image(request, name):
product_ = Product.get_by_id(name)
if not product_:
return render_json_response({'api_success':False,
'api_msg':'Product %s not found' % name},
status=400)
if request.method == 'POST':
try:
upload_files = get_uploads(request, 'file')
blob_info = upload_files[0]
im = Image.create(blob_info.key(), title=product_.title)
if not len(product_.images):
im.is_master = True
if im.get_cached_url():
product_.images.append(im)
product_.put()
api_upload_img_url = blobstore.create_upload_url(
url_for('shop/admin/product/upload_img',
name=product_.key.id()))
return render_json_response(
{'api_success':True,
'api_msg':'Image uploaded',
'api_upload_img_url':api_upload_img_url,
'img': im.to_json()})
else:
return render_json_response(
{'api_success':False,
'api_msg':'Invalid image'})
except Exception, e:
return render_json_response(
{'api_success':False,
'api_msg':str(e)}, status=400)
def get(self, **kwargs):
products = Product.all().order('-modified')
result = products.fetch(10)
context = {
'products': result,
}
return self.render_response('admin/shop/index.html', **context)
def get(self, **kwargs):
products = Product.all().order('-modified')
result = products.fetch(10)
context = {
'products': result,
}
return self.render_response('admin/shop/index.html', **context)
def create(data):
product_id= data.get('product_id', '')
product = Product.get_by_id(product_id)
if not product:
res = { 'api_success':False,
'api_msg':'Product %s not found' % product_id,
'api_function': create.__name__}
logging.warning(res)
return render_json_response(res)
image64 = data.get('image_data', '')
if not image64:
res = {'api_success': False, 'api_msg': 'Image data not found'}
logging.warning(res)
return render_json_response(res)
image64 = base64.decodestring(image64)
im = Image.create_from_data(image64, title=product.title)
if im.get_cached_url():
if product.master_image is None:
im.is_master = True
product.images.append(im)
product.put()
res = {'api_success': True, 'api_msg': 'Image uploaded'}
logging.info(res)
else:
res = {'api_success':False,
'api_msg':'Invalid image'}
logging.warning(res)
return render_json_response(res)
def get_products(request):
products = memcache.get("json_products")
if not products:
products = Product.query().fetch()
products = [product.to_json() for product in products]
memcache.add("json_products", products, 600)
return render_json_response(products)
def products_json(request):
available = request.values.get('available', None)
if available is None:
products_q = Product.query()
else:
if available.lower() == 'true':
products_q = Product.query(Product.available == True)
else:
products_q = Product.query(Product.available == False)
is_1c = request.values.get('id_1c')
if is_1c:
products = [product.id_1c for product in products_q.fetch(projection=[Product.id_1c])]
else:
products = [key.id() for key in products_q.fetch(keys_only=True)]
return render_json_response({
'success': True,
'result': products
})
def delete(request, key):
product_ = Product.get_by_id(key)
if product_:
product_.pre_delete()
product_.key.delete()
back_url = request.values.get('back_url')
if back_url:
return redirect(back_url)
return redirect(url_for('shop/admin/product'))
def get(self, **kwargs):
language = self.get_locale()
products = Product.get_latest_products(3, language=language)
posts = BlogPost.get_latest_posts(5, language=language)
context = {
'products': products,
'posts': posts,
'language': language,
}
return self.render_response('pages/welcome.html', **context)
def get(self, **kwargs):
language = self.get_locale()
products = Product.get_latest_products(3, language=language)
posts = BlogPost.get_latest_posts(5, language=language)
context = {
'products': products,
'posts': posts,
'language': language,
}
return self.render_response('pages/welcome.html', **context)
def create(self, validated_data):
category = validated_data.pop('category')
subcategories = validated_data.pop('subcategories')
photos = validated_data.pop('photos', [])
store = self.context['request'].user.seller.store
with transaction.atomic():
category = self._get_or_create_category(category)
validated_data.update({"category": category, "store": store})
product = Product(**validated_data)
product.save()
self._get_or_create_subcategories(product, subcategories)
self._get_or_create_photos(product, photos)
return product
def index(request):
available_product = Product.query(Product.available == True, Product.id_1c != '').get()
if not available_product:
available_product = Product.query().get()
if available_product:
available_product = available_product.key.id()
else:
available_product = 1024
available_union = Union.query(Union.available == True).get()
if not available_union:
available_union = Union.query().get()
if available_union:
available_union = available_union.key.id()
else:
available_union = 1025
return render_to_response('api/v3/index.html', {
'available_product': available_product,
'available_union': available_union
})
def filter_category(request):
is_available = request.values.get('available', '0')
is_available = is_available.lower() in ["1", "true", "yes"]
category_id = request.values.get('category')
if category_id:
category = Category.get_by_id(int(category_id))
if is_available:
products = category.get_available_products()
else:
products = category.get_not_available_products()
else:
if is_available:
products = Product.query().filter(Product.available == True).filter(Product.category == None)
else:
products = Product.query().filter(Product.available != True).filter(Product.category == None)
return render_to_response('shop/admin/product_filter.html', {
'products':products,
'available':is_available
})
def product_json(request):
key_id = request.values.get('id')
id_1c = request.values.get('id_1c')
if not key_id and not id_1c:
raise ApiException('Invalid request: "id" or "id_1c" params not found.')
if key_id is not None and id_1c is not None:
raise ApiException('Invalid request: "id" and "id_1c" together.')
product = None
if key_id:
product = Product.get_by_id(int(key_id))
if id_1c:
product = Product.query(Product.id_1c == id_1c).get()
if not product:
if key_id:
raise ApiException('Product with "%s" == %s not found' % ('id', key_id), status=404)
raise ApiException('Product with "%s" == %s not found' % ('id_1c', id_1c), status=404)
return render_json_response({
'success': True,
'result': product.to_json_api()
})
def get(self, **kwargs):
language = self.get_locale()
product = Product.get_promoted_product(language=language)
posts = BlogPost.get_latest_posts(5, language=language)
offer = Offer.get_latest_offer(language=language)
context = {
'product': product,
'posts': posts,
'offer': offer,
'format_currency': i18n.format_currency,
'language': language,
}
return self.render_response('pages/welcome.html', **context)
def set_properties(request, key):
product_ = Product.get_by_id(key)
if not product_:
return redirect(url_for('shop/admin/product'))
if request.method == 'POST':
selected_values = request.form.getlist('values')
product_.properties_ = []
for value in selected_values:
val_obj = ProductPropertyValue.get_by_id(value)
if val_obj:
product_.properties_.append(val_obj.key())
product_.put()
return redirect(url_for('shop/admin/product/edit', key=key))
def product(request):
all_product = Product.available_list()
all_hide_product = Product.not_available_list()
available_product_without_properties_count = 0
for pr in all_product:
if not len(pr.properties_):
available_product_without_properties_count += 1
unavailable_product_without_properties_count = 0
for pr in all_hide_product:
if not len(pr.properties_):
unavailable_product_without_properties_count += 1
brand_all_available_product = Product.available_list().filter(Product.brand != None)
logging.warning(brand_all_available_product.count())
brand_all_not_available_product = Product.not_available_list().filter(Product.brand != None)
no_brand_all_available_product_count = Product.available_list().filter(Product.brand == None).count()
no_brand_all_not_available_product_count = Product.not_available_list().filter(Product.brand == None).count()
available_brand = {}
for product_ in brand_all_available_product:
if not product_.brand in available_brand:
count = Product.available_list().filter(Product.brand == product_.brand).count()
available_brand[product_.brand] = count
not_available_brand = {}
for product_ in brand_all_not_available_product:
if not product_.brand in not_available_brand:
count = Product.not_available_list().filter(Product.brand == product_.brand).count()
not_available_brand[product_.brand] = count
categories = Category.query(Category.parent_category == None).order(Category.title)
properties = ProductProperty.query().order(ProductProperty.title)
brands = Brand.query().order(Brand.title)
available_uncategories = all_product
available_uncategories = available_uncategories.filter(Product.category == None)
unavailable_uncategories = all_hide_product
unavailable_uncategories = unavailable_uncategories.filter(Product.category == None)
return render_to_response('shop/admin/product.html',
locals()
)
def get_product(request, name):
if request.method == 'GET':
try:
product_obj = Product.get_by_id(name)
if product_obj:
data = {'api_success': True,
'api_msg':"Product %s found" % name }
data.update(product_obj.to_json())
return render_json_response(data)
else:
data = {'api_success': False,
'api_msg':"Product %s not found" % name }
return render_json_response(data, status = 404)
except Exception, e:
return render_json_response({'api_success':False,
'api_msg':str(e)})
def cart_item_to_json(item_id, count):
cart_item = {}
product = Product.get_by_id(item_id)
if not product:
product = Union.get_by_id(item_id)
if product:
cart_item['id'] = item_id
cart_item['title'] = product.title
cart_item['url'] = product.url
if product.master_image:
cart_item['img_url'] = product.master_image.get_url()
else:
cart_item['img_url'] = ""
cart_item['price'] = product.price
cart_item['count'] = count
return cart_item
def get(self, product_id=None, **kwargs):
"""Return a product to edit or an empty form to create"""
template = 'admin/product/new.html'
context = {
'form': self.form,
}
# render edit form
if product_id is not None:
product = Product.get_by_id(product_id)
if product:
self.form = ProductForm(obj=product)
self.form.tags.data = ', '.join(product.tags)
context.update({'form': self.form})
template = 'admin/product/edit.html'
else:
return redirect('/admin/shop/')
# render new form
return self.render_response(template, **context)
def get(self, product_id=None, **kwargs):
"""Return a product to edit or an empty form to create"""
template = 'admin/product/new.html'
context = {
'form': self.form,
}
# render edit form
if product_id is not None:
product = Product.get_by_id(product_id)
if product:
self.form = ProductForm(obj=product)
self.form.tags.data = ', '.join(product.tags)
context.update({ 'form': self.form })
template = 'admin/product/edit.html'
else:
return redirect('/admin/shop/')
# render new form
return self.render_response(template, **context)
def api_union(request, id):
union = Union.get_by_id(id)
if not union:
return render_json_response({"api": {"success": False, "msg": "Product %s not found" % id}}, status=400)
if request.method == "GET":
return render_json_response(union.to_json())
if request.method == "PUT":
model = simplejson.loads(request.data)
if type(model) != dict:
return render_json_response(
{"api": {"success": False, "msg": "Invalid data", "data": request.data}}, status=500
)
union.title = model.get("title", "")
union.uid = model.get("uid", "")
union.description = model.get("description", "")
union.available = model.get("available", False)
union.custom_price = model.get("price", 0.0)
products = model.get("products", [])
del union.products[:]
for product in products:
product = Product.get_by_id(product["id"])
if product:
union.products.append(product.key)
union.put()
return render_json_response(union.to_json())
if request.method == "DELETE":
for image in union.images:
image.pre_delete()
union.key.delete()
return render_json_response({"api": {"success": True, "msg": "Union %s was deleted" % id}})
return render_json_response(
{"api": {"success": False, "msg": "Request method %s not supported" % request.method}}, status=400
)
def get_image(request, product_name, img_key):
product_ = Product.get_by_id(product_name)
if not product_:
res = {'api_success': False,
'api_msg':'Product %s not found' % product_name}
logging.warning(res)
return render_json_response(res)
if request.method == 'DELETE':
for image in product_.images:
if image.uid == img_key:
master = False
if image.is_master:
master = True
image.pre_delete()
product_.images.remove(image)
if master and len(product_.images):
new_master = product_.images[0]
new_master.is_master = True
product_.put()
data = {'api_success': True, 'api_msg': 'Image %s deleted' % img_key}
return render_json_response(data)
if request.method == 'PUT':
model = simplejson.loads(request.data)
is_master = model.get('is_master', False)
if is_master:
old_master = None
for image in product_.images:
if image.is_master:
old_master = image
for image in product_.images:
if image.uid == img_key:
image.is_master = True
old_master.is_master = False
product_.put()
return render_json_response({'api_success': True,
'api_msg': 'Image %s updated'})
def get(self, **kwargs):
products = Product.get_latest_products(10, False)
context = {
'products': products,
}
return self.render_response('admin/product/index.html', **context)
def on_create(self, instance: models.Product):
instance.increment_category()
instance.increment_subcategories()
