Example #1
0
    def delete(self, request, id=None):
        ready_data_true =  {'success': True }
        ready_data_false = {'success': False}

        if not request.user.is_authenticated():
            ready_data_false["error"] = "Authorization is failed"
            return ready_data_false


        # TODO: Check if current profile allowed to delete orders
        currentProfile  = Profile.getProfile(request.user)
        
        if id:
            try:
                order = Order.objects.get(pk=id, user=currentProfile.parent_user)
                itemProduct = order.product
                item_id = str(order.item.id)
                itemProduct.delete()
                order.delete()
                updateBestPriced(None, None, item_id)
                return ready_data_true
            except ObjectDoesNotExist:
                ready_data_false['errors'] = "id doesn't exist, id=" + str(id)
                return ready_data_false

        else:
            ready_data_false['errors'] = 'id is required, id=' + str(id)
            return ready_data_false
Example #2
0
    def create(self, request):
        ready_data_true     =  {'success': True }
        ready_data_false    = {'success': False}

        if not request.user.is_authenticated():
            ready_data_false["error"] = "Authorization is failed"
            return ready_data_false

        try:
            item_id         = request.POST.get('item_id')
            product_id      = request.POST.get('product_id')
            user            = request.user
            currentProfile  = Profile.getProfile(request.user)
            items           = request.POST.get('items')

            # 1. product and item are given in request, need to create Order from product
            if product_id:
                product = Product.objects.get(pk=product_id)
                item = Item.objects.get(pk=item_id)

                itemproduct = ItemProduct.objects.create(  \
                    product_num     = product.product_num,    \
                    vendor          = product.vendor,        \
                    upc             = product.upc,   \
                    category        = product.category,      \
                    name1           = product.name1,         \
                    name2           = product.name2,         \
                    package         = product.package,       \
                    date_modified   = product.date_modified, \
                    price           = product.price,         \
                    brand           = product.brand,          \
                    ispriceperunit  = product.ispriceperunit, \
                    notes           = product.notes, \
                    price_per_unit  = 0, \
                    user            = currentProfile.parent_user)

                try:
                    Order.objects.get(item=item, product=itemproduct, user=currentProfile.parent_user)
                except:
                    order = Order.objects.create(item=item, product=itemproduct, user=currentProfile.parent_user)
                    updateBestPriced(None, None, item_id)
                    ready_data_true['items'] = order.list()
                    ready_data_true['total'] = 1
                    return ready_data_true
                else:
                    # normally must be False, but this is not actual error, so it's OK
                    return ready_data_true


                ready_data_false['itemproduct'] = itemproduct
                return ready_data_false

            # 2. fields are given in request to create an Order
            elif items:

                # These fields could be used to create Order
                #
                # "item_id": "1713",                                                Order               Required
                # "product_num": "100065",                                          ItemProduct         Required
                # "name1": "Foie Gras, Duck Ref Millefeuille Appetizer",             ItemProduct.name1   Required
                # "vendor_id": "89",                                                ItemProduct         Required
                # "price": "",                                                      ItemProduct
                # "category": "",                                                   ItemProduct
                # "total_units_per_package": "",                                    ItemProduct
                # "ispriceperunit": false,                                          ItemProduct
                # "package_pack": "",                                               ItemProduct.package
                # "notes": "",                                                      ItemProduct
                # "brand": "Food Innovations Bb",                                   ItemProduct
                # "upc": "",                                                        ItemProduct
                # "preferred": false                                                Order

                ext_posted_data = simplejson.loads(request.POST.get('items'))
                attrs = self.flatten_dict(ext_posted_data)

                data = {}
                ready_data_false['data'] = data

                if 'ispriceperunit' not in attrs:
                    data['ispriceperunit']=False
                else:
                    data['ispriceperunit']=attrs['ispriceperunit']

                if 'preferred' not in attrs:
                    preferred=False
                else:
                    preferred=attrs['preferred']

                data['product_num']=attrs['product_num']
                data['upc']=replace(attrs['upc'])
                data['name1']=replace(attrs['name1'])
                data['name2']=replace(attrs['name2'])
                data['vendor_id']=attrs['vendor_id']
                data['date_modified']= datetime.now()

                data['price'] = Decimal(str(attrs['price']))
                if data['price'] == '': data['price'] = '0'
                data['total_units_per_package']=str(attrs['total_units_per_package'])
                if data['total_units_per_package'] == '': data['total_units_per_package'] = str(0)

                data['package']=replace(attrs['package'])
                data['brand']=replace(attrs['brand'])
                data['category']=replace(attrs['category'])
                data['notes']=replace(attrs['notes'])

                # RE: price_per_unit, update it when price or total_units_per_package or ispriceperunit are updated
                if not data['ispriceperunit']:
                    if data['price'] and data['total_units_per_package'] is not '0':
                        pricePerUnit = float(data['price'])/float(data['total_units_per_package'])
                        p_u      = str('%.3f' % (pricePerUnit,))
                    else:
                        p_u      = '0'
                else:
                    if data['price'] and data['total_units_per_package'] is not '0':
                        p_u      = data['price']
                    else:
                        p_u      = '0'

                data['price_per_unit'] = p_u

                if logger.isEnabledFor(logging.DEBUG):
                    logger.debug('data: %s' % (data))
                itemproduct = ItemProduct.objects.create(user=currentProfile.parent_user, **data)

                item = Item.objects.get(pk=item_id)

                # need to avoid to have duplicate itemproducts
                # let's get all orders for current item
                # then compare
                orders = Order.objects.filter(item=item, user=currentProfile.parent_user)
                ready_data_false['orders'] = orders
                for order in orders:
                    if order.product.product_num == attrs['product_num'] and order.product.vendor_id == attrs['vendor_id']:
                        ready_data_true['items'] = order.list()
                        return ready_data_true

                # there is no identical order, so let's create one
                order = Order.objects.create(item=item, product=itemproduct, preferred=preferred, user=currentProfile.parent_user)
                updateBestPriced(None, None, item_id)
                ready_data_true['items']=order.list()
                ready_data_true['total']=1
                return ready_data_true

            return ready_data_false

        except Exception, err:
            ready_data_false['errors'] = err.message
            if logger.isEnabledFor(logging.ERROR):
                logger.error('%s' % (err))
                logger.error('%s' % (traceback.format_exc()))
                logger.error('User: %s' % (request.user))
                logger.error('Items: %s' % (items))

            return ready_data_false
