/// <summary>
/// 更新信息
/// </summary>
public int UpdateInfo(SqlTransaction trans, PortfolioModel porModel, long SN)
{
string key = "Cache_Portfolio_Model_" + SN;
CacheHelper.RemoveCache(key);
return(porDAL.UpdateInfo(trans, porModel, SN));
}
public async Task <ActionResult> EditAsync(int id, PortfolioModel model)
{
if (ModelState.IsValid)
{
if (Request.Form.Files.Count() > 0)
{
var file = Request.Form.Files.First();
MemoryStream ms = new MemoryStream();
file.CopyTo(ms);
model.image = ms.ToArray();
ms.Close();
ms.Dispose();
}
else
{
var current = await _db.PortfolioModels.FindAsync(id);
model.image = current.image;
}
_db.Update(model);
await _db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View());
}
public IActionResult Create([FromBody] PortfolioModel portfolioModel)
{
try
{
if (portfolioModel == null)
{
return(BadRequest("portfolio object is null"));
}
if (!ModelState.IsValid)
{
return(BadRequest("Invalid model object"));
}
var portfolio = _portfolioService.GetByISIN(portfolioModel.ISIN);
if (portfolio != null)
{
return(BadRequest("portfolio already exist"));
}
_portfolioService.Create(portfolioModel);
return(CreatedAtRoute("GetByISIN", new { isin = portfolioModel.ISIN }, portfolioModel));
}
catch (Exception e)
{
return(StatusCode(500, "Internal server error"));
}
}
public void Create(PortfolioModel portfolioModel)
{
var portfolio = _context.Portfolios.FirstOrDefault(x => x.ISIN == portfolioModel.ISIN);
if (portfolio == null)
{
var currency = _context.Currencys.FirstOrDefault(x => x.Name == portfolioModel.Currency);
var portfolioToAdd = new Entity.Entity.Portfolio {
ISIN = portfolioModel.ISIN, MarketValue = portfolioModel.MarketValue, Date = portfolioModel.Date, Currency = currency
};
_context.Portfolios.Add(portfolioToAdd);
if (portfolioModel.Positions != null)
{
var countrys = _context.Countrys.ToList();
var currencys = _context.Currencys.ToList();
var positionTypes = _context.PositionTypes.ToList();
List <Entity.Entity.Position> positions = new List <Entity.Entity.Position>();
foreach (var position in portfolioModel.Positions)
{
positions.Add(new Entity.Entity.Position {
ISIN = position.ISIN, Country = countrys.FirstOrDefault(x => x.Name == position.CountryName), Name = position.Name, MarketValue = position.MarketValue, Currency = currencys.FirstOrDefault(x => x.Name == position.CurrencyName), Type = positionTypes.FirstOrDefault(x => x.Name == position.TypeName), PortfolioId = portfolioToAdd.Id
});
}
_context.Positions.AddRange(positions);
}
_context.SaveChanges();
ChangeSharePercentageByISIN(portfolioModel);
}
}
protected void Button1_Click(object sender, EventArgs e)
{
var model = new PortfolioModel();
model.Discription = TextBox_discription.Text;
model.Background_Id = Convert.ToInt32(TextBox_BackGround.Value);
model.Log_Id = Convert.ToInt32(TextBox_Logo.Value);
model.SEO_discription = TextBox_SEO_D.Text;
model.SEO_Keyword = TextBox_SEO_K.Text;
model.Subject = TextBox_Subject.Text;
if (CheckBox_Show.Checked)
{
model.Show = 1;
}
else
{
model.Show = 0;
}
if (Request["Type"] == "Edit")
{
int Id = Convert.ToInt32(Request["Id"]);
model.PortfolioId = Id;
Logic.UpdatePorufolio(model);
}
else
{
model.PortfolioId = 0;
Logic.AddPorufolio(model);
}
}
public ActionResult Update(string isin, [FromBody] PortfolioModel portfolioModel)
{
try
{
if (portfolioModel == null)
{
return(BadRequest("portfolio object is null"));
}
if (!ModelState.IsValid)
{
return(BadRequest("Invalid model object"));
}
if (isin != portfolioModel.ISIN)
{
return(BadRequest());
}
var portfolio = _portfolioService.GetByISIN(portfolioModel.ISIN);
if (portfolio == null)
{
return(NotFound());
}
_portfolioService.Update(isin, portfolioModel);
return(new NoContentResult());
}
catch (Exception e)
{
return(StatusCode(500, "Internal server error"));
}
}
public ActionResult Portfolio(int id)
{
PortfolioModel model = new PortfolioModel();
if (!IsAuthorized(model))
{
return(RedirectToAction("Index", "Home"));
}
using (var db = new SqlLinkDataContext())
{
if (db.Fios.Any(f => f.Id == id))
{
var portfolio = db.Fios.Single(f => f.Id == id);
if (model.UserId != portfolio.UserId)
{
return(new HttpStatusCodeResult(403, "That portfolio doesn't belong to you!"));
}
model.Portfolio = portfolio;
model.Bills = portfolio.Bills.Select(b => new BillModel()
{
Bill = b, Payers = b.PaymentDetails.Select(pd => new KeyValuePair <Payer, PaymentDetail>(pd.Payer, pd)).ToArray()
}).ToArray();
model.People = portfolio.Payers.ToArray();
return(View("Summary", model));
}
else
{
return(new HttpNotFoundResult("That ID doesn't exist :("));
}
}
}
public async Task <PortfolioModel> Update(PortfolioModel model)
{
var entity = _mapper.Map <Portfolio>(model);
await _portfolioRepository.Update(entity);
return(_mapper.Map <PortfolioModel>(entity));
}
public IHttpActionResult Update([FromBody] PortfolioModel portfolio)
{
if (!ModelState.IsValid)
{
return(BadRequest("ModelState"));
}
try
{
if (portfolioService.CheckAccess(RequestContext.Principal.Identity.GetUserId(), portfolio.Id))
{
portfolioService.UpdatePortfolio(Mapper.Map <PortfolioModel, PortfolioDTO>(portfolio));
}
else
{
throw new Exception("You don't have access to portfolio with id: " + portfolio.Id);
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
logger.Error(ex.ToString());
return(BadRequest(ex.ToString()));
}
return(Ok());
}
public List <PortfolioModel> GetPortfolios()
{
base.Connect();
////////Portfolios
List <PortfolioModel> Portfolios = new List <PortfolioModel>();
DataTable dt = base.Select("SELECT [P_Id],[Subject],[BackGroundPicId],(SELECT [PicThumbnailAddress] FROM [tbl_PicUploader] where PicId=[BackGroundPicId]) as BackGroundPic,[LogoPicId],(SELECT [PicThumbnailAddress] FROM [tbl_PicUploader] where PicId=[LogoPicId]) as LogoPic ,[Discription],[SEO_KeyWord],[SEO_Discription],[Show_MainPage] FROM [tbl_Portfolio] where [Deleted]=0");
base.DC();
for (int i = 0; i < dt.Rows.Count; i++)
{
var Portfolio = new PortfolioModel()
{
Background_Id = Convert.ToInt32(dt.Rows[i]["BackGroundPicId"]),
Background_Path = dt.Rows[i]["BackGroundPic"].ToString(),
Discription = dt.Rows[i]["Discription"].ToString(),
Logo_Path = dt.Rows[i]["LogoPic"].ToString(),
Log_Id = Convert.ToInt32(dt.Rows[i]["LogoPicId"]),
PortfolioId = Convert.ToInt32(dt.Rows[i]["P_Id"]),
SEO_discription = dt.Rows[i]["SEO_Discription"].ToString(),
SEO_Keyword = dt.Rows[i]["SEO_KeyWord"].ToString(),
Subject = dt.Rows[i]["Subject"].ToString(),
Show = Convert.ToInt32(dt.Rows[i]["Show_MainPage"])
};
Portfolios.Add(Portfolio);
}
return(Portfolios);
}
public PortfolioViewModel()
{
base.ViewName = "Portfolio";
_portfolio = new PortfolioModel();
Name = "New Portfolio";
initPanels();
}
private Portfolio Map(PortfolioModel portfolio)
{
return(new Portfolio()
{
Id = portfolio.Id,
Name = portfolio.Name
});
}
public FileStreamResult Generate(PortfolioModel portfolioModel)
{
var portfolio = Mapper.Map <PortfolioDto>(portfolioModel);
var generatedPortfolio = _portfolioService.Calculate(portfolio);
var pdf = _portfolioService.GeneratePdf(generatedPortfolio);
return(new FileStreamResult(pdf, "application/pdf"));
}
private void CreateTab(PortfolioModel portfolio)
{
this.TabControl.SelectedIndex = this.TabControl.Items.Add(new TabItem
{
DataContext = this._positionsViewModelFactory.Create(portfolio),
Header = portfolio,
Content = this._positionsViewFactory.Create()
});
}
private static async Task <GithubPortfolioService> InitializeGithubClientInstanceAsync(IConfigurationSection configurationSection)
{
string username = configurationSection.GetSection("Username").Value;
GithubPortfolioService GithubService = new GithubPortfolioService("DalleDonDalle");
PortfolioModel p = GithubService.GetGithubRepos();
GithubPortfolio.Content = p;
return(GithubService);
}
public async Task <IActionResult> SaveFunds(PortfolioModel portfolioModel)
{
if (portfolioModel.PortfolioFunds == null || !portfolioModel.PortfolioFunds.Any())
{
throw new InvalidParameterException();
}
var percentList = portfolioModel.PortfolioFunds.Where(x => x.FundPercentNew != null && x.FundPercentNew.Value > 0).Select(x => x.FundPercentNew.Value).ToList();
decimal sumPercent = 0;
foreach (var percent in percentList)
{
sumPercent += percent;
}
if (sumPercent != 100)
{
ModelState.AddModelError("IsFundPercent100", Model.Resources.ValidationMessages.FundPercent100);
portfolioModel.KVRRPortfolios = _portfolioService.GetPortfolioById(portfolioModel.Id)?.KVRRPortfolios;
return(View("Detail", portfolioModel));
}
var portfolioFundOld = _portfolioService.GetPortfolioFundByPortfolioId(portfolioModel.Id).Result;
await _portfolioService.SaveFunds(portfolioModel);
if (CheckListPortfolioFund(portfolioModel.PortfolioFunds, portfolioFundOld))
{
// Send mail
var listAdmins = _userService.GetAdminUsers().Result;
if (listAdmins != null && listAdmins.Count > 0)
{
foreach (var admin in listAdmins)
{
if (!string.IsNullOrEmpty(admin.Email))
{
var sender = _userService.GetCurrentUser().Result;
var contentEmail = _configuration.GetValue <string>("EmailBody:RequestApproved").Replace("[FullName]", admin.FullName).Replace("[Sender]", sender.FullName).Replace("[SenderEmail]", sender.Email).Replace("[TaskType]", Model.Resources.Common.RequestPortfolioFund);
var mailConfig = SetMailConfig(sender.Email, admin.Email, _configuration.GetValue <string>("EmailSubject:RequestApproved"), contentEmail);
var sendEmail = _emailSender.SendEmail(mailConfig);
if (sendEmail)
{
ViewData["Message"] = ValidationMessages.SendMailSucess;
}
else
{
ViewData["Message"] = ValidationMessages.SendMailError;
}
}
}
}
}
return(RedirectToAction("Detail", new { id = portfolioModel.Id }));
}
public ActionResult Edit(PortfolioModel model)
{
if (model == null)
{
return(RedirectToAction("List"));
}
var portfolio = portfolioService.GetById(model.Id);
if (portfolio == null)
{
this.NotifyError("Item not found.");
return(RedirectToAction("List"));
}
if (ModelState.IsValid)
{
portfolio.IsActive = model.IsActive;
portfolio.CategoryId = model.CategoryId;
portfolio.Description = model.Content;
portfolio.Title = model.Title;
portfolio.UpdateDateUtc = DateTime.UtcNow;
portfolio.Format = model.PortfolioFormat.ToString();
portfolio.FormatValue = model.PortfolioFormatValue;
portfolio.PictureId = model.PictureId;
portfolio.ViewName = model.ViewName;
var result = portfolioService.Update(portfolio);
if (result)
{
this.NotifySuccess("Successfully saved.");
}
else
{
this.NotifyError("Item can not saved!");
}
urlService.Save(new UrlRecord()
{
EntityId = portfolio.Id,
EntityName = nameof(Portfolio),
Slug = model.Title.ToUrlSlug()
});
}
model.Categories = portfolioCategoryService.GetActives();
model.AvailableViewNames = this.GetViewNames(nameof(Portfolio));
model.Url = urlService.GetUrl(portfolio.Id, nameof(Portfolio));
model.CreateDate = portfolio.CreateDateUtc;
model.UpdateDate = portfolio.UpdateDateUtc;
model.ViewCount = portfolio.ViewCount;
return(View(model));
}
public async Task <ActionResult> EditAsync([Bind("Id,Name,Description,Completed")] PortfolioModel item)
{
if (ModelState.IsValid)
{
await _cosmosDbService.UpdateItemAsync(item.Id, item);
return(RedirectToAction("Index"));
}
return(View(item));
}
public ActionResult Create()
{
var model = new PortfolioModel();
model.CreateDate = DateTime.UtcNow;
model.IsActive = true;
model.ViewName = "View.Default";
model.Categories = portfolioCategoryService.GetActives();
model.AvailableViewNames = this.GetViewNames(nameof(Portfolio));
return(View(model));
}
public async Task <IActionResult> Post(PortfolioModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _portfolioService.Create(model);
return(Ok(result));
}
public async Task <IActionResult> Post([FromBody] PortfolioModel value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var portfolio = Map(value);
await _portfolioService.InsertAsync(portfolio);
return(Created($"Portfolio/{portfolio.Id}", Map(portfolio)));
}
public async Task <ActionResult> CreateAsync([Bind("Id,Name,Description,Headline,Completed")] PortfolioModel item)
{
if (ModelState.IsValid)
{
item.Id = Guid.NewGuid().ToString();
await _cosmosDbService.AddItemAsync(item);
return(RedirectToAction("Index"));
}
return(View(item));
}
public async Task <IActionResult> Put(int id, PortfolioModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
model.Id = id;
var result = await _portfolioService.Update(model);
return(Ok(result));
}
public async Task <Portfolio> Update(PortfolioModel portfolio)
{
try
{
var portfolioDto = _mapper.Map <PortfolioModel, Portfolio>(portfolio);
return(await _portfolioManager.Update(portfolioDto));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task SaveFunds(PortfolioModel portfolioModel)
{
try
{
var portfolio = _mapper.Map <Portfolio>(portfolioModel);
await _portfolioManager.SaveFunds(portfolio);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task UpdatePortfolio(PortfolioModel portfolio)
{
var result = await client.PutAsJsonAsync(path + "api/Portfolio", portfolio);
if (!result.IsSuccessStatusCode)
{
Console.WriteLine("Portfolio update was unsuccessful\n" + result.Content.ReadAsStringAsync().Result);
}
else
{
Console.WriteLine("Portfolio update was successful");
}
}
public async Task Post_ShouldRetrunBadRequest()
{
PortfolioModel model = null;
// Arrange
// Act
var result = await _portfolioController.Post(model);
// Assert
var returnResult = result as BadRequestObjectResult;
Assert.IsInstanceOf(typeof(BadRequestObjectResult), returnResult);
}
public async Task DeletePortfolio(int portfolioId)
{
PortfolioModel portfolio = null;
var result = await client.DeleteAsync(path + "api/Portfolio/" + portfolioId);
if (result.IsSuccessStatusCode)
{
Console.WriteLine("Portfolio delte was successful");
}
else
{
Console.WriteLine(result.Content.ReadAsStringAsync().Result);
}
}
public async Task <PortfolioModel> Create(PortfolioModel model)
{
var entity = _mapper.Map <Portfolio>(model);
entity.OwnerId = _currentUserScope.UserId;
await _portfolioRepository.Insert(entity);
var result = _mapper.Map <PortfolioModel>(entity);
result.Positions = await _positionService.CreatePositions(entity.Id, model.Positions);
return(result);
}
public ActionResult Save(PortfolioModel portfolioModel)
{
try
{
var portfolioDto = Mapper.Map <PortfolioModel, PortfolioDTO>(portfolioModel);
TempData["PortfolioId"] = portfolioService.CreateOrUpdatePortfolio(portfolioDto, User.Identity.GetUserId());
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
logger.Error(ex.ToString());
}
return(RedirectToAction("Index", "Home"));
}
