示例#1
0
        private async void saveChangesButton_Click(object sender, EventArgs e)
        {
            if (_selectedTransaction == null)
            {
                MessageBox.Show("You must select a transaction");
                return;
            }

            if (!ValidateForm())
            {
                MessageBox.Show("Invalid data");
                return;
            }

            var model = new StockTransaction();

            model.DateAdded             = _selectedTransaction.DateAdded;
            model.Details               = transactionDescriptionTextbox.Text;
            model.Id                    = _selectedTransaction.Id;
            model.NProductsAddedRemoved = int.Parse(nBoughtSoldTextbox.Text);
            model.ParentId              = _selectedTransaction.ParentId;
            model.Price                 = Decimal.Parse(transactionPriceTextbox.Text);
            model.TransactionType       = transactionTypeCombobox.Text;

            await _transactionManager.SaveTransactionAsync(model);

            await LoadDataIntoListView();

            MessageBox.Show("Changes saved successfully!");
        }
        public ActionResult Create([Bind(Include = "StockTransactionID,Shares,Order,Price")] StockTransaction stockTransaction, Int32 StockID)
        {
            Stock SelectedStock = db.Stocks.Find(StockID);

            List <StockPortfolio> portfolio = db.Users.Find(User.Identity.GetUserId()).Portfolio;

            stockTransaction.Portfolio = portfolio.First();

            //associate with transaction
            stockTransaction.Stock = SelectedStock;

            //assign price
            stockTransaction.Price = GetQuote.GetStock(SelectedStock.Symbol).PreviousClose;

            double t_value = stockTransaction.Shares * stockTransaction.Price;

            if (stockTransaction.Portfolio.CashBalance < t_value)
            {
                //overdraft logic
            }


            if (ModelState.IsValid)
            {
                db.StockOrders.Add(stockTransaction);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }
            ViewBag.AllStocks = GetAllStocks(stockTransaction);
            return(View(stockTransaction));
        }
示例#3
0
        public StockTransaction PostStockTransaction(StockTransaction stockTransaction)
        {
            var item = StockTransactions.FirstOrDefault(c => c.StockTransactionId == stockTransaction.StockTransactionId);
            var accountTransaction = GetAccountTransactionByStockTransactionId(stockTransaction.StockTransactionId);

            if (item != null)
            {
                item = stockTransaction;
            }
            else
            {
                stockTransaction.StockTransactionId = GenerateStockTransactionId();
                StockTransactions.Add(stockTransaction);
            }

            if (accountTransaction == null)
            {
                accountTransaction = PostAccountTransaction(new AccountTransaction
                {
                    Amount             = stockTransaction.Amount * stockTransaction.UnitPrice * (stockTransaction.TransactionType == TransactionType.Buy ? -1 : 1),
                    Date               = stockTransaction.Date,
                    StockTransactionId = stockTransaction.StockTransactionId,
                    StockTransaction   = stockTransaction,
                    AccountId          = Session.DefaultAccount.AccountId
                });
            }
            else
            {
                accountTransaction.Amount = stockTransaction.Amount * stockTransaction.UnitPrice * (stockTransaction.TransactionType == TransactionType.Buy ? -1 : 1);
            }

            stockTransaction.AccountTransactionId = accountTransaction.AccountTransactionId;
            return(stockTransaction);
        }
示例#4
0
        public async Task <StockTransactionVM> CreateAsync(CreateOrUpdateStockTransactionVM createOrUpdateStockTransactionVM)
        {
            var stock = await _mediator.Send(new GetSingleRequest <Stock>(createOrUpdateStockTransactionVM.StockId));

            var stock_transaction = new StockTransaction()
            {
                Id         = createOrUpdateStockTransactionVM.Id,
                Stock      = stock,
                Commission = createOrUpdateStockTransactionVM.Commission,
                Amount     = createOrUpdateStockTransactionVM.Amount,
                Price      = createOrUpdateStockTransactionVM.Price,
                When       = createOrUpdateStockTransactionVM.When,
                TradeType  = createOrUpdateStockTransactionVM.TradeType
            };

            var checkIfExists = await _mediator.Send(new CheckExistsRequest <StockTransaction>(stock_transaction));

            if (checkIfExists != null)
            {
                _notifications.AddNotification("400", "Already exist a transaction with the same data.");
                return(checkIfExists.ToVM());
            }

            stock_transaction = await _mediator.Send(new CreateRequest <StockTransaction>(stock_transaction));

            return(stock_transaction.ToVM());
        }