Example #3
0
    def update(self, request, id=None):

        ready_data_true =  {'success': True }
        ready_data_false = {'success': False}

        if not request.user.is_authenticated():
            ready_data_false["error"] = "Authorization is failed"
            return ready_data_false

            
        itemproduct = ''
        itemIds = None
        updateBestPricedCount = 0

        if 'items' in request.PUT:
            if id:    # this should be situation when a single item is being updated
                ext_posted_data = simplejson.loads(request.POST.get('items'))
                attrs = self.flatten_dict(ext_posted_data)

                req=check(id=id, request=request, attrs=attrs)
                
                req.worker()
                if req.success and req.role == 'Vendor':
                    itemproduct = req.data['itemproduct']
                    itemproduct.date_modified = datetime.now()
                    if itemproduct.price is not 0:
                        itemproduct.previous_price=itemproduct.price
                    itemproduct.price = req.attrs['price']
                    itemproduct.save()
                    itemIds = Order.objects.filter(product=itemproduct).values_list('item')
                    #  there are item products in db that we don't delete, but has no reference to Item
                    #  in that situation need to just continue, we updated item product that is not being used
                    if len(itemIds) > 0:
                        updateBestPriced(None, None, str(itemIds[0][0]))                                                            
                    ready_data_true['items'] = itemproduct
                    ready_data_true['total'] = 1
                    return ready_data_true
                if req.success and req.role == 'Vendor salesmen':
                    itemproduct = req.data['itemproduct']
                    itemproduct.date_modified = datetime.now()
                    itemproduct.previous_price = itemproduct.price
                    itemproduct.price = req.attrs['price']
                    itemproduct.save()
                    itemIds = Order.objects.filter(product=itemproduct).values_list('item')

                    #  there are item products in db that we don't delete, but has no reference to Item
                    #  in that situation need to just continue, we updated item product that is not being used
                    if len(itemIds) > 0:
                        updateBestPriced(None, None, str(itemIds[0][0]))
                    else:
                        ready_data_true['attrs'] = attrs
                        ready_data_true['customer_list'] = req.customer_list

                    ready_data_true['items'] = itemproduct
                    ready_data_true['total'] = 1
                    return ready_data_true
                elif req.success and req.role == 'Customer':
                    itemproduct = ItemProduct.objects.filter(pk=id).update(date_modified=datetime.now()**attrs)
                else:
                    ready_data_false['errors'] = req.reason
                    return ready_data_false

            else:  # this is situation when multiple data is loaded, from csv
                #logger.info('Inside Else Statement')

                ext_posted_data = simplejson.loads(request.POST.get('items'))
                #ready_data_true['count'] = len(ext_posted_data)
                #return ready_data_true
                
                user_customer_id = 0
                vendor_id = 0

                # user is Vendor or Vs
                if 'customer' in request.GET:
                    customer = request.GET['customer']
                    profile = Profile.getProfile(request.user)
                    user_customer_id=profile.user.id
                    user_vendor = profile.parent_user
