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));
}