示例#5
0
        private void button7_Click(object sender, EventArgs e)
        {
            label6.Text = "";
            StockTransaction        s = StockTransaction.findStocktransaction(Convert.ToInt32(textBox1.Text));
            List <StockTransaction> l = new List <StockTransaction>();

            l.Add(s);
            var l2 = (from cat in l
                      select new
            {
                cat.StockTransactionId,
                cat.Stock.StockId,
                cat.Stock.ProductName,
                cat.QuantityAfter,
                cat.QuantityBefore,
                cat.time,
                cat.comment,
            }).ToList();

            if (l.Count > 0)
            {
                dataGridView1.DataSource = l2;
            }
            else
            {
                label6.Text = "No transaction for ID:" + textBox1.Text + "/Invalid ID.";
            }
        }
示例#6
0
        private void button8_Click(object sender, EventArgs e)
        {
            label6.Text = "";
            List <StockTransaction> l = StockTransaction.allStocktransactions();

            if (l.Count > 0)
            {
                var l2 = (from cat in l
                          select new
                {
                    cat.StockTransactionId,
                    cat.Stock.StockId,
                    cat.Stock.ProductName,
                    cat.QuantityAfter,
                    cat.QuantityBefore,
                    cat.time,
                    cat.comment,
                }).ToList();
                dataGridView1.DataSource = l2;
            }
            else
            {
                dataGridView1.DataSource = null;
                label6.Text = "No transactions / Invalid ID.";
            }
        }
示例#7
0
        public ActionResult UpdateStock(int productItemId, int stockQty, string quantity, ProductItem item) //The method that changed the stock amount when managers/staff add stock
        {
            try
            {
                ProductItem myProductItem = _productService.GetProductItem(productItemId); //gets method in DAO for accessing product Item details
                var         user          = User.Identity.Name;                            //Itentifies the current user

                if (myProductItem.Discontinued == true)
                {
                    _productService.ToggleProductItem(myProductItem, user); // sets the prodcut as enabled, if it has been disabled
                }

                myProductItem.StockQty = (stockQty + int.Parse(quantity)); //adds to ProductItem Table- StockQuantity field the amount selected on the dropdown list

                _productService.EditProductItem(myProductItem);            //Calls the Edit Product Item method from the DAO

                StockTransaction stockTransaction = new StockTransaction() //takes details on the product, user, stock amaount, stock, change and the current date...
                {
                    ProductItemId = productItemId,
                    AddedBy       = user,
                    CurrentStock  = stockQty,
                    QtyToAdd      = int.Parse(quantity),
                    DateAdded     = DateTime.Now,
                };
                _productService.AddStockTransaction(stockTransaction);//and adds them to the table "stockTransactions" in the Model- this created a log for auditing purpose
            }
            catch (Exception ex)
            {
                Console.Out.WriteLine(ex);
            }

            return(Redirect(Request.UrlReferrer.ToString()));
        }
示例#8
0
        public long Save(long tranId, DateTime valueDate, int storeId, string partyCode, int priceTypeId, string referenceNumber, string data, string statementReference, string attachmentsJSON)
        {
            if (!StockTransaction.IsValidStockTransactionByTransactionMasterId(tranId))
            {
                throw new InvalidOperationException(Resources.Warnings.InvalidStockTransaction);
            }

            if (!StockTransaction.IsValidPartyByTransactionMasterId(tranId, partyCode))
            {
                throw new InvalidOperationException(Resources.Warnings.InvalidParty);
            }

            Collection <StockDetail> details = CollectionHelper.GetStockMasterDetailCollection(data, storeId);

            if (!this.ValidateDetails(details, tranId))
            {
                return(0);
            }

            Collection <Attachment> attachments = CollectionHelper.GetAttachmentCollection(attachmentsJSON);

            int  officeId = CurrentUser.GetSignInView().OfficeId.ToInt();
            int  userId   = CurrentUser.GetSignInView().UserId.ToInt();
            long loginId  = CurrentUser.GetSignInView().LoginId.ToLong();

            return(Data.Transactions.Return.PostTransaction(tranId, valueDate, officeId, userId, loginId, storeId, partyCode, priceTypeId, referenceNumber, statementReference, details, attachments));
        }
