Beispiel #1
0
 public async Task AddOrUpdateEntry(int entryId, ExcelTerm excelEntry)
 {
     if (!string.IsNullOrWhiteSpace(excelEntry.Source) && !string.IsNullOrWhiteSpace(excelEntry.Target))
     {
         await _excelTermLoaderService.AddOrUpdateTerm(entryId, excelEntry);
     }
 }
Beispiel #2
0
        public async Task <Dictionary <int, ExcelTerm> > GetTermsFromExcel(ExcelWorksheet worksheet)
        {
            var result = new Dictionary <int, ExcelTerm>();

            try {
                if (worksheet == null)
                {
                    return(result);
                }
                await Task.Run(() =>
                {
                    foreach (var cell in worksheet.Cells[worksheet.Dimension.Address])
                    {
                        var excellCellAddress = new ExcelCellAddress(cell.Address);

                        if (_providerSettings.HasHeader && excellCellAddress.Row == 1)
                        {
                            continue;
                        }
                        var id = excellCellAddress.Row;
                        if (!result.ContainsKey(id))
                        {
                            result[id] = new ExcelTerm();
                        }

                        SetCellValue(result[id], cell, excellCellAddress.Column);
                    }
                });
            }catch (Exception ex)
            {
                TelemetryService.Instance.AddException(ex);
            }
            return(result);
        }
Beispiel #3
0
        public IList <IEntryLanguage> CreateEntryLanguages(ExcelTerm excelTerm)
        {
            var result = new List <IEntryLanguage>();

            var sourceEntryLanguage = new ExcelEntryLanguage
            {
                Locale   = excelTerm.SourceCulture,
                Name     = excelTerm.SourceCulture.EnglishName,
                Terms    = CreateEntryTerms(excelTerm.Source),
                Fields   = new List <IEntryField>(),
                IsSource = true
            };

            result.Add(sourceEntryLanguage);

            if (excelTerm.Target != null)
            {
                var targetEntryLanguage = new ExcelEntryLanguage
                {
                    Locale   = excelTerm.TargetCulture,
                    Name     = excelTerm.TargetCulture.EnglishName,
                    Terms    = CreateEntryTerms(excelTerm.Target, excelTerm.Approved),
                    Fields   = new List <IEntryField>(),
                    IsSource = false
                };
                result.Add(targetEntryLanguage);
            }
            return(result);
        }
        public async Task <Dictionary <int, ExcelTerm> > GetTermsFromExcel(ExcelWorksheet worksheet)
        {
            var result = new Dictionary <int, ExcelTerm>();

            try {
                if (worksheet == null)
                {
                    return(result);
                }
                await Task.Run(() =>
                {
                    foreach (var cell in worksheet.Cells[worksheet.Dimension.Address])
                    {
                        var excellCellAddress = new ExcelCellAddress(cell.Address);

                        if (_providerSettings.HasHeader && excellCellAddress.Row == 1)
                        {
                            continue;
                        }
                        var id = excellCellAddress.Row;
                        if (!result.ContainsKey(id))
                        {
                            result[id] = new ExcelTerm();
                        }
                        SetCellValue(result[id], cell, excellCellAddress.Column);
                    }
                });
            }
            catch (Exception ex)
            {
                Log.Logger.Error($"GetTermsFromExcel method: {ex.Message}\n {ex.StackTrace}");
                throw ex;
            }
            return(result);
        }