#                    return str(user_vendor)
                    vendor_id = Vendor.objects.get(user=user_vendor).id

                # user is customer
                elif 'vendor' in request.GET:
                    vendor_id = request.GET['vendor']
                    profile = Profile.getProfile(request.user)
                    user_customer_id=profile.parent_user.id
                    parentProfile = Profile.getProfile(profile.parent_user)

                    # Let's find out if vendor has extra charge or discount
                    # this value is actually stored in Relationship object
                    vendor = Vendor.objects.select_related('profile').get(id=vendor_id)
                    relationship = Relationship.objects.get(Q(vendor=vendor.profile.id) & Q(customer=parentProfile))
                    ecod = relationship.ecod # extra charge or discount

                else:
                    ready_data_false['errors'] = u'Customer ID or Vendor Id is required'
                    return ready_data_false

                on_sale = False
                if 'mark_all_on_sale' in request.GET:
                    on_sale_value = request.GET['mark_all_on_sale']
                    if on_sale_value == 'true':
                        on_sale = True


                count = 0
                #logger.info('Update Prices before loop')
                for attrs in ext_posted_data:
                    try:
                        #logger.info('---------------------Looping ext_posted_data---------------------')
                        price = 0
                        if 'price' in attrs:
                            if attrs['price'] == '':
                                attrs['price'] = '0'
                            attrs['price'] = Decimal(str(attrs['price']).replace(',','.').replace('$','').replace(' ', ''))
                            if ecod is not None:
                                attrs['price_actual'] = str( Decimal(attrs['price'])*(  (Decimal(100) + Decimal(ecod))/Decimal(100) ) )
                            else:
                                attrs['price_actual'] = attrs['price']

                            price=attrs['price_actual']
                            #logger.info("price:%s" % price)

                        else: pass

                        if 'product_num' in attrs:
                            if attrs['product_num'] == '': pass
                            if attrs['product_num'] == '0': pass

                            #attrs['product_num'] = attrs['product_num'].strip().lstrip('0') # remove leading 0 and spaces
                            attrs['product_num'] = attrs['product_num'].strip() # remove spaces
                            #attrs['product_num'] = re.sub("^0+","",attrs['product_num'])    # remove all leading 0
                        else: pass

                        if 'uos' in attrs: # Unit Of Sale
                            attrs['uos'] = attrs['uos'].strip() # remove spaces

                        #logger.info('prod_num=' + attrs['product_num'] + ', user_id=' + str(user_customer_id) + ', vendor_id=' + str(vendor_id))
                        #orders = Order.objects.select_related('product', 'item').filter(product__product_num__iendswith=attrs['product_num'], \
                        orders = Order.objects.select_related().filter(product__product_num=attrs['product_num'], \
                                user=user_customer_id, product__vendor=vendor_id)

                        for order in orders:
                            #logger.info('Looping order.product.product_num=' + str(order.product.product_num) + ', order_id=' + str(order.id))
                            #if re.sub("^0+","",order.product.product_num) != attrs['product_num']:
                            #    continue # skip if product numbers are not the same

                            if 'uos' in attrs:
                                if attrs['uos'] and attrs['uos'] != '':
                                    order.product.total_units_per_package = attrs['uos'] # update total_units_per_package before calculations

                            # CALCULATE price_per_unit
                            if not order.product.ispriceperunit:
                                if order.product.total_units_per_package and price:
                                    pricePerUnit = float(price)/float(order.product.total_units_per_package)
                                    attrs['price_per_unit']      = str('%.3f' % (pricePerUnit,))
                                else:
                                    attrs['price_per_unit']      = '0'
                            else:

                                if order.product.total_units_per_package and price:

                                    attrs['price_per_unit']      = price
                                else:
                                    attrs['price_per_unit']      = '0'

                            best_price_per_unit = order.item.best_price
                            is_best_priced = order.best_priced

                            order.product.date_modified=datetime.now()
                            if order.product.price is None:
                                order.product.price = 0
                            if int(order.product.price) is not 0:
                                order.product.previous_price=order.product.price
                            order.product.price=attrs['price']
                            order.product.price_actual=attrs['price_actual']
                            order.product.price_per_unit=attrs['price_per_unit']
                            order.product.on_sale = on_sale
                            order.product.save()

                            doUpdateBestPriced = False
                            if order.enabled == True and order.item.enabled == True:
                                if is_best_priced: # this order was best priced
                                    if order.preferred: # this order is preferred so need to recalculate best price
                                        order.item.best_price = order.product.price_per_unit
                                        order.item.save() # calls DB
                                    else: # not preferred
                                        if float(order.product.price_per_unit) == 0 or float(order.product.price_per_unit) > float(best_price_per_unit):  # new price is more than old price
                                            doUpdateBestPriced = True
                                        else:
                                            order.item.best_price = order.product.price_per_unit
                                            order.item.save() # calls DB
                                else: # this order was not best priced
                                    # see if there is other preferred order for the item
                                    if Order.objects.filter(item=order.item, preferred=True).exists():
                                        pass # no need to update Best Price, Best price belongs to preferred order
                                    else:
                                        # new price is less then best price
                                        if float(order.product.price_per_unit) > 0 and float(order.product.price_per_unit) < float(best_price_per_unit):
                                            Order.objects.filter(item=order.item).update(best_priced=False)# calls DB
                                            order.best_priced = True
                                            order.save() # calls DB
                                            order.item.best_price = order.product.price_per_unit
                                            order.item.save() # calls DB
                                        else:
                                            doUpdateBestPriced = True

                            #logger.info('doUpdateBestPriced: %s' % doUpdateBestPriced)
                            if doUpdateBestPriced:
                                updateBestPriced(None, None, str(order.item.id))
                                updateBestPricedCount = updateBestPricedCount + 1

                            count += 1

                    except Exception, err:
                        #ready_data_true['itemIds'] = itemIds
                        ready_data_true[attrs['product_num']] = err
                        #ready_data_true[attrs['product_num'] + ' order.product'] = order.product
                        continue

                logger.debug('Update Prices after loop')
                ready_data_true['total'] = count
                ready_data_true['updateBestPricedCount'] = updateBestPricedCount
                return ready_data_true
