public async Task <AttachmentBurial> UpdateAsync(AttachmentBurial entity, CancellationToken cancellationToken)
{
db.AttachmentBurials.Update(entity);
await db.SaveChangesAsync(cancellationToken);
return(entity);
}
public async Task <ValidationModel <Burial> > InsertAsync(Burial newEntity, CancellationToken cancellationToken = default)
{
var validation = await burilValidation.InsertValidationAsync(newEntity, cancellationToken);
if (!validation.IsValid)
{
return(validation);
}
newEntity.CreatedAt = DateTime.Now;
newEntity.UpdatedAt = DateTime.Now;
validation.Result = await dataBurial.InsertAsync(newEntity, cancellationToken);
if (newEntity.Files is not null && !newEntity.Files.Count().Equals(0))
{
var fileDatas = await fileHelper.SaveFileRange(newEntity.Files);
foreach (var file in fileDatas)
{
var attachmentForm = new AttachmentBurial()
{
FilePath = file.FilePath,
FileName = file.FileName,
FileType = file.FileType,
BurialId = validation.Result.Id
};
await dataAttachmentBurial.InsertAsync(attachmentForm, cancellationToken);
}
}
return(validation);
}
private void MockData(
AttachmentBurial attachmentBurial = default,
IEnumerable <AttachmentBurial> attachmentBurialList = default,
ValidationModel <AttachmentBurial> validationAttachmentBurial = default
)
{
_fileHelper.Setup(x => x.SaveFile(It.IsAny <IFormFile>()))
.ReturnsAsync(GetFileModelByAttachmentBurial(attachmentBurial));
_fileHelper.Setup(x => x.SaveFileRange(It.IsAny <IList <IFormFile> >()))
.ReturnsAsync(GetFileModelListByAttachmentBurial(attachmentBurialList));
_fileHelper.Setup(x => x.DeleteFile(It.IsAny <string>()));
_dataAttachmentBurial.Setup(x => x.GetAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(attachmentBurial);
_dataAttachmentBurial.Setup(x => x.GetAllAsync(It.IsAny <CancellationToken>())).ReturnsAsync(attachmentBurialList);
_dataAttachmentBurial.Setup(x => x.InsertAsync(It.IsAny <AttachmentBurial>(), It.IsAny <CancellationToken>())).ReturnsAsync(attachmentBurial);
_dataAttachmentBurial.Setup(x => x.UpdateAsync(It.IsAny <AttachmentBurial>(), It.IsAny <CancellationToken>())).ReturnsAsync(attachmentBurial);
_dataAttachmentBurial.Setup(x => x.DeleteAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>()));
_attachmentBurialValidation.Setup(x => x.GetValidationAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(validationAttachmentBurial);
_attachmentBurialValidation.Setup(x => x.InsertValidationAsync(It.IsAny <AttachmentBurial>(), It.IsAny <CancellationToken>())).ReturnsAsync(validationAttachmentBurial);
_attachmentBurialValidation.Setup(x => x.UpdateValidationAsync(It.IsAny <AttachmentBurial>(), It.IsAny <CancellationToken>())).ReturnsAsync(validationAttachmentBurial);
_attachmentBurialValidation.Setup(x => x.DeleteValidationAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(validationAttachmentBurial);
_service = new AttachmentBurialService(_fileHelper.Object, _dataAttachmentBurial.Object, _attachmentBurialValidation.Object);
}
public async Task UpdateValidationAsync_Null_UnSucces()
{
// Arrange
MockData(
isExsitAttachmentBurial: false,
isExsitBurial: false
);
AttachmentBurial entity = null;
var listError = new Dictionary <string, string>()
{
{ nameof(AttachmentBurial), string.Format(BaseValidation.ObjectNotCanBeNull, nameof(AttachmentBurial)) }
};
// Act
var result = await _validation.UpdateValidationAsync(entity);
// Assert
Assert.Multiple(() =>
{
Assert.NotNull(result.Errors);
Assert.IsNotEmpty(result.Errors);
Assert.IsFalse(result.IsValid);
foreach (var error in result.Errors)
{
Assert.IsTrue(listError.ContainsKey(error.Key));
Assert.AreEqual(listError[error.Key], error.Value);
}
});
}
private void MockData(
Burial burial = default,
AttachmentBurial attachmentBurial = default,
IEnumerable <Burial> burialList = default,
IEnumerable <AttachmentBurial> attachmentBurialList = default,
ValidationModel <Burial> validationBurial = default
)
{
_dataBurial.Setup(x => x.GetAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(burial);
_dataBurial.Setup(x => x.GetAllAsync(It.IsAny <CancellationToken>())).ReturnsAsync(burialList);
_dataBurial.Setup(x => x.InsertAsync(It.IsAny <Burial>(), It.IsAny <CancellationToken>())).ReturnsAsync(burial);
_dataBurial.Setup(x => x.UpdateAsync(It.IsAny <Burial>(), It.IsAny <CancellationToken>())).ReturnsAsync(burial);
_dataBurial.Setup(x => x.DeleteAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>()));
_dataAttachmentBurial.Setup(x => x.GetAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(attachmentBurial);
_dataAttachmentBurial.Setup(x => x.GetAllAsync(It.IsAny <CancellationToken>())).ReturnsAsync(attachmentBurialList);
_dataAttachmentBurial.Setup(x => x.InsertAsync(It.IsAny <AttachmentBurial>(), It.IsAny <CancellationToken>())).ReturnsAsync(attachmentBurial);
_dataAttachmentBurial.Setup(x => x.UpdateAsync(It.IsAny <AttachmentBurial>(), It.IsAny <CancellationToken>())).ReturnsAsync(attachmentBurial);
_dataAttachmentBurial.Setup(x => x.DeleteAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>()));
_burialValidation.Setup(x => x.GetValidationAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(validationBurial);
_burialValidation.Setup(x => x.InsertValidationAsync(It.IsAny <Burial>(), It.IsAny <CancellationToken>())).ReturnsAsync(validationBurial);
_burialValidation.Setup(x => x.UpdateValidationAsync(It.IsAny <Burial>(), It.IsAny <CancellationToken>())).ReturnsAsync(validationBurial);
_burialValidation.Setup(x => x.DeleteValidationAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(validationBurial);
_service = new BurialService(_fileHelper.Object, _dataBurial.Object, _dataAttachmentBurial.Object, _burialValidation.Object);
}
public async Task <AttachmentBurial> InsertAsync(AttachmentBurial entity, CancellationToken cancellationToken)
{
await db.AttachmentBurials.AddAsync(entity, cancellationToken);
await db.SaveChangesAsync(cancellationToken);
return(entity);
}
public async Task <bool> ExistAsync(AttachmentBurial entity, CancellationToken cancellationToken)
{
return(await db.AttachmentBurials.AnyAsync(db =>
db.FileName == entity.FileName &&
db.FileType == entity.FileType &&
db.FilePath == entity.FilePath,
cancellationToken));
}
private FileModel GetFileModelByAttachmentBurial(AttachmentBurial attachmentBurial = default)
{
return(new FileModel()
{
FileName = attachmentBurial.FileName,
FilePath = attachmentBurial.FilePath,
FileType = attachmentBurial.FileType
});
}
public async Task <ValidationModel <AttachmentBurial> > UpdateAsync(AttachmentBurial newEntity, CancellationToken cancellationToken = default)
{
var validation = await attachmentBurialValidation.UpdateValidationAsync(newEntity, cancellationToken);
if (!validation.IsValid)
{
return(validation);
}
newEntity.UpdatedAt = DateTime.Now;
validation.Result = await dataAttachmentBurial.UpdateAsync(newEntity, cancellationToken);
return(validation);
}
public async Task TestUpdateAsync()
{
// Arrange
var random = new Random(0);
var number = random.Next(5);
var entity = GetList()[number];
await _service.InsertAsync(entity);
_dbContext.Entry(entity).State = EntityState.Detached;
_dbContext.Entry(entity.Burial).State = EntityState.Detached;
entity = new AttachmentBurial()
{
Id = entity.Id,
BurialId = Guid.NewGuid(),
Burial = GetBurial(),
FileName = Guid.NewGuid().ToString(),
CreatedAt = DateTime.Now.AddMinutes(60),
UpdatedAt = DateTime.Now.AddMinutes(60)
};
await _service.UpdateAsync(entity);
_dbContext.Entry(entity).State = EntityState.Detached;
_dbContext.Entry(entity.Burial).State = EntityState.Detached;
// Act
var result = await _service.GetAsync(entity.Id);
_dbContext.Entry(result).State = EntityState.Detached;
_dbContext.Entry(result.Burial).State = EntityState.Detached;
// Assert
Assert.Multiple(() =>
{
Assert.IsTrue(entity.FileName == result.FileName);
Assert.IsTrue(entity.FilePath == result.FilePath);
Assert.IsTrue(entity.FileType == result.FileType);
Assert.IsTrue(entity.BurialId == result.BurialId);
Assert.IsTrue(entity.CreatedAt == result.CreatedAt);
Assert.IsTrue(entity.UpdatedAt == result.UpdatedAt);
});
}
public async Task <ValidationModel <AttachmentBurial> > InsertAsync(AttachmentBurial newEntity, CancellationToken cancellationToken = default)
{
var validation = await attachmentBurialValidation.InsertValidationAsync(newEntity, cancellationToken);
if (!validation.IsValid)
{
return(validation);
}
var fileData = await fileHelper.SaveFile(newEntity.File);
newEntity.FilePath = fileData.FilePath;
newEntity.FileName = fileData.FileName;
newEntity.FileType = fileData.FileType;
newEntity.CreatedAt = DateTime.Now;
newEntity.UpdatedAt = DateTime.Now;
validation.Result = await dataAttachmentBurial.InsertAsync(newEntity, cancellationToken);
return(validation);
}
public async Task <ValidationModel <AttachmentBurial> > UpdateValidationAsync(AttachmentBurial newEntity, CancellationToken cancellationToken = default)
{
if (newEntity is not null)
{
if (!await dataAttachmentBurial.ExistByIdAsync(newEntity.Id, cancellationToken))
{
validation.Errors.Add(nameof(AttachmentBurial),
string.Format(BaseValidation.ObjectNotExistById, nameof(AttachmentBurial), newEntity.Id));
}
if (!await dataBurial.ExistByIdAsync(newEntity.BurialId, cancellationToken))
{
validation.Errors.Add(nameof(AttachmentBurial.Burial),
string.Format(BaseValidation.ObjectNotExistById, nameof(AttachmentBurial.Burial), newEntity.BurialId));
}
if (newEntity.File is null)
{
validation.Errors.Add(nameof(AttachmentBurial.File),
string.Format(BaseValidation.FileNotCanBeNull));
}
}
else
{
validation.Errors.Add(nameof(AttachmentBurial),
string.Format(BaseValidation.ObjectNotCanBeNull, nameof(AttachmentBurial)));
}
return(validation);
}
public async Task <ValidationModel <AttachmentBurial> > InsertValidationAsync(AttachmentBurial newEntity, CancellationToken cancellationToken = default)
{
if (newEntity is not null)
{
if (newEntity.File is null)
{
validation.Errors.Add(nameof(AttachmentBurial.File),
string.Format(BaseValidation.FileNotCanBeNull));
}
}
else
{
validation.Errors.Add(nameof(AttachmentBurial),
string.Format(BaseValidation.ObjectNotCanBeNull, nameof(AttachmentBurial)));
}
return(validation);
}