Beispiel #5
0
        private async Task Save()
        {
            try
            {
                if (sourceListView.SelectedObject == null)
                {
                    return;
                }
                var entry = new ExcelTerm();
                var terms = sourceListView.Objects.Cast <ExcelEntry>().ToList();

                var source = (ExcelEntry)sourceListView.SelectedObject;
                if (source.Id == 0)
                {
                    var maxId = terms.Max(x => x.Id);
                    source.Id = maxId + 1;
                }
                var entryId = source.Id;
                entry.Source = source.SearchText;

                foreach (var cultureCast in source.Languages.Cast <ExcelEntryLanguage>())
                {
                    if (cultureCast.IsSource)
                    {
                        entry.SourceCulture = cultureCast.Locale;
                    }
                    else
                    {
                        entry.TargetCulture = cultureCast.Locale;
                    }
                }

                var targetTerms = bsTarget.DataSource as List <ExcelDataGrid>;
                if (targetTerms != null)
                {
                    var termValue     = string.Join(_providerSettings.Separator.ToString(), targetTerms.Select(x => x.Term));
                    var approvedValue = string.Join(_providerSettings.Separator.ToString(),
                                                    targetTerms.Select(x => x.Approved));
                    entry.Target   = termValue;
                    entry.Approved = approvedValue;
                }
                var entryLanguage = _transformerService.CreateEntryLanguages(entry);
                var entryToUpdate = terms.Find(item => item.Id == entryId);

                if (entryToUpdate != null)
                {
                    entryToUpdate.Languages = entryLanguage;
                }
                await _excelTermProviderService.AddOrUpdateEntry(entryId, entry);

                source.IsDirty = false;
                _terminologyProviderExcel.Terms.Add(source);
            }
            catch (Exception ex)
            {
                Log.Logger.Error($"Save method: {ex.Message}\n {ex.StackTrace}");
                throw ex;
            }
        }
Beispiel #6
0
        private void AddTermInternal(string source, string target)
        {
            var excelTerm = new ExcelTerm
            {
                SourceCulture = _providerSettings.SourceLanguage,
                TargetCulture = _providerSettings.TargetLanguage,
                Source        = source,
                Target        = target
            };

            AddTermInternal(excelTerm);
        }
        private void AddTermToWorksheet(int entryId, ExcelTerm excelTerm, ExcelWorksheet workSheet)
        {
            var sourceColumnAddress = $"{_providerSettings.SourceColumn}{entryId}";
            var targetColumnAddress = $"{_providerSettings.TargetColumn}{entryId}";

            workSheet.SetValue(sourceColumnAddress, excelTerm.Source);
            workSheet.SetValue(targetColumnAddress, excelTerm.Target);
            if (!string.IsNullOrEmpty(_providerSettings.ApprovedColumn))
            {
                var approvedColumnAddress = $"{_providerSettings.ApprovedColumn}{entryId}";
                workSheet.Cells[approvedColumnAddress].Value = excelTerm.Approved;
            }
        }
        public async Task AddOrUpdateTerm(int entryId, ExcelTerm excelTerm)
        {
            using (var excelPackage = new ExcelPackage(new FileInfo(_providerSettings.TermFilePath)))
            {
                var workSheet = await GetTerminologyWorksheet(excelPackage);

                if (workSheet == null)
                {
                    return;
                }
                AddTermToWorksheet(entryId, excelTerm, workSheet);
                excelPackage.Save();
            }
        }
