private void ProcessText(ConversionItem item, ISegment segment)
{
if (item.Search.TagPair && taskMode == BatchTaskMode.Source)
{
TagPairUpdate(item);
return;
}
foreach (var pair in textList)
{
if (string.IsNullOrEmpty(pair.Item1))
{
Reporter.Report(this, ErrorLevel.Warning, "Source was empty", new TextLocation(pair.Item2, 0), new TextLocation(pair.Item2, pair.Item1.Length));
}
else
{
ProcessSingleString(pair.Item1, pair.Item2, item);
}
}
TextListUpdater updater = new TextListUpdater();
updater.VisitSegment(segment);
// Replace list with current version
textList = updater.TextList;
}
private bool TryRegexUpdate(string original, ConversionItem item, out string updatedText, bool wholeWord = false)
{
var search = item.Search;
var replacement = item.Replacement;
string searchText;
if (wholeWord)
{
searchText = "\\b" + Regex.Escape(search.Text) + "\\b";
}
else
{
searchText = search.Text;
}
updatedText = null;
if (!string.IsNullOrWhiteSpace(searchText))
{
if (original.RegexCompare(searchText, search.CaseSensitive))
{
updatedText = original.RegexReplace(searchText, replacement, search.CaseSensitive);
}
}
// Because the method returns input unchanged if there is no match, you can use
// the Object.ReferenceEquals method to determine whether the method has made any
// replacements to the input string.
return((updatedText != null) && !object.ReferenceEquals(original, updatedText));
}
private void ProcessInternal(ConversionItem item)
{
if (ShouldSkip(item))
{
return;
}
var search = item.Search;
var replacement = item.Replacement;
foreach (var text in textList)
{
var original = text.Properties.Text;
if (!string.IsNullOrEmpty(original))
{
string updatedText;
var replaceSuccessful = TryReplaceString(text.Properties.Text, item, search, out updatedText);
if (replaceSuccessful)
{
reportGenerator.AddConversionItem("Non translatable", original, updatedText, item.Search.Text, item.Replacement.Text);
text.Properties.Text = updatedText;
}
}
}
}
private bool ShouldSkip(ConversionItem item)
{
var search = item.Search;
var replacement = item.Replacement;
return(search.TagPair || search.EmbeddedTags || replacement.Placeholder);
}
private void TagPairUpdate(ConversionItem item)
{
var search = item.Search;
var replacement = item.Replacement;
if (SearchTextValid(search))
{
foreach (var tagpair in tagPairList)
{
var stringBuilder = new StringBuilder();
GetFullText(tagpair, stringBuilder);
var fullText = stringBuilder.ToString();
string updatedText;
var result = TryRegexUpdateTagPair(fullText, item, out updatedText);
if (result)
{
UpdateTagPair(updatedText, fullText, tagpair, item);
if (tagpair.Parent is ISegment)
{
var segment = (ISegment)tagpair.Parent;
reportGenerator.AddConversionItem(segment.Properties.Id.Id, fullText, updatedText, item.Search.Text, item.Replacement.Text);
}
}
}
}
}
private ArrayList GetDataSource()
{
if (_conversion != null)
{
ArrayList result = new ArrayList();
//string aux = Variables.GetValueString("Prodcutos.Medidas.PorcentajesSugeridos");
ArrayList lista = mz.erp.systemframework.Util.Parse("0,10,15,20,25", ",");
ConversionItem item = _conversion.Items.Get(0);
foreach (string procentaje in lista)
{
PorcentajeSugeridoItem psi = new PorcentajeSugeridoItem();
psi.Porcentaje = Convert.ToDecimal(procentaje);
psi.IncrementoOrigen = item.ValorSinConvertir * psi.Porcentaje / 100;
psi.CantidadOrigen = item.ValorSinConvertir + psi.IncrementoOrigen;
_itemAux.ValorSinConvertir = psi.CantidadOrigen;
psi.CantidadDestino = _itemAux.ValorConvertido;
result.Add(psi);
}
return(result);
}
else
{
return(new ArrayList());
}
}
public bool MostrarSugerencias()
{
Conversion conversion = this._miItem.Conversion;
ConversionItem item = conversion.Items.Get(0);
//Harcodeado
//return true;
return(item.IdUnidadOrigen.Equals("1") && item.IdUnidadDestino.Equals("3"));
}
private bool TryNormalStringUpdate(string original, ConversionItem item, out string updatedText)
{
var search = item.Search;
var replacement = item.Replacement;
updatedText = null;
if (original.NormalStringCompare(search.Text, search.CaseSensitive, settings.SourceCulture))
{
updatedText = original.NormalStringReplace(search.Text, replacement.Text, search.CaseSensitive);
}
return(updatedText != null);
}
public PorcentajeAdicionalMedidaSugeridoController(Conversion conversion)
{
_conversion = conversion;
ConversionItem item = _conversion.Items.Get(0);
_itemAux = new ConversionItem();
//_itemAux.Descripcion = item.Descripcion;
_itemAux.Formula = item.Formula;
_itemAux.IdUnidadDestino = item.IdUnidadDestino;
_itemAux.IdUnidadOrigen = item.IdUnidadOrigen;
_itemAux.UnidadDestino = item.UnidadDestino;
_itemAux.UnidadOrigen = item.UnidadOrigen;
_itemAux.ValorConversion = item.ValorConversion;
_itemAux.ValorSinConvertir = item.ValorSinConvertir;
}
private void Log(string original, IText itext, ConversionItem item, string convertedText)
{
if (itext.Parent is ISegment)
{
var segment = (ISegment)itext.Parent;
reportGenerator.AddConversionItem(segment.Properties.Id.Id, original, convertedText, item.Search.Text, item.Replacement.Text);
}
else if (itext.Parent is ITagPair)
{
var tagPair = (ITagPair)itext.Parent;
if (tagPair.Parent is ISegment)
{
var segment = (ISegment)tagPair.Parent;
reportGenerator.AddConversionItem(segment.Properties.Id.Id, original, convertedText, item.Search.Text, item.Replacement.Text);
}
}
}
private bool TryReplaceString(string original, ConversionItem item, SearchText search, out string updatedText)
{
var result = false;
if (search.UseRegex)
{
result = TryRegexUpdate(original, item, out updatedText);
}
else if (search.WholeWord)
{
result = TryRegexUpdate(original, item, out updatedText, true);
}
else
{
result = TryNormalStringUpdate(original, item, out updatedText);
}
return(result);
}
void CheckForNewFiles(string inputDirectory, RasterImageFormat saveFormat)
{
try
{
if (!Directory.Exists(inputDirectory))
{
return;
}
string[] files = Directory.GetFiles(inputDirectory);
foreach (string file in files)
{
if (!bContinue)
{
break;
}
if (FileLocked(file))
{
continue;
}
ConversionItem newItem = new ConversionItem(file, String.Empty, RasterImageFormat.Unknown);
if (!conversionList.ContainsKey(file))
{
//This is a new file. Add it to our internal list
newItem.SaveFormat = saveFormat;
lock (conversionListLockObj)
{
conversionList.Add(file, newItem);
}
ThreadPool.QueueUserWorkItem(new WaitCallback(ConversionProc), newItem);
}
}
}
catch (Exception ex)
{
//log
string error = String.Format("An unexpected error has occured. Exception = {0}", ex.Message);
eventLog.WriteEntry(error, EventLogEntryType.Error);
}
}
private async void HandleFileConversion(string filepath)
{
//Path.get
string filename = Path.GetFileNameWithoutExtension(filepath);
var job = new ConversionItem
{
Title = filename,
};
ConversionJobs.Add(job);
ConversionJobsListView.ScrollIntoView(job);
// Convert
job.Status = ConversionJobStatus.Converting;
filename = MediaConverter.RemoveInvalidFilenameCharacters(filename);
string dstFilepath = MediaConverter.EnsureUniqueFilepath($"{Settings.OutputFolder}\\{filename}.wav");
await MediaConverter.FFmpegConvertToWavAsync(filepath, dstFilepath, Settings.OutputFrequency, Settings.OutputVolumeMultiplier);
// Finish
job.Status = ConversionJobStatus.Done;
}
private bool TryStrConvUpdate(string original, ConversionItem item, out string updatedText)
{
var search = item.Search;
var replacement = item.Replacement;
updatedText = null;
if (SearchTextValid(search))
{
VbStrConv vbStrConv = ConvertToEnum(search);
try
{
if (settings.SourceCulture != null)
{
updatedText = original.RegexReplace(search.Text, replacement, search.CaseSensitive,
m => Strings.StrConv(m.Value, vbStrConv, settings.SourceCulture.LCID));
}
else if (vbStrConv.HasFlag(VbStrConv.Hiragana) || vbStrConv.HasFlag(VbStrConv.Katakana))
{
updatedText = original.RegexReplace(search.Text, replacement, search.CaseSensitive,
m => Strings.StrConv(m.Value, vbStrConv, new CultureInfo("ja-JP").LCID));
}
else
{
updatedText = original.RegexReplace(search.Text, replacement, search.CaseSensitive,
m => Strings.StrConv(m.Value, vbStrConv));
}
}
catch (ArgumentException e)
{
Reporter.Report(this, ErrorLevel.Warning, $"Error {search.Text}: {e.Message}", "Exception happened");
}
}
// String compare has to be always case-sensitive here
return((updatedText != null) && !original.NormalStringCompare(updatedText, true, settings.SourceCulture));
}
private void VbStrConv_CheckBoxCheckedChanged(object sender, EventArgs e)
{
var checkBoxItems = view.VbStrConv.CheckBoxItems;
if (checkBoxItems["Uppercase"].Checked || checkBoxItems["Lowercase"].Checked)
{
view.VbStrConv.CheckBoxItems["LinguisticCasing"].Enabled = true;
}
else
{
view.VbStrConv.CheckBoxItems["LinguisticCasing"].Enabled = false;
}
CheckMutuallyExclusiveValues("Wide", "Narrow");
CheckMutuallyExclusiveValues("Narrow", "Wide");
ConversionItem curItem = GetCurrentItem();
if (curItem != null)
{
var checkedItems = new List <VbStrConv>();
foreach (var cb in view.VbStrConv.CheckBoxItems)
{
if (cb.Checked)
{
var name = cb.ComboBoxItem as string;
VbStrConv v;
if (Enum.TryParse(name, out v))
{
checkedItems.Add(v);
}
}
}
curItem.Search.VbStrConv = checkedItems;
}
}
private void UpdateTagContent(string updatedText, ITagPair tagPair, ConversionItem conversionItem)
{
var match = Regex.Match(updatedText, "(<.+?>)(.+?)(</.+?>)");
if (match.Success)
{
var entitizer = new HtmlEntitizer();
var markupData = CreateMarkupData(match.Groups[2].Value, new HtmlTagTable(entitizer.Entitize(match.Groups[2].Value, conversionItem.Search.Text)), entitizer, conversionItem);
if (markupData.Count > 0)
{
tagPair.Clear();
foreach (var item in markupData)
{
tagPair.Add(item);
}
}
}
else
{
Reporter.Report(this, ErrorLevel.Error, "Could not update tag content", $"Error: {updatedText}");
}
}
public void Aceptar()
{
ConversionItem item = _conversion.Items.Get(0);
item.ValorSinConvertir = _itemAux.ValorSinConvertir;
}
private void CreatePlaceHolder(string updatedText, IText itext, string replacementText, ConversionItem conversionItem)
{
if (string.IsNullOrEmpty(replacementText))
{
Reporter.Report(this, ErrorLevel.Warning, "Replacement text was empty", updatedText);
return;
}
var m = Regex.Match(replacementText, @"<(\w+)\b\s*[^<]*?/>");
var parent = itext.Parent;
if (m.Success)
{
var matches = Regex.Matches(updatedText, $@"<{m.Groups[1].Value}\b\s*[^<]*?/>");
if (matches.Count > 0)
{
var index = itext.IndexInParent;
var splitString = "";
foreach (Match match in matches)
{
if (string.IsNullOrEmpty(splitString))
{
splitString += $"({Regex.Escape(match.Value)})";
}
else
{
splitString += $"|({Regex.Escape(match.Value)})";
}
}
foreach (var item in Regex.Split(updatedText, splitString))
{
if (string.IsNullOrEmpty(item))
{
continue;
}
var phMatch = Regex.Match(item, $@"<{m.Groups[1].Value}\b\s*[^<]*?/>");
if (phMatch.Success)
{
var phTag = CreatePlaceHolderTag(phMatch.Value);
if (phTag != null)
{
StorePlaceholder(phMatch.Value);
if (index >= 0)
{
parent.Insert(index++, phTag);
}
}
}
else
{
parent.Insert(index++, CreateIText(item));
}
}
itext.RemoveFromParent();
}
}
else
{
var matchTagPair = Regex.Match(updatedText, "(<.+?>)(.+?)(</.+?>)");
if (matchTagPair.Success)
{
CreateTagPair(updatedText, itext, parent, conversionItem);
}
else
{
Reporter.Report(this, ErrorLevel.Warning, "Placeholder not found", $"{updatedText}");
}
}
}
private void UpdateTagPair(string updatedText, string fullText, ITagPair tagPair, ConversionItem conversionItem)
{
var parent = tagPair.Parent;
if (ContainsTags(updatedText))
{
try
{
// Check if element name changed
if (TagsChanged(updatedText, fullText))
{
ReplaceTagPair(updatedText, tagPair, parent, conversionItem);
}
else
{
// Check if the attributes changed
if (AttributesChanged(updatedText, fullText))
{
var attributes = XElement.Parse(updatedText).Attributes();
var formatting = tagPair.StartTagProperties.Formatting;
var match = Regex.Match(updatedText, "(<.+?>)(.+?)(</.+?>)");
var oldTagContent = tagPair.StartTagProperties.TagContent.Split(new[] { ' ', '>' });
tagPair.StartTagProperties.DisplayText = match.Groups[1].Value;
tagPair.StartTagProperties.TagContent = match.Groups[1].Value;
foreach (var attrib in attributes)
{
var formattingItem = FormattingFactory.CreateFormatting(attrib.Name.LocalName, attrib.Value);
formatting.Add(formattingItem);
var metaDataList = new List <KeyValuePair <string, string> >();
foreach (var data in tagPair.TagProperties.MetaData)
{
foreach (var piece in oldTagContent)
{
var m = Regex.Match(piece, "(.+?)=\"(.+?)\"");
if (m.Success)
{
var updated = data.Value.Replace($"\"{m.Groups[2].Value}\"", $"\"{attrib.Value}\"");
if (!ReferenceEquals(data.Value, updated))
{
metaDataList.Add(new KeyValuePair <string, string>(data.Key, updated));
}
}
}
}
foreach (var pair in metaDataList)
{
tagPair.TagProperties.SetMetaData(pair.Key, pair.Value);
}
}
}
if (ContentChanged(updatedText, fullText))
{
UpdateTagContent(updatedText, tagPair, conversionItem);
}
}
}
catch (ArgumentException)
{
Reporter.Report(this, ErrorLevel.Error, "Error parsing updated text. Xml invalid.", $"Error: {updatedText}");
}
}
else
{
var itext = CreateIText(updatedText);
parent.Add(itext);
tagPair.RemoveFromParent();
}
}
//Only compare the source file when checking if an item already exist.
public override bool Equals(object e)
{
ConversionItem conversionItem = (ConversionItem)e;
return(String.Compare(SourceFile, conversionItem.SourceFile, true) == 0);
}
private void ProcessSingleString(string original, IText itext, ConversionItem item)
{
var search = item.Search;
var replacement = item.Replacement;
if (search.EmbeddedTags && taskMode == BatchTaskMode.Source)
{
bool result = false;
if (search.UseRegex)
{
result = original.RegexCompare(search.Text, search.CaseSensitive);
}
else if (search.WholeWord)
{
var searchText = "\\b" + Regex.Escape(search.Text) + "\\b";
result = original.RegexCompare(searchText, search.CaseSensitive);
}
else
{
result = original.NormalStringCompare(search.Text, search.CaseSensitive, settings.SourceCulture);
}
if (result)
{
Log(original, itext, item, original);
CreateTagPair(original, itext, itext.Parent, item);
StoreTagPair(original);
}
}
else if (replacement.Placeholder && taskMode == BatchTaskMode.Source)
{
string updatedText;
bool result = false;
if (search.UseRegex)
{
result = TryRegexUpdate(original, item, out updatedText);
}
else if (search.WholeWord)
{
result = TryRegexUpdate(original, item, out updatedText, true);
}
else
{
result = TryNormalStringUpdate(original, item, out updatedText);
}
if (result)
{
Log(original, itext, item, updatedText);
CreatePlaceHolder(updatedText, itext, replacement.Text, item);
}
}
else if (!search.TagPair && !search.EmbeddedTags && !replacement.Placeholder)
{
string convertedText;
var replaceSuccessful = TryReplaceString(original, item, search, out convertedText);
if (replaceSuccessful)
{
Log(original, itext, item, convertedText);
UpdateIText(convertedText, itext);
}
}
}
void ConversionProc(object stateInfo)
{
if (!bContinue)
{
return;
}
Interlocked.Increment(ref numItemsInPool);
ConversionItem conversionItem = (ConversionItem)stateInfo;
bool deleteDummyDest = false;
try
{
//convert file
RasterCodecs codecs = GetRasterCodecs(conversionItem.SaveFormat);
conversionItem.DestFile = GetFreeFilename(Path.Combine(_conversionSettings.OutputPath, Path.GetFileNameWithoutExtension(conversionItem.SourceFile) + GetExtension(conversionItem.SaveFormat)));
using (RasterImage image = codecs.Load(conversionItem.SourceFile))
codecs.Save(image, conversionItem.DestFile, conversionItem.SaveFormat, 0);
}
catch (Exception ex)
{
deleteDummyDest = true;
if (!String.IsNullOrEmpty(conversionItem.SourceFile))
{
//Create error file in output directory
try
{
using (TextWriter textWriter = new StreamWriter(Path.Combine(_conversionSettings.OutputPath, Path.GetFileNameWithoutExtension(conversionItem.SourceFile) + ".log"), true))
{
textWriter.WriteLine(String.Format("Source: {0}", conversionItem.SourceFile));
textWriter.WriteLine(String.Format("Format: {0}", conversionItem.SaveFormat));
textWriter.WriteLine(String.Format("Error: {0}", ex.Message));
}
}
catch (Exception ex2)
{
//Log
string error = String.Format("An unexpected error has occured while writing the error file. Sourcefile = {0} Exception = {1}", conversionItem.SourceFile, ex2.Message);
eventLog.WriteEntry(error, EventLogEntryType.Error);
}
}
}
finally
{
try
{
//Should we move the source file?
if (!String.IsNullOrEmpty(_conversionSettings.MoveSourcePath))
{
//Does nothing if the directory already exist
Directory.CreateDirectory(_conversionSettings.MoveSourcePath);
//Move source file
string destFile = Path.Combine(_conversionSettings.MoveSourcePath, Path.GetFileName(conversionItem.SourceFile));
File.Copy(conversionItem.SourceFile, GetFreeFilename(destFile), true);
}
}
catch (Exception ex)
{
//Log
string error = String.Format("An error occured while moving the source file. Sourcefile = {0} Exception = {1}", conversionItem.SourceFile, ex.Message);
eventLog.WriteEntry(error, EventLogEntryType.Error);
}
try
{
//If we did not convert the file successfully, we need to delete the dummy file
if (deleteDummyDest && File.Exists(conversionItem.DestFile))
{
File.Delete(conversionItem.DestFile);
}
//Delete the sourcefile
File.Delete(conversionItem.SourceFile);
}
catch (Exception ex)
{
//Log
string error = String.Format("An error occured while deleting the source file. Sourcefile = {0} Exception = {1}", conversionItem.SourceFile, ex.Message);
eventLog.WriteEntry(error, EventLogEntryType.Error);
}
//remove from list
lock (conversionListLockObj)
{
conversionList.Remove(conversionItem.SourceFile);
}
Interlocked.Decrement(ref numItemsInPool);
}
}
private async void HandleYoutubeConversion(string videoUrl)
{
var job = new ConversionItem
{
Title = videoUrl
};
ConversionJobs.Add(job);
ConversionJobsListView.ScrollIntoView(job);
#region New libvideo code.
//// Resolve
//job.Status = ConversionJobStatus.Resolving;
//var queryResult = await YoutubeDownloader.QueryYoutubeVideo(link);
//if(queryResult.IsError)
//{
// job.Status = ConversionJobStatus.Error;
// job.StatusDetails = queryResult.Error;
//}
//else
//{
// var video = queryResult.Value;
// // Download
// job.Status = ConversionJobStatus.Downloading;
// job.Title = $"{video.Title} ({video.Resolution.ToString()}p)";
// var downloadResult = await YoutubeDownloader.DownloadYoutubeVideo(video);
// if(downloadResult.IsError)
// {
// job.Status = ConversionJobStatus.Error;
// job.StatusDetails = downloadResult.Error;
// }
// else
// {
// var download = downloadResult.Value;
// // Convert
// job.Status = ConversionJobStatus.Converting;
// string filename = MediaConverter.RemoveInvalidFilenameCharacters(download.Video.Title);
// await MediaConverter.FFmpegConvertToWavAsync(download.Filepath, $"{Settings.OutputFolder}\\{filename}.wav", Settings.OutputBitrate, Settings.OutputVolume);
// // Finish
// job.Status = ConversionJobStatus.Done;
// File.Delete(download.Filepath);
// }
//}
#endregion
// Resolve
job.Status = ConversionJobStatus.Resolving;
var queryResult = await YoutubeDownloader.GetYoutubeVideoInfo(videoUrl);
if (queryResult.IsError)
{
job.Status = ConversionJobStatus.Error;
job.StatusDetails = queryResult.Error;
}
else
{
// Download
job.Status = ConversionJobStatus.Downloading;
var video = queryResult.Value;
var highestQualityVersion = video.Formats
.Where(v => v.AudioCodec != AudioCodec.Unkown)
.OrderByDescending(info => info.Resolution)
.First();
job.Title = $"YouTube - {video.Title}";
var downloadResult = await YoutubeDownloader.DownloadYoutubeVideo(highestQualityVersion);
if (downloadResult.IsError)
{
job.Status = ConversionJobStatus.Error;
job.StatusDetails = downloadResult.Error;
}
else
{
// Convert
job.Status = ConversionJobStatus.Converting;
var download = downloadResult.Value;
string filename = MediaConverter.RemoveInvalidFilenameCharacters(video.Title);
string dstFilepath = MediaConverter.EnsureUniqueFilepath($"{Settings.OutputFolder}\\{filename}.wav");
await MediaConverter.FFmpegConvertToWavAsync(download.Filepath, dstFilepath, Settings.OutputFrequency, Settings.OutputVolumeMultiplier);
// Finish
job.Status = ConversionJobStatus.Done;
File.Delete(download.Filepath);
}
}
}
private bool TryRegexUpdateTagPair(string original, ConversionItem item, out string updatedText, bool wholeWord = false)
{
var result = false;
var search = item.Search;
var replacement = item.Replacement;
updatedText = null;
if (search.StrConv == false &&
replacement.ToLower == false &&
replacement.ToUpper == false)
{
return(TryRegexUpdate(original, item, out updatedText, wholeWord));
}
// Create a dummy ConversionItem has ToUpper, ToLower and StrConv set to false
var dummy = new ConversionItem()
{
Search = new SearchText()
{
CaseSensitive = search.CaseSensitive,
Text = search.Text,
UseRegex = search.UseRegex,
WholeWord = search.WholeWord
},
Replacement = new ReplacementText()
{
Placeholder = replacement.Placeholder,
Text = replacement.Text
}
};
string updatedTextTemp1;
string updatedTextTemp2;
result = TryRegexUpdate(original, dummy, out updatedTextTemp1, wholeWord);
result = TryRegexUpdate(original, item, out updatedTextTemp2, wholeWord);
if (result)
{
if (ContainsTags(updatedTextTemp2))
{
var match1 = Regex.Match(updatedTextTemp1, "(<.+?>)(.+?)(</.+?>)");
var match2 = Regex.Match(updatedTextTemp2, "(<.+?>)(.+?)(</.+?>)");
if (match1.Success && match2.Success)
{
updatedText = match1.Groups[1].Value +
match2.Groups[2].Value +
match1.Groups[3].Value;
}
else
{
// By setting this to updatedTextTemp1 we ignore ToUpper, ToLower and Strconv
//
updatedText = updatedTextTemp1;
}
}
else
{
// If it doesn't contain tags, we just use the normal version
updatedText = updatedTextTemp2;
}
}
return(result);
}
public static Conversion GetConversion(string IdConversion, string IdUnidadDestino, string momento)
{
System.Data.DataRow rowConversion = null;
if (IdConversion != null)
{
rowConversion = mz.erp.businessrules.tsh_Conversiones.GetByPk(IdConversion);
}
if (rowConversion != null)
{
System.Data.DataSet dataDetalle = mz.erp.businessrules.tsh_DetalleConversiones.GetList(IdConversion, null, null);
Conversion conversion = new Conversion();
conversion.Nombre = (string)rowConversion["Nombre"];
conversion.Descripcion = (string)rowConversion["Descripcion"];
int count = 0;
foreach (System.Data.DataRow rowItem in dataDetalle.Tables[0].Rows)
{
System.Data.DataRow row;
ConversionItem conversionItem = new ConversionItem();
conversionItem.IdUnidadOrigen = (string)rowItem["IdUnidadOrigen"];
row = mz.erp.businessrules.tsh_Unidades.GetByPk(conversionItem.IdUnidadOrigen);
conversionItem.UnidadOrigen = (string)row["Nombre"];
conversionItem.IdUnidadDestino = (string)rowItem["IdUnidadDestino"];
row = mz.erp.businessrules.tsh_Unidades.GetByPk(conversionItem.IdUnidadDestino);
conversionItem.UnidadDestino = (string)row["Nombre"];
conversionItem.Ordinal = (int)rowItem["Ordinal"];
conversionItem.Formula = Convert.ToString(rowItem["FormulaConversion"]);
conversionItem.ValorConversion = (decimal)rowItem["ValorConversion"];
conversion.Items.Add(conversionItem);
count++;
}
/*Aca la llamada a la propiedad de Conversion*******************/
ArrayList medidasOrigen = Conversion.UnidadesMedidaPorDefault(momento);
/*Cambiar*******************************************************/
ArrayList conversionItemsList = new ArrayList();
foreach (string IdUnidadOrigen in medidasOrigen)
{
ConversionItems cvs = conversion.Items.Filter(IdUnidadOrigen, IdUnidadDestino);
if (cvs.Count > 0)
{
conversionItemsList.Add(cvs);
}
}
if (conversionItemsList.Count > 0)
{
/* Por ahora tomo el primero, tal vez mas adelante hay criterios de selecccion */
conversion.Items = (ConversionItems)conversionItemsList[0];
return(conversion);
}
else
{
Conversion conversionDefault = new Conversion();
conversionDefault.Nombre = "Conversion Default";
conversionDefault.Descripcion = "Conversion Default";
//Agrego la conversion por defecto, la de su propia unidad de medida
ConversionItem conversionItemDefault = new ConversionItem();
System.Data.DataRow row;
if (IdUnidadDestino == null)
{
//Harcodeado cambiar por unidad por defecto tomado de una variable del sistema
conversionItemDefault.IdUnidadOrigen = "4";
conversionItemDefault.IdUnidadDestino = "4";
}
else
{
conversionItemDefault.IdUnidadOrigen = IdUnidadDestino;
conversionItemDefault.IdUnidadDestino = IdUnidadDestino;
}
row = mz.erp.businessrules.tsh_Unidades.GetByPk(conversionItemDefault.IdUnidadOrigen);
conversionItemDefault.UnidadOrigen = (string)row["Nombre"];
row = mz.erp.businessrules.tsh_Unidades.GetByPk(conversionItemDefault.IdUnidadDestino);
conversionItemDefault.UnidadDestino = (string)row["Nombre"];
conversionItemDefault.Ordinal = 0;
//conversionItemDefault.Formula = " = ";
conversionItemDefault.ValorConversion = 1;
conversionDefault.Items.Add(conversionItemDefault);
return(conversionDefault);
}
}
else
{
Conversion conversionDefault = new Conversion();
conversionDefault.Nombre = "Conversion Default";
conversionDefault.Descripcion = "Conversion Default";
//Agrego la conversion por defecto, la de su propia unidad de medida
ConversionItem conversionItemDefault = new ConversionItem();
if (IdUnidadDestino == null || IdUnidadDestino.Equals(string.Empty))
{
//Harcodeado cambiar por unidad por defecto tomado de una variable del sistema
conversionItemDefault.IdUnidadOrigen = "4";
conversionItemDefault.IdUnidadDestino = "4";
}
else
{
conversionItemDefault.IdUnidadOrigen = IdUnidadDestino;
conversionItemDefault.IdUnidadDestino = IdUnidadDestino;
}
System.Data.DataRow row;
row = mz.erp.businessrules.tsh_Unidades.GetByPk(conversionItemDefault.IdUnidadOrigen);
conversionItemDefault.UnidadOrigen = (string)row["Nombre"];
row = mz.erp.businessrules.tsh_Unidades.GetByPk(conversionItemDefault.IdUnidadDestino);
conversionItemDefault.UnidadDestino = (string)row["Nombre"];
conversionItemDefault.Ordinal = 0;
conversionItemDefault.Formula = " = ";
conversionItemDefault.ValorConversion = 1;
conversionDefault.Items.Add(conversionItemDefault);
return(conversionDefault);
}
return(null);
}
private List <IAbstractMarkupData> CreateMarkupData(string input, HtmlTagTable tagTable, HtmlEntitizer entitizer, ConversionItem conversionItem)
{
var markupList = new List <IAbstractMarkupData>();
var parser = new HtmlHelper(entitizer.Entitize(input, conversionItem.Search.Text), tagTable);
if (parser.ParseErrors.Any())
{
return(ParseTagsFallback(input, markupList));
}
foreach (var node in parser.Descendants())
{
if (node.NodeType == HtmlNodeType.Element)
{
if (!tagTable.Table[node.OriginalName].HasEndTag)
{
var ph = parser.GetRawStartTag(node);
var phTag = CreatePlaceHolderTag(ph);
markupList.Add(phTag);
}
else if (tagTable.Table[node.OriginalName].IsEndGhostTag)
{
var eTag = parser.GetRawEndTag(node);
markupList.Add(CreatePlaceHolderTag(eTag));
}
else
{
var stTag = parser.GetRawStartTag(node);
if (node.Closed)
{
var eTag = parser.GetRawEndTag(node);
var startTag = CreateStartTag(stTag);
var endTag = CreateEndTag(eTag);
var tagPair = CreateTagPair(startTag, endTag);
if (!ContainsTags(node.InnerHtml))
{
if (!string.IsNullOrEmpty(node.InnerHtml))
{
var itext = CreateIText(entitizer.DeEntitize(node.InnerHtml));
tagPair.Add(itext);
}
// Experimental:
// Creation of new formatting
CreateNewFormatting(node, tagPair);
}
else
{
var list = CreateMarkupData(node.InnerHtml, tagTable, entitizer, conversionItem);
foreach (var item in list)
{
tagPair.Add(item);
}
}
markupList.Add(tagPair);
}
else
{
var phTag = CreatePlaceHolderTag(stTag);
markupList.Add(phTag);
var list = CreateMarkupData(node.InnerHtml, tagTable, entitizer, conversionItem);
foreach (var item in list)
{
markupList.Add(item);
}
}
node.RemoveAllChildren();
}
}
else if (node.NodeType == HtmlNodeType.Text)
{
//check for data like {M:>0},{M:<0},{M:≥0} which is treated like a text but tghe intention is to convert them in placeholder
if (Regex.IsMatch(input, "(?:>|≤|<|≥)\\d+"))
{
var originalTextSplited =
entitizer.GetOriginalTextSplited(entitizer.DeEntitize(node.InnerText), conversionItem.Search.Text);
ReplaceSpecialPlaceholders(originalTextSplited, markupList);
}
else
{
markupList.Add(CreateIText(entitizer.DeEntitize(node.InnerText)));
}
}
else
{
markupList.Add(CreateIText(entitizer.DeEntitize(node.InnerHtml)));
}
}
return(markupList);
}
public IConversionFileView CreateConversionFileView(bool saveButtonEnabled = true,
bool saveAsButtonEnabled = true,
bool descriptionEnabled = true,
bool searchEnabled = true,
bool replaceEnabled = true,
bool caseSensitiveEnabled = true,
bool regexEnabled = true,
bool wholeWordEnabled = true,
bool tagPairEnabled = true,
bool embeddedTags = true,
bool strConvEnabled = true,
bool toLowerEnabled = true,
bool toUpperEnabled = true,
bool placeHolderEnabled = true,
bool subSegmentEnabled = true,
ConversionItem convItem = null)
{
var view = Substitute.For <IConversionFileView>();
view.SaveButton.Returns(new Button()
{
Enabled = saveButtonEnabled
});
view.SaveAsButton.Returns(new Button()
{
Enabled = saveAsButtonEnabled
});
view.Description.Returns(new TextBox()
{
Enabled = descriptionEnabled
});
view.Search.Returns(new TextBox()
{
Enabled = searchEnabled
});
view.Replace.Returns(new TextBox()
{
Enabled = replaceEnabled
});
view.CaseSensitive.Returns(new CheckBox()
{
Enabled = caseSensitiveEnabled
});
view.Regex.Returns(new CheckBox()
{
Enabled = regexEnabled
});
view.WholeWord.Returns(new CheckBox()
{
Enabled = wholeWordEnabled
});
view.TagPair.Returns(new CheckBox()
{
Enabled = tagPairEnabled
});
view.EmbeddedTags.Returns(new CheckBox()
{
Enabled = embeddedTags
});
view.StrConv.Returns(new CheckBox()
{
Enabled = strConvEnabled
});
view.ToLower.Returns(new CheckBox()
{
Enabled = toLowerEnabled
});
view.ToUpper.Returns(new CheckBox()
{
Enabled = toUpperEnabled
});
view.Placeholder.Returns(new CheckBox()
{
Enabled = placeHolderEnabled
});
var bindingSource = new BindingSource();
if (convItem != null)
{
bindingSource.Add(convItem);
}
view.BindingSource.Returns(bindingSource);
return(view);
}
private void ReplaceTagPair(string updatedText, ITagPair tagPair, IAbstractMarkupDataContainer parent, ConversionItem conversionItem)
{
var entitizer = new HtmlEntitizer();
var markupData = CreateMarkupData(updatedText, new HtmlTagTable(entitizer.Entitize(updatedText, conversionItem.Search.Text)), entitizer, conversionItem);
var index = tagPair.IndexInParent;
if (markupData.Count > 0)
{
foreach (var item in markupData)
{
parent.Insert(index++, item);
}
tagPair.RemoveFromParent();
}
}
