Ejemplo n.º 1
0
        public void XliffReader_XLIFFSupportSniffer_ReturnsEqual(Enumerators.XLIFFSupport support)
        {
            // arrange
            var sniffer        = new XliffSniffer();
            var segmentBuilder = new SegmentBuilder();
            var xliffReader    = new XliffReder(sniffer, segmentBuilder);
            //var pocoFilterManager = new PocoFilterManager(false);
            var fileTypeManager = DefaultFileTypeManager.CreateInstance(true);
            var importOptions   = new ImportOptions();
            var analysisBands   = new List <AnalysisBand>();
            var sdlxliffWriter  = new SdlxliffWriter(fileTypeManager, segmentBuilder, importOptions, analysisBands);

            var testFile = support == Enumerators.XLIFFSupport.xliff12polyglot
                                ? _testFilesUtil.GetSampleFilePath("Xliff12", "Polyglot", "QuotesSample.docx.sdlxliff.xliff")
                                : _testFilesUtil.GetSampleFilePath("Xliff12", "xsi", "QuotesSample.docx.sdlxliff.xliff");
            var sdlxliffFile = _testFilesUtil.GetSampleFilePath("Sdlxliff", "QuotesSample.docx.sdlxliff");

            // act
            var xliff      = xliffReader.ReadXliff(testFile);
            var outputFile = sdlxliffFile + ".out.sdlxliff";
            var success    = sdlxliffWriter.UpdateFile(xliff, sdlxliffFile, outputFile);

            // assert
            Assert.Equal(support, xliff.Support);
        }
Ejemplo n.º 2
0
        private TaskContext CreateBackTranslationTaskContext(FileBasedProject newStudioProject,
                                                             IReadOnlyCollection <FileData> languageFileData, string localProjectFolder,
                                                             SdlxliffReader sdlxliffReader, SdlxliffWriter sdlxliffWriter, XliffWriter xliffWriter)
        {
            var newStudioProjectInfo = newStudioProject.GetProjectInfo();

            var action    = Enumerators.Action.CreateBackTranslation;
            var workFlow  = Enumerators.WorkFlow.Internal;
            var setttings = GetSettings();

            var taskContext = new TaskContext(action, workFlow, setttings);

            taskContext.AnalysisBands = _projectAutomationService.GetAnalysisBands(newStudioProject);
            taskContext.ExportOptions.IncludeBackTranslations = true;
            taskContext.ExportOptions.IncludeTranslations     = true;
            taskContext.ExportOptions.CopySourceToTarget      = false;


            taskContext.LocalProjectFolder = newStudioProjectInfo.LocalProjectFolder;
            taskContext.WorkflowFolder     = taskContext.GetWorkflowPath();

            var workingProject = _projectAutomationService.GetProject(newStudioProject, null);

            workingProject.ProjectFiles.RemoveAll(a => a.TargetLanguage == workingProject.SourceLanguage.CultureInfo.Name);
            taskContext.Project          = workingProject;
            taskContext.FileBasedProject = newStudioProject;
            taskContext.ProjectFiles     = workingProject.ProjectFiles;

            foreach (var projectFile in taskContext.ProjectFiles)
            {
                projectFile.Selected = true;
                var fileData = GetFileData(languageFileData, localProjectFolder, projectFile);

                var tmpInputFile = Path.GetTempFileName();
                File.Move(tmpInputFile, tmpInputFile + ".sdlxliff");
                tmpInputFile = tmpInputFile + ".sdlxliff";

                var paragraphMap = GetParagraphMap(sdlxliffReader, projectFile.ProjectId, projectFile.FileId,
                                                   projectFile.Location, projectFile.TargetLanguage);
                AlignParagraphIds(fileData.Data, paragraphMap.Keys.ToList());

                var filePath = Path.Combine(taskContext.WorkingFolder, projectFile.Path.Trim('\\'));

                var externalFilePath = Path.Combine(filePath, projectFile.Name + ".xliff");
                if (!Directory.Exists(filePath))
                {
                    Directory.CreateDirectory(filePath);
                }

                xliffWriter.WriteFile(fileData.Data, externalFilePath, true);

                var success = sdlxliffWriter.UpdateFile(fileData.Data, projectFile.Location, tmpInputFile, true);
                if (success)
                {
                    projectFile.Date                        = taskContext.DateTimeStamp;
                    projectFile.Action                      = action;
                    projectFile.WorkFlow                    = workFlow;
                    projectFile.Status                      = Enumerators.Status.Success;
                    projectFile.Report                      = string.Empty;
                    projectFile.ExternalFilePath            = externalFilePath;
                    projectFile.ConfirmationStatistics      = sdlxliffWriter.ConfirmationStatistics;
                    projectFile.TranslationOriginStatistics = sdlxliffWriter.TranslationOriginStatistics;
                }

                var activityFile = new ProjectFileActivity
                {
                    ProjectFileId               = projectFile.FileId,
                    ActivityId                  = Guid.NewGuid().ToString(),
                    Action                      = action,
                    WorkFlow                    = workFlow,
                    Status                      = success ? Enumerators.Status.Success : Enumerators.Status.Error,
                    Date                        = projectFile.Date,
                    Name                        = Path.GetFileName(projectFile.ExternalFilePath),
                    Path                        = Path.GetDirectoryName(projectFile.ExternalFilePath),
                    Report                      = string.Empty,
                    ProjectFile                 = projectFile,
                    ConfirmationStatistics      = projectFile.ConfirmationStatistics,
                    TranslationOriginStatistics = projectFile.TranslationOriginStatistics
                };

                projectFile.ProjectFileActivities.Add(activityFile);

                File.Copy(projectFile.Location, Path.Combine(filePath, projectFile.Name));
                File.Delete(projectFile.Location);

                File.Copy(tmpInputFile, projectFile.Location, true);
                File.Delete(tmpInputFile);
            }

            return(taskContext);
        }