public async Task <IHttpActionResult> GetReturnsForCalculationPeriodAsync(int assetId, int portfolioId, ICollection <DatePeriodDto> calculationPeriods)
{
var assetInDb = await _assetRepository.GetAsync(assetId);
if (assetInDb == null)
{
return(NotFound());
}
var portfolioInDb = await _portfolioRepository.GetAsync(portfolioId);
if (portfolioInDb == null)
{
return(NotFound());
}
var submittedPeriods = calculationPeriods.Map <List <Tuple <DateTime, DateTime> > >();
try
{
var calculatedReturnRate = _assetService.GetPortfolioAssetReturnsForPeriod(submittedPeriods, portfolioInDb, assetInDb);
_assetRepository.Add(assetInDb);
return(Ok(calculatedReturnRate));
}
catch (NoCalculationResultException exception)
{
return(BadRequest(exception.Message));
}
}
public Tuple <Asset, bool, int, string> Add(Asset asset)
{
//Save first the asset
repository.Add(asset);
//the define de info for the QR code and generates the QR Code image
asset.QrCode = TxtQrCodeGenerator(asset.AssetID);
//save the asset again with the QR code.
asset = repository.Update(asset);
//Check in more Assets need to be added:
bool stillNeedToAddAsset = false;
string message = "";
int qtyAssetsStillNeedToAdd = QtyAssetsStillNeedToAdd(asset.PurchaseItemID);
if (qtyAssetsStillNeedToAdd == 0)
{
message = "All assets are generated!";
asset = FindById(asset.AssetID);
return(new Tuple <Asset, bool, int, string>(asset, stillNeedToAddAsset, 0, message));
}
stillNeedToAddAsset = true;
message = "Still need to be added " + qtyAssetsStillNeedToAdd + "x assets";
return(new Tuple <Asset, bool, int, string>(asset, stillNeedToAddAsset, qtyAssetsStillNeedToAdd, message));
}
private async ValueTask CreateAssetsIfNotExists(string code, string name, string symbol, string groupCode, IEnumerable <Group> groups, int index, CancellationToken cancellationToken = default)
{
var curAsset = await _assetRepository.GetByCode(code, cancellationToken)
.ConfigureAwait(false);
if (curAsset == null)
{
var group = groups.FirstOrDefault(g => g.Code == groupCode);
if (group == null)
{
return;
}
curAsset = new Asset
{
Code = code,
Name = name,
Symbol = symbol,
Order = index,
CreatedAt = DateTime.UtcNow,
GroupId = group.Id
};
await _assetRepository.Add(curAsset, cancellationToken)
.ConfigureAwait(false);
}
}
public async Task <IResult <AssetModel> > Handle(CreateAssetCommand request, CancellationToken cancellationToken)
{
var asset = new Asset
{
Code = request.Input.Code,
Name = request.Input.Name,
GroupId = request.Input.GroupId,
Order = request.Input.Order,
Icon = request.Input.Icon,
Symbol = request.Input.Symbol,
CreatedAt = DateTime.UtcNow,
OwnerId = _userIdAccesor.Id
};
if (await _assetRepository.Exists(asset, cancellationToken).ConfigureAwait(false))
{
return(Result.Failure <AssetModel>(ErrorCodes.Forbid));
}
asset = await _assetRepository.Add(asset, cancellationToken)
.ConfigureAwait(false);
_userCacheService.Remove(CacheRegion.Assets);
return(_mapper.Map <Asset, AssetModel>(asset).AsResult());
}
public void AssetRepositoryAdd()
{
Asset assetTest = new Asset
{
AssetTypeID = 1,
AreaID = 1,
Name = "Unit test Name",
AssetCode = "UTN1",
StartDate = DateTime.Now,
Quantity = 1,
Description = "Test",
ApplicationUserID = 1,
Active = true,
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now,
};
var actual = _assetRepository.Add(assetTest);
_unitOfWork.Commit();
var expected = "UTN1";
Assert.IsNotNull(actual);
Assert.AreEqual(expected, actual.AssetCode);
}
public ActionResult <Asset> PostAsset(Asset asset)
{
_assetRepository.Add(asset);
_assetRepository.Save();
return(CreatedAtAction("GetAsset", new { id = asset.Id }, asset));
}
public async Task <int> CreateAsync(CreateAssetDto request)
{
Asset asset = AssetMapper.ToEntity(request);
_assetRepository.Add(asset);
return(await _unitOfWork.SaveChangesAsync());
}
public async Task <int> CreateAsync(AssetDto asset)
{
var toInsert = _mapper.Map <Asset>(asset);
_assetRepository.Add(toInsert);
await _unitOfWork.CommitAsync();
return(toInsert.ID);
}
public async Task <bool> Create(Asset item)
{
//Execute domain validation for the create page operation
Validate(item, Operation.Create);
_repository.Add(item);
//Save the changes to data layer
return(await CompleteAsync());
}
/// <summary>
/// https://github.com/Studio-42/elFinder/wiki/Client-Server-API-2.0#mkdir
/// </summary>
/// <param name="elFinderParameter"></param>
/// <returns></returns>
private async Task <JObject> ExecuteMkdir(ElFinderParameter elFinderParameter)
{
var target = elFinderParameter.Target;
if (string.IsNullOrWhiteSpace(target))
{
return(new ErrorResponse(string.Format(Constants.Errors.ErrParamNotSpecified, Constants.ElFinderDtoNames.Target)).GetJson());
}
var asset = await _assetRepository.Get(target);
if (asset == null)
{
return(new ErrorResponse(Constants.ElFinderErrors.ErrTrgFolderNotFound).GetJson());
}
var recordPath = asset.Path + Constants.PathSeparator + elFinderParameter.Name;
var record = new AssetAggregate
{
CanRead = true,
CanWrite = true,
IsLocked = false,
Name = elFinderParameter.Name,
CreatedAt = DateTime.UtcNow,
ResourceParentHash = asset.Hash,
Path = recordPath,
Hash = HashHelper.GetHash(recordPath),
MimeType = Constants.MimeNames.Directory
};
if (!(await _assetRepository.Add(new[] { record })))
{
return(new ErrorResponse(Constants.Errors.ErrInsertAsset).GetJson());
}
var files = new JArray(GetFile(record));
var result = new JObject();
result.Add(Constants.ElFinderResponseNames.Added, files);
return(result);
}
public void CreateAsset(AssetViewModel assetViewModel)
{
if (assetViewModel.Id > 0)
{
assetsRepository.Update(Mapper.Map <AssetViewModel, Asset>(assetViewModel));
}
else
{
assetsRepository.Add(Mapper.Map <AssetViewModel, Asset>(assetViewModel));
}
SaveAsset();
}
public async Task <Asset> Create(Asset assetIn)
{
var ressourceTypeIn = await _ressourceTypeRepository.GetById(assetIn.AssetTypeId);
if (ressourceTypeIn == null)
{
throw new RessourceTypeRepositoryException(string.Format(_errorHandler.GetMessage(ErrorMessagesEnum.NotFound),
nameof(RessourceType), assetIn.AssetTypeId), nameof(assetIn.AssetTypeId));
}
try
{
if (assetIn.SpaceId != null)
{
var spaceIn = await _spaceRepository.GetById(assetIn.SpaceId);
if (spaceIn != null)
{
assetIn.Status = Status.Chained;
}
else
{
throw new SpaceRepositoryException(string.Format(_errorHandler.GetMessage(ErrorMessagesEnum.NotFound),
nameof(Space), assetIn.SpaceId), nameof(assetIn.SpaceId));
}
}
else
{
assetIn.Status = Status.Unchained;
}
ressourceTypeIn.Count++; // Increamenting count when adding an asset
await _ressourceTypeRepository.Update(ressourceTypeIn);
assetIn.AssetTypeName = ressourceTypeIn.Name;
await _assetRepository.Add(assetIn);
}
catch (MongoWriteException mwx)
{
if (mwx.WriteError.Category == ServerErrorCategory.DuplicateKey)
{
var pattern = @"\{(?:[^{*}])*\}";
Match result = Regex.Match(mwx.Message, pattern); // get the dublicated feild from the string error msg
JObject duplicatedField = JsonConvert.DeserializeObject <JObject>(result.Value); // parse it to get the field
throw new AssetRepositoryException(string.Format(_errorHandler.GetMessage(ErrorMessagesEnum.DuplicateKey),
nameof(Asset), duplicatedField.First.Path), duplicatedField.First.Path);
}
}
return(assetIn);
}
public IActionResult UpdatePaperAssets([FromBody] IEnumerable <JsonAssetModel> assetModels)
{
var userId = HttpContext.User.GetUserId();
if (string.IsNullOrEmpty(userId))
{
return(BadRequest("User not found"));
}
var assets = assetModels.Select(_mapper.Map <Asset>);
var userAssets = _assetRepository.GetByUserId(userId).Where(o =>
o.TradingMode == TradingMode.PaperTesting &&
string.IsNullOrEmpty(o.StrategyId));
var toDelete = userAssets.Where(o => !assets.Any(p => p.Id == o.Id));
foreach (var item in toDelete)
{
_assetRepository.DeleteNotSave(item);
}
foreach (var item in assets)
{
if (string.IsNullOrEmpty(item.Id))
{
_assetRepository.Add(new Asset
{
Amount = item.Amount,
Currency = item.Currency,
Exchange = item.Exchange,
TradingMode = TradingMode.PaperTesting,
UserId = userId,
IsActive = true,
});
}
else
{
var originalAsset = userAssets.FirstOrDefault(o => o.Id == item.Id);
if (originalAsset == null)
{
return(BadRequest("Asset not found"));
}
originalAsset.Amount = item.Amount;
_assetRepository.EditNotSave(originalAsset);
}
}
_assetRepository.Save();
return(Ok());
}
public MethodResult <Asset> AddAsset(string serialNumber, string name, string description, int customerId)
{
var existingAsset = _assetRepository.GetBySerialNumberForCustomer(serialNumber, customerId);
if (existingAsset != null)
{
return(MethodResult <Asset> .CreateFaultedResult("The asset is already created."));
}
var newAsset = new Asset
{
SerialNumber = serialNumber,
Name = name,
Description = description,
CustomerId = customerId
};
_assetRepository.Add(newAsset);
return(new MethodResult <Asset>(newAsset));
}
public bool Add(Asset entity)
{
return(_repository.Add(entity));
}
public async Task <IActionResult> UploadAsync([FromForm] Int16 assettype)
{
AssetTypes assetType = (AssetTypes)assettype;
if (assetType == AssetTypes.Folder)
{
return(StatusCode(500, "Could not uplaod file."));
}
var request = await HttpContext.Request.ReadFormAsync();
if (request.Files == null)
{
return(StatusCode(500, "Could not uplaod file."));
}
var files = request.Files;
if (files.Count != 1)
{
return(StatusCode(500, "Could uplaod just only one file."));
}
// Analyze Image
ImageAnalysis metadatalist = new ImageAnalysis();
if (assetType == AssetTypes.Image)
{
using (var streamimage = files[0].OpenReadStream())
{
metadatalist = await _azureImageAnalyzer.AnalyzImageAsync(streamimage);
}
}
// create folder and upload original file in storage
creatFolders(new List <string> {
"Original"
});
string filename = Helper.GetRandomBlobName(files[0].FileName, Path.GetExtension(files[0].FileName));
string filepath = await _azureBlobService.UploadAcync(files, filename, "Original");
// add Original asset in database
var parent = _assetRepository.GetEntityByPath("/Original");
Guid newAssetID = Guid.NewGuid();
_assetRepository.Add(new AssetModel
{
AssetId = newAssetID,
AssetFileName = filename,
AssetFilePath = filepath,
Datetime = DateTime.Now,
AssetType = assetType,
MetaData = JsonConvert.SerializeObject(metadatalist).ToString(),
Parent = parent != null ? parent.AssetId : Guid.Empty
});
_assetRepository.Complete();
// Create and upload SocialRequirement
await uploadSocialRequirementsAsync(newAssetID, assetType, files[0], filepath, metadatalist);
return(Ok("Asset uploded successfully."));
}
public void Add(Asset asset)
{
_assetRepository.Add(asset);
}
