class ProductTests(TestCase):
    def setUp(self):
        stuff = FoodStuff(name='some stuff 2')
        stuff.save()

        recipe = Recipe(name='some recipe 2')
        recipe.save()

        ingredient = RecipeIngredient(stuff=stuff, recipe=recipe, count=1.5)
        ingredient.save()

        self.product = Product(name='some product 2', recipe=recipe)
        self.product.save()

    def test_str(self):
        self.assertEqual('some product 2', str(self.product))

    def test_prepare_price(self):
        check = self.product.prepare_price(100)
        self.assertEqual(100, check)

        self.product.markup = 2
        check = self.product.prepare_price(100)
        self.assertEqual(200, check)

        self.product.markup = 1.44
        check = self.product.prepare_price(100)
        self.assertEqual(150, check)

def AddProduct(request):
    if request.POST.has_key('display_name'):
        NewDisplayName = request.POST['display_name']
    if request.POST.has_key('detail_name'):
        NewDetailName = request.POST['detail_name']
    if request.POST.has_key('material'):
        NewMaterial = request.POST['material']
    if request.POST.has_key('series'):
        NewSeries = request.POST['series']
    if request.POST.has_key('function'):
        NewFunction = request.POST['function']
    if request.POST.has_key('origin'):
        NewOrigin = request.POST['origin']
    AlreadyExist = Product.objects.filter(
        display_name=NewDisplayName,
        detail_name=NewDetailName,
        material=NewMaterial,
        series=NewSeries,
        function=NewFunction,
        origin=NewOrigin
    )
    if len(AlreadyExist) != 0:
        #该产品已存在
        result="AlreadyExist"
        return HttpResponse(result, mimetype="application/text")
    productToAdd = Product(
        display_name=NewDisplayName,
        detail_name=NewDetailName,
        material=NewMaterial,
        series=NewSeries,
        function=NewFunction,
        origin=NewOrigin
    )
    productToAdd.save()
    return HttpResponse(productToAdd.id, mimetype="application/text")

    def manage_settings(self, product):
        product_data = self.retrieve_product(product)
        if type(product_data) is str:
            title = "%s Manage Settings" % product.title()
            product_data = None
            form = forms.ManageProduct()
        else:
            title = "%s Manage Settings" % product_data.title
            form = forms.ManageProduct(obj=product_data)

        if request.method == "POST" and form.validate_on_submit():
            to_save = Product(request.form.to_dict())
            if product_data and product_data.db_name:
                to_save.db_name = product_data.db_name
                to_save.groups = product_data.groups
            else:
                to_save.set_db_name()

            g.db.api_settings.update({}, {"$set": {product: to_save.__dict__}})
            if to_save.active:
                g.db.api_settings.update({}, {"$addToSet": {"active_products": product}})
            else:
                g.db.api_settings.update({}, {"$pull": {"active_products": product}})

            flash("Product was successfully updated", "success")
            return redirect("/%s/manage" % product)
        else:
            if request.method == "POST":
                flash("Form was not saved successfully", "error")

            return render_template("manage/manage_product.html", title=title, form=form, product=product_data)

 def set_data_for(self, value=None):
     products = [(Product.get(id=rpt.product_id).name) for rpt in
                 Report.select(fn.Distinct(Report.product))]
     if value:
         products = [(prod.name) for prod in Product.select().where(Product.name.contains(value))
                     .where(Product.name << products).order_by(Product.name.desc())]
     self.data = [(prd, "") for prd in products]

 def post(self, subdomain):
     namespace_manager.set_namespace(subdomain)
     visible = False
     if self.request.get('visible') == 'yes':
         visible = True
     name = self.request.get('name')
     categories = self.request.get('category').split(',')
     logging.info(categories)
     cat_refs = []
     for category in categories:
         logging.info(category)
         if Category.get_by_key_name(category):
             cat_refs.append(Category.get_by_key_name(category).key())
     logging.info(cat_refs)
     entity = Product(key_name=name,
                       name=name,
                       shop_id=Shop.get_by_key_name(subdomain),
                       stock=int(self.request.get('qty')),
                       description=self.request.get('description'),
                       price=float(self.request.get('price')),
                       tags=self.request.get('tags').split(','),
                       video=self.request.get('video'),
                       visible=visible,
                       categories=cat_refs
                           )
     entity.put()
     self.redirect(webapp2.uri_for('addproducts'))