Beispiel #9
0
 private void AddTermInternal(string source, string target)
 {
     if (!string.IsNullOrWhiteSpace(target))
     {
         var excelTerm = new ExcelTerm
         {
             SourceCulture = _providerSettings.SourceLanguage,
             TargetCulture = _providerSettings.TargetLanguage,
             Source        = source,
             Target        = target
         };
         AddTermInternal(excelTerm);
     }
     else
     {
         MessageBox.Show(@"Taget selection cannot be empty", string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
     }
 }
        private void SetCellValue(ExcelTerm excelTerm, ExcelRangeBase cell, int columnIndex)
        {
            var columnLetter = ExcelCellAddress.GetColumnLetter(columnIndex);

            if (columnLetter == _providerSettings.SourceColumn)
            {
                excelTerm.Source        = cell.Text;
                excelTerm.SourceCulture = _providerSettings.SourceLanguage;
            }
            if (columnLetter == _providerSettings.TargetColumn.ToUpper())
            {
                excelTerm.Target        = cell.Text;
                excelTerm.TargetCulture = _providerSettings.TargetLanguage;
            }
            if (columnLetter == _providerSettings.ApprovedColumn?.ToUpper())
            {
                excelTerm.Approved = cell.Text;
            }
        }
        public static ExcelTerm ToExcelTerm(this ExcelEntry excelEntry)
        {
            var result = new ExcelTerm();

            foreach (var entryLanguages in excelEntry.Languages.Cast <ExcelEntryLanguage>())
            {
                if (entryLanguages.IsSource)
                {
                    result.SourceCulture = entryLanguages.Locale;
                    result.Source        = string.Join("|", entryLanguages.Terms.Select(x => x.Value));
                }
                else
                {
                    result.TargetCulture = entryLanguages.Locale;
                    result.Target        = string.Join("|", entryLanguages.Terms.Select(x => x.Value));
                    result.Approved      = string.Join("|", entryLanguages.GetTermCustomFields());
                }
            }
            return(result);
        }
Beispiel #12
0
        private void AddTermInternal(ExcelTerm excelTerm)
        {
            try
            {
                if (_providerSettings.IsReadOnly)
                {
                    MessageBox.Show(@"Terminology Provider is configured as read only!", @"Read Only", MessageBoxButtons.OK);
                    return;
                }
                if (!_providerSettings.IsFileReady())
                {
                    MessageBox.Show(
                        @"The excel file configured as a terminology provider appears to be also opened in the Excel application. Please close the file!",
                        @"Excel file is used by another process",
                        MessageBoxButtons.OK);
                    return;
                }
                var entryLanguages = _transformerService.CreateEntryLanguages(excelTerm);

                var excelEntry = new ExcelEntry
                {
                    Id         = 0,
                    Fields     = new List <IEntryField>(),
                    Languages  = entryLanguages,
                    SearchText = excelTerm.Source,
                    IsDirty    = true
                };

                sourceListView.AddObject(excelEntry);
                JumpToTerm(excelEntry);
            }
            catch (Exception ex)
            {
                Log.Logger.Error($"AddTermInternal method: {ex.Message}\n {ex.StackTrace}");
                throw ex;
            }
        }
Beispiel #13
0
        public void AddAndEdit(IEntry entry, ExcelDataGrid excelDataGrid)
        {
            try
            {
                if (_providerSettings.IsReadOnly)
                {
                    MessageBox.Show("Terminology Provider is configured as read only!", "Read Only", MessageBoxButtons.OK);
                    return;
                }
                if (!_providerSettings.IsFileReady())
                {
                    MessageBox.Show(
                        @"The excel file configured as a terminology provider appears to be also opened in the Excel application. Please close the file!",
                        @"Excel file is used by another process",
                        MessageBoxButtons.OK);
                    return;
                }
                var terms = sourceListView.Objects.Cast <ExcelEntry>().ToList();

                var selectedTerm = terms.FirstOrDefault(item => item.Id == entry.Id);


                var excelTerm = new ExcelTerm
                {
                    SourceCulture = _providerSettings.SourceLanguage,
                    TargetCulture = _providerSettings.TargetLanguage,
                    Target        = excelDataGrid.Term
                };
                var source = (ExcelEntry)entry;
                source.IsDirty   = true;
                excelTerm.Source = source.SearchText;

                var exist          = false;
                var targetlanguage = selectedTerm?.Languages.Cast <ExcelEntryLanguage>()
                                     .FirstOrDefault(x => !x.IsSource);

                if (targetlanguage != null)
                {
                    foreach (var term in targetlanguage.Terms)
                    {
                        if (term.Value == excelDataGrid.Term)
                        {
                            exist = true;
                        }
                    }

                    if (exist == false)
                    {
                        var termToAdd = new EntryTerm
                        {
                            Value = excelDataGrid.Term
                        };
                        targetlanguage.Terms.Add(termToAdd);

                        terms[entry.Id].Languages = selectedTerm.Languages;
                    }
                }

                JumpToTerm(entry);
                Task.Run(Save);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #14
0
 public Task AddOrUpdateTerm(int entryId, ExcelTerm excelTerm)
 {
     throw new NotImplementedException();
 }