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