255 lines
9.5 KiB
C#
255 lines
9.5 KiB
C#
|
|
using System.Text.RegularExpressions;
|
|
using System.IO;
|
|
using Newtonsoft.Json.Linq;
|
|
|
|
namespace libObsidean
|
|
{
|
|
public class Obsidean
|
|
{
|
|
static HashSet<string> technicalTerms;
|
|
|
|
static string GetObsidianConfigPath()
|
|
{
|
|
string appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
|
|
return Path.Combine(appDataPath, "obsidian", "obsidian.json");
|
|
}
|
|
|
|
static string GetVaultPath(string vaultName)
|
|
{
|
|
try
|
|
{
|
|
string pathToJsonFile = GetObsidianConfigPath();
|
|
string jsonContent = File.ReadAllText(pathToJsonFile);
|
|
JObject jsonObject = JObject.Parse(jsonContent);
|
|
JObject vaults = (JObject)jsonObject["vaults"];
|
|
|
|
foreach (var vault in vaults)
|
|
{
|
|
// 'vault' es un KeyValuePair<string, JToken>
|
|
// 'vault.Key' es la clave (ID del vault), 'vault.Value' es el valor (detalles del vault como JToken)
|
|
string path = (string)vault.Value["path"];
|
|
if (!string.IsNullOrEmpty(path))
|
|
{
|
|
// Añadir una barra al final asegura que Path.GetDirectoryName funcione correctamente
|
|
string lastDirectoryName = Path.GetFileName(Path.GetDirectoryName(path.TrimEnd('\\') + "\\"));
|
|
|
|
if (lastDirectoryName.Equals(vaultName, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return path;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error al leer o parsear el archivo JSON: " + ex.Message);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void LeerPalabrasTecnicas()
|
|
{
|
|
// "C:\Users\migue\OneDrive\Miguel\Obsidean\Trabajo\VM\Palabras Tecnicas\Lista.md"
|
|
string pathToMarkdown = GetVaultPath("VM");
|
|
if (!string.IsNullOrEmpty(pathToMarkdown))
|
|
{
|
|
string pathToLista = pathToMarkdown + "\\Palabras Tecnicas\\Lista.md";
|
|
string[] lines = File.ReadAllLines(pathToLista);
|
|
technicalTerms = ExtractTechnicalTerms(lines);
|
|
}
|
|
|
|
// Ahora puedes usar technicalTerms para tu lógica de corrección
|
|
}
|
|
|
|
public string[,] LeerPasswords()
|
|
{
|
|
// C:\Users\migue\OneDrive\Miguel\Obsidean\Trabajo\VM\DB\Passwords
|
|
string pathToMarkdown = GetVaultPath("VM");
|
|
if (!string.IsNullOrEmpty(pathToMarkdown))
|
|
{
|
|
string pathToTabla = pathToMarkdown + "\\DB\\Passwords\\HMI passwords.md";
|
|
string[,] tableArray = ParseTableFromMarkdown(pathToTabla);
|
|
return tableArray;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void EscribirPasswords(string[,] tabla)
|
|
{
|
|
// C:\Users\migue\OneDrive\Miguel\Obsidean\Trabajo\VM\DB\Passwords
|
|
string pathToMarkdown = GetVaultPath("VM");
|
|
if (!string.IsNullOrEmpty(pathToMarkdown))
|
|
{
|
|
string pathToTabla = pathToMarkdown + "\\DB\\Passwords\\HMI passwords.md";
|
|
SaveTableToMarkdown(pathToTabla, tabla);
|
|
}
|
|
}
|
|
|
|
|
|
public HashSet<string> ExtractTechnicalTerms(string[] lines)
|
|
{
|
|
var terms = new HashSet<string>();
|
|
foreach (var line in lines)
|
|
{
|
|
// Suponiendo que cada línea contiene un término técnico
|
|
terms.Add(line.Trim());
|
|
}
|
|
return terms;
|
|
}
|
|
|
|
public string MarkTechnicalTerms(string text)
|
|
{
|
|
// Utilizar Regex para identificar palabras individualmente
|
|
return Regex.Replace(text, @"\b(\w+)\b", match =>
|
|
{
|
|
string word = match.Groups[1].Value;
|
|
// Verificar si la palabra está en el conjunto de términos técnicos
|
|
if (technicalTerms.Contains(word))
|
|
{
|
|
return $"[[{word}]]"; // Encerrar la palabra en corchetes si es técnica
|
|
}
|
|
return word; // Devolver la palabra sin modificar si no es técnica
|
|
});
|
|
}
|
|
|
|
public string MarkTechnicalTerms_IgnoreCase(string text)
|
|
{
|
|
// Utilizar Regex para identificar palabras individualmente, ignorando mayúsculas y minúsculas
|
|
return Regex.Replace(text, @"\b(\w+)\b", match =>
|
|
{
|
|
string word = match.Groups[1].Value;
|
|
// Verificar si la palabra está en el conjunto de términos técnicos, ignorando mayúsculas y minúsculas
|
|
if (technicalTerms.Contains(word, StringComparer.OrdinalIgnoreCase))
|
|
{
|
|
return $"[[{word}]]"; // Encerrar la palabra en corchetes si es técnica
|
|
}
|
|
return word; // Devolver la palabra sin modificar si no es técnica
|
|
}, RegexOptions.IgnoreCase);
|
|
}
|
|
|
|
public string RemoveTechnicalTermMarkers(string text)
|
|
{
|
|
// Utilizar Regex para encontrar y remover los dobles corchetes
|
|
return Regex.Replace(text, @"\[\[(.*?)\]\]", match =>
|
|
{
|
|
string word = match.Groups[1].Value;
|
|
// Verificar si la palabra está en el conjunto de términos técnicos, ignorando mayúsculas y minúsculas
|
|
if (technicalTerms.Contains(word))
|
|
{
|
|
return word; // Devolver la palabra sin corchetes si es técnica
|
|
}
|
|
return match.Value; // Devolver la palabra con corchetes si no es técnica
|
|
});
|
|
}
|
|
|
|
public string RemoveTechnicalTermMarkers_IgnoreCase(string text)
|
|
{
|
|
// Utilizar Regex para encontrar y remover los dobles corchetes
|
|
return Regex.Replace(text, @"\[\[(.*?)\]\]", match =>
|
|
{
|
|
string word = match.Groups[1].Value;
|
|
// Verificar si la palabra está en el conjunto de términos técnicos, ignorando mayúsculas y minúsculas
|
|
if (technicalTerms.Contains(word.ToLowerInvariant(), StringComparer.OrdinalIgnoreCase))
|
|
{
|
|
return word; // Devolver la palabra sin corchetes si es técnica
|
|
}
|
|
return match.Value; // Devolver la palabra con corchetes si no es técnica
|
|
});
|
|
}
|
|
|
|
|
|
public static string[,] ParseTableFromMarkdown(string filePath)
|
|
{
|
|
var lines = File.ReadAllLines(filePath);
|
|
var tableLines = ExtractTableLines(lines);
|
|
return ConvertTableLinesToArray(tableLines);
|
|
}
|
|
|
|
private static List<string> ExtractTableLines(string[] lines)
|
|
{
|
|
List<string> tableLines = new List<string>();
|
|
bool inTable = false;
|
|
|
|
foreach (var line in lines)
|
|
{
|
|
if (line.StartsWith("|") && line.EndsWith("|"))
|
|
{
|
|
inTable = true;
|
|
tableLines.Add(line.Trim());
|
|
}
|
|
else if (inTable)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
return tableLines;
|
|
}
|
|
|
|
private static string[,] ConvertTableLinesToArray(List<string> tableLines)
|
|
{
|
|
if (tableLines.Count == 0)
|
|
return new string[0, 0];
|
|
|
|
var header = tableLines[0].Split('|').Select(h => h.Trim()).Where(h => !string.IsNullOrEmpty(h)).ToArray();
|
|
int columns = header.Length;
|
|
int rows = tableLines.Count - 1;
|
|
|
|
string[,] tableArray = new string[rows, columns];
|
|
|
|
for (int i = 1; i < rows; i++)
|
|
{
|
|
var row = tableLines[i+1].Split('|').ToArray();
|
|
for (int j = 0; j < columns; j++)
|
|
{
|
|
if (i >= rows || j >= columns || i<0 || j<0)
|
|
return null;
|
|
tableArray[i - 1, j] = row[j+1];
|
|
}
|
|
}
|
|
|
|
return tableArray;
|
|
}
|
|
|
|
public static void SaveTableToMarkdown(string filePath, string[,] tableArray)
|
|
{
|
|
var tableLines = ConvertArrayToTableLines(tableArray);
|
|
File.WriteAllLines(filePath, tableLines);
|
|
}
|
|
|
|
private static List<string> ConvertArrayToTableLines(string[,] tableArray)
|
|
{
|
|
List<string> tableLines = new List<string>();
|
|
|
|
if (tableArray.GetLength(0) == 0 || tableArray.GetLength(1) == 0)
|
|
return tableLines;
|
|
|
|
// Add header line
|
|
List<string> headerLine = new List<string>();
|
|
for (int j = 0; j < tableArray.GetLength(1); j++)
|
|
{
|
|
headerLine.Add(tableArray[0, j]);
|
|
}
|
|
tableLines.Add("| " + string.Join(" | ", headerLine) + " |");
|
|
|
|
// Add separator line (assumes all columns have same width header)
|
|
tableLines.Add("|" + string.Join("|", headerLine.Select(h => new string('-', h.Length + 2))) + "|");
|
|
|
|
// Add data lines
|
|
for (int i = 1; i < tableArray.GetLength(0); i++)
|
|
{
|
|
List<string> rowLine = new List<string>();
|
|
for (int j = 0; j < tableArray.GetLength(1); j++)
|
|
{
|
|
rowLine.Add(tableArray[i, j]);
|
|
}
|
|
tableLines.Add("| " + string.Join(" | ", rowLine) + " |");
|
|
}
|
|
|
|
return tableLines;
|
|
}
|
|
}
|
|
|
|
}
|