def create(request):
    if request.method != "POST":
        raise Http404("Invalid HTTP method!")
    go_back = False
    if len(request.POST["name"]) < 1:
        messages.add_message(request, messages.INFO, "Product Name cannot be blank!")
        go_back = True
    elif len(request.POST["name"]) < 8:
        messages.add_message(request, messages.INFO, "Product Name must be at least 8 characters!")
        go_back = True
    if len(request.POST["price"]) < 1:
        messages.add_message(request, messages.INFO, "Price cannot be blank!")
        go_back = True
    elif float(request.POST["price"]) < 0:
        messages.add_message(request, messages.INFO, "Price cannot be less than $0!")
        go_back = True
    if len(request.POST["description"]) < 1:
        messages.add_message(request, messages.INFO, "Description cannot be blank!")
        go_back = True
    elif len(request.POST["description"]) > 50:
        messages.add_message(request, messages.INFO, "Description cannot be more than 50 characters!")
        go_back = True
    if go_back:
        return redirect("/products")
    else:
        prod = Product(
            name=request.POST["name"],
            manufacturer=request.POST["manufacturer"],
            price=float(request.POST["price"]),
            description=request.POST["description"],
        )
        prod.save()
        return redirect("/products")

    def post(self, request):
        url = request.POST['url']
        try:
            response = urllib2.urlopen(url, timeout=300)
        except urllib2.HTTPError as e:
            if e.code == 404:
                raise Http404('Product not found')
            raise e
        except ValueError as e:
            return HttpResponseBadRequest('Invalid url')
        except urllib2.URLError as e:
            return HttpResponseBadRequest('Site is not available')

        html = response.read()
        response.close()
        soup = BeautifulSoup(html)
        image = soup.find('img', {'id': 'base_image'})
        image_src = image['src']
        image_name = image['src'].split('/')[-1]
        title = image['title']
        my_image_path = os.path.join('media', image_name)
        image_my_src = os.path.join(BASE_DIR, my_image_path)
        urllib.urlretrieve(image_src, image_my_src)
        price = soup.find('div', {'name': 'prices_active_element_original'}).find('span', {'itemprop': 'price'}).text

        product = Product(title=title, image='/{0}'.format(my_image_path), price=float(price))
        product.save()

        return HttpResponseRedirect('/list/')

def product(request):
    """ Get list of products ordered with the cheapest first.
    Create product if method `POST`
    """

    if request.method == 'GET':

        sql = 'SELECT * FROM products_product order by CAST(price AS DECIMAL(6,2))'

        arg = QueryDict(request.GET.urlencode()).dict()
        slc = int(arg.get('page', 1)) * 10

        inst_list = Product.objects.raw(sql)[slc - 10: slc]

        return json_response({'result': [to_dict(ins) for ins in inst_list]})

    # create product
    elif request.method == 'POST':
        data = json.loads(request.body)
        if not data.get('name'):
            return json_response(FIELD_REQUIRED)

        p = Product(**data)
        p.save()
        return json_response({'id': p.id}, status=201)

    return HttpResponse(status=405)

def Addproduct(request):
    form=ProductForm(request.POST or None)
    if form.is_valid():
        ModelName = form.cleaned_data['ModelName']
        description = form.cleaned_data['description']
        photo = form.cleaned_data['photo']
        manufacturer = form.cleaned_data['manufacturer']
        price_in_dollars = form.cleaned_data['price_in_dollars']
        Quantity = form.cleaned_data['Quantity']
        Serial_No =form.cleaned_data['Serial_No']
        product=Product()
        product.ModelName=ModelName
        product.description=description
        product.photo=photo
        product.manufacturer=manufacturer
        product.price_in_dollars=price_in_dollars
        product.Quantity=Quantity
        product.Serial_No=Serial_No  
        product.save()
        return HttpResponseRedirect(reverse('ecom:product'))
        
        
        #return HttpResponseRedirect(reverse('ecom:product'))
    else:
        return render(request,"ItemMaster.html",{"form":form})    

 def click_item(self, row, column, *args):
     if column != 2:
         self.choix = Product.filter(name=self.data[row][1]).get()
         self.parent.table_info.refresh_(self.choix.id)
     if column == 2:
         # self.removeRow(row)
         self.choix = Product.filter(name=self.data[row][1]).get()
         self.parent.table_invoice.refresh_(self.choix)

def save_products(data):
    for key, value in data.iteritems():
        if type(key) is unicode:
            key = int(key)
        product = Product(
            product_id=key, mpn=value["mpn"], image=value["image"], link=value["link"], name=value["name"]
        )
        product.save()

 def setUp(self):
     self.products = []
     for i in range(1,10):
         product = Product(product_id=i, key_name="test_product_"+str(i),price=round(random.uniform(1,10),2),tax_percent=18.00)
         product.put()
         product.add_stock("test_product_"+str(i),10)
         self.products.append("test_product_"+str(i))
     self.cart = Cart()
     random.shuffle(self.products)

def create_product(request):
  kwargs = {}
  for k in request.POST:
    if k != 'csrfmiddlewaretoken':
      kwargs[k] = request.POST[k]
  product =  Product(**kwargs)
  product.save()
  for k in request.FILES:
    filename = img_utils.thumb_image('main_image', str(product.pk), request.FILES[k], (300, 273))
    setattr(product, k, filename)
  product.save()

 def test_reserved(self):
     qty = random.randint(1,10)
     print ' To reserve: ',qty,
     if Product.reserve(self.name,qty):
         p = Product.get_by_key_name(self.name)
         print ' AVAILABLE: ',p.available
         self.assertEqual(p.available, p.stock - qty, 'Not reserving correctly')
     else:
         p = Product.get_by_key_name(self.name)
         print ' Not enough stock', p.available
         self.assertGreater(qty, p.available, 'Not reserving correctly')

 def create_product(self,request):
     u = self.current_user(request)
     e = json.load(open('%s/json/elements.json'%settings.STATIC_ROOT))
     c = request.REQUEST['category']
     category = e['locale_cat'].index(c)
     credit = request.REQUEST['credit']
     name = request.REQUEST['name']
     description = request.REQUEST['description']
     product = Product(category=category,credit=credit,visual='',
     name='$$%s'%name,description=description,user=u)
     product.save()
     return redirect('productimage')

