public void UpsertFileDataSourceMustCallValidateIfUpdating()
{
//Arrange
var source = new FileDataSource {
Id = newSourceId, InputStatus = SourceStatus.PendingExtraction
};
mockContext
.Setup(context => context.GetFileDataSource(It.IsAny <Guid>(), It.IsAny <string>()))
.Returns(source)
.Verifiable();
var uploadContract = new FileDataContract
{
SourceId = newSourceId,
OriginalFileName = "Original Name"
};
var fileStream = new MemoryStream(new byte[] { 100 });
//Act
CreateService().UpsertFileDataSource(uploadContract, fileStream);
//Assert
mockService
.Verify(service => service.ValidateSource(It.Is <Guid>(guid => guid == newSourceId)));
}
public void AdaptFile(IEnumerable <OrganizationFile> fromValue, IEnumerable <FileDataContract> toValue)
{
var fileDataContracts = toValue.ToList();
var organizationFiles = fromValue.ToList();
Guard.Against.Zero(organizationFiles.Count(), nameof(OrganizationFile));
Guard.Against.Zero(fileDataContracts.Count(), nameof(FileDataContract));
foreach (var organizationFile in organizationFiles)
{
var value = new FileDataContract
{
Id = organizationFile.Id,
AllDataInFile = organizationFile.AllDataInFile,
FileFormat = organizationFile.FileFormat,
FileLocationOrigin = organizationFile.FileLocationOrigin,
FileMigrated = organizationFile.FileMigrated.ToString(),
FileSize = organizationFile.FileSize,
LocationToCopy = organizationFile.LocationToCopy,
OrgCode = organizationFile.OrgCode,
Status = organizationFile.Status.ToString(),
FileDescription = organizationFile.FileDescription,
FileMigratedOn = organizationFile.FileMigratedOn
};
var dt = new[] { value };
toValue = fileDataContracts.Concat(dt);
}
}
public void UpsertFileDataSourceMustCancelfInsertingAndSourceIdNotNull()
{
//Arrange
var source = new FileDataSource {
Id = newSourceId
};
mockContext
.Setup(context => context.AddDataSource(It.IsAny <FileDataSource>()))
.Returns(source)
.Verifiable();
var uploadContract = new FileDataContract
{
SourceId = newSourceId,
OriginalFileName = "Original Name"
};
//Act
CreateService().UpsertFileDataSource(uploadContract, new MemoryStream());
//Assert
mockContext.Verify();
mockService
.Verify(service => service.CancelFileSourceExtraction(It.Is <Guid>(guid => guid == newSourceId)));
}
public void UpsertFileDataSourceMustSetTheFileHashIfInserting()
{
//Arrange
var source = new FileDataSource {
Id = newSourceId
};
mockContext
.Setup(context => context.AddDataSource(It.IsAny <FileDataSource>()))
.Returns(source)
.Verifiable();
var uploadContract = new FileDataContract
{
SourceId = newSourceId,
OriginalFileName = "Original Name",
};
var fileStream = new MemoryStream(new byte[] { 100 });
//Act
CreateService().UpsertFileDataSource(uploadContract, fileStream);
//Assert
mockContext
.Verify(context => context.AddDataSource(
It.Is <FileDataSource>(
dataSource =>
(dataSource.OriginalFileName == "Original Name") &&
(dataSource.FileHash) == "<686ÏNffi¢]¢€¡†\\-(t")));
}
public void UpsertFileDataSourceMustCallAddDatasourceWhenInserting()
{
//Arrange
var contract = new FileDataContract
{
ReferenceNotes = "reference notes",
OriginalFileName = "Original name",
HandlerName = "handler name"
};
mockContext
.Setup(context => context.AddDataSource(It.Is <FileDataSource>(
source =>
(source.InputStatus == SourceStatus.PendingExtraction) &&
(source.ReferenceNotes == "reference notes") &&
(source.OriginalFileName == "Original name") &&
(source.HandlerName == "handler name") &&
(source.UserName == "TestUserName"))))
.Returns(new FileDataSource {
Id = newSourceId, InputStatus = SourceStatus.PendingExtraction
})
.Verifiable();
//Act
CreateService().UpsertFileDataSource(contract, new MemoryStream());
//Assert
mockContext.Verify();
}
public FileDataContract Update(string key, FileDataContract data)
{
var currentFile = _repository.GetById(key);
if (currentFile == null)
{
return(null);
}
var updateFile = _mapper.Map <File>(data);
ValidationResult results = _validator.Validate(updateFile);
if (!results.IsValid)
{
data.Error = new List <InfoDataContract>();
foreach (var error in results.Errors)
{
data.Error.Add(new InfoDataContract {
Field = error.PropertyName, Message = error.ErrorMessage
});
}
return(data);
}
currentFile.Status = data.Status;
currentFile.ProcessDate = DateTime.Now;
var updatedFile = _repository.Update(currentFile);
return(_mapper.Map <FileDataContract>(updatedFile));
}
public static FileDataContract GetFileDataContract(string codOrg)
{
var dataContract = new FileDataContract(null, codOrg, "firstFile.xml", 555,
"xml", "c:/temp/teste", "y:/copy/file",
"Processed", false, null, new List <BsonDocument>()
);
return(dataContract);
}
/// <summary>
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <FileDataContract> GetOrganizationFileById(string id)
{
var match = await _repositoryInstance.GetByIdAsync(id);
if (match == null)
{
return(null);
}
var toOrganizationFile = new FileDataContract();
_adapter.AdaptFile(match, toOrganizationFile);
return(toOrganizationFile);
}
public void CanConvert(string identifier, int fileId, string fileSignature, string icon)
{
var value = new FileDataContract
{
Id = identifier,
Icon = icon
};
var result = this.converter.Convert(value, null);
Assert.NotNull(result);
Assert.NotNull(result.IconFileUrl);
Assert.Equal(fileId, result.FileId);
Assert.Equal(fileSignature, result.FileSignature);
Assert.Equal(icon, result.IconFileUrl.ToString());
}
public void CanConvert(string identifier, int fileId, string fileSignature, string icon)
{
var value = new FileDataContract
{
Id = identifier,
Icon = icon
};
var result = this.converter.Convert(value, null);
Assert.NotNull(result);
Assert.NotNull(result.IconFileUrl);
Assert.Equal(fileId, result.FileId);
Assert.Equal(fileSignature, result.FileSignature);
Assert.Equal(icon, result.IconFileUrl.ToString());
}
public void AdaptFile(OrganizationFile fromValue, FileDataContract toValue)
{
Guard.Against.Null(fromValue, nameof(OrganizationFile));
Guard.Against.Null(toValue, nameof(FileDataContract));
toValue.Id = fromValue.Id;
toValue.AllDataInFile = fromValue.AllDataInFile;
toValue.FileFormat = fromValue.FileFormat;
toValue.FileLocationOrigin = fromValue.FileLocationOrigin;
toValue.FileMigrated = fromValue.FileMigrated.ToString();
toValue.FileSize = fromValue.FileSize;
toValue.LocationToCopy = fromValue.LocationToCopy;
toValue.OrgCode = fromValue.OrgCode;
toValue.Status = fromValue.Status.ToString();
toValue.FileDescription = fromValue.FileDescription;
toValue.FileMigratedOn = fromValue.FileMigratedOn;
}
public virtual async Task <IHttpActionResult> UploadFile()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new Exception();
}
var provider = new MultipartMemoryStreamProvider();
await Request.Content.ReadAsMultipartAsync(provider);
var fileInfo = new FileDataContract {
UserName = User.Identity.Name
};
Stream buffer = null;
foreach (var content in provider.Contents)
{
var name = content.Headers.ContentDisposition.Name.Trim('\"');
if (string.Equals(name, "referenceNotes", StringComparison.InvariantCultureIgnoreCase))
{
fileInfo.ReferenceNotes = await content.ReadAsStringAsync();
continue;
}
if (string.Equals(name, "fileHandler", StringComparison.InvariantCultureIgnoreCase))
{
fileInfo.HandlerName = await content.ReadAsStringAsync();
continue;
}
if (string.Equals(name, "mediaType", StringComparison.InvariantCultureIgnoreCase))
{
fileInfo.MediaType = await content.ReadAsStringAsync();
continue;
}
if (!string.Equals(name, "file", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
fileInfo.OriginalFileName = content.Headers.ContentDisposition.FileName.Trim('\"');
buffer = await content.ReadAsStreamAsync();
}
var result = await service.UpsertFileDataSource(fileInfo, buffer);
return(Ok(result));
}
public virtual Task <SourceResultDataContract> UpsertFileDataSource(FileDataContract fileData, Stream stream)
{
return(Task.Run(() =>
{
lock (UpsertFileDataSourceLock)
{
var hash = GetHash(stream);
var fileSource = Context.GetFileDataSource(fileData.SourceId, hash);
if (fileSource == null)
{
fileSource = new FileDataSource
{
OriginalFileName = fileData.OriginalFileName,
DateEdit = DateTime.Now,
InputStatus = SourceStatus.PendingExtraction,
ReferenceNotes = fileData.ReferenceNotes,
UserName = fileData.UserName,
HandlerName = fileData.HandlerName,
FileHash = hash,
MediaType = fileData.MediaType
};
fileSource = Context.AddDataSource(fileSource);
var newFileName = streamManager
.StageStream(
fileSource.Id,
fileData.OriginalFileName,
stream);
fileSource.CurrentFileName = newFileName;
}
if (fileSource.InputStatus != SourceStatus.PendingExtraction)
{
return DataContractError(fileSource.Id,
DataSourceServiceResources.FileSourceIsNotPendingExtraction);
}
fileSource.OriginalFileName = fileData.OriginalFileName ?? fileSource.OriginalFileName;
fileSource.HandlerName = fileData.HandlerName ?? fileSource.HandlerName;
fileSource.MediaType = fileData.MediaType ?? fileSource.MediaType;
fileSource.UserName = fileData.UserName;
fileSource.DateEdit = DateTime.Now;
fileSource.ReferenceNotes = fileData.ReferenceNotes ?? fileSource.ReferenceNotes;
Context.UpdateDataSource(fileSource);
return ValidateSource(fileSource.Id);
}
}));
}
public ActionResult Post([FromBody] FileDataContract file, [FromServices] IFileOperations operations)
{
try
{
var result = operations.Insert(file);
if (result.Error.Any())
{
return(BadRequest(result.Error));
}
return(Created("", result));
}
catch (Exception ex)
{
return(BadRequest(new { Code = HttpContext.Response.StatusCode, Message = ex.Message }));
}
}
public void UpsertFileDataMustNotUpdateReferenceNotesIfNull()
{
//Arrange
var source = new FileDataSource
{
Id = newSourceId,
InputStatus = SourceStatus.PendingExtraction,
HandlerName = "oldHandlerName",
OriginalFileName = "oldFileName",
ReferenceNotes = "oldReferenceNotes"
};
mockContext
.Setup(context => context.GetFileDataSource(It.IsAny <Guid>(), It.IsAny <string>()))
.Returns(source)
.Verifiable();
CreateService();
mockService
.Setup(service => service.ValidateSource(It.IsAny <Guid>()))
.Returns((SourceResultDataContract)null)
.Verifiable();
var contract = new FileDataContract
{
SourceId = newSourceId,
HandlerName = "newHandlerName",
OriginalFileName = "newFileName",
};
//Act
mockService.Object.UpsertFileDataSource(contract, new MemoryStream());
//Assert
mockService.Verify();
mockContext.Verify();
mockContext
.Verify(context => context.UpdateDataSource(It.Is <FileDataSource>(
dataSource =>
(dataSource.Id == newSourceId) &&
(dataSource.UserName == "testUserName") &&
(dataSource.OriginalFileName == "newFileName") &&
(dataSource.HandlerName == "newHandlerName") &&
(dataSource.ReferenceNotes == "oldReferenceNotes"))));
}
public void AdaptToOrganizationFile(FileDataContract fromFileData, TermDetailConfig configuration)
{
Guard.Against.Null(fromFileData, nameof(FileDataContract));
Guard.Against.Null(configuration, nameof(TermDetailConfig));
Enum.TryParse <StatusType>(fromFileData.Status, true, out var statusType);
bool.TryParse(fromFileData.FileMigrated, out var fileMigrated);
configuration.AddOrganizationFile("", fromFileData.OrgCode,
fromFileData.FileDescription,
fromFileData.FileSize,
fromFileData.FileFormat,
fromFileData.FileLocationOrigin,
fromFileData.LocationToCopy,
statusType,
fileMigrated,
fromFileData.FileMigratedOn,
fromFileData.AllDataInFile, true);
//var configTemp = item.TermDetailConfigs.GetTermDetailConfiguration(item.Id, item.CodOrg);
}
/// <summary>
///
/// </summary>
/// <param name="fileContract"></param>
/// <returns></returns>
public async Task CreateOrganizationFile(FileDataContract fileContract)
{
Guard.Against.Null(fileContract, nameof(fileContract));
//retrieve OrganizationConfigurations based on orgCode
//TODO change to verify type of debt
var config = await _configRepositoryInstance.GetEqualField("OrgCode", fileContract.OrgCode);
var configResult = config.FirstOrDefault();
if (config == null)
{
throw new Exception("configuration of organization was not found.");
}
//Verify if exists document with the same name
var allFilesDb = _repositoryInstance.GetEqualField("OrgCode", fileContract.OrgCode);
var match = allFilesDb.Result.FirstOrDefault(x => x.FileDescription.Trim().Equals(fileContract.FileDescription));
if (match == null)
{
Enum.TryParse <StatusType>(fileContract.Status, true, out var status);
Boolean.TryParse(fileContract.FileMigrated, out var fileMigrated);
var org = new OrganizationFile(string.Empty, fileContract.FileDescription,
fileContract.FileSize, fileContract.FileFormat, fileContract.FileLocationOrigin,
fileContract.LocationToCopy, status, fileMigrated,
null, configResult, fileContract.AllDataInFile);
_repositoryInstance.Add(org);
fileContract.Id = org.Id;
}
else
{
throw new InvalidOperationException(
$"Can not save File '{match.FileDescription + " and " + match.OrgCode}' already exist.");
}
}
public FileDataContract Insert(FileDataContract data)
{
var newFile = _mapper.Map <File>(data);
ValidationResult results = _validator.Validate(newFile);
if (!results.IsValid)
{
data.Error = new List <InfoDataContract>();
foreach (var error in results.Errors)
{
data.Error.Add(new InfoDataContract {
Field = error.PropertyName, Message = error.ErrorMessage
});
}
return(data);
}
var fileResult = _repository.Insert(newFile);
return(_mapper.Map <FileDataContract>(fileResult));
}
public void UpsertFilesourceMustUpdateCurrentFileNameWithTheNewName()
{
//Arrange
var source = new FileDataSource {
Id = newSourceId, InputStatus = SourceStatus.PendingExtraction
};
mockStreamManager
.Setup(manager => manager.StageStream(
It.Is <Guid>(guid => guid == newSourceId),
It.Is <string>(s => s == "Original Name"),
It.IsAny <Stream>()))
.Returns("NewFileName")
.Verifiable();
mockContext
.Setup(context => context.AddDataSource(It.IsAny <FileDataSource>()))
.Returns(source);
var uploadContract = new FileDataContract
{
SourceId = newSourceId,
OriginalFileName = "Original Name"
};
//Act
CreateService().UpsertFileDataSource(uploadContract, new MemoryStream());
//Assert
mockService.Verify();
mockStreamManager.Verify();
mockContext.Verify(context => context.UpdateDataSource(It.Is <FileDataSource>(
dataSource =>
(dataSource.Id == newSourceId) &&
(dataSource.InputStatus == SourceStatus.PendingExtraction) &&
(dataSource.CurrentFileName == "NewFileName"))), Times.Once);
}
public ActionResult Put(string idFile, [FromBody] FileDataContract file, [FromServices] IFileOperations operations)
{
try
{
var result = operations.Update(idFile, file);
if (result == null)
{
return(OkWithSuccess(result, System.Net.HttpStatusCode.NotFound));
}
if (result.Error.Any())
{
return(BadRequest(result.Error));
}
return(OkWithSuccess(result));
}
catch (Exception ex)
{
return(BadRequest(new { Code = HttpContext.Response.StatusCode, Message = ex.Message }));
}
}
