public async Task <IActionResult> PutProductUnit(int id, ProductUnitVM puvm)
        {
            if (id != puvm.Product_Unit_ID)
            {
                return(BadRequest());
            }

            Product_Unit pu = new Product_Unit();

            pu.Product_Unit_ID       = puvm.Product_Unit_ID;
            pu.Product_Unit_Quantity = puvm.Product_Unit_Quantity;

            db1.Entry(pu).State = EntityState.Modified;
            await db1.SaveChangesAsync();

            try
            {
                await db1.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!Product_UnitExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <IActionResult> Create([FromBody] Product_UnitViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            Product_Unit product_unit = new Product_Unit
            {
                productId = model.productId,
                unitId    = model.unitId,
                cost      = model.cost,
                price     = model.price
            };

            _context.product_Units.Add(product_unit);
            try
            {
                await _context.SaveChangesAsync();
            }
            catch
            {
                return(BadRequest());
            }
            return(Ok());
        }
        public async Task <IActionResult> PutProduct_Unit([FromRoute] int id, [FromBody] Product_Unit product_Unit)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != product_Unit.unitId)
            {
                return(BadRequest());
            }

            _context.Entry(product_Unit).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!Product_UnitExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <IActionResult> PostProduct_Unit([FromBody] Product_Unit product_Unit)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            _context.product_Units.Add(product_Unit);
            await _context.SaveChangesAsync();

            return(CreatedAtAction("GetProduct_Unit", new { id = product_Unit.unitId }, product_Unit));
        }
        public async Task <ActionResult <Product_Unit> > PostProductUnit([FromBody] ProductUnitVM puvm)
        {
            Product_Unit pu = new Product_Unit();

            //pu.Product_Unit_ID = puvm.Product_Unit_ID;
            pu.Product_Unit_Quantity = puvm.Product_Unit_Quantity;

            db1.Product_Unit.Add(pu);

            //db1.Entry(pu).State = EntityState.Modified;
            await db1.SaveChangesAsync();

            return(Ok());
        }
Example #6
0
        public JsonResult CreateNewProduct(string name, int category_id, decimal original_price,
                                           int quantity, int quota_min, int quota_max,
                                           string[] barcode, string[] unit_name, int[] quantitiesPerUnit, decimal[] sell_price, string[] img)
        {
            using (IPosEntities ctx = new IPosEntities())
            {
                try
                {
                    int    default_bar_code  = GetMaxProductCodeNumber();
                    string base_product_code = barcode[0].Length > 0 ? barcode[0] : string.Format("P{0}", (++default_bar_code).ToString("D" + _product_code_number_length));
                    // Khởi tạo sản phẩm
                    Products _new_product = new Products();
                    _new_product.ID   = ctx.Products.Any() ? ctx.Products.Max(b => b.ID) + 1 : 1;
                    _new_product.Name = name;
                    _new_product.Product_Category_ID = category_id;
                    _new_product.Min_Quota           = quota_min;
                    _new_product.Max_Quota           = quota_max;
                    _new_product.Base_Product_Code   = base_product_code;
                    ctx.Products.Add(_new_product);

                    // Khởi tạo unit
                    for (int i = 0; i < barcode.Length; i++)
                    {
                        Product_Unit _new_product_unit = new Product_Unit();
                        _new_product_unit.Product_Code      = i == 0 ? base_product_code : barcode[i].Length > 0 ? barcode[i] : string.Format("P{0}", (++default_bar_code).ToString("D" + _product_code_number_length));
                        _new_product_unit.Product_ID        = _new_product.ID;
                        _new_product_unit.Base_Product_Code = base_product_code;
                        _new_product_unit.Name            = unit_name[i];
                        _new_product_unit.Original_Price  = original_price * quantitiesPerUnit[i];
                        _new_product_unit.QuantityPerUnit = quantitiesPerUnit[i];
                        _new_product_unit.Sell_Price      = sell_price[i];
                        ctx.Product_Unit.Add(_new_product_unit);
                    }

                    // Khởi tạo image
                    long _last_image_id = ctx.Product_Image.Any() ? ctx.Product_Image.Max(b => b.ID) + 1 : 1;
                    for (int i = 0; i < img.Length; i++)
                    {
                        Product_Image _new_image = new Product_Image();
                        _new_image.ID         = _last_image_id++;
                        _new_image.Number     = i + 1;
                        _new_image.Product_ID = _new_product.ID;
                        _new_image.Contents   = img[i];
                        ctx.Product_Image.Add(_new_image);
                    }

                    // Khởi tạo giao dịch "Initiation"
                    Transaction _new_transaction = new Transaction();
                    _new_transaction.code         = Utilities.Utilities.CreateNewTransactionCode(Utilities.Utilities.TransactionType.Initiation());
                    _new_transaction.Type         = Utilities.Utilities.TransactionType.Initiation();
                    _new_transaction.Created_Time = DateTime.Now;
                    _new_transaction.Created_User = ""; // MANHDC - TODO
                    _new_transaction.Shop_ID      = 0;  // MANHDC - TODO
                    _new_transaction.Discount     = 0;
                    _new_transaction.Note         = "Khởi tạo sản phẩm";
                    ctx.Transaction.Add(_new_transaction);

                    // Khởi tạo chi tiết giao dịch (số lượng, giá tiền)
                    Transaction_Detail _new_transaction_detail = new Transaction_Detail();
                    _new_transaction_detail.Transaction_Code = _new_transaction.code;
                    _new_transaction_detail.Product_Code     = _new_product.Base_Product_Code;
                    _new_transaction_detail.Quantity         = quantity;
                    _new_transaction_detail.Price            = original_price;
                    _new_transaction_detail.Total            = quantity * original_price;
                    ctx.Transaction_Detail.Add(_new_transaction_detail);

                    ctx.SaveChanges();
                }
                catch (Exception ex)
                {
                    string msg = ex.Message;
                    while (ex.InnerException != null)
                    {
                        ex  = ex.InnerException;
                        msg = ex.Message;
                    }
                    return(Json("ERR:" + msg, JsonRequestBehavior.AllowGet));
                }
            }

            return(Json("OK", JsonRequestBehavior.AllowGet));
        }