示例#9
0
        private void StockTimerCallback(object state)
        {
            // Create a new random stock transaction
            Stock stock = m_Stocks[m_Stocks.Keys.ElementAt(m_Rnd.Next(m_Stocks.Count))];

            // Get a random value between -1.00 and 1.00
            decimal change = ((decimal)m_Rnd.Next(-100, 100)) / 100M;

            // Make sure share price cannot go negative
            if (stock.Price + change < 0)
            {
                change = -change;
            }

            // Update stock price
            stock.Price += change;
            var tx = new StockTransaction(stock, DateTime.Now, change, m_Rnd.Next(1, 1000));

            // Notify subscribed clients
            foreach (string key in m_Clients.Keys.ToList())
            {
                try
                {
                    if (m_Clients[key].IsActive)
                    {
                        m_Clients[key].ClientCallback.StockUpdated(tx);
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Error contacting client '{0}': {1}", key, ex.Message);
                    Logout(key);
                }
            }
        }
示例#10
0
        public void WithdrawManyItems(string[] itemCodes, string[] retrievedQtys)
        {
            List <StockTransaction> stockTransactions = new List <StockTransaction>();

            using (db = new LogicEntities())
            {
                for (int x = 0; x < itemCodes.Length; x++)
                {
                    Product p = db.Product.Find(itemCodes[x]);
                    if (-1 * Convert.ToInt32(retrievedQtys[x]) > p.Qty)
                    {
                        //Throw an error    //Not used due to modification made to view validation
                    }
                    else
                    {
                        StockTransaction stockTransaction = new StockTransaction
                        {
                            ProductId    = itemCodes[x],
                            Qty          = -1 * Convert.ToInt32(retrievedQtys[x]),
                            TranDate     = DateTime.Now,
                            Remarks      = "Inventory Withdrawal, Date: " + DateTime.Now.Date.ToString("d"),
                            TotalBalance = p.Qty - Convert.ToInt32(retrievedQtys[x])
                        };
                        stockTransactions.Add(stockTransaction);
                    }
                }
                db.StockTransaction.AddRange(stockTransactions);
                db.SaveChanges();
            }
        }
        public async Task <ActionResult> CreateTransactionist11(int id, TransactionToCreateVM transactionVM)
        {
            transactionVM.Email = User.RetrieveEmailFromPrincipal();

            await _transactionService.InitialisingTaxLiability(transactionVM.Email);

            // ovo stavljaš anual
            //  await _transactionService.CreatingPurchaseNewAnnualProfitOrLoss(transactionVM.Email);


            var transaction = new StockTransaction
            {
                Id       = transactionVM.Id,
                Date     = DateTime.Now,
                StockId  = id,
                Purchase = true,
                Quantity = transactionVM.Quantity,
                Price    = transactionVM.Price,
                Resolved = transactionVM.Resolved,
                Email    = transactionVM.Email
            };

            var transaction1 = await _transactionService.CreateTransaction(transaction);

            return(Ok(transaction1));
        }
        public async Task <ActionResult> CreateTransactionist2(int id,
                                                               TransactionToCreateVM transactionVM)
        {
            transactionVM.Email = User.RetrieveEmailFromPrincipal();

            // var userId = await _transactionService.GetUserId();

            if (await _transactionService.TotalQuantity(transactionVM.Email, id) < transactionVM.Quantity)
            {
                // stavio si badrequest kako bi ti prošla ona fora od Felipea
                // return new BadRequestObjectResult
                // (new ApiValidationErrorResponse{Errors = new []{"You are selling more than you have!"}});

                return(BadRequest("You are selling more than you have!"));
            }

            var transaction = new StockTransaction
            {
                Id       = transactionVM.Id,
                Date     = DateTime.Now,
                StockId  = id,
                Purchase = false,
                Quantity = transactionVM.Quantity,
                Price    = transactionVM.Price,
                Resolved = transactionVM.Resolved,
                Email    = transactionVM.Email
            };

            var transaction1 = await _transactionService
                               .CreateTransaction1(transaction, id, User.RetrieveEmailFromPrincipal());

            await _transactionService.UpdateTaxLiability(transactionVM.Email);

            return(Ok(transaction1));
        }
示例#13
0
        public long Save(long tranId, DateTime valueDate, int storeId, string partyCode, int priceTypeId, string referenceNumber, string data, string statementReference, string attachmentsJSON)
        {
            if (!StockTransaction.IsValidStockTransactionByTransactionMasterId(tranId))
            {
                throw new InvalidOperationException(Resources.Warnings.InvalidStockTransaction);
            }

            if (!StockTransaction.IsValidPartyByTransactionMasterId(tranId, partyCode))
            {
                throw new InvalidOperationException(Resources.Warnings.InvalidParty);
            }

            Collection <StockMasterDetailModel> details = CollectionHelper.GetStockMasterDetailCollection(data, storeId);

            if (!this.ValidateDetails(details, tranId))
            {
                return(0);
            }

            JavaScriptSerializer         js          = new JavaScriptSerializer();
            Collection <AttachmentModel> attachments = js.Deserialize <Collection <AttachmentModel> >(attachmentsJSON);

            int  officeId = SessionHelper.GetOfficeId();
            int  userId   = SessionHelper.GetUserId();
            long loginId  = SessionHelper.GetLogOnId();

            return(Data.Helpers.Return.PostTransaction(tranId, valueDate, officeId, userId, loginId, storeId, partyCode, priceTypeId, referenceNumber, statementReference, details, attachments));
        }
示例#14
0
        public List <StockTransaction> GetStockTransactionWithRedis(string code, DateTime begin, DateTime end)
        {
            logger.Info(string.Format("begin to fetch stock{0} daily data from {1} to {2}...", code, begin, end));
            var stocks = new List <StockTransaction>();

            if (redis == false)
            {
                return(stocks);
            }
            var tradingDates = dateRepo.GetStockTransactionDate(begin, end);

            if (tradingDates != null && tradingDates.Count > 0)
            {
                foreach (var date in tradingDates)
                {
                    StockTransaction trans = FetchStockFromRedis(code, date);
                    if (trans == null)//just run once
                    {
                        LoadStockTransactionToSqlFromSource(code, tradingDates);
                        LoadStockTransactionToRedisFromSql(code, tradingDates);
                        trans = FetchStockFromRedis(code, date);
                    }
                    stocks.Add(trans);
                }
            }
            logger.Info(string.Format("completed fetching stock{0} daily data from {1} to {2}...", code, begin, end));
            return(stocks);
        }
示例#15
0
        // Remove Stock
        public ActionResult TakeStock(int productItemId, int stockQty, string quantity, ProductItem item)// Performs almost the same as the above method, but where the previous method added stock, this one takes away
        {
            try
            {
                ProductItem myProductItem = _productService.GetProductItem(productItemId);

                myProductItem.StockQty = (stockQty - int.Parse(quantity));

                _productService.EditProductItem(myProductItem);

                var user = User.Identity.Name;
                StockTransaction stockTransaction = new StockTransaction() //And logs who has taken stock away and when
                {
                    ProductItemId = productItemId,
                    AddedBy       = user,
                    CurrentStock  = stockQty,
                    QtyToAdd      = -int.Parse(quantity),
                    DateAdded     = DateTime.Now,
                };
                _productService.AddStockTransaction(stockTransaction);
            }
            catch (Exception ex)
            {
                Console.Out.WriteLine(ex);
            }

            return(Redirect(Request.UrlReferrer.ToString()));
        }
示例#16
0
        public void ToggleProductItem(ProductItem productItem, string user) // This method toggles the Enable/Disabled function of a productItem.
        {
            ProductItem myProductItem = GetProductItem(productItem.ProductItemId);

            if (myProductItem.Discontinued == true) // If discontinued
            {
                myProductItem.Discontinued = false; // Change to active
            }
            else
            {
                StockTransaction stockTransaction = new StockTransaction()  //In addition to toggling the status, this method removes all current stock on the item being discontinued and logs it in the stock transaction table
                {
                    ProductItemId = myProductItem.ProductItemId,
                    AddedBy       = user,
                    CurrentStock  = myProductItem.StockQty,
                    QtyToAdd      = -myProductItem.StockQty,
                    DateAdded     = DateTime.Now
                };

                AddStockTransaction(stockTransaction);

                myProductItem.Discontinued = true;
                myProductItem.StockQty     = 0;
            }
            EditProductItem(myProductItem);
            _context.SaveChanges();
        }
示例#17
0
        private async void addButton_Click(object sender, EventArgs e)
        {
            if (!ValidateForm())
            {
                MessageBox.Show("Invalid data");
                return;
            }

            var newTransaction = new StockTransaction();

            newTransaction.TransactionType = transactionTypeCombobox.Text;
            newTransaction.ParentId        = _selectedProduct.Id;
            newTransaction.Id                    = Guid.NewGuid();
            newTransaction.DateAdded             = DateTime.Now;
            newTransaction.NProductsAddedRemoved = int.Parse(nBoughtSoldTextbox.Text);
            newTransaction.Price                 = Decimal.Parse(transactionPriceTextbox.Text);
            newTransaction.Details               = transactionDetailsTextbox.Text;

            await _transactionManager.SaveTransactionAsync(newTransaction);

            transactionTypeCombobox.Text   = "";
            nBoughtSoldTextbox.Text        = "";
            transactionPriceTextbox.Text   = "";
            transactionDetailsTextbox.Text = "";

            MessageBox.Show("Transaction successfully added");
        }
        public Message actionCreateNewDiscrepancy(Discrepancy discrepancy)
        {
            discrepancy.datetime_reported = DateTime.Now;
            data.Discrepancies.AddObject(discrepancy);

            Stationery stationery = data.Stationeries.Where(o => o.id == discrepancy.stationery).Single();

            stationery.quantity_in_stock = stationery.quantity_in_stock - discrepancy.quantity;

            StockTransaction stockTransaction = new StockTransaction();

            stockTransaction.stationery        = stationery.id;
            stockTransaction.quantity          = "-" + discrepancy.quantity;
            stockTransaction.description       = discrepancy.remark;
            stockTransaction.balance           = stationery.quantity_in_stock.ToString();
            stockTransaction.datetime_inserted = DateTime.Now;
            data.StockTransactions.AddObject(stockTransaction);

            try
            {
                if (data.SaveChanges() == 3)
                {
                    return(new Message(true));
                }
                else
                {
                    return(new Message(false));
                }
            }
            catch (Exception e)
            {
                return(new Message(false, Helper.getExceptionMessage(e)));
            }
        }
示例#19
0
        //Stock Transaction API
        public bool AddAPIStockTransaction(StockTransaction stockTransaction) // Adds Stock Transaction so outside enties that consume our code are logged and aufited as well
        {
            {
                try
                {
                    _context.StockTransaction.Add(stockTransaction);
                    _context.SaveChanges();
                    return(true);
                }
                catch (DbEntityValidationException ex)
                {
                    foreach (var eve in ex.EntityValidationErrors)
                    {
                        Console.WriteLine("Entity of type \"{ 0}\" in state \"{1}\" has the following validation errors:",
                                          eve.Entry.Entity.GetType().Name, eve.Entry.State);
                        foreach (var ve in eve.ValidationErrors)
                        {
                            Console.WriteLine("- Property: \"{0}\", Value: \"{1}\", Error: \"{2}\"",
                                              ve.PropertyName,
                                              eve.Entry.CurrentValues.GetValue <object>(ve.PropertyName),
                                              ve.ErrorMessage);
                        }
                    }
                    return(false);

                    throw;
                }
            }
        }
        public List <StockTransaction> GetStockTransactionWithRedis(string code, DateTime start, DateTime end)
        {
            //logger.Info(string.Format("begin to fetch stock{0} minute data from {1} to {2}...", code, start, end));
            var stocks = new List <StockTransaction>();

            if (redis == false)
            {
                return(stocks);
            }
            var tradingDates = dateTimeRepo.GetStockTransactionDate(start.Date, end.Date == DateTime.Now.Date?end.Date.AddDays(-1):end.Date);
            var timeInterval = new StockMinuteInterval(start, end, tradingDates);

            while (timeInterval.MoveNext())
            {
                var currentTime        = timeInterval.Current;
                StockTransaction stock = FetchStockMinuteTransFromRedis(code, currentTime);
                if (stock == null)
                {
                    //从万德客户端API获取分钟数据
                    BulkLoadStockMinuteToSqlFromSource(code, currentTime);
                    BulkLoadStockMinuteToRedisFromSql(code, currentTime);
                    stock = FetchStockMinuteTransFromRedis(code, currentTime);
                }

                stocks.Add(stock);
            }
            //logger.Info(string.Format("completed fetching stock{0} minute data from {1} to {2}...", code, start, end));
            return(stocks);
        }
示例#21
0
        public long Save(long tranId, DateTime valueDate, int storeId, string partyCode, int priceTypeId,
                         string referenceNumber, string data, string statementReference, string attachmentsJSON)
        {
            try
            {
                if (!StockTransaction.IsValidStockTransactionByTransactionMasterId(AppUsers.GetCurrentUserDB(), tranId))
                {
                    throw new InvalidOperationException(Warnings.InvalidStockTransaction);
                }

                if (!StockTransaction.IsValidPartyByTransactionMasterId(AppUsers.GetCurrentUserDB(), tranId, partyCode))
                {
                    throw new InvalidOperationException(Warnings.InvalidParty);
                }

                Collection <StockDetail> details = CollectionHelper.GetStockMasterDetailCollection(data, storeId);


                Collection <Attachment> attachments = CollectionHelper.GetAttachmentCollection(attachmentsJSON);

                int  officeId = AppUsers.GetCurrentLogin().View.OfficeId.ToInt();
                int  userId   = AppUsers.GetCurrentLogin().View.UserId.ToInt();
                long loginId  = AppUsers.GetCurrentLogin().View.LoginId.ToLong();

                return(Data.Transactions.Return.PostTransaction(AppUsers.GetCurrentUserDB(), tranId, valueDate, officeId, userId, loginId, storeId,
                                                                partyCode, priceTypeId, referenceNumber, statementReference, details, attachments));
            }
            catch (Exception ex)
            {
                Log.Warning("Could not save purchase return entry. {Exception}", ex);
                throw;
            }
        }
示例#22
0
        private async void transactionsListView_DoubleClick(object sender, EventArgs e)
        {
            ProductModel product = _product;

            if (product == null)
            {
                Guid ProductId = Guid.Empty;

                Guid.TryParse(transactionsListView.SelectedItems[0].SubItems[1].Text, out ProductId);

                product = await _productManager.GetProductByGuid(ProductId);
            }


            Guid TransactionId = Guid.Empty;

            Guid.TryParse(transactionsListView.SelectedItems[0].SubItems[0].Text, out TransactionId);

            StockTransaction transaction = await _transactionManager.GetStockTransactionById(TransactionId);

            _selectedTransaction = transaction;

            nameParentProductTextbox.Text      = product.Name;
            transactionDateTextbox.Text        = transaction.DateAdded.ToLongDateString();
            transactionDescriptionTextbox.Text = transaction.Details;
            transactionTypeCombobox.Text       = transaction.TransactionType;
            transactionPriceTextbox.Text       = transaction.Price.ToString();
            nBoughtSoldTextbox.Text            = transaction.NProductsAddedRemoved.ToString();
        }
        public Message actionCreateNewDiscrepancy(Discrepancy discrepancy)
        {
            discrepancy.datetime_reported = DateTime.Now;
            data.Discrepancies.AddObject(discrepancy);

            Stationery stationery = data.Stationeries.Where(o => o.id == discrepancy.stationery).Single();
            stationery.quantity_in_stock = stationery.quantity_in_stock - discrepancy.quantity;

            StockTransaction stockTransaction = new StockTransaction();
            stockTransaction.stationery = stationery.id;
            stockTransaction.quantity = "-" + discrepancy.quantity;
            stockTransaction.description = discrepancy.remark;
            stockTransaction.balance = stationery.quantity_in_stock.ToString();
            stockTransaction.datetime_inserted = DateTime.Now;
            data.StockTransactions.AddObject(stockTransaction);

            try
            {
                if (data.SaveChanges() == 3)
                {
                    return new Message(true);
                }
                else
                {
                    return new Message(false);
                }
            }
            catch (Exception e)
            {
                return new Message(false, Helper.getExceptionMessage(e));
            }
        }
示例#24
0
        public async Task <IHttpActionResult> CreateStockTransaction(StockItemViewModel stockItem)
        {
            if (!ModelState.IsValid)
            {
                foreach (var v in ModelState.Values)
                {
                    foreach (var e in v.Errors)
                    {
                        if (e.Exception != null)
                        {
                            return
                                (BadRequest(
                                     "Something went wrong. Please check your form fields for disallowed or missing values."));
                        }
                    }
                }

                return(BadRequest(ModelState));
            }

            if (stockItem.StockItemQuantity == 0)
            {
                return(BadRequest("You can't add a quantity of 0."));
            }

            var stockTransaction = new StockTransaction
            {
                StockTransactionItem     = db.StockItems.FirstOrDefault(g => g.StockItemGuid == stockItem.StockItemGuid),
                StockTransactionDate     = DateTime.Now,
                StockTransactionGuid     = Guid.NewGuid(),
                StockTransactionQuantity = stockItem.StockItemQuantity,
                StockTransactionUser     = UserManager().FindById(User.Identity.GetUserId()),
                StockTransactionOrder    =
                    stockItem.Order == null
                        ? null
                        : await db.Orders.FirstOrDefaultAsync(g => g.OrderGuid == stockItem.Order.OrderGuid),
                StockTransactionSupply =
                    stockItem.Supply == null
                        ? null
                        : await db.Supplys.FirstOrDefaultAsync(g => g.SupplyGuid == stockItem.Supply.SupplyGuid)
            };

            db.StockTransactions.Add(stockTransaction);

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateException)
            {
                if (StockExists(stockTransaction.StockTransactionItem.StockItemStock.StockGuid))
                {
                    return(Conflict());
                }
                throw;
            }

            return(CreatedAtRoute("DefaultApi", new { id = stockTransaction.StockTransactionGuid }, stockTransaction));
        }