Example #4
0
    def update(self, request, id=None):
        ready_data_true =  {'success': True }
        ready_data_false = {'success': False}

        if not request.user.is_authenticated():
            ready_data_false["error"] = "Authorization is failed"
            return ready_data_false

        try:
            if logger.isEnabledFor(logging.DEBUG):
                logger.debug('request:%s' % (request))
                logger.debug('request.data:%s' % (request.data))

            request.method = "POST"
            request._load_post_and_files()
            request.method = "PUT"
            request.PUT = request.POST

            if logger.isEnabledFor(logging.DEBUG):
                logger.debug('request:%s' % (request))
                logger.debug('request.data:%s' % (request.data))
                logger.debug('request.PUT:%s' % (request.PUT))

            items = request.PUT.get('items')

            if logger.isEnabledFor(logging.DEBUG):
                logger.debug('items:%s' % (items))


            currentProfile  = Profile.getProfile(request.user)
            parentProfile   = Profile.getProfile(currentProfile.parent_user)

            if id:
                # These fields could be used to update Order
                #
                # "product_num": "100065",                                          ItemProduct         Required
                # "name": "Foie Gras, Duck Ref Millefeuille Appetizer",             ItemProduct.name1   Required
                # "vendor_id": "89",                                                ItemProduct         Required
                # "price": "",                                                      ItemProduct
                # "category": "",                                                   ItemProduct
                # "total_units_per_package": "",                                    ItemProduct
                # "ispriceperunit": false,                                          ItemProduct
                # "package": "",                                                    ItemProduct.package
                # "notes": "",                                                      ItemProduct
                # "brand": "Food Innovations Bb",                                   ItemProduct
                # "upc": "",                                                        ItemProduct
                # "order_qt": "2"                                                   Order
                # "on_sae": "true"                                                  Order
                # "preferred": false                                                Order
                # "price_per_unit": ""                                              ItemProduct

                ext_posted_data = simplejson.loads(items)
                attrs = self.flatten_dict(ext_posted_data)

                update_total_price = False
                update_best_priced = False
                update_price_per_unit = False

                if logger.isEnabledFor(logging.DEBUG):
                    logger.debug('attrs:%s' % (attrs))

                if 'vendor_id' in attrs:
                    attrs['vendor'] = attrs['vendor_id']
                    del attrs['vendor_id']

                order = Order.objects.select_related('item', 'product', 'product__vendor__profile').get(pk=id)

                # Let's find out if vendor has extra charge or discount
                # this value is actually stored in Relationship object
                relationship = Relationship.objects.get(Q(vendor=order.product.vendor.profile.id) & Q(customer=parentProfile))
                ecod = relationship.ecod

                if 'preferred' in attrs:
                    preferred = attrs['preferred']
                    del attrs['preferred']
                    if preferred == True:
                        Order.objects.filter(item=order.item, preferred=True).update(preferred=False)
                    order.preferred=preferred
                    Order.objects.filter(item=order.item, best_priced=True).update(best_priced=False)
                    update_best_priced = True

                if 'enabled' in attrs:
                    enabled = attrs['enabled']
                    del attrs['enabled']
                    order.enabled=enabled
                    if enabled == False:
                        order.preferred = False # if order is disabled, it can not be prefer
                    update_best_priced = True

                if 'order_qt' in attrs:
                    order_qt = str(attrs['order_qt'])
                    if order_qt == "None" or order_qt == "":
                        order_qt = '0'
                    del attrs['order_qt']
                    order.order_qt=order_qt
                    update_total_price = True

                if 'po_notes' in attrs:
                    po_notes = str(attrs['po_notes'])
                    del attrs['po_notes']
                    order.po_notes=po_notes
                    

                order.save()

                if 'id' in attrs: del attrs['id']
                if 'date_modified' in attrs: del attrs['date_modified']
                if 'total_units_per_package' in attrs:
                    attrs['total_units_per_package'] = str(attrs['total_units_per_package'])
                    if attrs['total_units_per_package'] == '': attrs['total_units_per_package'] = str(0)
                    total_units_per_package = attrs['total_units_per_package']
                    update_total_price = True
                    update_best_priced = True
                    update_price_per_unit = True
                else:
                    total_units_per_package = order.product.total_units_per_package

                if 'price' in attrs:
                    if order.product.price is None:
                        attrs['previous_price'] = "0"
                    else:
                        if int(order.product.price) is not 0:
                            attrs['previous_price'] = order.product.price
                    attrs['price'] = str(attrs['price'])
                    attrs['date_modified'] = datetime.now()

                    # change price_actual if ecod is not NONE
                    if ecod is not None:
                        attrs['price_actual'] = str( Decimal(attrs['price'])*(  (Decimal(100) + Decimal(ecod))/Decimal(100) ) )
                    else:
                        attrs['price_actual'] = attrs['price']

                    price=attrs['price']
                    update_total_price = True
                    update_best_priced = True
                    update_price_per_unit = True
                else:
                    price = order.product.price

                if 'ispriceperunit' in attrs:
                    ispriceperunit = attrs['ispriceperunit']
                    update_best_priced = True
                    update_price_per_unit = True
                else:
                    ispriceperunit = order.product.ispriceperunit

                # RE: price_per_unit, update it when price or total_units_per_package or ispriceperunit are updated
                if update_price_per_unit:
                    if not ispriceperunit:
                        if price and total_units_per_package is not '0':
                            pricePerUnit = float(price)/float(total_units_per_package)
                            p_u      = str('%.3f' % (pricePerUnit,))
                        else:
                            p_u      = '0'
                    else:
                        if price and total_units_per_package is not '0':
                            p_u      = price
                        else:
                            p_u      = '0'

                    # change price_actual if ecod is not NONE
                    if ecod is not None:
                        attrs['price_per_unit'] = str( Decimal(p_u)*(  (Decimal(100) + Decimal(ecod))/Decimal(100) ) )
                    else:
                        attrs['price_per_unit'] = p_u

                                
                itemProduct = order.product
                ready_data_false['itemProduct']=itemProduct
                itemProduct = ItemProduct.objects.filter(id=itemProduct.id).update(**attrs)

                if update_total_price == True:
                    order.updateTotalPrice();
                if update_best_priced == True:
                    updateBestPriced(None, None, str(order.item.id))


                ready_data_true['items'] = order.list()
                return ready_data_true

            else:
                ready_data_false['errors'] = u'id is required'
                return ready_data_false

        except Exception, err:
            ready_data_false['errors'] = err.message
            if logger.isEnabledFor(logging.ERROR):
                logger.error('%s' % (err))
                logger.error('items=%s' % (err, str(request.PUT.get('items'))))
            return ready_data_false
