public async Task <string> ConvertFile(string file, string destinationExtension)
{
var fi = new FileInfo(file);
Log.Information("Start converting file: {FullName}", fi.FullName);
try
{
var stopWatch = new Stopwatch();
stopWatch.Start();
var conversionSettings = new JobInitRequest
{
FileNameWithExtension = fi.Name,
RequestedProcessType = ProcessType.Rendering
};
var registrationResponse = await jobInitRequestClient.Request(conversionSettings);
if (registrationResponse.IsInvalid)
{
throw new Exception($"JobInit request was not valid. Error message: {registrationResponse.ErrorMessage}");
}
Log.Information("Successfully registered job for conversion of file {Name}. Got job id {JobId}", fi.Name,
registrationResponse.JobGuid);
await UploadFile(registrationResponse, fi);
Log.Information("File '{Name}' uploaded", fi.Name);
var requestSettings = new ConversionStartRequest
{
JobGuid = registrationResponse.JobGuid,
DestinationExtension = destinationExtension
};
Log.Information("Sent actual conversion request for job id {jobGuid}", registrationResponse.JobGuid);
var convertionResponse = await conversionRequestClient.Request(requestSettings);
if (convertionResponse.IsInvalid)
{
throw new Exception(convertionResponse.ErrorMessage);
}
var result = await DownloadAndStoreFile(convertionResponse, fi.Directory);
Log.Information(
$"Retrieved conversion result for file {fi.FullName} in {stopWatch.ElapsedMilliseconds} ms. Length of content is {result.LengthOfContent} bytes.");
return(result.TargetPath);
}
catch (Exception ex)
{
Log.Error(ex, "Unexpected error while converting file {FullName}", fi.FullName);
throw;
}
}
public JobInitResult RegisterNewJob(JobInitRequest jobInitRequest)
{
if (fileServer == null)
{
throw new InvalidOperationException("Sftp server is not configured and started");
}
try
{
// Create a new unique user and a unique directory for that user
var newJobGuid = Guid.NewGuid().ToString("N");
var user = new FileServerUser(newJobGuid, password);
Debug.Assert(user != null);
var di = GetJobDirectory(newJobGuid);
di.Create();
// Create a sftp file system object and assign it to the user.
var localFileSystem = CreateFileSystem(di.FullName);
user.SetFileSystem(localFileSystem);
lock (fileServerLock)
{
fileServer.Users.Add(user);
}
var jobInitResult = new JobInitResult
{
JobGuid = newJobGuid,
User = user.Name,
Password = password,
UploadUrl = baseAddress,
Port = port
};
// Add the information about the job to our local in memory storage
var jobInfoDetails = new JobInfoDetails {
Request = jobInitRequest, Result = jobInitResult
};
jobStorage.AddOrUpdate(newJobGuid, jobInfoDetails, (k, v) => v);
return(jobInitResult);
}
catch (Exception e)
{
Log.Error(e, e.Message);
return(new JobInitResult
{
IsInvalid = true,
ErrorMessage = e.Message
});
}
}
public void Test(string sourceFolder)
{
try
{
LogConfigurator.ConfigureForService();
var initClient = CreateJobInitRequestClient();
var extractionClient = CreateDocumentExtractionRequestClient();
var conversionClient = CreateDocumentConversionRequestClient();
var supportedFileTypesClient = CreateSupportedFileTypesRequestClient();
// Create the target ouptut folder as subdirectory. Make sure it is empty
var targetFolder = new DirectoryInfo(Path.Combine(sourceFolder, "Output"));
if (targetFolder.Exists)
{
targetFolder.Delete(true);
}
targetFolder.Create();
var sourceFiles = new DirectoryInfo(sourceFolder).GetFiles("*.*", SearchOption.AllDirectories);
var jobs = new List <JobInitRequest>();
foreach (var sourceFile in sourceFiles)
{
var extractionJob = new JobInitRequest
{
FileNameWithExtension = sourceFile.FullName,
RequestedProcessType = ProcessType.TextExtraction
};
var conversionJob = new JobInitRequest
{
FileNameWithExtension = sourceFile.FullName,
RequestedProcessType = ProcessType.Rendering
};
jobs.Add(extractionJob);
jobs.Add(conversionJob);
}
// Print out supported file types
var conversionSupportedFileTypes = supportedFileTypesClient
.Request(new SupportedFileTypesRequest {
ProcessType = ProcessType.Rendering
}).GetAwaiter().GetResult();
var extractionSupportedFileTypes = supportedFileTypesClient
.Request(new SupportedFileTypesRequest {
ProcessType = ProcessType.TextExtraction
}).GetAwaiter().GetResult();
Console.WriteLine($"Supported types for conversion: {string.Join(", ", conversionSupportedFileTypes.SupportedFileTypes)}");
Console.WriteLine($"Supported types for text extraction: {string.Join(", ", extractionSupportedFileTypes.SupportedFileTypes)}");
Console.WriteLine("");
foreach (var job in jobs)
{
// Init Job
var jobInitResult = initClient.Request(job).GetAwaiter().GetResult();
if (!jobInitResult.IsInvalid)
{
// Upload File
UploadFile(jobInitResult, new FileInfo(job.FileNameWithExtension));
// Start actual job, based on request type
switch (job.RequestedProcessType)
{
case ProcessType.TextExtraction:
var extractedText = extractionClient.Request(new ExtractionStartRequest {
JobGuid = jobInitResult.JobGuid
})
.GetAwaiter().GetResult();
SaveTextExtractionResult(new FileInfo(job.FileNameWithExtension), extractedText.Text, targetFolder);
break;
case ProcessType.Rendering:
var conversionResult = conversionClient.Request(new ConversionStartRequest
{
JobGuid = jobInitResult.JobGuid,
DestinationExtension = GetDestinationBasedOnInput(new FileInfo(job.FileNameWithExtension).Extension)
})
.GetAwaiter()
.GetResult();
if (!conversionResult.IsInvalid)
{
DownloadAndStoreFile(conversionResult, targetFolder);
}
else
{
Console.WriteLine($"Unable to convert file. Error: {conversionResult.ErrorMessage}");
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public async Task <string> ExtractText(string file)
{
var fi = new FileInfo(file);
try
{
var stopWatch = new Stopwatch();
stopWatch.Start();
var conversionSettings = new JobInitRequest
{
FileNameWithExtension = fi.Name,
RequestedProcessType = ProcessType.TextExtraction
};
var registrationResponse = await jobRequestClient.Request(conversionSettings);
Log.Information("Successfully registered job for text extraction of file {Name}. Got job id {JobId}", fi.Name,
registrationResponse.JobGuid);
await UploadFile(registrationResponse, fi);
Log.Information("File '{Name}' uploaded", fi.Name);
var requestSettings = new ExtractionStartRequest
{
JobGuid = registrationResponse.JobGuid
};
Log.Information("Sent actual text extraction request for job id {jobGuid}", registrationResponse.JobGuid);
var extractionResult = await extractionRequestClient.Request(requestSettings);
if (extractionResult.IsInvalid)
{
throw new Exception(extractionResult.ErrorMessage);
}
var lengthInBytes = string.IsNullOrEmpty(extractionResult.Text) ? 0 : extractionResult.Text.Length;
Log.Information("Retrieved content for file {Name} in {ElapsedMilliseconds} ms. Length of content is {lengthInBytes} bytes.", fi.Name,
stopWatch.ElapsedMilliseconds,
lengthInBytes);
return(extractionResult.Text);
}
catch (Exception ex)
{
Log.Error(ex, "Unexpected error while extracting text for file {FullName}", fi.FullName);
throw;
}
finally
{
if (fi.Exists)
{
fi.Delete();
fi.Refresh();
if (fi.Exists)
{
Log.Warning($"Unable to delete file '{fi.FullName}'");
}
}
}
}
