public IEnumerable <IValidationIssue> ApplyIfValid( RootModel model, Taxonomy taxonomy, RepositoryManager repositoryManager, String username, String userEmail, SqlConnection connection, SecurityRepository securityRepository, BasketRepository basketRepository, PortfolioRepository portfolioRepository, CalculationTicket ticket, ref CalculationInfo info ) { var issues = this.ValidateModelAndPermissions(model, username, ticket); var traverser = new IssueTraverser(); var traversedIssues = traverser.TraverseAll(issues); if (traversedIssues.Any(x => x is ErrorIssue)) { return(issues); } try { this.Apply(model, taxonomy, repositoryManager, username, userEmail, connection, securityRepository, basketRepository, portfolioRepository, ref info); return(issues); } catch (ValidationException exception) { return(issues.Union(new IValidationIssue[] { exception.Issue })); } }
public void GetAll_Return_Valu() { //Arrange var options = new DbContextOptionsBuilder <ExchangeContext>() .UseInMemoryDatabase(databaseName: "GetPortfolio") .Options; using (var context = new ExchangeContext(options)) { var trade = new List <Trade> { new Trade { Action = "Buy", NoOfShares = 302, Id = 2, Price = 2332 } }; context.Portfolios.Add(new Portfolio { Id = 1, Name = "Adewale Johnson", Trade = trade }); context.SaveChanges(); //Act IPortfolioRepository repo = new PortfolioRepository(context); var result = repo.GetAll(); //Assert Assert.NotNull(result); } }
public void Initialize( RootModel root, SecurityRepository securityRepository, PortfolioRepository portfolioRepository, ManagingPst.PortfolioSecurityTargetRepository portfolioSecurityTargetRepository ) { var allFlatTargets = new List <BuPortfolioSecurityTargetInfo>(); foreach (var overlayItem in root.Factors.Items) { var factor = overlayItem.OverlayFactor.EditedValue; if (!factor.HasValue) { continue; } var flatTargets = this.targetsFlattener.Flatten( overlayItem.BottomUpPortfolio.Id, factor.Value, portfolioSecurityTargetRepository, portfolioRepository ).ToArray(); allFlatTargets.AddRange(flatTargets); var s = allFlatTargets.Sum(a => a.Target); } var resolver = new IsoCodeToOverlayTargetValueResolver(securityRepository, allFlatTargets); this.Initialize(root, resolver); }
public void GetPortfolioScreenshots() { try { var options = CreateNewContextOptions(); using (var db = new PortfolioContext(options)) { var repository = new PortfolioRepository(db); WorkTestHelper.PopulateDefaultDataPortfolioCtx(db); var item = GenerateModel(); Assert.DoesNotThrow(() => repository.Save(item)); var portfolioVideo = new PortfolioScreenshot { Screenshot = GenerateAttachment(), Description = "myNew Video" }; IEnumerable <PortfolioScreenshot> result = null; Assert.DoesNotThrow(() => result = repository.GetPortfolioScreenshots(item.Id)); Assert.True(result == null || !result.Any()); Assert.DoesNotThrow(() => repository.AddScreenshot(item, portfolioVideo)); Assert.DoesNotThrow(() => repository.AddScreenshot(item, new PortfolioScreenshot { Screenshot = GenerateAttachment(), Description = "myNew Video" })); Assert.DoesNotThrow(() => result = repository.GetPortfolioScreenshots(item.Id)); Assert.NotNull(result); Assert.True(result.Count() == 2); } } catch (Exception ex) { LogEventManager.Logger.Error(ex); throw; } }
public void RemoveScreenShot() { try { var options = CreateNewContextOptions(); using (var db = new PortfolioContext(options)) { var repository = new PortfolioRepository(db); WorkTestHelper.PopulateDefaultDataPortfolioCtx(db); var item = GenerateModel(); Assert.DoesNotThrow(() => repository.Save(item)); var portfolioVideo = new PortfolioScreenshot { Screenshot = GenerateAttachment(), Description = "myNew Video" }; Assert.DoesNotThrow(() => repository.AddScreenshot(item, portfolioVideo)); Assert.DoesNotThrow(() => repository.RemoveScreenshot(item, portfolioVideo)); } } catch (Exception ex) { LogEventManager.Logger.Error(ex); throw; } }
public IEnumerable <IValidationIssue> ApplyIfValid( RootModel root, String username, String userEmail, SqlConnection connection, TargetingTypeRepository targetingTypeRepository, SecurityRepository securityRepository, BasketRepository basketRepository, PortfolioRepository portfolioRepository, CalculationTicket ticket, ref CalculationInfo info ) { var targetingType = targetingTypeRepository.GetTargetingType(root.TargetingType.Id); var issues = this.modelApplier.ApplyIfValid( root, targetingType.Taxonomy, this.repositoryManager, username, userEmail, connection, securityRepository, basketRepository, portfolioRepository, ticket, ref info ); return(issues); }
public TargetingType DeserializeToTargetingType( TargetingTypeInfo targetingTypeInfo, TaxonomyRepository taxonomyRepository, IEnumerable <TargetingTypePortfolioInfo> whateverPortfolioCompositionInfos, PortfolioRepository portfolioRepository ) { var taxonomy = taxonomyRepository.GetTaxonomy(targetingTypeInfo.TaxonomyId); var owned = whateverPortfolioCompositionInfos .Where(x => x.TargetingTypeId == targetingTypeInfo.Id); var broadGlobalActivePortfolios = owned .Select(x => portfolioRepository.FindBroadGlobalActivePortfolio(x.PortfolioId)) .Where(x => x != null); var bottomUpPortfolios = this.GetBottomUpPortfolios(owned, portfolioRepository); var result = new TargetingType( targetingTypeInfo.Id, targetingTypeInfo.Name, targetingTypeInfo.TargetingTypeGroupId, targetingTypeInfo.BenchmarkIdOpt, taxonomy, broadGlobalActivePortfolios, bottomUpPortfolios ); return(result); }
public RootModel DeserializeFromJson( String bpstModelAsJson, SecurityRepository securityRepository, TargetingTypeGroupRepository targetingTypeGroupRepository, BasketRepository basketRepository, PortfolioRepository portfolioRepository, IOnDemand <IDataManager> ondemandManager ) { using (var reader = new JsonReader(new Newtonsoft.Json.JsonTextReader(new StringReader(bpstModelAsJson)))) { var result = reader.Read(delegate { return(this.modelDeserializer.DeserializeRoot( reader, securityRepository, targetingTypeGroupRepository, basketRepository, portfolioRepository, this.repositoryManager, ondemandManager )); }); return(result); } }
/// <summary> /// Method that returns all Portfolios used in this example /// </summary> /// <returns>List of Portfolios</returns> public static IList<TBL_Portfolio> GetPortfolios() { PortfolioRepository portRepo = null; portRepo = new PortfolioRepository(); var portfolios = portRepo.GetAll().ToList(); return portfolios; }
public ActionResult Delete([FromQuery] int id) { IPortfolioRepository repository = new PortfolioRepository(); repository.Delete(id); return(Ok()); }
public void Store() { File.Copy("testportfolio_no_header.csv", "store.csv", true); var sut = new PortfolioRepository("store.csv"); var p = sut.Load(); p.Entries[0].Qty = 100; p.Entries[1].Symbol = "XXX"; p.Entries.Add(new Portfolio.Stock { Name = "Test", Symbol = "TTT", Currency = "USD", Bought = new DateTime(2010, 1, 2), Qty = 99, BuyingPrice = 100.0m, CurrentPrice = 111.0m, LastUpdated = new DateTime(2019, 5, 2) }); sut.Store(p); var lines = File.ReadAllLines("x.csv"); Assert.Equal(4, lines.Length); Assert.StartsWith("Apple", lines[0]); Assert.StartsWith("Test", lines[3]); Assert.EndsWith("2019-05-02", lines[3]); p = sut.Load(); Assert.Equal(100, p.Entries[0].Qty); Assert.Equal("XXX", p.Entries[1].Symbol); Assert.Equal(111.0m, p.Entries[3].CurrentPrice); }
public SecurityModel CreateSecurity( TargetingTypeGroup targetingTypeGroup, IBasket basket, ISecurity security, IEnumerable <BroadGlobalActivePortfolio> bgaPortfolios, TargetingTypeGroupBasketSecurityBaseValueRepository ttgbsbvRepository, BasketSecurityPortfolioTargetRepository bsptRepository, PortfolioRepository portfolioRepository ) { var portfolioTargets = new List <PortfolioTargetModel>(); var targetsOfSecurity = bsptRepository.GetTargets(basket, security); var targetsByPortfolio = targetsOfSecurity.ToDictionary(x => x.PortfolioId); foreach (var bgaPortfolio in bgaPortfolios) { var portfolioTargetExpression = this.modelBuilder.CreatePortfolioTargetExpression(bgaPortfolio.Name); var portfolioModel = new PortfolioTargetModel(bgaPortfolio, portfolioTargetExpression); BasketPortfolioSecurityTargetInfo target; if (targetsByPortfolio.TryGetValue(bgaPortfolio.Id, out target)) { // there is a target for the given portfolio portfolioModel.Target.InitialValue = target.Target; } portfolioTargets.Add(portfolioModel); } var baseExpression = this.modelBuilder.CreateBaseExpression(); var baseInfoOpt = ttgbsbvRepository.TryGetBaseValue(targetingTypeGroup, basket, security); if (baseInfoOpt != null) { // there is a base value for this security already defined baseExpression.InitialValue = baseInfoOpt.BaseValue; } else { // it will have a default base value which is null) } var benchmarkExpression = this.modelBuilder.CreateBenchmarkExpression(); var baseActiveExpression = this.modelBuilder.CreateBaseActiveExpression(baseExpression, benchmarkExpression); var securityModel = new SecurityModel( security, baseExpression, benchmarkExpression, portfolioTargets, baseActiveExpression ); return(securityModel); }
public CoreModel GetCoreModel( TargetingTypeGroup targetingTypeGroup, IBasket basket, SecurityRepository securityRepository, TargetingTypeGroupBasketSecurityBaseValueRepository ttgbsbvRepository, BasketSecurityPortfolioTargetRepository bpstRepository, PortfolioRepository portfolioRepository ) { var bgaPortfolios = targetingTypeGroup.GetBgaPortfolios(); // both base values and target values can contribute to the list of securities var securityIds = ttgbsbvRepository .GetBaseValues(targetingTypeGroup, basket).Select(x => x.SecurityId) .Union(bpstRepository.GetTargets(basket).Select(x => x.SecurityId)); var securityModels = new List <SecurityModel>(); foreach (var securityId in securityIds) { var security = securityRepository.GetSecurity(securityId); var securityModel = this.CreateSecurity( targetingTypeGroup, basket, security, bgaPortfolios, ttgbsbvRepository, bpstRepository, portfolioRepository ); securityModels.Add(securityModel); } var portfolios = bgaPortfolios.Select(portfolio => { return(new PortfolioModel( portfolio, this.modelBuilder.CreatePortfolioTargetTotalExpression(portfolio, securityModels) )); } ).ToArray(); var baseTotalExpression = this.modelBuilder.CreateBaseTotalExpression(securityModels); var benchmarkTotalExpression = this.modelBuilder.CreateBenchmarkTotalExpression(securityModels); var baseActiveTotalExpression = this.modelBuilder.CreateBaseActiveTotalExpression(securityModels); var core = new CoreModel( targetingTypeGroup, basket, portfolios, securityModels, baseTotalExpression, benchmarkTotalExpression, baseActiveTotalExpression ); return(core); }
public void Load_with_no_header() { var sut = new PortfolioRepository("testportfolio_no_header.csv"); var result = sut.Load(); Assert.Equal(3, result.Entries.Count); Assert.Equal("AAPL", result.Entries[0].Symbol); Assert.Equal(7, result.Entries[1].Qty); Assert.Equal(new DateTime(2018, 9, 15), result.Entries[2].Bought); }
public Mail_IChangeResolver(ChangesetApplier applier, IDataManager manager, SecurityRepository securityRepository, PortfolioRepository portfolioRepository, List <String> mail, String username, DateTime date, String portfolioName) { this.applier = applier; this.manager = manager; this.mail = mail; this.username = username; this.date = date; this.securityRepository = securityRepository; this.portfolioName = portfolioName; this.portfolioRepository = portfolioRepository; }
protected void Apply( RootModel model, Taxonomy taxonomy, RepositoryManager repositoryManager, String username, String userEmail, SqlConnection connection, SecurityRepository securityRepository, BasketRepository basketRepository, PortfolioRepository portfolioRepository, ref CalculationInfo calculationInfo ) { using (var transaction = connection.BeginTransaction()) { var manager = this.dataManagerFactory.CreateDataManager(connection, transaction); var btChangesetOpt = this.btModelTransformer.TryTransformToChangeset(model, taxonomy); if (btChangesetOpt != null) { // saving unsaved baskets and modified taxonomy this.btChangesetApplier.Apply(btChangesetOpt, connection, transaction, repositoryManager); } var pstoChangesetOpt = this.pstoModelTransformer.TryTransformToChangeset(model, username); var ttbbvChangesetOpt = this.ttbbvModelTransformer.TryTransformToChangeset(model, username); var ttbptChangesetOpt = this.ttbptModelTransformer.TryTransformToChangeset(model, username); if (pstoChangesetOpt == null && ttbbvChangesetOpt == null && ttbptChangesetOpt == null) { return; // no changes to apply, why bother? } calculationInfo = this.calculationRequester.RequestCalculation(manager); if (pstoChangesetOpt != null) { this.pstoChangesetApplier.Apply(calculationInfo.Id, pstoChangesetOpt, manager); } if (ttbbvChangesetOpt != null) { this.ttbbvChangesetApplier.Apply(calculationInfo.Id, ttbbvChangesetOpt, manager); } if (ttbptChangesetOpt != null) { this.ttbptChangesetApplier.Apply(calculationInfo.Id, ttbptChangesetOpt, manager); } SendNotification(model.TargetingType.Name, model.Portfolio.Name, pstoChangesetOpt, ttbbvChangesetOpt, ttbptChangesetOpt, manager, securityRepository, basketRepository, portfolioRepository, userEmail); //#warning HACK!!! prevent test changes to DB //transaction.Rollback(); transaction.Commit(); } }
public void SetUp() { var config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build(); var connectionString = config["ConnectionStrings:DefaultConnection"]; var exchangeContext = new DbContextOptionsBuilder <ExchangeContext>(); exchangeContext.UseSqlServer(connectionString); PortfolioRepository = new PortfolioRepository(new ExchangeContext(exchangeContext.Options)); TradeRepository = new Mock <ITradeRepository>(); ShareRepository = new ShareRepository(new ExchangeContext(exchangeContext.Options)); }
public void TradeRepository_GetAllTest() { var optionsbuilder = new DbContextOptionsBuilder <ExchangeContext>(); optionsbuilder.UseInMemoryDatabase(databaseName: "XOProjectDb"); var _dbContext = new ExchangeContext(optionsbuilder.Options); IPortfolioRepository _portfolioRepository = new PortfolioRepository(_dbContext); var result = _portfolioRepository.GetAll(); Assert.NotNull(result); }
public void PortfolioReturns() { using (var db = new ApplicationDbContext(null)) { var portfolioLines = new PortfolioRepository(db).GetPortfolioRetLines(); foreach (var l in portfolioLines) { Console.WriteLine(l); } } }
public void PortfolioQuery() { var repo = new PortfolioRepository("smallportfolio.csv"); var sut = new MessageHandling(repo, null); var result = sut.Handle(new PortfolioQuery()); Assert.Equal(180.0m, result.PortfolioValue); Assert.Equal(0.5m, result.PortfolioRateOfReturn); Assert.Equal(20.0m, result.Stocks[0].CurrentValue); Assert.Equal(0.45m, result.Stocks[1].RateOfReturn, 2); }
public void Get_Portfolio() { try { var options = CreateNewContextOptions(); using (var db = new PortfolioContext(options)) { var repository = new PortfolioRepository(db); WorkTestHelper.PopulateDefaultDataPortfolioCtx(db); var item = GenerateModel(); var item2 = GenerateModel(); item2.UserId = 2; item2.Code = "code2"; IEnumerable <PortfolioItem> result = null; Assert.DoesNotThrow(() => repository.Save(item)); Assert.DoesNotThrow(() => repository.Save(item2)); Assert.DoesNotThrow(() => result = repository.Get(new PortfolioFilter { UserId = 1 })); Assert.NotNull(result); Assert.True(result.Count() == 1); Assert.DoesNotThrow(() => result = repository.Get(new PortfolioFilter { UserId = 1, FinishDateStart = DateTime.Now.AddDays(-1), FinishDateEnd = DateTime.Now })); Assert.NotNull(result); Assert.True(result.Count() == 1); Assert.DoesNotThrow(() => result = repository.Get(new PortfolioFilter { UserId = 1, FinishDateStart = DateTime.Now.AddDays(-1), })); Assert.NotNull(result); Assert.True(result.Count() == 1); Assert.DoesNotThrow(() => result = repository.Get(new PortfolioFilter { UserId = 1, FinishDateEnd = DateTime.Now.AddDays(1), })); Assert.NotNull(result); Assert.True(result.Count() == 1); } } catch (Exception ex) { LogEventManager.Logger.Error(ex); throw; } }
protected void InitializeOverlay( RootModel root, SecurityRepository securityRepository, PortfolioRepository portfolioRepository, ManagingPst.PortfolioSecurityTargetRepository bottomUpPortfolioSecurityTargetRepository ) { this.overlayInitializer.Initialize( root, securityRepository, portfolioRepository, bottomUpPortfolioSecurityTargetRepository ); }
public PortfolioTargetModel DeserializePortfolioTarget(JsonReader reader, PortfolioRepository portfolioRepository) { var portfolioId = reader.ReadAsString(JsonNames.PortfolioId); var bgaPortfolio = portfolioRepository.GetBroadGlobalActivePortfolio(portfolioId); var portfolioTargetExpression = this.modelBuilder.CreatePortfolioTargetExpression(bgaPortfolio.Name); reader.Read(JsonNames.Target, delegate { this.expressionDeserializer.PopulateEditableExpression(reader, portfolioTargetExpression); }); var result = new PortfolioTargetModel(bgaPortfolio, portfolioTargetExpression); return(result); }
public TargetingTypeRepository ClaimTargetingTypeRepository( IOnDemand <IDataManager> ondemandManager, TaxonomyRepository taxonomyRepository, PortfolioRepository portfolioRepository ) { return(this.targetingTypeRepositoryStorage.Claim(TargetingTypeRepositoryStorageKey, delegate { return this.CreateTargetingTypeRepository( ondemandManager.Claim(), taxonomyRepository, portfolioRepository ); })); }
public async Task GetPortfoliobyID_Database_test(int id) { using var connection = Database_init(); var options = new DbContextOptionsBuilder <mmpproject2Context>().UseSqlite(connection).Options; using var context = new mmpproject2Context(options); var repo = new PortfolioRepository(options); var portfolio = await repo.GetAsync(id); var portfolioActual = context.Portfolios.Where(x => x.Id == id).Single(); Assert.Equal(portfolio.Id, portfolioActual.Id); Assert.Equal(portfolio.Name, portfolioActual.Name); Assert.Equal(portfolio.Funds, portfolioActual.Funds); }
static void Main(string[] args) { var repo = new PortfolioRepository(); var ex = new StockExchangeProvider(); var pqh = new PortfolioQueryHandler(repo); var upc = new UpdatePortfolioCommandHandler(repo, ex); var csq = new CandidateStocksQueryHandler(ex); var bsc = new BuyStockCommandHandler(repo); var psq = new PortfolioStockQueryHandler(repo); var ssc = new SellStockCommandHandler(repo); var frontend = new UserInterface(); frontend.OnPortfolioQuery += q => { var result = pqh.Handle(q); frontend.Display(result); }; frontend.OnUpdatePortfolioCommand += c => { upc.Handle(c); var result = pqh.Handle(new PortfolioQuery()); frontend.Display(result); }; frontend.OnCandidateStocksQuery += q => { var result = csq.Handle(q); if (frontend.SelectStockToBuy(result, out var cmd)) { bsc.Handle(cmd); frontend.DisplayBuyConfirmation(cmd.StockSymbol, cmd.Qty, cmd.StockPrice); } }; frontend.OnPortfolioStockQuery += q => { var result = psq.Handle(q); if (frontend.SelectStockToSell(result, out var cmd)) { ssc.Handle(cmd); frontend.DisplaySellConfirmation(cmd.StockSymbol); } }; frontend.Run(); }
protected IEnumerable <BottomUpPortfolio> GetBottomUpPortfolios( IEnumerable <TargetingTypePortfolioInfo> portfolioInfos, PortfolioRepository portfolioRepository ) { //var result = new List<BottomUpPortfolio>(); //foreach (var portfolioInfo in portfolioInfos) //{ // var bottomUpPorfolioOpt = portfolioRepository.FindBottomUpPortfolio(portfolioInfo.PortfolioId); // if (bottomUpPorfolioOpt != null) // { // result.Add(bottomUpPorfolioOpt); // } //} //return result; return(portfolioRepository.GetAllBottomUpPortfolios()); }
public RootModel GetOverlayModel( TargetingType targetingType, String porfolioId, PortfolioRepository portfolioRepository, SecurityRepository securityRepository, IDataManager manager ) { // first, we get already saved overlays // (with overlay factor numbers) var savedFactors = manager.GetBgaPortfolioSecurityFactors(porfolioId); var itemsForSavedOverlays = savedFactors.Select(overlay => { var security = securityRepository.GetSecurity(overlay.SecurityId); var portfolio = portfolioRepository.ResolveToBottomUpPortfolio(overlay.SecurityId); var item = new ItemModel( portfolio, this.modelBuilder.CreateOverlayFactorExpression(portfolio.Name) ); item.OverlayFactor.InitialValue = overlay.Factor; return(item); }); // second we need to get potentially enabled overlays that haven't been saved yet, // but need to be offered to the user who, may be, is going to save them // (there is no overlay factor numbers) var itemsForPotentialOverlays = targetingType.BottomUpPortfolios // for all the portoflios defined for the targeting type .Where(x => !itemsForSavedOverlays.Select(y => y.BottomUpPortfolio).Contains(x) && x.Fund != null) // get only those which are not in the 'saved' list yet .Select(bottomUpPortfolio => { var item = new ItemModel( bottomUpPortfolio, this.modelBuilder.CreateOverlayFactorExpression(bottomUpPortfolio.Name) ); return(item); }); // order by name var items = itemsForSavedOverlays .Union(itemsForPotentialOverlays) .OrderBy(x => x.BottomUpPortfolio.Name); var result = new RootModel(items); return(result); }
private IEnumerable <FileParserInput> DownloadDepots() { var downloadResults = new List <FileParserInput>(); try { NavigateDepots(); Browser.WaitForJavaScript(); for (var i = 1; i < GetAccountLinks().Count; i++) { GetAccountLinks()[i].Click(); Browser.WaitForJavaScript(2000); var portfolioNumber = Browser.FindElement(new ByChained(By.ClassName("info-box"), By.TagName("h3"))).Text.CleanString(); var portfolio = PortfolioRepository.GetByPortfolioNumberAndBankName(portfolioNumber, Constants.DownloadHandler.BankNameRaiffeisen); if (portfolio == null) { portfolio = new PortfolioEntity { PortfolioNumber = portfolioNumber, BankName = Constants.DownloadHandler.BankNameRaiffeisen, AccountName = Constants.DownloadHandler.AccountNameDepot }; PortfolioRepository.Insert(portfolio); } TakeScreenshot(portfolio.PortfolioNumber); var resultingFile = DownloadFromWebElement(Browser.FindElement(By.ClassName("icon-csv")), portfolioNumber); downloadResults.Add(new FileParserInput { OwningEntity = portfolio, FileParser = ComponentContext.ResolveKeyed <IFileParser>(Constants.UniqueContainerKeys.FileParserRaiffeisenDepot), FilePath = resultingFile, TargetEntity = typeof(RaiffeisenPositionEntity) }); } } catch (NoSuchElementException e) { Logger.LogWarning(e, "Error occured downloading depot status."); } return(downloadResults); }
public async Task SaveAsync_Test() { var repository = new PortfolioRepository(); var list = new List <PortfolioEntity> { new PortfolioEntity { Price = 1065, Quantity = 100, Symbol = "MSFT", TransactionDate = DateTime.Parse("1/2/2018"), TransactionType = TransactionType.Buy }, new PortfolioEntity { Price = 1065, Quantity = 50, Symbol = "GOOGL", TransactionDate = DateTime.Parse("1/2/2018"), TransactionType = TransactionType.Buy }, new PortfolioEntity { Price = 1065, Quantity = 150, Symbol = "MSFT", TransactionDate = DateTime.Parse("1/10/2018"), TransactionType = TransactionType.Buy } }; await repository.SaveAsync(list); }
public PortfolioModel CreateEditPortfolio(PortfolioModel model) { PortfolioEntity entity; //is update if (model.Id != default(long)) { entity = PortfolioRepository.GetById(model.Id); entity = Mapper.Map(model, entity); } else { entity = Mapper.Map <PortfolioEntity>(model); entity = PortfolioRepository.Insert(entity); } PortfolioRepository.Save(); return(Mapper.Map <PortfolioModel>(entity)); }