public void Process(ResourceSessionDirector resourceDirector)
{
var work = new CreateOrUpdateProjectBasicDataWork(m_projectRepository, resourceDirector);
var projectId = work.Execute();
resourceDirector.SetSessionInfoValue(SessionInfo.ProjectId, projectId);
}
private void AddBookAccessories(ResourceSessionDirector resourceSessionDirector, BookData bookData)
{
if (bookData.Accessories != null)
{
foreach (var file in bookData.Accessories)
{
if (!string.IsNullOrWhiteSpace(file.FileName))
{
var accessory = new FileResource
{
FileName = file.FileName,
FullPath = Path.Combine(resourceSessionDirector.SessionPath, file.FileName),
ResourceType = GetResourceTypeByBookAccessory(file)
};
if (m_log.IsInfoEnabled)
{
m_log.InfoFormat($"Adding resource: '{accessory.FileName}' as type '{accessory.ResourceType}'");
}
resourceSessionDirector.Resources.Add(accessory);
}
}
}
}
private FileResource GenerateFullBookArchive(List <TrackRecordingData> recordings, BookData bookData, AudioTypeEnum audioType,
ResourceSessionDirector resourceSessionDirector)
{
var archiveName = GetArchiveName(bookData, audioType);
var fullPath = Path.Combine(resourceSessionDirector.SessionPath, archiveName);
using (var fs = new FileStream(fullPath, FileMode.Create))
{
using (var zipFile = new ZipArchive(fs, ZipArchiveMode.Create))
{
foreach (var record in recordings)
{
var sessionResource = resourceSessionDirector.GetResourceFromSession(ResourceType.Audio, record.FileName);
if (sessionResource != null)
{
zipFile.CreateEntryFromFile(sessionResource.FullPath, record.FileName, CompressionLevel.Optimal);
}
else
{
if (m_log.IsErrorEnabled)
{
m_log.ErrorFormat($"Found metadata info about audioFileRecord : {record.FileName} but file was not uploaded to session.");
}
}
}
}
}
return(new FileResource
{
FileName = archiveName,
FullPath = fullPath,
ResourceType = ResourceType.Audio,
});
}
public void Process(ResourceSessionDirector resourceSessionDirector)
{
foreach (var resource in resourceSessionDirector.Resources)
{
m_fileSystemManager.SaveResource(
resourceSessionDirector.GetSessionInfoValue <string>(SessionInfo.BookId),
resourceSessionDirector.GetSessionInfoValue <string>(SessionInfo.VersionId), resource);
}
}
public void Process(ResourceSessionDirector resourceSessionDirector)
{
var projectId = resourceSessionDirector.GetSessionInfoValue <long>(SessionInfo.ProjectId);
var versionXmlId = resourceSessionDirector.GetSessionInfoValue <string>(SessionInfo.VersionXmlId);
foreach (var resource in resourceSessionDirector.Resources)
{
m_fileSystemManager.SaveResource(projectId, versionXmlId, resource);
}
}
private FileResource GetMetadataForProcessing(ResourceSessionDirector resourceSessionDirector)
{
var metaData = resourceSessionDirector.Resources.FirstOrDefault(resource => resource.ResourceType == ResourceType.UploadedMetadata) ??
resourceSessionDirector.Resources.FirstOrDefault(resource => resource.ResourceType == ResourceType.ConvertedMetadata);
if (metaData == null)
{
throw new ResourceMissingException("Metadata not found in resources");
}
return(metaData);
}
public void Process(ResourceSessionDirector resourceSessionDirector)
{
var archives = resourceSessionDirector.Resources.Where(x => x.ResourceType == ResourceType.ExtractableArchive);
foreach (var archive in archives.ToList())
{
var filesFromArchive = ExtractFilesFromArchive(archive, resourceSessionDirector);
foreach (var extractedFile in filesFromArchive)
{
resourceSessionDirector.AddResourceAndFillResourceTypeByExtension(extractedFile);
}
}
}
public SaveNewBookDataWork(ProjectRepository projectRepository, MetadataRepository metadataRepository,
ResourceRepository resourceRepository, CatalogValueRepository catalogValueRepository,
PersonRepository personRepository, ResourceSessionDirector resourceDirector) : base(projectRepository)
{
m_projectRepository = projectRepository;
m_metadataRepository = metadataRepository;
m_resourceRepository = resourceRepository;
m_catalogValueRepository = catalogValueRepository;
m_personRepository = personRepository;
m_nullableProjectId = resourceDirector.GetSessionInfoValue <long?>(SessionInfo.ProjectId);
m_bookData = resourceDirector.GetSessionInfoValue <BookData>(SessionInfo.BookData);
m_message = resourceDirector.GetSessionInfoValue <string>(SessionInfo.Message);
m_userId = resourceDirector.GetSessionInfoValue <int>(SessionInfo.UserId);
}
public void Process(ResourceSessionDirector resourceDirector)
{
var existFileResources =
resourceDirector.Resources.Where(
resource =>
resource.ResourceType == ResourceType.Book ||
resource.ResourceType == ResourceType.Page ||
resource.ResourceType == ResourceType.BibliographyDocument ||
resource.ResourceType == ResourceType.Transformation);
foreach (var resource in existFileResources)
{
if (string.IsNullOrEmpty(resource.FileName) && m_log.IsFatalEnabled)
{
m_log.ErrorFormat("Resource of type {0} and path {1} does not have fileName", resource.ResourceType,
resource.FullPath);
continue;
}
using (var dataStream = File.Open(resource.FullPath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var resourceUploadContract = GetVersionResourceUploadContract(resource, resourceDirector, dataStream);
switch (resource.ResourceType)
{
case ResourceType.BibliographyDocument:
UploadBibliographyFile(resourceUploadContract);
break;
case ResourceType.Book:
UploadResourceToBookVersion(resourceUploadContract);
break;
case ResourceType.Page:
UploadResourceToBookVersion(resourceUploadContract);
break;
case ResourceType.Transformation:
UploadTransformationResource(resourceUploadContract);
break;
default:
throw new ArgumentException($"ResourceType: '{resource.ResourceType}' not meant for ExistDb upload");
}
}
}
}
public void Process(ResourceSessionDirector resourceSessionDirector)
{
var bookData = resourceSessionDirector.GetSessionInfoValue <BookData>(SessionInfo.BookData);
if (bookData.Tracks == null)
{
return;
}
//DISCOVER all entites
var recordings = ExtractAudioRecordingsInfo(bookData);
//GENERATE audioArchive
PackAllBookAudioArchives(resourceSessionDirector, recordings, bookData);
}
public void Process(ResourceSessionDirector resourceSessionDirector)
{
var bookVersion = resourceSessionDirector.GetSessionInfoValue <BookVersion>(SessionInfo.BookVersionEntity);
var trans = resourceSessionDirector.Resources.Where(x => x.ResourceType == ResourceType.Transformation);
if (bookVersion.Transformations == null)
{
bookVersion.Transformations = new List <Transformation>();
}
foreach (var transResource in trans)
{
var transformation = GetTransformationObject(transResource);
bookVersion.Transformations.Add(transformation);
}
}
private void PackAllBookAudioArchives(ResourceSessionDirector resourceSessionDirector, Dictionary <AudioTypeEnum, List <TrackRecordingData> > recordings, BookData bookData)
{
bookData.FullBookRecordings = new List <FullBookRecordingData>();
foreach (var audioType in recordings.Keys)
{
var allBookArchive = GenerateFullBookArchive(recordings[audioType], bookData, audioType, resourceSessionDirector);
resourceSessionDirector.Resources.Add(allBookArchive);
var entity = new FullBookRecordingData
{
AudioType = audioType,
FileName = allBookArchive.FileName,
MimeType = MimeType
};
bookData.FullBookRecordings.Add(entity);
}
}
public void Process(ResourceSessionDirector resourceSessionDirector)
{
var metaData = GetMetadataForProcessing(resourceSessionDirector);
var xmlFileStream = File.Open(metaData.FullPath, FileMode.Open);
BookData bookData = m_xmlMetadataProcessingManager.GetXmlMetadata(xmlFileStream);
bookData.VersionDescription = resourceSessionDirector.GetSessionInfoValue <string>(SessionInfo.Message);
bookData.CreateTime = resourceSessionDirector.GetSessionInfoValue <DateTime>(SessionInfo.CreateTime);
resourceSessionDirector.SetSessionInfoValue(SessionInfo.BookData, bookData);
resourceSessionDirector.SetSessionInfoValue(SessionInfo.BookXmlId, bookData.BookXmlId);
resourceSessionDirector.SetSessionInfoValue(SessionInfo.VersionXmlId, bookData.VersionXmlId);
AddBookAccessories(resourceSessionDirector, bookData);
AddBookPages(resourceSessionDirector, bookData);
}
private static void AddBookPages(ResourceSessionDirector resourceSessionDirector, BookData bookData)
{
if (bookData.Pages != null)
{
foreach (var page in bookData.Pages)
{
if (!string.IsNullOrWhiteSpace(page.XmlResource))
{
var pageResource = new FileResource
{
FileName = page.XmlResource,
FullPath = Path.Combine(resourceSessionDirector.SessionPath, page.XmlResource),
ResourceType = ResourceType.Page
};
resourceSessionDirector.Resources.Add(pageResource);
}
}
}
}
private List <Resource> ExtractFilesFromArchive(Resource extractableArchive, ResourceSessionDirector resourceSessionDirector)
{
var result = new List <Resource>();
using (ZipArchive archive = ZipFile.OpenRead(extractableArchive.FullPath))
{
foreach (ZipArchiveEntry entry in archive.Entries)
{
var fileName = entry.Name;
var fullPath = resourceSessionDirector.GetFullPathForNewSessionResource(fileName);
if (!string.IsNullOrWhiteSpace(fileName))
{
if (!string.IsNullOrWhiteSpace(fileName))
{
try
{
if (m_log.IsDebugEnabled)
{
m_log.Debug($"Extracting file '{fileName}' from archive '{extractableArchive.FullPath}'");
}
entry.ExtractToFile(fullPath, false);
result.Add(new Resource
{
FileName = fileName,
FullPath = fullPath
});
}
catch (InvalidDataException ex)
{
if (m_log.IsErrorEnabled)
{
m_log.ErrorFormat("Cannot extract resource: '{0}' from archive '{1}'. Exception: '{2}'", fileName,
extractableArchive.FullPath, ex.Message);
}
}
}
}
}
}
return(result);
}
public void Process(ResourceSessionDirector resourceDirector)
{
var bookEntity = resourceDirector.GetSessionInfoValue <BookVersion>(SessionInfo.BookVersionEntity);
var bookVersionId = m_bookVersionRepository.Create(bookEntity);
var bookVersion = m_bookVersionRepository.FindById <BookVersion>(bookVersionId);
var categories = m_categoryRepository.GetAllCategories();
var categoriesDictionary = categories.ToDictionary(category => category.Id);
var bookVersionCategories = m_categoryRepository.GetDirectCategoriesByBookVersionId(bookVersionId);
var allBookVersionCategoryIds = new List <int>();
foreach (var bookVersionCategory in bookVersionCategories)
{
Category category;
if (categoriesDictionary.TryGetValue(bookVersionCategory.Id, out category))
{
allBookVersionCategoryIds.Add(category.Id);
while (category.ParentCategory != null && categoriesDictionary.TryGetValue(category.ParentCategory.Id, out category))
{
allBookVersionCategoryIds.Add(category.Id);
}
}
}
var specialPermissions = m_permissionRepository.GetAutoimportPermissionsByCategoryIdList(allBookVersionCategoryIds);
var groupsWithAutoimport = m_permissionRepository.GetGroupsBySpecialPermissionIds(specialPermissions.Select(x => x.Id));
var newPermissions = groupsWithAutoimport.Select(groupWithAutoimport => new Permission
{
Book = bookVersion.Book,
Group = groupWithAutoimport
});
foreach (var newPermission in newPermissions)
{
m_permissionRepository.CreatePermissionIfNotExist(newPermission);
}
}
public CreateOrUpdateProjectBasicDataWork(ProjectRepository projectRepository, ResourceSessionDirector resourceDirector) : base(projectRepository)
{
m_projectRepository = projectRepository;
m_nullableProjectId = resourceDirector.GetSessionInfoValue <long?>(SessionInfo.ProjectId);
m_bookData = resourceDirector.GetSessionInfoValue <BookData>(SessionInfo.BookData);
m_userId = resourceDirector.GetSessionInfoValue <int>(SessionInfo.UserId);
m_projectType = resourceDirector.GetSessionInfoValue <ProjectTypeContract>(SessionInfo.ProjectType);
}
public void Process(ResourceSessionDirector resourceDirector)
{
var existFileResources =
resourceDirector.Resources.Where(
resource =>
resource.ResourceType == ResourceType.Book ||
resource.ResourceType == ResourceType.Page ||
resource.ResourceType == ResourceType.BibliographyDocument ||
resource.ResourceType == ResourceType.Transformation);
var storeType = resourceDirector.GetSessionInfoValue <FulltextStoreTypeContract>(SessionInfo.StoreType);
var bookData = resourceDirector.GetSessionInfoValue <BookData>(SessionInfo.BookData);
var fulltextResourceProcessor = m_fulltextStoreProcessorProvider.GetByStoreType(storeType);
foreach (var resource in existFileResources)
{
if (string.IsNullOrEmpty(resource.FileName))
{
if (m_log.IsErrorEnabled)
{
m_log.ErrorFormat("Resource of type {0} and path {1} does not have fileName", resource.ResourceType, resource.FullPath);
}
continue;
}
using (var dataStream = File.Open(resource.FullPath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var resourceUploadContract = GetVersionResourceUploadContract(resource, resourceDirector, dataStream);
switch (resource.ResourceType)
{
case ResourceType.BibliographyDocument:
fulltextResourceProcessor.UploadBibliographyFile(resourceUploadContract);
break;
case ResourceType.Book:
fulltextResourceProcessor.UploadFullbookToBookVersion(resourceUploadContract);
break;
case ResourceType.Page:
var pageId = fulltextResourceProcessor.UploadPageToBookVersion(resourceUploadContract);
if (pageId != null)
{
var bookPageData = bookData.Pages.FirstOrDefault(x => x.XmlResource == resource.FileName);
if (bookPageData != null)
{
bookPageData.XmlId = pageId;
}
}
break;
case ResourceType.Transformation:
fulltextResourceProcessor.UploadTransformationResource(resourceUploadContract);
break;
default:
throw new ArgumentException($"ResourceType: '{resource.ResourceType}' not meant for ExistDb upload");
}
}
}
}
private VersionResourceUploadContract GetVersionResourceUploadContract(FileResource resource, ResourceSessionDirector resourceDirector, Stream dataStream)
{
return(new VersionResourceUploadContract
{
BookId = resourceDirector.GetSessionInfoValue <string>(SessionInfo.BookXmlId),
BookVersionId = resourceDirector.GetSessionInfoValue <string>(SessionInfo.VersionXmlId),
FileName = resource.FileName,
ResourceType = resource.ResourceType,
DataStream = dataStream
});
}
public void Process(ResourceSessionDirector resourceSessionDirector)
{
var inputFilesResource = resourceSessionDirector.Resources.Where(resource => resource.ResourceType == ResourceType.SourceDocument).OrderBy(r => r.FileName, StringComparer.CurrentCultureIgnoreCase);
var inputFileResource = inputFilesResource.First();
string metaDataFileName;
if (resourceSessionDirector.Resources.Any(x => x.ResourceType == ResourceType.UploadedMetadata))
{
metaDataFileName = string.Format("{0}_converted.xmd", Path.GetFileNameWithoutExtension(inputFileResource.FileName));
}
else
{
metaDataFileName = string.Format("{0}.xmd", Path.GetFileNameWithoutExtension(inputFileResource.FileName));
}
var metaDataResource = new FileResource
{
FileName = metaDataFileName,
FullPath = Path.Combine(resourceSessionDirector.SessionPath, metaDataFileName),
ResourceType = ResourceType.ConvertedMetadata
};
var tmpDirPath = Path.Combine(resourceSessionDirector.SessionPath, "tmp");
if (!Directory.Exists(tmpDirPath))
{
Directory.CreateDirectory(tmpDirPath);
}
var message = resourceSessionDirector.GetSessionInfoValue <string>(SessionInfo.Message);
var createTime = resourceSessionDirector.GetSessionInfoValue <DateTime>(SessionInfo.CreateTime);
var projectType = (ProjectTypeEnum)resourceSessionDirector.GetSessionInfoValue <ProjectTypeContract>(SessionInfo.ProjectType);
var versionProviderHelper = new VersionProviderHelper(message, createTime, m_projectRepository, m_versionIdGenerator, projectType);
var settings = new DocxToTeiConverterSettings
{
Debug = false,
InputFilesPath = inputFilesResource.Select(p => p.FullPath).ToArray(),
UploadedFilesPath = resourceSessionDirector.Resources.GroupBy(resource => resource.ResourceType).
ToDictionary(resourceGroup => resourceGroup.Key,
resourceGroup => resourceGroup.Select(resource => resource.FullPath).ToArray()),
//MetadataFilePath = null,
OutputDirectoryPath = resourceSessionDirector.SessionPath,
OutputMetadataFilePath = metaDataResource.FullPath,
TempDirectoryPath = tmpDirPath,
GetVersionList = versionProviderHelper.GetVersionsByBookXmlId,
SplitDocumentByPageBreaks = true,
// HttpRuntime.BinDirectory is used instead of HostingEnvironment.ApplicationPhysicalPath because all required files are in bin folder
DataDirectoryPath = Path.Combine(HttpRuntime.BinDirectory, m_dataDirectoryPath)
};
var evidenceFolderPath = Path.Combine(HttpRuntime.BinDirectory,
m_conversionMetadataPath);
var evidenceXmlFiles = Directory.GetFiles(evidenceFolderPath);
ConversionResult conversionResult = null;
foreach (var evidenceXmlFile in evidenceXmlFiles)
{
settings.MetadataFilePath = evidenceXmlFile;
var converter = new DocxToTeiConverter();
conversionResult = converter.Convert(settings);
if (conversionResult.Errors.Count == 0)
{
break;
}
}
if (conversionResult.IsConverted)
{
resourceSessionDirector.Resources.Add(metaDataResource);
}
else
{
var exception = conversionResult.Errors.FirstOrDefault();
throw new ConversionException(string.Format("File was not converted sucessfully. See InnerException : '{0}'", exception), exception);
}
}
public void Process(ResourceSessionDirector resourceSessionDirector)
{
var inputFilesResource = resourceSessionDirector.Resources.Where(resource => resource.ResourceType == ResourceType.SourceDocument).OrderBy(r => r.FileName, StringComparer.CurrentCultureIgnoreCase);
var inputFileResource = inputFilesResource.First();
string metaDataFileName;
if (resourceSessionDirector.Resources.Any(x => x.ResourceType == ResourceType.UploadedMetadata))
{
metaDataFileName = string.Format("{0}_converted.xmd", Path.GetFileNameWithoutExtension(inputFileResource.FileName));
}
else
{
metaDataFileName = string.Format("{0}.xmd", Path.GetFileNameWithoutExtension(inputFileResource.FileName));
}
var metaDataResource = new Resource
{
FileName = metaDataFileName,
FullPath = Path.Combine(resourceSessionDirector.SessionPath, metaDataFileName),
ResourceType = ResourceType.ConvertedMetadata
};
var tmpDirPath = Path.Combine(resourceSessionDirector.SessionPath, "tmp");
if (!Directory.Exists(tmpDirPath))
{
Directory.CreateDirectory(tmpDirPath);
}
var message = resourceSessionDirector.GetSessionInfoValue <string>(SessionInfo.Message);
var createTime = resourceSessionDirector.GetSessionInfoValue <DateTime>(SessionInfo.CreateTime);
var versionProviderHelper = new VersionProviderHelper(message, createTime, m_bookRepository, m_versionIdGenerator);
var settings = new DocxToTeiConverterSettings
{
Debug = false,
InputFilesPath = inputFilesResource.Select(p => p.FullPath).ToArray(),
UploadedFilesPath = resourceSessionDirector.Resources.GroupBy(resource => resource.ResourceType).
ToDictionary(resourceGroup => resourceGroup.Key,
resourceGroup => resourceGroup.Select(resource => resource.FullPath).ToArray()),
MetadataFilePath = m_conversionMetadataPath,
OutputDirectoryPath = resourceSessionDirector.SessionPath,
OutputMetadataFilePath = metaDataResource.FullPath,
TempDirectoryPath = tmpDirPath,
GetVersionList = versionProviderHelper.GetVersionsByBookId,
SplitDocumentByPageBreaks = true,
DataDirectoryPath = m_dataDirectoryPath
};
var converter = new DocxToTeiConverter();
var conversionResult = converter.Convert(settings);
if (conversionResult.IsConverted)
{
resourceSessionDirector.Resources.Add(metaDataResource);
}
else
{
var exception = conversionResult.Errors.FirstOrDefault();
throw new ConversionException(string.Format("File was not converted sucessfully. See InnerException : '{0}'", exception), exception);
}
}
public void Process(ResourceSessionDirector resourceDirector)
{
var storeType = resourceDirector.GetSessionInfoValue <FulltextStoreTypeContract>(SessionInfo.StoreType);
var autoImportPermissions = resourceDirector.GetSessionInfoValue <IList <PermissionFromAuthContract> >(SessionInfo.AutoImportPermissions);
var bookData = resourceDirector.GetSessionInfoValue <BookData>(SessionInfo.BookData);
bookData.FileNameMapping = new Dictionary <string, FileResource>();
foreach (var fileResource in resourceDirector.Resources.Where(x => x.NewNameInStorage != null))
{
bookData.FileNameMapping.Add(fileResource.FileName, fileResource);
}
bookData.ContainsEditionNote = true; //HACK always create new EditionNoteResource, TODO determine if edition note exists
var saveNewBookDataWork = new SaveNewBookDataWork(m_projectRepository, m_metadataRepository, m_resourceRepository, m_catalogValueRepository, m_personRepository, resourceDirector);
saveNewBookDataWork.Execute();
var projectId = saveNewBookDataWork.ProjectId;
var userId = saveNewBookDataWork.UserId;
var message = saveNewBookDataWork.Message;
var resourceVersionIds = saveNewBookDataWork.ImportedResourceVersionIds;
var bookVersionId = saveNewBookDataWork.BookVersionId;
var createNewSnapshot = new CreateSnapshotForImportedDataWork(m_projectRepository, projectId, userId, resourceVersionIds, bookData, message, bookVersionId);
createNewSnapshot.Execute();
PublishSnapshotToExternalDatabase(createNewSnapshot.SnapshotId, projectId, bookData.Pages, storeType);
//var bookVersionId = m_bookVersionRepository.Create(bookData);
//var bookVersion = m_bookVersionRepository.FindById<BookVersion>(bookVersionId);
//var categories = m_categoryRepository.GetAllCategories();
//var categoriesDictionary = categories.ToDictionary(category => category.Id);
//var bookVersionCategories = m_categoryRepository.GetDirectCategoriesByBookVersionId(bookVersionId);
//var allBookVersionCategoryIds = new List<int>();
//foreach (var bookVersionCategory in bookVersionCategories)
//{
// Category category;
// if (categoriesDictionary.TryGetValue(bookVersionCategory.Id, out category))
// {
// allBookVersionCategoryIds.Add(category.Id);
// while (category.ParentCategory != null && categoriesDictionary.TryGetValue(category.ParentCategory.Id, out category))
// {
// allBookVersionCategoryIds.Add(category.Id);
// }
// }
//}
var processAutoImportPermission = new ProcessAutoImportPermissionWork(m_permissionRepository, projectId, createNewSnapshot.BookTypes, autoImportPermissions);
processAutoImportPermission.Execute();
//var specialPermissions = m_permissionRepository.GetAutoimportPermissionsByCategoryIdList(allBookVersionCategoryIds);
//var groupsWithAutoimport = m_permissionRepository.GetGroupsBySpecialPermissionIds(specialPermissions.Select(x => x.Id));
//var newPermissions = groupsWithAutoimport.Select(groupWithAutoimport => new Permission
//{
// Book = bookVersion.Book,
// Group = groupWithAutoimport
//});
//foreach (var newPermission in newPermissions)
//{
// m_permissionRepository.CreatePermissionIfNotExist(newPermission);
//}
resourceDirector.SetSessionInfoValue(SessionInfo.ProjectId, projectId);
}
