public Asset Create(CreateAssetCommand command)
{
var newValue = _assetService.Create(command).Result;
if (command.ContainerRootId.HasValue)
{
_relationshipService.Create(new CreateRelationshipCommand()
{
FromType = ObjectType.Container,
FromId = command.ContainerRootId.Value,
ToType = ObjectType.Asset,
ToId = newValue.Id,
CreateByUserId = command.CreateByUserId,
Payload = JsonConvert.SerializeObject(new AssetPayloadModel()
{
X = command.PayloadData?.X, Y = command.PayloadData?.Y
})
});
}
_auditTrailService.LogAction(AuditTrailAction.CreateAsset, newValue.Id, new AuditTrailPayloadModel()
{
Data = JsonConvert.SerializeObject(command)
});
return(newValue);
}
public async Task Call_Method_Create_Returns_Object()
{
var createdasset = await assetService.Create(AssetDTOMockdata.First());
Assert.IsNotNull(createdasset);
Assert.IsNotNull(createdasset.AssetId);
}
public void AssetService_Create_CallInsertsAssetAndCallsSaveChanges()
{
#region Arrange
var asset = new Asset
{
Id = 3,
FileExtension = ".mp4",
FileName = Guid.NewGuid().ToString(),
OriginalFileName = "AddServiceDomain",
MimeType = "video/mp4",
FullPath = "C:\\Media\\Video\\AddServiceDomain.mp4"
};
#endregion
#region Act
var response = _assetService.Create(asset);
#endregion
#region Assert
_mockAssetRepository.Verify(x => x.Insert(It.IsAny <Asset>()), Times.Once());
_mockUnitOfWork.Verify(x => x.Save(), Times.Exactly(1));
Assert.IsNotNull(response);
Assert.AreEqual(3, response);
#endregion
}
public async Task <IActionResult> CreateGroup([FromBody] CreateAssetCommand command)
{
command.IsGroup = true;
var newValue = await _assetService.Create(command);
foreach (var item in command.Assets)
{
_relationshipService.Create(new CreateRelationshipCommand()
{
FromType = ObjectType.AssetGroup, FromId = newValue.Id, ToType = ObjectType.Asset, ToId = item
});
}
if (command.ContainerRootId.HasValue)
{
_relationshipService.Create(new CreateRelationshipCommand()
{
FromType = ObjectType.Container, FromId = command.ContainerRootId.Value, ToType = ObjectType.AssetGroup, ToId = newValue.Id
});
}
_auditTrailService.LogAction(AuditTrailAction.CreateAssetGroup, newValue.Id, new AuditTrailPayloadModel()
{
Data = JsonConvert.SerializeObject(command)
});
return(Ok(newValue));
}
public async Task <ActionResult <Asset> > Create(Asset asset)
{
if (ModelState.IsValid)
{
if (ModelState.IsValid)
{
try
{
var result = await _assetService.Create(asset);
}
catch (RessourceTypeRepositoryException ex)
{
ModelState.AddModelError(ex.Field, ex.Message);
return(BadRequest(new ValidationProblemDetails(ModelState)));
}
catch (SpaceRepositoryException ex)
{
ModelState.AddModelError(ex.Field, ex.Message);
return(BadRequest(new ValidationProblemDetails(ModelState)));
}
catch (AssetRepositoryException ex)
{
ModelState.AddModelError(ex.Field, ex.Message);
return(BadRequest(new ValidationProblemDetails(ModelState)));
}
return(CreatedAtRoute("GetSpace", new { id = asset.Id.ToString() }, asset));
}
return(BadRequest(new ValidationProblemDetails(ModelState)));
}
return(BadRequest(new ValidationProblemDetails(ModelState)));
}
public async Task <IActionResult> Post([FromBody] Model.AssetForCreation model)
{
try
{
//Check to see if the model is Valid. If not return the ModelState
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_logger.LogInformation("Creating new Asset");
var userId = User.Claims.FirstOrDefault(c => c.Type == "sub").Value;
var organizationId = _userService.GetById(Convert.ToInt32(userId)).SelectedOrganizationId;
//Create new asset and map properties
var newItem = new Core.Entities.Asset
{
CreateDt = DateTime.Now
};
newItem = _mapper.Map <Core.Entities.Asset>(model);
//Add Asset Location
newItem.AssetLocations.Add(new Core.Entities.AssetLocation()
{
LocationId = model.LocationId,
Asset = newItem,
Note = model.Note,
CreateDt = new DateTime(2018, 12, 4)
});
//Associate Asset with Organization
newItem.AssetOrganizations.Add(new Core.Entities.AssetOrganization()
{
OrganizationId = organizationId
});
if (await _service.Create(newItem))
{
return(Created(Url.Link("AssetGet",
new { id = newItem.Id }),
_mapper.Map <Core.Entities.Asset>(
_service.GetById(newItem.Id))));
}
}
catch (EntityException ex)
{
_logger.LogWarning($"Could not save Asset to the database due to following error: {ex.Message}");
ModelState.AddModelError(ex.Source, ex.Message);
}
catch (Exception ex)
{
_logger.LogError($"Threw exception while saving Asset: {ex}");
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> PostAsset(Guid id, [FromBody] AssetBizModel value)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ErrorResponse()
.AddModelStateErrors(ModelState)));
}
value.Id = await _assetService.Create(_principal,
_mapper.Map <VFileSystemItem>(value), id);
return(CreatedAtAction(nameof(GetFolderById), new { id = value.Id }, value));
}
public IActionResult Create([FromBody] AssetMaintainDTO model)
{
// map model to entity
var asset = _mapper.Map <AssetMaintain>(model);
try
{
// create user
_assetService.Create(asset);
return(Ok());
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public IActionResult Create([FromBody] Requests.AssetDto assetDto)
{
// map dto to entity
var asset = _mapper.Map <Asset>(assetDto);
try
{
// save
_assetService.Create(asset);
return(Ok());
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(ex.Message));
}
}
public IHttpActionResult PostAsset([FromBody] Asset asset)
{
try
{
var existAsset = _AssetService.GetById(asset.Id);
if (existAsset != null)
{
return(SendErrorMessage("Asset already exist", HttpStatusCode.Found));
}
return(Ok(_AssetService.Create(asset)));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public AssetCreateResponse Asset([FromBody] AssetCreateRequest request)
{
return(_assetService.Create(request));
}
