Exemple #1
0
        public PaginatedListResult <PortfolioTransactionModel> Save(PortfolioTransactionModel model)
        {
            string filePath = string.Empty;

            if (model.PortfolioTransactionID <= 0)
            {
                filePath = System.IO.Path.Combine(Helper.RootPath, "SQL", "Portfolio", "Insert.sql");
            }
            else
            {
                filePath = System.IO.Path.Combine(Helper.RootPath, "SQL", "Portfolio", "Update.sql");
            }
            string sql = System.IO.File.ReadAllText(filePath);
            List <SqlParameter> sqlParameterCollection = new List <SqlParameter>();

            PropertyInfo[] properties       = model.GetType().GetProperties();
            SqlParameter   sqlp             = null;
            List <String>  ignoreProperties = new List <string>()
            {
                "CompanyName", "TransactionTypeName", "Symbol", "Amount"
            };

            foreach (var p in properties)
            {
                if (ignoreProperties.Contains(p.Name) == false)
                {
                    sqlp = new SqlParameter();
                    sqlp.ParameterName = p.Name;
                    sqlp.Value         = p.GetValue(model);
                    sqlParameterCollection.Add(sqlp);
                }
            }
            SqlHelper.ExecuteNonQuery(sql, sqlParameterCollection);
            if (model.PortfolioTransactionID <= 0)
            {
                sql = "SELECT idENT_CURRENT ('PortFolioTransaction') AS Current_Identity;";
                model.PortfolioTransactionID = DataTypeHelper.ToInt32(SqlHelper.ExecuteScaler(sql, new List <SqlParameter>()));
            }
            return(this.Get(new SearchModel {
                id = model.PortfolioTransactionID, SortName = "id"
            }));
        }
        // Add Purchase Order Stocks Count To Portofolio
        public void TransferPurchaseToStocks(PurchaseInvoiceModel purchaseInvoiceModel)
        {
            var Details = purchaseInvoiceModel.DetailsModels;

            if (unitOfWork.PortfolioTransactionsRepository.Get(filter: m => m.PortfolioID == purchaseInvoiceModel.PortfolioID).Count() != 0)
            {
                var PortofolioStocks = unitOfWork.PortfolioTransactionsRepository.Get(filter: m => m.PortfolioID == purchaseInvoiceModel.PortfolioID);

                foreach (var detail in Details)
                {
                    if (PortofolioStocks.Any(x => x.PartnerID == detail.PartnerID))
                    {
                        foreach (var item in PortofolioStocks)
                        {
                            if (detail.PartnerID == item.PartnerID)
                            {
                                item.CurrentStocksCount = item.CurrentStocksCount + detail.StockCount;
                                item.CurrentStockValue  = (((decimal)item.CurrentStocksCount * item.CurrentStockValue) +
                                                           ((decimal)detail.StockCount * detail.PurchaseValue))
                                                          / (decimal)(item.CurrentStocksCount + detail.StockCount);
                                unitOfWork.PortfolioTransactionsRepository.Update(item);
                                unitOfWork.Save();
                            }
                        }
                    }
                    else
                    {
                        foreach (var item in Details)
                        {
                            PortfolioTransactionModel portfolioTransactionModel = new PortfolioTransactionModel();
                            portfolioTransactionModel.PortfolioID        = purchaseInvoiceModel.PortfolioID;
                            portfolioTransactionModel.PartnerID          = item.PartnerID;
                            portfolioTransactionModel.PortTransID        = 0;
                            portfolioTransactionModel.CurrentStocksCount = item.StockCount;
                            portfolioTransactionModel.CurrentStockValue  = item.PurchaseValue;

                            var trancaction = _mapper.Map <PortfolioTransaction>(portfolioTransactionModel);
                            unitOfWork.PortfolioTransactionsRepository.Insert(trancaction);
                            unitOfWork.Save();
                        }
                    }
                }
            }

            else
            {
                foreach (var item in Details)
                {
                    PortfolioTransactionModel portfolioTransactionModel = new PortfolioTransactionModel();
                    portfolioTransactionModel.PortfolioID        = purchaseInvoiceModel.PortfolioID;
                    portfolioTransactionModel.PartnerID          = item.PartnerID;
                    portfolioTransactionModel.PortTransID        = 0;
                    portfolioTransactionModel.CurrentStocksCount = item.StockCount;
                    portfolioTransactionModel.CurrentStockValue  = item.PurchaseValue;

                    var trancaction = _mapper.Map <PortfolioTransaction>(portfolioTransactionModel);
                    unitOfWork.PortfolioTransactionsRepository.Insert(trancaction);
                    unitOfWork.Save();
                }
            }
        }