class SaleOfferTests(TestCase):
    def setUp(self):
        self.stuff = FoodStuff(name='some stuff 3')
        self.stuff.save()

        recipe = Recipe(name='some recipe 3')
        recipe.save()

        ingredient = RecipeIngredient(
            stuff  = self.stuff,
            recipe = recipe,
            count  = 1.5
        )
        ingredient.save()

        self.product = Product(
            name   = 'some product 3',
            recipe = recipe,
            markup = 1.5
        )
        self.product.save()

        provider = FoodProvider(name='some provider')
        provider.save()

        purchase = Purchase(
            provider   = provider,
            stuff      = self.stuff,
            cost       = 200,
            unit_count = 10,
            unit_size  = 1,
        )
        purchase.save()

        self.offer = SaleOffer(product=self.product)
        self.offer.save()

    def test_str(self):
        self.assertEqual('some product 3', str(self.offer))

    def test_save_change_actual(self):
        self.assertEqual(True, self.offer.is_actual)

        offer_2 = SaleOffer(product=self.product)
        offer_2.save()

        self.offer.refresh_from_db()
        self.assertEqual(False, self.offer.is_actual)

    def test_save(self):
        self.assertEqual(30, self.offer.cost)
        self.assertEqual(50, self.offer.price)

    def manage_settings(self, product):
        product_data = self.retrieve_product(product)
        if type(product_data) is str:
            title = "%s Manage Settings" % product.title()
            product_data = None
            form = forms.ManageProduct()
        else:
            title = "%s Manage Settings" % product_data.title
            form = forms.ManageProduct(obj=product_data)

        if request.method == 'POST' and form.validate_on_submit():
            to_save = Product(request.form.to_dict())
            if product_data and product_data.db_name:
                to_save.db_name = product_data.db_name
                to_save.groups = product_data.groups
            else:
                to_save.set_db_name()

            g.db.api_settings.update(
                {}, {
                    '$set': {
                        product: to_save.__dict__
                    }
                }
            )
            if to_save.active:
                g.db.api_settings.update(
                    {}, {
                        '$addToSet': {'active_products': product}
                    }
                )
            else:
                g.db.api_settings.update(
                    {}, {
                        '$pull': {'active_products': product}
                    }
                )

            flash('Product was successfully updated', 'success')
            return redirect('/%s/manage' % product)
        else:
            if request.method == 'POST':
                flash('Form was not saved successfully', 'error')

            return render_template(
                'manage/manage_product.html',
                title=title,
                form=form,
                product=product_data,
            )

def upload_xml(xml):

    doc = parseString(xml)
    products = doc.getElementsByTagName("product")

    for prod in products:
        mongoProduct = Product()

        for node in prod.childNodes:
            if (node.nodeType == node.ELEMENT_NODE
                    and node.firstChild != None
                    and node.firstChild.nodeType == node.TEXT_NODE):
                nodeVal = parse_value(node.firstChild.nodeValue)
                mongoProduct.attr[node.nodeName] = nodeVal
        mongoProduct.save()

    def check_onsale_product(self, id, url):
        prd = Product.objects(key=id).first()
        if prd is None:
            print '\n\nshopbop {0}, {1}\n\n'.format(id, url)
            return

        ret = self.fetch_page(url)
        if isinstance(ret, int):
            print("\n\nshopbop download product page error: {0}".format(url))
            return

        tree = lxml.html.fromstring(ret)

        listprice = price = None
        for price_node in tree.cssselect('div#productPrices div.priceBlock'):
            if price_node.cssselect('span.salePrice'):
                price = price_node.cssselect('span.salePrice')[0].text_content().replace(',', '').replace('$', '').strip()
            elif price_node.cssselect('span.originalRetailPrice'):
                listprice = price_node.cssselect('span.originalRetailPrice')[0].text_content().replace(',', '').replace('$', '').strip()

        soldout = True if tree.cssselect('img#soldOutImage') else False

        if listprice and prd.listprice != listprice:
            prd.listprice = listprice
            prd.update_history.update({ 'listprice': datetime.utcnow() })
        if prd.price != price:
            prd.price = price
            prd.update_history.update({ 'price': datetime.utcnow() })
        if prd.soldout != soldout:
            prd.soldout = soldout
            prd.update_history.update({ 'soldout': datetime.utcnow() })
        prd.save()

    def set_data_for(self, prod_find):

        products = Product.select().order_by(Product.name.asc())
        if prod_find:
            products = products.where(Product.name.contains(prod_find))

        self.data = [("", prod.name, "") for prod in products]