Example #5
0
File: item.py Project: bovitobo/bo
def update(profile, args=None, id=None):
    ready_data_true =  {'success': True }
    ready_data_false = {'success': False}

    try:
        doUpdateBestPriced = False

        if profile == None:
            raise Exception('No Profile specified')

        if profile.get_role_display() != 'Customer': # only Customer and Sub-customer are allowed to modify Item
            if profile.get_role_display() != 'Sub-customer' :
                logger.error("Wrong User Type: " + profile.get_role_display())
                raise Exception('Not Allowed: Wrong User Type')

        if args == None:
            raise Exception('No Arguments are given')

        item = None
        item_id = None

        if id:
            item_id = id
            try:
                item = Item.objects.get(id=item_id, user=profile.parent_user)
            except ObjectDoesNotExist:
                raise Exception (u"Item is not found")

        if 'id' in args:
            item_id = args['id']
            try:
                item = Item.objects.get(id=item_id, user=profile.parent_user)
            except ObjectDoesNotExist:
                raise Exception (u"Item is not found")

        if 'item_id' in args:
            item_id = args['item_id']
            try:
                item = Item.objects.get(id=item_id, user=profile.parent_user)
            except ObjectDoesNotExist:
                raise Exception (u"Item is not found")

        if not item:
            raise Exception (u"Item is NOT found")

        if 'unit_id' in args:
            unit_id = args['unit_id']
            try:
                item.unit = Unit.objects.get(id=unit_id, user=profile.parent_user)
            except ObjectDoesNotExist:
                raise Exception (u"Unit is not found")

        if 'category_id' in args:
            category_id = args['category_id']
            if category_id.lower() == 'root':
                item.category = None
            else:
                try:
                    item.category = Category.objects.get(id=category_id, user=profile.parent_user)
                except ObjectDoesNotExist:
                    raise Exception (u"Category is not found")

        if 'name' in args:
            item.name = replace(args['name'])

        if 'upc' in args:
            upc = replace(args['upc'])
            if upc != '':
                exist = Item.objects.filter(user=profile.parent_user, upc=upc). \
                            exclude(id=item_id).exists()
                if exist == True:
                    raise Exception ("Duplicate UPC, %s is not UNIQUE, UPDATE FAILED For UPC: %s" % (upc, item.upc))
                else:
                    item.upc = upc
        if 'upc_2' in args:
            item.upc_2 = replace(args['upc_2'])

        if 'upc_3' in args:
            item.upc_3 = replace(args['upc_3'])

        if 'upc_case' in args:
            item.upc_case = replace(args['upc_case'])

        if 'image_url' in args:
            item.image_url = replace(args['image_url'])

        if 'notes' in args:
            item.notes = replace(args['notes'])

        if 'inventory_no_count' in args and args['inventory_no_count'] != None:
            if args['inventory_no_count'] == 'false':
                item.inventory_no_count = False
            else:
                item.inventory_no_count = True

        if 'qt_in_stock' in args:                        
            qt_in_stock = args['qt_in_stock']
            if qt_in_stock == '' or qt_in_stock == 'NaN':
                item.qt_in_stock = '0'
            elif float(item.qt_in_stock) != float(qt_in_stock): # change only if different
                item.qt_in_stock_last_updated = datetime.now()
                diff = float(qt_in_stock) - float(item.qt_in_stock)
                d = str(diff)
                if d.endswith('.0'):
                    d = d[:-2]
                if d.endswith('.00'):
                    d = d[:-3]
                if diff > 0:
                    item.qt_in_stock_last_diff = '+' + str(d)
                else:
                    item.qt_in_stock_last_diff = str(d)
                item.qt_in_stock    = replace(qt_in_stock)

                if settings.HGM == True:
                    # UPDATE qt_in_stock in WWW
                    updateWwwQtInStock(item)

        if 'min_qt_in_stock' in args:
            min_qt_in_stock = replace(args['min_qt_in_stock'])
            if min_qt_in_stock == '' or min_qt_in_stock == 'NaN':
                min_qt_in_stock = '0'
            item.min_qt_in_stock = min_qt_in_stock

        if 'qt_to_stock' in args:
            qt_to_stock = replace(args['qt_to_stock'])
            if qt_to_stock == '' or qt_to_stock == 'NaN':
                qt_to_stock = '0'
            item.qt_to_stock = qt_to_stock

        if 'temp_stock' in args:
            temp_stock = replace(args['temp_stock'])
            if temp_stock == '' or temp_stock == 'NaN' or temp_stock == 'null' or temp_stock == None:
                item.temp_stock = None
            else:
                item.temp_stock = Decimal(temp_stock)

        if 'best_price' in args:
            best_price = replace(args['best_price'])
            if best_price == '' or best_price == 'NaN' or best_price == 'null' or best_price == None:
                item.best_price = None
            else:
                item.best_price = Decimal(best_price)

        if 'cost_per_unit' in args:
                    cost_per_unit = replace(args['cost_per_unit'])
                    if cost_per_unit == '' or cost_per_unit == 'NaN' or cost_per_unit == 'null' or cost_per_unit == None:
                        item.cost_per_unit = None
                    else:
                        item.cost_per_unit = Decimal(cost_per_unit)

        if 'loc_stock' in args:
            item.loc_stock = replace(args['loc_stock'])

        if 'loc_ret_dept' in args:
            newDept = replace(args['loc_ret_dept'])

            if newDept == '' or newDept == 'None':
                logger.error('ATTEMPT TO ERAZE DEPARTMENT: upc-' + item.upc)
            else:
                item.loc_ret_dept = newDept
        if 'loc_ret_col' in args:
            item.loc_ret_col = replace(args['loc_ret_col'])

        if 'loc_ret_row' in args:
            item.loc_ret_row = replace(args['loc_ret_row'])

        if 'enabled' in args:
            if args['enabled'] == 'false':
                item.enabled = False
            else:
                if item.enabled != True:
                    item.enabled = True
                    doUpdateBestPriced = True

        if 'so_ignore_no_sales' in args and args['so_ignore_no_sales'] != None:
            if args['so_ignore_no_sales'] == 'false':
                item.so_ignore_no_sales = False
            else:
                item.so_ignore_no_sales = True

        if 'so_do_not_order' in args and args['so_do_not_order'] != None:
            if args['so_do_not_order'] == 'false':
                item.so_do_not_order = False
            else:
                item.so_do_not_order = True

        if 'so_always_order' in args and args['so_always_order'] != None:
                item.so_always_order = args['so_always_order']

        if 'total_units_per_case' in args:
            item.total_units_per_case = replace(args['total_units_per_case'])

        #item.sales_price    = 0
        item.save()

        # orders from disabled items are not calculated for Best Priced
        # so if item is changed to enabled, need to calculate best Priced Order
        if doUpdateBestPriced:
            updateBestPriced(None, None, str(item.id))

        ready_data_true['items'] = item.list(item.id)
        return ready_data_true


    except Exception, err:
        #if str(err).startswith( 'Duplicate UPC' ):
        #    logger.error(err)
        #else:
        logger.error(err)
        raise Exception(err)