def test_product_well_defined(self):
product_sku = 1
product = Product(sku_id=product_sku, description='Butter', price=1.0)
product.save()
product_test = Product.objects.get(sku_id=product_sku)
assert product_test.description == product.description
assert product_test.price == product.price
def mutate(self, info, name):
try:
product = Product(name=name)
product.save()
return CreateProduct(success=True, product=product)
except Exception as err:
return CreateProduct(success=False, errors=['exception', str(err)])
def post(self, request, *args, **kwargs):
subCategoryId = request.data.get('subCategoryId',None)
product_name = request.data.get('product_name',None)
amount = request.data.get('amount',None)
print(subCategoryId, product_name, amount)
sub_category = ProductSubCategory.objects.get(pk=subCategoryId)
product = Product(sub_category=sub_category,product_name=product_name, amount=amount)
product.save()
return Response(status=HTTP_201_CREATED)
def asin_submit(request):
# if not UserSettings.objects.get(user=request.user).status in ABOVE_V1:
# messages.success(request, '请购买VIP后继续使用网站功能.')
# return redirect('/recharge')
detail_to_user = Product_to_user.objects.filter(user=request.user,detail=True)
asin_details = detail_to_user.values_list('asin', flat=True)
asin_details = Product.objects.filter(id__in=asin_details)
form = Asin_detail_Form()
if 'asins_in' in request.POST:
form = Asin_detail_Form(data=request.POST or None)
print(request.POST,form.is_valid())
if form.is_valid():
new_asin = form.save(commit=False)
for asin in new_asin.asins_in.splitlines():
if not Product.objects.filter(asin=asin,country=new_asin.country,detail=True):
if Product.objects.filter(asin=asin,country=new_asin.country):
product=Product.objects.filter(asin=asin,country=new_asin.country)[0]
product.detail=True
product.save()
else:
product=Product(asin=asin,country=new_asin.country,detail=True)
product.save()
if not Product_to_user.objects.filter(asin=product,user=request.user,detail=True):
detail_to_user=Product_to_user(asin=product,user=request.user,detail=True)
detail_to_user.save()
else:
product=Product.objects.get(asin=asin,country=new_asin.country,detail=True)
if not Product_to_user.objects.filter(asin=product,user=request.user,detail=True):
if Product_to_user.objects.filter(asin=product,user=request.user):
detail_to_user=Product_to_user.objects.get(asin=product,user=request.user)
detail_to_user.detail=True
detail_to_user.save()
else:
detail_to_user=Product_to_user(asin=product,user=request.user,detail=True)
detail_to_user.save()
messages.success(request, '查询任务已经保存,稍后开始为您查询.')
return redirect('/asin_detail/')
elif 'delete' in request.POST:
products=Product.objects.filter(pk__in=request.POST.getlist('delete'))
Product_to_user.objects.filter(asin__in=products,user=request.user).prefetch_related().update(detail=False)
return redirect('/asin_detail/')
paginator = Paginator(asin_details, 200)
page = request.GET.get('page')
try:
asin_detail_page = paginator.page(page)
except PageNotAnInteger:
asin_detail_page = paginator.page(1)
except EmptyPage:
asin_detail_page = paginator.page(paginator.num_pages)
return render(request, 'crawler/asin_detail/asin_submit.html', {'form':form,'asin_details': asin_detail_page,})
def test_product_name(self):
group, _ = (Group.objects.get_or_create(description='Ferramentas'))
product = Product()
product.description = 'Alicate de Pressão'
product.group = group
product.price = 10
product.status = Product.ACTIVE
product.save()
self.assertEqual(product.description, str(product))
def test_unique_sku(self):
product_a = Product()
product_a.name = 'a'
product_a.sku = 'a'
product_a.save()
product_b = Product()
product_b.name = 'a'
product_b.sku = 'a'
with self.assertRaises(IntegrityError):
with transaction.atomic():
product_b.save()
def update(product_id):
p = openfoodfacts.products.get_product(str(product_id))
off_link = 'https://fr.openfoodfacts.org/produit/'
updated = Product(
id=product_id,
name=p['product']['product_name'],
ng=p['product']['nutrition_grades'],
img=p['product']['selected_images']['front']['display']['fr'],
link_off=off_link + str(product_id),
energy=p['product']['nutriments']['energy_100g'],
fat=p['product']['nutriments']['fat_100g'],
saturated_fat=p['product']['nutriments']['saturated-fat_100g'],
carbohydrate=p['product']['nutriments']['carbohydrates_100g'],
sugars=p['product']['nutriments']['sugars_100g'],
proteins=p['product']['nutriments']['proteins_100g'],
salt=p['product']['nutriments']['salt_100g'])
updated.save()
def handle_noargs(self, *args, **kwargs):
print "fetching product list"
f = urllib2.urlopen(URL)
products = json.loads(f.read())
for (i, product_data) in enumerate(products):
try:
product = Product.objects.get(fairtrade_org_uk_key=product_data['key'])
except Product.DoesNotExist:
product = Product(fairtrade_org_uk_key=product_data['key'])
if product_data['manufacturer'] == 'N/A':
manufacturer = None
else:
manufacturer, created = BusinessEntity.objects.get_or_create(name=product_data['manufacturer'])
category = None
# walk down category tree
for category_name in product_data['category'].split('/'):
if not category:
try:
category = ProductCategory.get_root_nodes().get(name=category_name)
except ProductCategory.DoesNotExist:
category = ProductCategory.add_root(name=category_name)
else:
try:
category = category.get_children().get(name=category_name)
except ProductCategory.DoesNotExist:
category = category.add_child(name=category_name)
product.name = product_data['name']
product.manufacturer = manufacturer
product.category = category
if product_data['description']:
product.description = product_data['description']
if product_data['url']:
product.url = product_data['url']
product.save()
if i % 100 == 0:
print "imported %d products" % i
def form_valid(self, request, form, files):
""" Enters here iff form is valid in the post() method """
print(request.user)
tags = form.cleaned_data[
'tags'] # Returns a string representation of a dictionaries: [{"value":"i'm_a_tag"},{"value":"tag_me"}]
tags = json.loads(tags) # Use json to convert it into a dic
product = Product(
owner=request.user,
title=form.cleaned_data['product_title'],
desc=form.cleaned_data['product_description'],
)
product.save()
# Add tag list to taggit
[product.tags.add(tag['value']) for tag in tags]
product.save()
for image in files:
ProductImages(product=product, image=image).save()
return super(PostProduct, self).form_valid(form)
def test_unique_slug(self):
product_a = Product()
product_a.name = "a"
product_a.save()
product_b = Product()
product_b.name = product_a.name
product_b.site = Site.objects.get(pk=2)
product_b.save()
product_c = Product()
product_c.name = product_a.name
product_c.save()
self.assertNotEqual(product_a.slug, product_c.slug)
self.assertEqual(product_a.slug, product_b.slug)
def product_submit(request):
#if not UserSettings.objects.get(user=request.user).status in ABOVE_V1:
# messages.success(request, '请购买VIP后继续使用网站功能.')
# return redirect('/recharge')
form = Product_Form(data=request.POST or None)
if form.is_valid():
new_asin = form.save(commit=False)
overflow = False
for asin in new_asin.asins_in.splitlines():
if len(
Product_to_user.objects.filter(user=request.user,
review_qa=True)) > 4:
overflow = True
else:
if not Product.objects.filter(
asin=asin, country=new_asin.country, review_qa=True):
if Product.objects.filter(asin=asin,
country=new_asin.country):
product = Product.objects.filter(
asin=asin, country=new_asin.country)[0]
product.review_qa = True
product.review_qa_apply_time = timezone.now()
product.save()
else:
product = Product(asin=asin,
country=new_asin.country,
review_qa_apply_time=timezone.now(),
review_qa=True)
product.save()
if not Product_to_user.objects.filter(
asin=product, user=request.user, review_qa=True):
detail_to_user = Product_to_user(asin=product,
user=request.user,
review_qa=True)
detail_to_user.save()
else:
product = Product.objects.get(asin=asin,
country=new_asin.country,
review_qa=True)
if not Product_to_user.objects.filter(
asin=product, user=request.user, review_qa=True):
if Product_to_user.objects.filter(asin=product,
user=request.user):
detail_to_user = Product_to_user.objects.get(
asin=product, user=request.user)
detail_to_user.review_qa = True
detail_to_user.save()
else:
detail_to_user = Product_to_user(asin=product,
user=request.user,
review_qa=True)
detail_to_user.save()
if overflow:
messages.success(request, '抓取评论和问答的服务处于试用期,每个用户最多采集五个ASIN.')
else:
messages.success(request, '查询任务已经保存,稍后开始为您查询.')
return redirect('/review_qa_collect')
product_to_user = Product_to_user.objects.filter(user=request.user,
review_qa=True)
products = product_to_user.values_list('asin', flat=True)
products = Product.objects.filter(id__in=products)
paginator = Paginator(products, 12)
page = request.GET.get('page')
try:
products_page = paginator.page(page)
except PageNotAnInteger:
products_page = paginator.page(1)
except EmptyPage:
products_page = paginator.page(paginator.num_pages)
return render(request, 'crawler/review_qa_collect/product_submit.html', {
'form': form,
'products': products_page,
'page': page
})
class ModelProductTests(TestCase):
fixtures = ['user', 'unit_test']
def setUp(self):
self.new_product = Product()
def test_create_product(self):
self.new_product.sku = generate_sku()
self.new_product.name = "Chocolate Chips"
self.new_product.available = True
self.new_product.save()
self.assertTrue(self.new_product.pk)
def test_unique_sku(self):
product_a = Product()
product_a.name = 'a'
product_a.sku = 'a'
product_a.save()
product_b = Product()
product_b.name = 'a'
product_b.sku = 'a'
with self.assertRaises(IntegrityError):
with transaction.atomic():
product_b.save()
def test_unique_slug(self):
product_a = Product()
product_a.name = "a"
product_a.save()
product_b = Product()
product_b.name = product_a.name
product_b.site = Site.objects.get(pk=2)
product_b.save()
product_c = Product()
product_c.name = product_a.name
product_c.save()
self.assertNotEqual(product_a.slug, product_c.slug)
self.assertEqual(product_a.slug, product_b.slug)
def test_valid_msrp(self):
msrp = "JPY,10.99"
self.assertIsNone(validate_msrp_format(msrp))
def test_raise_error_invalid_country_code_msrp(self):
msrp = "JP,10.00"
with self.assertRaises(ValidationError):
validate_msrp_format(msrp)
def test_raise_error_no_price_on_msrp(self):
msrp = "MXN,"
with self.assertRaises(ValidationError):
validate_msrp_format(msrp)
def test_raise_error_no_country_on_msrp(self):
msrp = ",10.00"
with self.assertRaises(ValidationError):
validate_msrp_format(msrp)
def test_raise_error_only_comma_msrp(self):
msrp = ","
with self.assertRaises(ValidationError):
validate_msrp_format(msrp)
def test_get_best_currency_success(self):
product = Product.objects.get(pk=1)
self.assertEquals(product.get_best_currency(), 'usd')
def test_get_best_currency_fail(self):
product = Product.objects.get(pk=1)
self.assertEquals(product.get_best_currency('mxn'), 'usd')
def test_create_product_valid_msrp(self):
self.assertIsNone(validate_msrp({'msrp': {'default': 'usd', 'usd': 20 }}))
def test_create_product_valid_msrp_multiple_currencies(self):
self.assertIsNone(validate_msrp({'msrp': {'default': 'usd', 'usd': 20, 'jpy': 12 }}))
def test_create_product_in_valid_msrp(self):
with self.assertRaises(ValidationError):
validate_msrp({'msrp': {'default': 'rub', 'rub': 20 }})
def test_create_product_in_valid_msrp(self):
with self.assertRaises(ValidationError):
validate_msrp({'msrp': {'default': 'usd', 'usd': 21, 'rub': 20 }})
def test_product(self):
cards = Product(name="Cards")
cards.save()
product = Product.objects.get(name__iexact="Cards")
self.assertEqual(product.__unicode__(), 'Cards')
def save(request):
"""
AJAX function, used to save (or update) product in database
If user is connected & the product is not already in DB
Add product & bind it to the user
If user is connected, the product is in DB but not bounded to the user
Update the product with the (maybe) new value
Add the user to the product
If user not connected
Do nothing & ask him to login
"""
# p = product(s).
# Convert request.GET string to list with ast.literal_eval()
sub = ast.literal_eval(request.GET.get('substitute'))
if request.user.is_authenticated:
current_user = request.user.id
if Product.objects.filter(id=sub['id'], users=current_user).exists():
data = {
'success':
False,
'message':
'Le produit "' + sub['name'] +
'" est déjà associé à votre compte'
}
else:
"""
'p' will erase previously stored value for a given (id) product
It will conserve ManyToMany relation
The user requesting the save will be added alongside with past one
It act as an update for the DataBase
"""
p = Product(
id=sub['id'],
name=sub['name'],
ng=sub['ng'],
img=sub['img'],
link_off=sub['link_off'],
energy=sub['energy'],
fat=sub['fat'],
saturated_fat=sub['saturated_fat'],
carbohydrate=sub['carbohydrate'],
sugars=sub['sugars'],
proteins=sub['proteins'],
salt=sub['salt'],
)
p.save()
p.users.add(current_user)
data = {
'success':
True,
'message':
'Le produit "' + sub['name'] +
'" a bien été ajouté à votre compte'
}
logger.info('New save',
exc_info=True,
extra={
'product_id': p.id,
'product_name': p.name
})
else:
data = {
'success': False,
'message': "Veuillez vous connecter avant d'enregistrer un produit"
}
return JsonResponse(data)
else:
outofline = 0
else:
outofline = 0
ncm = gen_ncm()
b = random.randint(1, 20)
brand = Brand.objects.get(pk=b)
product = product_list[i]['product']
price = float(gen_decimal(4, 2))
ipi = 0
if imported == 1:
ipi = float(gen_ipi())
if ipi > 0.5:
ipi = ipi - 0.5
stock = random.randint(1, 999)
stock_min = random.randint(1, 20)
obj = Product(
imported=imported,
outofline=outofline,
ncm=ncm,
brand=brand,
product=product,
price=price,
ipi=ipi,
stock=stock,
stock_min=stock_min,
)
obj.save()
print('%d Produtos salvo com sucesso.' % REPEAT)
