public ActionResult <Asset> DeleteAsset(int id)
        {
            var asset = _assetRepository.Find(id);

            if (asset == null)
            {
                return(NotFound());
            }

            _assetRepository.Delete(id);
            _assetRepository.Save();

            return(asset);
        }
Example #2
0
        public async Task <UseCaseResponse <bool> > Execute(Guid id)
        {
            var response = new UseCaseResponse <bool>();

            try
            {
                await assetRepository.Delete(id);

                return(response.SetResult(true));
            }
            catch (Exception e)
            {
                logger.LogError(e.Message, e);
                return(response.SetInternalServerError("Unexpected error: " + e.Message));
            }
        }
Example #3
0
        public async Task <Response <string> > DeleteAsset(int id)
        {
            var response = new Response <string>();
            var asset    = await _assetRepository.Find(id);

            if (asset is null)
            {
                response.Message = $"Asset with Id {id} does not exists";
                return(response);
            }
            await _assetRepository.Delete(id);

            response.Success = true;
            response.Message = $"Asset with Id {id} has been deleted successfully";
            return(response);
        }
Example #4
0
        public async Task <SaveAssetResponse> DeleteAsync(int Id)
        {
            var assetToDelete = await _assetRepository.FindByIdAsync(Id);

            if (assetToDelete == null)
            {
                return(new SaveAssetResponse($"Asset with Id = {Id} does not exist."));
            }

            try
            {
                _assetRepository.Delete(assetToDelete);
                await _unitOfWork.CompleteAsync();

                return(new SaveAssetResponse(assetToDelete));
            }
            catch (Exception ex)
            {
                return(new SaveAssetResponse($"An error occured while deleting the asset: {ex.Message}"));
            }
        }
Example #5
0
        public async Task <IResult> Handle(DeleteAssetCommand request, CancellationToken cancellationToken)
        {
            var asset = await _assetRepository.GetById(request.Id, cancellationToken)
                        .ConfigureAwait(false);

            if (asset == null)
            {
                return(Result.Failure(ErrorCodes.NotFound));
            }

            if (asset.OwnerId != _userIdAccesor.Id)
            {
                return(Result.Failure(ErrorCodes.Forbid));
            }

            await _assetRepository.Delete(asset.Id, cancellationToken)
            .ConfigureAwait(false);

            _userCacheService.Remove(CacheRegion.Assets);

            return(Result.Success());
        }
Example #6
0
 public ActionResult DeleteConfirmed(int id)
 {
     _assetRepository.Delete(id);
     _unitOfWork.Commit();
     return(RedirectToAction("Index"));
 }
Example #7
0
 public void Delete(string id)
 {
     AssetRepository.Delete(id);
 }
Example #8
0
 public bool Delete(Asset entity)
 {
     return(repository.Delete(entity));
 }