Exemple #3
0
        public IActionResult Update(int id, [FromBody] PortfolioModel portModel)
        {
            if (id != portModel.PortfolioID)
            {
                return(Ok(1));
            }

            if (ModelState.IsValid)
            {
                if (portModel.EstablishDate == null)
                {
                    portModel.EstablishDate = DateTime.Now.ToString();
                }
                var model         = _mapper.Map <Portfolio>(portModel);
                var currentstocks = unitOfWork.PortfolioTransactionsRepository.Get(filter: x => x.PortfolioID == model.PortfolioID);

                //var Checkselles = unitOfWork.SellingInvoiceReposetory.Get(filter: q => q.PortfolioID == model.PortfolioID);
                //if (Checkselles.Any(m => m.PortfolioID == model.PortfolioID))
                //{
                //    return Ok(5);
                //}

                var Checkpurches = unitOfWork.PurchaseOrderRepository.Get(filter: q => q.PortfolioID == model.PortfolioID);
                if (Checkpurches.Any(m => m.PortfolioID == model.PortfolioID))
                {
                    return(Ok(5));
                }

                var currentStocks = unitOfWork.PortfolioTransactionsRepository.Get(x => x.PortfolioID == model.PortfolioID);
                //foreach (var item in currentStocks)
                //{
                //    if (item.HasTransaction == true)
                //    {
                //        return Ok(5);
                //    }

                //}
                // عدد الاسهم الحاليه
                if (portModel.portfolioTransactionModels != null)
                {
                    portModel.TotalStocksCount = 0;

                    foreach (var item in portModel.portfolioTransactionModels)
                    {
                        portModel.TotalStocksCount += item.CurrentStocksCount;
                    }
                }

                var OpeningStocks = portModel.portfolioOpeningStocksArray;
                var Check         = unitOfWork.PortfolioRepository.Get(NoTrack: "NoTrack");

                if (!Check.Any(m => m.Code == portModel.Code))
                {
                    unitOfWork.PortfolioRepository.Update(model);

                    // portfolio accounts
                    unitOfWork.PortfolioRepository.Update(model);
                    unitOfWork.Save();
                    var oldAccount = unitOfWork.PortfolioAccountRepository.GetEntity(x => x.PortfolioID == model.PortfolioID);
                    unitOfWork.PortfolioAccountRepository.Delete(oldAccount.PortfolioAccountID);
                    if (portModel.AccountID != null)
                    {
                        PortfolioAccountModel portfolioAccountModel = new PortfolioAccountModel();
                        portfolioAccountModel.AccountID   = portModel.AccountID;
                        portfolioAccountModel.PortfolioID = model.PortfolioID;
                        portfolioAccountModel.Type        = true;
                        var portfolioAccount = _mapper.Map <PortfolioAccount>(portfolioAccountModel);
                        unitOfWork.PortfolioAccountRepository.Insert(portfolioAccount);
                    }

                    // shareholders
                    var oldHolders = unitOfWork.PortfolioOpeningStocksRepository

                                     .Get(filter: m => m.PortfolioID == model.PortfolioID);

                    if (oldHolders != null)
                    {
                        unitOfWork.PortfolioOpeningStocksRepository.RemovRange(oldHolders);
                    }
                    if (OpeningStocks != null)
                    {
                        foreach (var item5 in OpeningStocks)
                        {
                            item5.PortfolioID = model.PortfolioID;
                            var newHolder = _mapper.Map <PortfolioOpeningStocks>(item5);

                            unitOfWork.PortfolioOpeningStocksRepository.Insert(newHolder);
                        }

                        //CurrentStocks

                        if (currentStocks != null)
                        {
                            unitOfWork.PortfolioTransactionsRepository.RemovRange(currentStocks);
                        }
                        foreach (var item6 in OpeningStocks)
                        {
                            PortfolioTransactionModel portfolioTransaction = new PortfolioTransactionModel();
                            portfolioTransaction.PortfolioID        = model.PortfolioID;
                            portfolioTransaction.PartnerID          = item6.PartnerID;
                            portfolioTransaction.CurrentStockValue  = item6.OpeningStockValue;
                            portfolioTransaction.CurrentStocksCount = item6.OpeningStocksCount;
                            var obj = _mapper.Map <PortfolioTransaction>(portfolioTransaction);
                            unitOfWork.PortfolioTransactionsRepository.Insert(obj);
                        }
                    }
                }
                else
                {
                    if (Check.Any(m => m.Code == portModel.Code && m.PortfolioID == id))
                    {
                        unitOfWork.PortfolioRepository.Update(model);

                        var oldAccount = unitOfWork.PortfolioAccountRepository.GetEntity(x => x.PortfolioID == model.PortfolioID);
                        unitOfWork.PortfolioAccountRepository.Delete(oldAccount.PortfolioAccountID);
                        // portfolio accounts
                        if (portModel.AccountID != null)
                        {
                            PortfolioAccountModel portfolioAccountModel = new PortfolioAccountModel();
                            portfolioAccountModel.AccountID   = portModel.AccountID;
                            portfolioAccountModel.PortfolioID = model.PortfolioID;
                            portfolioAccountModel.Type        = true;
                            var portfolioAccount = _mapper.Map <PortfolioAccount>(portfolioAccountModel);
                            unitOfWork.PortfolioAccountRepository.Insert(portfolioAccount);
                        }



                        // shareholders
                        var oldHolders = unitOfWork.PortfolioOpeningStocksRepository

                                         .Get(filter: m => m.PortfolioID == model.PortfolioID);

                        if (oldHolders != null)
                        {
                            unitOfWork.PortfolioOpeningStocksRepository.RemovRange(oldHolders);
                        }
                        if (OpeningStocks != null)
                        {
                            foreach (var item2 in OpeningStocks)
                            {
                                item2.PortfolioID = model.PortfolioID;
                                var newHolder = _mapper.Map <PortfolioOpeningStocks>(item2);

                                unitOfWork.PortfolioOpeningStocksRepository.Insert(newHolder);
                            }

                            //CurrentStocks
                            if (currentStocks != null)
                            {
                                unitOfWork.PortfolioTransactionsRepository.RemovRange(currentStocks);
                            }
                            foreach (var item3 in OpeningStocks)
                            {
                                PortfolioTransactionModel portfolioTransaction = new PortfolioTransactionModel();
                                portfolioTransaction.PortfolioID        = model.PortfolioID;
                                portfolioTransaction.PartnerID          = item3.PartnerID;
                                portfolioTransaction.CurrentStockValue  = item3.OpeningStockValue;
                                portfolioTransaction.CurrentStocksCount = item3.OpeningStocksCount;
                                var obj = _mapper.Map <PortfolioTransaction>(portfolioTransaction);
                                unitOfWork.PortfolioTransactionsRepository.Insert(obj);
                            }
                        }


                        var result = unitOfWork.Save();
                        if (result == 200)
                        {
                            var UserID = loggerHistory.getUserIdFromRequest(Request);

                            loggerHistory.InsertUserLog(UserID, "بطاقه المحفظه", "تعديل المحفظه", true);
                            return(Ok(4));
                        }
                        else
                        {
                            return(Ok(6));
                        }
                    }
                    else
                    {
                        if (Check.Any(m => m.Code == portModel.Code && m.PortfolioID == id))
                        {
                            unitOfWork.PortfolioRepository.Update(model);

                            var oldAccount = unitOfWork.PortfolioAccountRepository.GetEntity(x => x.PortfolioID == model.PortfolioID);
                            unitOfWork.PortfolioAccountRepository.Delete(oldAccount.PortfolioAccountID);
                            // portfolio accounts
                            if (portModel.AccountID != null)
                            {
                                PortfolioAccountModel portfolioAccountModel = new PortfolioAccountModel();
                                portfolioAccountModel.AccountID   = portModel.AccountID;
                                portfolioAccountModel.PortfolioID = model.PortfolioID;
                                portfolioAccountModel.Type        = true;
                                var portfolioAccount = _mapper.Map <PortfolioAccount>(portfolioAccountModel);
                                unitOfWork.PortfolioAccountRepository.Insert(portfolioAccount);
                            }



                            // shareholders
                            var oldHolders = unitOfWork.PortfolioOpeningStocksRepository

                                             .Get(filter: m => m.PortfolioID == model.PortfolioID);

                            if (oldHolders != null)
                            {
                                unitOfWork.PortfolioOpeningStocksRepository.RemovRange(oldHolders);
                            }
                            if (OpeningStocks != null)
                            {
                                foreach (var item2 in OpeningStocks)
                                {
                                    item2.PortfolioID = model.PortfolioID;
                                    var newHolder = _mapper.Map <PortfolioOpeningStocks>(item2);

                                    unitOfWork.PortfolioOpeningStocksRepository.Insert(newHolder);
                                }

                                //CurrentStocks
                                if (currentStocks != null)
                                {
                                    unitOfWork.PortfolioTransactionsRepository.RemovRange(currentStocks);
                                }
                                foreach (var item3 in OpeningStocks)
                                {
                                    PortfolioTransactionModel portfolioTransaction = new PortfolioTransactionModel();
                                    portfolioTransaction.PortfolioID        = model.PortfolioID;
                                    portfolioTransaction.PartnerID          = item3.PartnerID;
                                    portfolioTransaction.CurrentStockValue  = item3.OpeningStockValue;
                                    portfolioTransaction.CurrentStocksCount = item3.OpeningStocksCount;
                                    var obj = _mapper.Map <PortfolioTransaction>(portfolioTransaction);
                                    unitOfWork.PortfolioTransactionsRepository.Insert(obj);
                                }
                            }

                            var result = unitOfWork.Save();
                            if (result == 200)
                            {
                                var UserID = loggerHistory.getUserIdFromRequest(Request);

                                loggerHistory.InsertUserLog(UserID, "بطاقه المحفظه", "تعديل المحفظه", true);
                                return(Ok("Succeeded"));
                            }
                            else
                            {
                                return(Ok(6));
                            }
                        }
                        else
                        {
                            return(Ok(2));
                        }
                    }
                }
                var Result = unitOfWork.Save();
                if (Result == 200)
                {
                    var UserID = loggerHistory.getUserIdFromRequest(Request);

                    loggerHistory.InsertUserLog(UserID, "بطاقه المحفظه", "تعديل المحفظه", true);
                    return(Ok(4));
                }
                else if (Result == 501)
                {
                    return(Ok(5));
                }
                else
                {
                    return(Ok(6));
                }
            }
            else
            {
                return(Ok(3));
            }
        }