示例#25
0
        public static void PostIssue(int issueId)
        {
            // Open a connection manualy since EF has issues with MSDTC transactions
            var connection = new EntityConnection(ConfigurationManager.ConnectionStrings[INVENTORY_CONNECTION].ConnectionString);

            connection.Open();

            var context   = new InventoryEntities(connection);
            var issue     = context.Issues.Single(i => i.IssueId == issueId);
            var warehouse = issue.WarehouseId;

            try
            {
                using (EntityTransaction scope = connection.BeginTransaction())
                {
                    foreach (var item in issue.IssueItems)
                    {
                        // 1. Check the availablity of stock (ItemId and WarehouseId)
                        var stock = context.StockStatus.Single(s => s.ItemId == item.ItemId && s.WarehouseId == warehouse);

                        // 2. If availalbe < requested then throw an error
                        if (stock.Quantity < item.Quantity)
                        {
                            var msg = "Error posting current record. The requested and available quantity do not match.\n";
                            msg += string.Format("Item: {0} \nAvailable Quantity: {1}\nRequested Quantity:{2}", item.ItemDetail.ItemNo, stock.Quantity, item.Quantity);
                            throw new ApplicationException(msg);
                        }

                        // 3. If available > requested then update balance and set status of issue to posted.
                        var status = context.StockStatus.Single(s => s.ItemId == item.ItemId && s.WarehouseId == warehouse);
                        status.Quantity -= item.Quantity;

                        // 4. Add transaction log to stock_transaction
                        var transaction = new StockTransaction();
                        transaction.TransactionTypeId = OWNER_ISSUE;
                        transaction.OwnerId           = issue.IssueId;
                        transaction.ItemId            = item.ItemId;
                        transaction.Quantity          = item.Quantity;
                        transaction.WarehouseId       = warehouse;
                        transaction.TransactionDate   = DateTime.Now;
                        AddTransactionRecord(transaction);

                        issue.StatusId   = STATUS_POSTED;
                        issue.PostedDate = DateTime.Now;  //TODO: Consider getting the date from the server instead of the client.
                        var user = SecurityHelper.GetUserDetail(Thread.CurrentPrincipal.Identity.Name);
                        issue.PostedBy = string.Format("{0} ({1})", user.FullName, user.UserName);

                        // SEND ALL CHANGES TO THE DATABASE - MIGHTY SAVE!!!!!!
                        context.SaveChanges();

                        scope.Commit();
                    }
                }
            }
            catch (Exception exception)
            {
                throw new ApplicationException("Error occured while posting the current issue.", exception);
            }
        }
        public ActionResult DeleteConfirmed(int id)
        {
            StockTransaction stockTransaction = db.StockOrders.Find(id);

            db.StockOrders.Remove(stockTransaction);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
示例#27
0
        private bool ValidateDetails(IEnumerable <StockMasterDetailModel> details, long stockMasterId)
        {
            foreach (var model in details)
            {
                return(StockTransaction.ValidateItemForReturn(stockMasterId, model.StoreId, model.ItemCode, model.UnitName, model.Quantity, model.Price));
            }

            return(false);
        }
        public async Task <ActionResult> CreateTransaction(StockTransaction transaction)
        {
            transaction.Date = DateTime.Now;
            // transaction.UserId = User.FindFirstValue(ClaimTypes.NameIdentifier);
            transaction.UserId = await _transactionService.GetUserId();

            var stockTrans = await _transactionService.CreateTransaction(transaction);

            return(Ok(stockTrans));
        }
示例#29
0
        public OpeningStockViewModel SaveOpeningStock(OpeningStockViewModel model)
        {
            exceptionService.Execute((m) =>
            {
                if (model.Details.Count == 0)
                {
                    model.Errors.Add(new ValidationResult("Please enter detail.", new string[] { "" }));
                }

                if (model.Errors.Any())
                {
                    return;
                }

                if (!model.Validate())
                {
                    return;
                }

                var entity = new StockTransaction();

                if (model.Id > 0)
                {
                    entity         = stockTransactionReporsitory.GetById(model.Id);
                    entity.Date    = model.DateBS.GetDate();
                    entity.Remarks = model.Remarks;
                    stockTransanctionDetailRepository.DeleteRange(entity.StockTransactionDetails);
                }
                else
                {
                    model.DocumentSetupId = (int)eDocumentSetup.Opening;
                    model.Date            = model.DateBS.GetDate();
                    entity = AutomapperConfig.Mapper.Map <StockTransaction>(model);
                    stockTransactionReporsitory.Insert(entity);
                }

                foreach (var item in model.Details)
                {
                    var detail = AutomapperConfig.Mapper.Map <StockTransactionDetail>(item);
                    detail.StockTransactionId = entity.Id;
                    stockTransanctionDetailRepository.Insert(detail);
                }

                if (model.Id == 0)
                {
                    model.Message = localizationService.GetLocalizedText("Message.DataSavedSuccessfully", "Data saved successfully.");
                }
                else
                {
                    model.Message = localizationService.GetLocalizedText("Message.DataSavedSuccessfully", "Save changes successfully.");
                }
            }, model);

            return(model);
        }
示例#30
0
        public async Task InsertStockTransaction(StockTransaction stockTransaction)
        {
            EnsureDirectoryExist();

            var stockTransactions = (await GetStockTransactionsBy(stockTransaction.CustomerId)).ToList();

            stockTransaction.Id = !stockTransactions.Any() ? 1 : stockTransactions.Max(trx => trx.Id) + 1;
            stockTransactions.Add(stockTransaction);

            await UpsertStockTransactions(stockTransactions, stockTransaction.CustomerId);
        }
示例#31
0
        public async Task <StockTransactionVM> GetAsync(string id)
        {
            StockTransaction transaction = await _mediator.Send(new GetSingleRequest <StockTransaction>(id));

            if (transaction == null)
            {
                _notifications.AddNotification("404", "stock transaction was not found.");
            }

            return(transaction.ToVM());
        }
        public void actionCreateStockTransaction(int stationery, int balance, String description, String quantity)
        {
            StockTransaction st=new StockTransaction();
            st.stationery=stationery;
            st.balance = balance.ToString();
            st.description = description;
            st.quantity = quantity;
            st.datetime_inserted = DateTime.Now;

            data.StockTransactions.AddObject(st);
            data.SaveChanges();
        }
 public static StockTransaction CreateStockTransaction(int ID, string transactionPeriod, global::System.DateTime transactionDate, string transactionNo, string transactionType, short itemSequence, int locationId, int productId, string lotNo, double quantity, decimal costPrice, byte[] rowVersion)
 {
     StockTransaction stockTransaction = new StockTransaction();
     stockTransaction.Id = ID;
     stockTransaction.TransactionPeriod = transactionPeriod;
     stockTransaction.TransactionDate = transactionDate;
     stockTransaction.TransactionNo = transactionNo;
     stockTransaction.TransactionType = transactionType;
     stockTransaction.ItemSequence = itemSequence;
     stockTransaction.LocationId = locationId;
     stockTransaction.ProductId = productId;
     stockTransaction.LotNo = lotNo;
     stockTransaction.Quantity = quantity;
     stockTransaction.CostPrice = costPrice;
     stockTransaction.RowVersion = rowVersion;
     return stockTransaction;
 }
 public void AddToStockTransactions(StockTransaction stockTransaction)
 {
     base.AddObject("StockTransactions", stockTransaction);
 }