public void EnsureValidPhysicalFileAndFolderNames(RepositoryPackage package, string rootFolderName)
{
// Make sure, that the max path length is shortened, if the root folder name length is very long.
// But do not make the max path length bigger than 200, as the end users unzip path might be
MaxPathLength = MaxAllowedPathLength - rootFolderName.Length < 200 ? MaxAllowedPathLength - rootFolderName.Length : MaxPathLength;
CreateValidNames(package);
var packageItems = ConvertToRepositoryObject(package);
var tryCount = 0;
// Try as long as path is too long, and we haven't shortenend every item
while (packageItems.Any(p => p.FullName.Length > MaxPathLength) && tryCount <= packageItems.Count)
{
// Get the new name for the longest element
var itemToShorten = GetNewShorterNameForLongestElement(packageItems);
// Update the original entry with the shortened entry
UpdatePackage(package, itemToShorten);
// Convert the changed package again
packageItems = ConvertToRepositoryObject(package);
tryCount++;
}
// Make sure, we do not have identical names in the same directory.
CheckForDuplicateFilesInPackage(package);
// Remove ending dots and spaces from names
// Spaces shouldn't exist from cut-off or creating valid names, but just to be sure
RemoveTrailingChars(package, ".");
RemoveTrailingChars(package, " ");
}
/// <summary>
/// Creates a repository package with file entries within the content folder.
/// We are taking a shortcut here, because we are not building the full folder
/// structure but use relative filenames.
/// But in the end, this should work the same.
/// </summary>
/// <param name="fileName">The full file name of the zip file.</param>
/// <param name="archiveRecordId">The archive record id</param>
/// <returns></returns>
private RepositoryPackage CreateRepositoryPackage(string fileName, string archiveRecordId)
{
const string contentFolderName = "content/";
var package = new RepositoryPackage()
{
ArchiveRecordId = archiveRecordId, PackageFileName = (new FileInfo(fileName)).Name
};
using (var zipArchive = ZipFile.OpenRead(fileName))
{
// Sort the entries using their depth in the zip archive, so we can add
foreach (var zipArchiveEntry in zipArchive.Entries.Where(f => f.FullName.StartsWith(contentFolderName) && f.Length > 0)
.OrderBy(e => e.FullName.Split('\\').Length).ThenBy(e => e.FullName))
{
var relativeFileName = zipArchiveEntry.FullName.Substring(contentFolderName.Length);
package.Files.Add(new RepositoryFile
{
PhysicalName = relativeFileName,
SizeInBytes = zipArchiveEntry.Length,
Exported = true
});
}
}
package.FileCount = package.Files.Count;
package.SizeInBytes = package.Files.Sum(f => f.SizeInBytes);
return(package);
}
private static string GetText(eSplitterObjectType splitterObjectType, RepositoryPackage oldRepositoryPackage, RepositoryPackage newRepositoryPackage)
{
var repositoryPackage = splitterObjectType.IsNew() ? newRepositoryPackage : oldRepositoryPackage;
var path = splitterObjectType.IsSpec() ? repositoryPackage.SpecRepFullPath : repositoryPackage.BodyRepFullPath;
return(File.ReadAllText(path));
}
public static void SplitTest()
{
SplitPackageCaseBase splitCase = new SplitCase1();
RepositoryPackage NewRepositoryPackage = new RepositoryPackage("NEW_" + splitCase.RepositoryPackage.Name, splitCase.RepositoryPackage.Owner);
Config.Instanse().NewPackageOwner = NewRepositoryPackage.Owner;
Config.Instanse().NewPackageName = NewRepositoryPackage.Name;
// Сортируем по убыванию, так как мы сначала должны создать новый пакет, затем обновить старый
foreach (eSplitterObjectType splitterObjectType in Enum.GetValues(typeof(eSplitterObjectType)).Cast <eSplitterObjectType>().OrderByDescending(x => x))
{
if (splitCase.ExceptedPart.ContainsKey(splitterObjectType))
{
Seri.Log.Information($"Begin split: {splitterObjectType}");
// Если мы дошли до OldSpec, и до этого генерировали OldBody, то OldSpec не должно повторно запускаться.
if (splitterObjectType != eSplitterObjectType.OldSpec || !splitCase.ExceptedPart.ContainsKey(eSplitterObjectType.OldBody))
{
splitCase.RunSplit(splitterObjectType, eSplitParam.GenerateHeader | eSplitParam.DirectlyUpdateRep);
}
var ExceptedText = splitCase.ExceptedPart[splitterObjectType];
Seri.Log.Information($"ExceptedText: {ExceptedText}");
var ActualText = GetText(splitterObjectType, splitCase.RepositoryPackage, NewRepositoryPackage);
Seri.Log.Information($"ActualText: {ActualText}");
Assert.AreEqual(ExceptedText, ActualText);
Seri.Log.Information($"Split Done");
}
}
}
public static string RepositoryPackageMD5(RepositoryPackage package)
{
var sha1 = CalculateMD5path(package.SpecRepFullPath);
var sha2 = CalculateMD5path(package.BodyRepFullPath);
return(CalculateMD5string(sha1 + sha2));
}
public bool CheckPackage(RepositoryPackage repPackage, out Package package)
{
Seri.Log.Verbose($"CheckParsedPackage begin repPackage={repPackage}");
bool answer;
package = null;
var SavedInstancePath = GetSavedInstancePath(repPackage);
Seri.Log.Verbose($"SavedInstancePath={SavedInstancePath}");
if (!File.Exists(SavedInstancePath))
{
answer = false;
}
else
{
var currentSha = MD5Utils.RepositoryPackageMD5(repPackage);
string fileText = File.ReadAllText(SavedInstancePath);
var packageResult = JsonConvert.DeserializeObject <PackageResult>(fileText);
package = packageResult._package;
answer = package.SHA == currentSha;
}
Seri.Log.Verbose($"CheckParsedPackage answer:{answer}");
return(answer);
}
public List <TempValidationObject> ConvertToRepositoryObject(RepositoryPackage package)
{
var retVal = new List <TempValidationObject>();
AddFolder(retVal, package.Folders, "", "", 0);
AddFiles(retVal, package.Files, "", "", 0);
return(retVal);
}
private static List <ElasticRepositoryObject> GetRepositoryItems(RepositoryPackage repositoryPackage)
{
var retVal = new List <ElasticRepositoryObject>();
ProcessFiles(repositoryPackage.Files, "/", retVal);
ProcessFolders(repositoryPackage.Folders, "/", retVal);
return(retVal);
}
private string GetTempFolder(RepositoryPackage package)
{
var packageFileName = Path.Combine(Settings.Default.PickupPath, package.PackageFileName);
var fi = new FileInfo(packageFileName);
var tempFolder = Path.Combine(fi.DirectoryName ?? throw new InvalidOperationException(), fi.Name.Remove(fi.Name.Length - fi.Extension.Length));
return(tempFolder);
}
public static void GetPackageTest2()
{
OraParser oracleParser = OraParser.Instance();
DBRep.Instance().RepositoryPath = "C:\\TestRep";
RepositoryPackage rep = new RepositoryPackage("c_package", "alpha");
var z = oracleParser.GetSavedPackage(rep);
}
private void LoadOraclePackage(object obj)
{
if (obj is RepositoryObject repositoryObject)
{
var repositoryPackage = new RepositoryPackage(repositoryObject);
pw = new ParserWindow(repositoryPackage);
pw.Show();
}
}
public void Setup()
{
assetManager.Reset();
cacheHelper.Reset();
assetReady.Reset();
passwordHelper.Reset();
repositoryPackage = new RepositoryPackage {
PackageFileName = "testfile.zip", ArchiveRecordId = "112"
};
}
public Package(ParsedPackagePart spec, ParsedPackagePart body, RepositoryPackage repositoryPackage)
{
elements = new List <PackageElement>();
this.repositoryPackage = repositoryPackage;
SetObject(body, ePackageElementDefinitionType.BodyFull, repositoryPackage.BodyRepFullPath);
SetObject(spec, ePackageElementDefinitionType.Spec, repositoryPackage.SpecRepFullPath);
UpdateBeginLine();
}
public void Setup()
{
harness = new InMemoryTestHarness();
assetManager.Reset();
preparationEngine.Reset();
scanProcessorMock.Reset();
transformEngineMock.Reset();
repositoryPackage = new RepositoryPackage {
PackageFileName = "testfile.zip", ArchiveRecordId = "112"
};
}
/// <summary>
/// This procedure updates the repository package so it correctly reflects the contents of the package
/// </summary>
/// <param name="repositoryPackage"></param>
/// <param name="paket"></param>
private void UpdateRepositoryPackage(RepositoryPackage repositoryPackage, PaketDIP paket)
{
repositoryPackage.Files.Clear();
repositoryPackage.Folders.Clear();
var contentFolder = paket.Inhaltsverzeichnis.Ordner;
Debug.Assert(contentFolder.Count == 1, "There should be only one folder at the content level");
repositoryPackage.Files.AddRange(ConvertToRepositoryFiles(contentFolder.First().Datei));
repositoryPackage.Folders.AddRange(ConvertToRepositoryFolders(contentFolder.First().Ordner));
}
private long GetSizeInBytesFromMetadata(RepositoryPackage package, bool onlyExported)
{
var retVal = package.Files.Sum(f => onlyExported ? f.Exported ? f.SizeInBytes : 0 : f.SizeInBytes);
foreach (var folder in package.Folders)
{
retVal += GetSizeInBytesForFolder(folder, onlyExported);
}
return(retVal);
}
private int GetFileCountFromMetadata(RepositoryPackage package, bool onlyExported)
{
var retVal = package.Files.Count(f => !onlyExported || f.Exported);
foreach (var folder in package.Folders)
{
retVal += GetFileCountForFolder(folder, onlyExported);
}
return(retVal);
}
protected void SaveTextToFile()
{
RepositoryPackage = new RepositoryPackage(PackageName, "TestRepository");
if (!Directory.Exists(RepositoryPackage.OwnerFullPath))
{
Directory.CreateDirectory(RepositoryPackage.OwnerFullPath);
}
File.WriteAllText(RepositoryPackage.SpecRepFullPath, SpecText);
File.WriteAllText(RepositoryPackage.BodyRepFullPath, BodyText);
}
public void SaveParsedPackage(RepositoryPackage repPackage, Package package)
{
if (!Directory.Exists(SAVED_PATH))
{
Directory.CreateDirectory(SAVED_PATH);
}
package.SetSha(MD5Utils.RepositoryPackageMD5(repPackage));
var packageResult = new PackageResult(package, repPackage.ObjectName);
var json = JsonConvert.SerializeObject(packageResult);
File.WriteAllText(GetSavedInstancePath(repPackage), json);
}
public RepositoryPackage CreateTestData()
{
var package = new RepositoryPackage();
fileTestData = File.ReadAllLines(Path.Combine(TestContext.CurrentContext.TestDirectory, "FileTestData.csv"), Encoding.UTF8);
folderTestData = File.ReadAllLines(Path.Combine(TestContext.CurrentContext.TestDirectory, "FolderTestData.csv"), Encoding.UTF8);
folderIndexCounter = 0;
fileIndexCounter = 0;
CreateTestFiles(package.Files);
CreateTestFolders(package.Folders, 1);
return(package);
}
public void UpdatePackage(RepositoryPackage package, KeyValuePair <string, string> itemToShorten)
{
// Neet to find the item by the id
RepositoryFile file;
// Try the files in the root
if (TryFindFile(package.Files, itemToShorten.Key, out file))
{
file.PhysicalName = itemToShorten.Value.Trim();
return;
}
// Look in the subfolders and their files
UpdateFolderOrFile(package.Folders, itemToShorten.Key, itemToShorten.Value);
}
public Package GetSavedPackage(RepositoryPackage repositoryPackage)
{
Seri.Log.Debug($"Начинаем GetSavedPackage, repPackage={repositoryPackage}");
Package answer = null;
var manager = new PackageManager();
if (manager.CheckPackage(repositoryPackage, out Package savedParderPackage))
{
Seri.Log.Debug("Пресохраненные данные найдены, возвращаем их");
answer = savedParderPackage;
}
return(answer);
}
/// This version adds all the files from the file system to the repro package
/// Only required for development, as normally the package is updated from the metadata.xml
private void UpdateRepositoryPackageFromDisk(RepositoryPackage repositoryPackage, string tempFolder)
{
repositoryPackage.Files.Clear();
repositoryPackage.Folders.Clear();
var contentFolder = Path.Combine(tempFolder, "content");
contentFolder = contentFolder.EndsWith("\\") ? contentFolder : contentFolder + "\\";
var files = new DirectoryInfo(contentFolder).GetFiles("*.*", SearchOption.AllDirectories);
repositoryPackage.Files.AddRange(files.Select(f => new RepositoryFile
{
Id = f.FullName,
PhysicalName = f.FullName.Replace(contentFolder, ""),
Exported = true
}));
}
/// <summary>
/// Получить текст ссылки на метод в новом пакете
/// </summary>
/// <param name="element"></param>
/// <param name="repositoryPackage"></param>
/// <returns></returns>
private string[] GetLink(PackageElement element, RepositoryPackage repositoryPackage)
{
Func <int, string> GetSpaces = (n) => string.Join(string.Empty, Enumerable.Range(0, n).Select(x => " "));
// Получаем текст метода до ключевого слова IS/AS
var position = element.Position[ePackageElementDefinitionType.BodyDeclaration];
var text = DBRep.Instance().GetTextOfFile(repositoryPackage.BodyRepFullPath, position.LineBeg, position.LineEnd, position.ColumnEnd);
// Считаем количество пробелов до начала метода (до слова function/procedure)
var SpaceBeforeTextBegin = 0;
var ch = text[SpaceBeforeTextBegin];
while (ch == ' ')
{
ch = text[++SpaceBeforeTextBegin];
}
var beginIndent = GetSpaces(SpaceBeforeTextBegin);
// Текст ссылки на метод в новом пакете
var NewPackageCallText = $"{Config.Instanse().NewPackageName.ToLower()}.{element.Name}";
// Добавляем схему если новая схема отличается от текущей
if (repositoryPackage.Owner.ToUpper() != Config.Instanse().NewPackageOwner.ToUpper())
{
NewPackageCallText = $"{Config.Instanse().NewPackageOwner.ToLower()}.{NewPackageCallText}";
}
// Добавляем слово return для функции
if (element.ElementType == ePackageElementType.Function)
{
NewPackageCallText = $"return {NewPackageCallText}";
}
// Отступ длинною в текст ссылки (необходим для отступов параметров)
var IndentName = GetSpaces(NewPackageCallText.Count());
// Добавляем параметры
string parametersText = string.Empty;
if (element.Parametres.Any())
{
parametersText += "(";
for (int i = 0; i < element.Parametres.Count; i++)
{
var paramName = element.Parametres[i].Name;
// Первый параметр без отступов, остальные с отступами
parametersText += $"{(i == 0 ? string.Empty : $"{beginIndent} {IndentName} ")}{paramName} => {paramName},\r\n";
private void CreatePackageOnDisk(string tempRootName, RepositoryPackage package, List <string> fileTypesToIgnore)
{
// Save the primary data to the content direcotry
var contentDirectroyName = Path.Combine(tempRootName, contentFolderName);
if (!Directory.Exists(contentDirectroyName))
{
Directory.CreateDirectory(contentDirectroyName);
}
foreach (var repositoryFolder in package.Folders)
{
SaveFolderContent(contentDirectroyName, repositoryFolder, fileTypesToIgnore);
}
// Save the files of the root folder
SaveFiles(contentDirectroyName, package.Files, fileTypesToIgnore);
}
public async Task <Package> ParsePackage(RepositoryPackage repositoryPackage, bool allowNationalChars)
{
Seri.Log.Information($"Запускаем парсинг объекта, repPackage={repositoryPackage}");
var spec = await GetPart(repositoryPackage.SpecRepFullPath, allowNationalChars);
ObjectWasParsed?.Invoke(eRepositoryObjectType.Package_Spec);
var body = await GetPart(repositoryPackage.BodyRepFullPath, allowNationalChars);
ObjectWasParsed?.Invoke(eRepositoryObjectType.Package_Body);
var answer = new Package(spec, body, repositoryPackage);
var manager = new PackageManager();
manager.SaveParsedPackage(repositoryPackage, answer);
ObjectWasParsed = null;
return(answer);
}
/// <summary>
/// Initializes the folders in a helper collection.
/// From the entry point we traverse up to the "Ablieferungen" node
/// and down accoring to the information in the package.
/// </summary>
/// <param name="package">The package.</param>
private void InitFolders(RepositoryPackage package)
{
Log.Verbose("Initializing folders for package {packageId}", package.PackageId);
var entryPoint = repositoryAccess.GetRepositoryRoot(package.PackageId);
entryFolder = repositoryAccess.GetCmisFolder(entryPoint.Id);
// Traverse each parent and create a info folder object
Log.Verbose("Traverse up from the entry folder");
var cmisFolder = entryFolder;
FolderInfo previous = null;
while (cmisFolder.FolderParent != null)
{
var addedFolder = AddFolderToTreeList(cmisFolder, true, cmisFolder == entryFolder);
// Add the new folder as a parent of the previous one
// (remember we traverse up the hierachy here)
if (previous != null)
{
previous.Parent = addedFolder;
}
// When we reach "Ablieferungen" then we can stop
if (addedFolder.FolderType == PackageFolderType.Ablieferung)
{
break;
}
cmisFolder = cmisFolder.FolderParent;
previous = addedFolder;
}
// And now traverse down and the lower folders
Log.Verbose("Traverse down from the entry folder");
var parent = FoldersTreeList.Last();
AddRepositoryFoldersToTreeList(package.Folders, parent);
Log.Verbose("Finished to initialize folder tree. Data is {FoldersTreeList}", JsonConvert.SerializeObject(FoldersTreeList));
}
public Task <PreprocessingResult> OptimizePdfIfRequired(RepositoryPackage package, string tempFolder, int primaerdatenAuftragId)
{
try
{
Log.Information("Starting to detect and optimize PDF for primaerdatenAuftrag with id {PrimaerdatenAuftragId}", primaerdatenAuftragId);
analyzerOptimizePdf.AnalyzeRepositoryPackage(package, tempFolder);
return(Task.FromResult(new PreprocessingResult()
{
Success = true
}));
}
catch (Exception ex)
{
Log.Error(ex, "Unexpected error while detect and optimize PDF for primaerdatenAuftrag with id {PrimaerdatenAuftragId}",
primaerdatenAuftragId);
return(Task.FromResult(new PreprocessingResult()
{
Success = false, ErrorMessage = "Unexpected error while detect and optimize PDF."
}));
}
}
public Task <PreprocessingResult> DetectAndFlagLargeDimensions(RepositoryPackage package, string tempFolder, int primaerdatenAuftragId)
{
try
{
Log.Information("Starting to detect large dimensions in documents for primaerdatenAuftrag with id {PrimaerdatenAuftragId}",
primaerdatenAuftragId);
analyzerDetectAndFlagLargeDimensions.AnalyzeRepositoryPackage(package, tempFolder);
return(Task.FromResult(new PreprocessingResult {
Success = true
}));
}
catch (Exception ex)
{
Log.Error(ex,
"Unexpected error while detecting large dimensions in documents for primaerdatenAuftrag with id {PrimaerdatenAuftragId}",
primaerdatenAuftragId);
return(Task.FromResult(new PreprocessingResult
{
Success = false, ErrorMessage = "Unexpected error while detecting large dimensions in documents."
}));
}
}
private void RemoveTrailingChars(RepositoryPackage package, string nameEnding)
{
var packageItems = ConvertToRepositoryObject(package);
while (packageItems.Any(p => p.Name.EndsWith(nameEnding, StringComparison.CurrentCultureIgnoreCase)))
{
foreach (var item in packageItems.Where(p => p.Name.EndsWith(nameEnding)))
{
var newValue = item.Name;
// remove all trailing dots at the end
while (newValue.EndsWith(nameEnding))
{
newValue = newValue.Substring(0, newValue.Length - 1).Trim();
}
UpdatePackage(package, new KeyValuePair <string, string>(item.RepositoryId, newValue));
}
// New get new package items and test, if no forbidden endings exist.
packageItems = ConvertToRepositoryObject(package);
}
}