Exemple #4
0
        public IActionResult PostEmp([FromBody] PortfolioModel portModel)
        {
            if (ModelState.IsValid)
            {
                var Check = unitOfWork.PortfolioRepository.Get();
                if (portModel == null)
                {
                    return(Ok(0));
                }
                if (Check.Any(m => m.Code == portModel.Code))
                {
                    return(Ok(2));
                }
                else
                {
                    // عدد الاسهم الحاليه
                    if (portModel.portfolioTransactionModels != null)
                    {
                        portModel.TotalStocksCount = 0;

                        foreach (var item in portModel.portfolioTransactionModels)
                        {
                            portModel.TotalStocksCount += item.CurrentStocksCount;
                        }
                    }
                    if (portModel.EstablishDate == null)
                    {
                        portModel.EstablishDate = DateTime.Now.ToString();
                    }
                    var model = _mapper.Map <Portfolio>(portModel);

                    #region Bind List Accounts & Shareholders


                    var OpeningStocks = portModel.portfolioOpeningStocksArray;


                    #endregion


                    unitOfWork.PortfolioRepository.Insert(model);

                    // portfolio accounts

                    if (portModel.AccountID != null)
                    {
                        PortfolioAccountModel portfolioAccountModel = new PortfolioAccountModel();
                        portfolioAccountModel.AccountID   = portModel.AccountID;
                        portfolioAccountModel.PortfolioID = model.PortfolioID;
                        portfolioAccountModel.Type        = true;

                        var portfolioAccount = _mapper.Map <PortfolioAccount>(portfolioAccountModel);
                        unitOfWork.PortfolioAccountRepository.Insert(portfolioAccount);
                    }
                    // shareholders
                    if (OpeningStocks != null)
                    {
                        foreach (var item in OpeningStocks)
                        {
                            if (item.PortOPenStockID == 0)
                            {
                                item.PortfolioID = model.PortfolioID;
                                var obj = _mapper.Map <PortfolioOpeningStocks>(item);

                                unitOfWork.PortfolioOpeningStocksRepository.Insert(obj);
                            }
                            else
                            {
                                var obj = _mapper.Map <PortfolioOpeningStocks>(item);

                                unitOfWork.PortfolioOpeningStocksRepository.Update(obj);
                            }
                        }

                        //CurrentStocks
                        foreach (var item in OpeningStocks)
                        {
                            PortfolioTransactionModel portfolioTransaction = new PortfolioTransactionModel();
                            portfolioTransaction.PortfolioID        = model.PortfolioID;
                            portfolioTransaction.PartnerID          = item.PartnerID;
                            portfolioTransaction.CurrentStockValue  = item.OpeningStockValue;
                            portfolioTransaction.CurrentStocksCount = item.OpeningStocksCount;
                            var ob = _mapper.Map <PortfolioTransaction>(portfolioTransaction);
                            unitOfWork.PortfolioTransactionsRepository.Insert(ob);
                        }
                    }



                    var Result = unitOfWork.Save();
                    if (Result == 200)
                    {
                        var UserID = loggerHistory.getUserIdFromRequest(Request);

                        loggerHistory.InsertUserLog(UserID, "بطاقه المحفظه", "اضافه المحفظه", true);
                        return(Ok(4));
                    }
                    else if (Result == 501)
                    {
                        return(Ok(5));
                    }
                    else
                    {
                        return(Ok(6));
                    }
                }
            }
            else
            {
                return(Ok(3));
            }
        }
        public ActionResult Save(PortfolioTransactionModel model)
        {
            IPortfolioRepository repository = new PortfolioRepository();

            return(Ok(repository.Save(model)));
        }