public deft_swedb_gui(grabber g, settings s)
{
InitializeComponent();
this.g = g;
this.s = s;
//#if DEBUG
// log.loglevel = log.loglvl.debug;
//#else
log.loglevel = log.loglvl.debug;
//#endif
log.notice("");
log.notice("App start");
this.SizeChanged += new System.EventHandler(this.SizeChangedEv);
s.AppDataChanged += new AppDataChangedHandler(appDataChanged);
s.init(ConstructSettingsFromForm()); /*default values on form sets default values in settings*/
SetFormFromSettings(s.sd);
string[] args = Environment.GetCommandLineArgs();
foreach (string arg in args)
{
if (arg == "-m")
{
this.ShowInTaskbar = false;
this.WindowState = FormWindowState.Minimized;
}
}
}
/// <summary>
/// Reads the setting from the file and returns it as string.
/// </summary>
/// <param name="SettingToRead">Index of the setting to read.</param>
/// <returns></returns>
public static string ReadSetting(settings SettingToRead)
{
settingStrings = File.ReadAllLines(settingsDirectory);
switch (SettingToRead)
{
case settings.font:
return settingStrings[0];
case settings.color:
return settingStrings[1];
case settings.shuffle:
return settingStrings[2];
case settings.minuteOfChangeWallpaper:
return settingStrings[3];
case settings.wallpaperFolderDirectory:
return settingStrings[4];
case settings.startPointX:
return settingStrings[5];
case settings.startPointY:
return settingStrings[6];
case settings.lastWallpaperLocation:
return settingStrings[7];
case settings.fontSize:
return settingStrings[8];
case settings.lastWallpaperIndex:
return settingStrings[9];
case settings.startMinimized:
return settingStrings[10];
default:
return null;
}
}
//METHODS
//creates preference object from XMLElement
public Preference(XmlElement fileElement)
{
serviceName = fileElement.GetAttribute("name");
if (serviceName.Length == 0)
{
throw new Exception("XML Element was not well formed");
}
XmlNodeList children = fileElement.GetElementsByTagName("preference");
if (children.Count != 1)
{
throw new Exception("XML Element was not well formed");
}
XmlElement preference = (XmlElement)children[0];
string settingString = preference.GetAttribute("setting");
if (settingString == "default")
{
setting = settings.defaultDisplay;
}
else if (settingString == "always")
{
setting = settings.alwaysDisplay;
}
else if (settingString == "never")
{
setting = settings.neverDisplay;
}
else
{
throw new Exception("XML Element was not well formed");
}
}
public static void ExpandStringField()
{
var settings = new settings { value1 = S1 + S2 + S3 };
Environment.SetEnvironmentVariable(EnvVar1, "def");
Environment.SetEnvironmentVariable(EnvVar2, "123");
Visit(new EnvironmentVariableExpander(), s => s.value1, settings);
Assert.That((string)settings.value1, Is.EqualTo("abcdef123456" + S3));
}
public static void ExpandStringArrayField()
{
var settings = new settings { array = new[] { S1, S2, S3 } };
Visit(new ConfigurationVariableExpander(_vars), s => s.array, settings);
Assert.That(settings.array[0], Is.EqualTo("abcdef"));
Assert.That(settings.array[1], Is.EqualTo("123456"));
Assert.That(settings.array[2], Is.EqualTo(S3));
}
static void Main(string[] args)
{
Console.CancelKeyPress += new ConsoleCancelEventHandler(closeHandler);
settings.loadPlugins();
Settings = settings.load();
Settings.validate();
Roboto.Process();
Settings.save();
}
public static void ExpandStringArrayField()
{
var settings = new settings { array = new[] { S1, S2, S3 } };
Environment.SetEnvironmentVariable(EnvVar1, "def");
Environment.SetEnvironmentVariable(EnvVar2, "123");
Visit(new EnvironmentVariableExpander(), s => s.array, settings);
Assert.That(settings.array[0], Is.EqualTo("abcdef"));
Assert.That(settings.array[1], Is.EqualTo("123456"));
Assert.That(settings.array[2], Is.EqualTo(S3));
}
public static void ThrowsInvalidVarName()
{
string[] invalidVarNames = new string[] { null, "", "my var", "my.var", "!", "*", "*", "%","^", "-" };
var fieldVisitor = new ConfigurationVariableMapBuilder();
foreach (var varName in invalidVarNames)
{
var settings = new settings { var = new variable { name = varName } };
Assert.That(
() => SettingsManager.TraverseSeetingsTree(settings, fieldVisitor),
Throws.An<ConfigurationException>());
}
}
public static void ThrowsDuplicatedVar()
{
var settings = new settings
{
var = new variable { name = "var1", value = "value1" },
varArray = new[]{ new variable { name="var1", value="value2"} }
};
var fieldVisitor = new ConfigurationVariableMapBuilder();
Assert.That(
() => SettingsManager.TraverseSeetingsTree(settings, fieldVisitor),
Throws.An<ConfigurationException>());
}
public static void SkipSealedFields()
{
var settings = new settings
{
value1 = S1,
value2 = S1
};
var fieldVisitor = new ConfigurationVariableExpander(_vars);
Visit(fieldVisitor, s => s.value1, settings);
Visit(fieldVisitor, s => s.value2, settings);
Assert.That(settings.value1, Is.EqualTo("abcdef"));
Assert.That(settings.value2, Is.EqualTo($"abc${{Var1}}"));
}
public static void SkipSealedFields()
{
var settings = new settings
{
value1 = S1,
value2 = S1
};
Environment.SetEnvironmentVariable(EnvVar1, "def");
var fieldVisitor = new EnvironmentVariableExpander();
Visit(fieldVisitor, s => s.value1, settings);
Visit(fieldVisitor, s => s.value2, settings);
Assert.That(settings.value1, Is.EqualTo("abcdef"));
Assert.That(settings.value2, Is.EqualTo($"abc%{EnvVar1}%"));
}
public static void BuildValidVarMap()
{
var settings = new settings
{
var = new variable { name = "var1", value = "value1" },
varArray = new[]
{
new variable { name="Var2", value="value2"},
new variable { name="var_3", value="value3"},
new variable { name="444", value="value4"},
new variable { name="_", value="value5"}
}
};
var fieldVisitor = new ConfigurationVariableMapBuilder();
SettingsManager.TraverseSeetingsTree(settings, fieldVisitor);
Assert.That(fieldVisitor.Variables.Keys, Has.Items("var1", "Var2", "var_3", "444", "_"));
Assert.That(fieldVisitor.Variables.Values, Has.Items("value1", "value2", "value3", "value4", "value5"));
}
protected void loadSettings()
{
// Load configuration file
config = AppCfg.LoadConfiguration();
// Set snapshotter settings
settings settings = new settings();
settings.interval = config.ConfigElement.interval;
settings.directory = config.ConfigElement.directory;
ss.settings = settings;
// Update UI
directorybox.Text = config.ConfigElement.directory;
intervalbox.Value = config.ConfigElement.interval;
folderchooserbutton.SetCurrentFolder(config.ConfigElement.directory);
}
protected void Page_Load(object sender, EventArgs e)
{
settings lsettings = new settings();
chart lchart = new chart();
chartGraphsGraph[] graph = new chartGraphsGraph[1];
graph[0] = new chartGraphsGraph();
graph[0].gid = "1";
graph[0].title = HttpUtility.UrlEncode("Test Graph %");
graph[0].value = new chartGraphsGraphValue[2];
graph[0].value[0] = new chartGraphsGraphValue ( );
graph[0].value[0].start = 0;
graph[0].value[0].Value = 92.2;
graph[0].value[0].xid = "Question1";
graph[0].value[1] = new chartGraphsGraphValue();
graph[0].value[1].start = 0;
graph[0].value[1].Value = -22.2;
graph[0].value[1].xid = "Question2";
lchart.graphs = graph;
lchart.series = new chartValue[2];
lchart.series[0] = new chartValue();
lchart.series[1] = new chartValue();
lchart.series[0].Value = "Question1";
lchart.series[0].xid = "Question1";
lchart.series[1].Value = "Question2";
lchart.series[1].xid = "Question2";
AmChart.DataSource = new ChartDataSource( lchart, lsettings );
AmChart.DataBind();
AmChartFileSettings.DataSource = new ChartDataSource(lchart, "/testSite/path/chartTestSettings.Xml");
AmChart.DataBind();
}
public void UpdatePreference(string serviceName, settings newSetting)
{
Preference preference = getPreferenceByName(serviceName);
if (preference == null)
{
throw new Exception("the serviceName does not exist in the preference list");
}
preference.Setting = newSetting;
XmlElement serviceElement = getPrefElementByName(serviceName);
XmlElement pref = (XmlElement)serviceElement.GetElementsByTagName("preference")[0];
if (newSetting == settings.alwaysDisplay)
{
pref.SetAttribute("setting", "always");
}
else if (newSetting == settings.neverDisplay)
{
pref.SetAttribute("setting", "never");
}
else //if (newSetting == settings.defaultDisplay)
{
pref.SetAttribute("setting", "default");
}
preferenceDoc.Save(xmlFilename);
}
TestDatabaseSettings.TestDatabaseType.SqlServer => CreateSqlServer(settings, loggerFactory, dbFactory),
=> FindInDirectory(settings, texture.Split('/', '\\'), new List <string>());
TestDatabaseSettings.TestDatabaseType.Sqlite => new SqliteTestDatabase(settings, dbFactory, loggerFactory),
void Awake()
{
instance = this;
}
public static language languageFile()
{
settings settings = new settings();
if (File.Exists(AppDomain.CurrentDomain.BaseDirectory + "\\settings.json"))
{
settings = JsonSerializer.Deserialize <settings>(
File.ReadAllText(AppDomain.CurrentDomain.BaseDirectory + "\\settings.json"));
}
Directory.CreateDirectory(AppDomain.CurrentDomain.BaseDirectory + "\\lang");
if (Directory.Exists(AppDomain.CurrentDomain.BaseDirectory + "\\lang"))
{
if (!File.Exists(AppDomain.CurrentDomain.BaseDirectory + "\\lang\\lang_en.json"))
{
jsonWriter.WriteJson(AppDomain.CurrentDomain.BaseDirectory + "lang\\lang_en.json", true,
lang_en.lang_english());
}
if (!File.Exists(AppDomain.CurrentDomain.BaseDirectory + "\\lang\\lang_tr.json"))
{
jsonWriter.WriteJson(AppDomain.CurrentDomain.BaseDirectory + "lang\\lang_tr.json", true,
lang_tr.lang_turkish());
}
System.Collections.Generic.List <string> existLanguages = Directory
.GetFiles(AppDomain.CurrentDomain.BaseDirectory + "lang\\", "lang_??.json")
.Select(Path.GetFileNameWithoutExtension)
.ToList();
string currentCultureLangCode = CultureInfo.CurrentCulture.TwoLetterISOLanguageName;
foreach (string lang in existLanguages)
{
string langCode = lang.Substring(lang.Length - 2);
if (settings.language == "auto")
{
if (currentCultureLangCode == langCode)
{
return(JsonSerializer.Deserialize <language>(
File.ReadAllText(AppDomain.CurrentDomain.BaseDirectory + "lang\\lang_" + langCode +
".json")));
}
}
else
{
return(JsonSerializer.Deserialize <language>(
File.ReadAllText(AppDomain.CurrentDomain.BaseDirectory + "lang\\lang_" + settings.language +
".json")));
}
}
foreach (string lang in existLanguages)
{
if (settings.language == "auto")
{
if (currentCultureLangCode != lang)
{
return(JsonSerializer.Deserialize <language>(
File.ReadAllText(AppDomain.CurrentDomain.BaseDirectory + "lang\\lang_" + "en" +
".json")));
}
}
}
return(null);
}
return(null);
}
public void AddPreference(string serviceName, settings setting)
{
Preference preference = new Preference(serviceName, setting);
AddPreference(preference);
}
private void AddContactForm_FormClosed(object sender, FormClosedEventArgs e)
{
settings settingsForm = new settings(new ChatHome());
settingsForm.Show();
}
public ComplexSteps(settings settings) => _settings = settings;
new MethodFunctionFactory(settings, api, "Flag as rejected", "FlagAsReject", a => a.LrSelection.FlagAsReject()),
public static void ExpandStringField()
{
var settings = new settings { value1 = S1 + S2 + S3 };
Visit(new ConfigurationVariableExpander(_vars), s => s.value1, settings);
Assert.That(settings.value1, Is.EqualTo("abcdef123456" + S3));
}
.Intersect(GetPassedDeadlinePaymentMethods(availability, settings, date)) .Intersect(GetContractKindPaymentTypes(contractKind))
private static void checkSaveFile()
{
if (keybindingSettings == null)
{
keybindingSettings = new settings();
keybindingSettings.load("", "keybindingSettings", "keybindingSettings");
}
}
public void make_op(object ob)
{
string[,] sim_to_ch = null;;
try { sim_to_ch = functions_stl.get_sim_to_ch("cfg\\Список подстановки.txt"); }
catch { MessageBox.Show("Не удалось загрузить Список подстановки.txt"); }
object[] inf = ob as object[];
string xml = Convert.ToString(inf[0]);
string folder_options = Convert.ToString(inf[1]);
string save = Convert.ToString(inf[2]);
cfg_data cfg = (cfg_data)inf[3];
string cfg_folder = Convert.ToString(inf[4]);
List <string> tmpl_description = (List <string>)inf[5];
string [] key_words = (string[])inf[6];
const uint shift = 2;
settings sets = new settings(/*xml, */ folder_options, save, cfg, cfg_folder);
List <Options> options = new List <Options>(); // опции всех файлов
List <int> index = new List <int>(); // список индексов из данных парсера
string[] files_opions = Directory.GetFiles(folder_options); // список файлов
if (files_opions.Length == 0)
{
return;
}
string name_f = "";
string save_uload = "";
List <string> title_tmp = new List <string>();
List <string> title = new List <string>();
List <string> unload = new List <string>();
Regex get_line = new Regex("(.+)$", RegexOptions.Multiline);
string words = "";
StringBuilder sb = new StringBuilder();
foreach (string file_option in files_opions)
{
StringBuilder normal_file = new StringBuilder();
title_tmp.Clear();
name_f = Path.GetFileNameWithoutExtension(file_option);
string fileText = "";
try { fileText = System.IO.File.ReadAllText(file_option, Encoding.Default); }
catch { MessageBox.Show("Не найден фаил описания"); }
// -------------------------------------------- Заголовок --------------------------------------------
Regex sub_string = new Regex(";");
words = get_line.Match(fileText).Groups[1].Value;
string[] title_l = sub_string.Split(words);
List <int> not_found_index = new List <int>(); // Индексы столбцов не найденных в заголовке
for (int il = 0; il < title_l.Length; il++)
{
bool fine = false;
if (il == shift)
{
/*title.Add("PROIZVODITEL"); */
title_tmp.Add("NAME"); title_tmp.Add("FULL_NAME"); title_tmp.Add("EKSPORT");
title_tmp.Add("DESCRIPTION"); title_tmp.Add("LENGTH_PACK"); title_tmp.Add("WIDTH_PACK"); title_tmp.Add("HEIGHT_PACK"); title_tmp.Add("WEIGHT_V"); title_tmp.Add("WEIGHT");
title_tmp.Add("DELIVERY_PACKAGE_TYPE"); title_tmp.Add("DELIVERY_PACKAGE");
}
foreach (string[] it in sets.cfg.options)
{
if ((title_l[il] == "\"" + it[0] + "\"") || (title_l[il] == it[0]))
{
fine = true;
title_tmp.Add(it[1]); // заголовок из наденных свойств
break;
}
}
if (!fine)
{
not_found_index.Add(il);
unload.Add(title_l[il]); // не найденные свойства
}
}
foreach (string s in unload)
{
save_uload += s + "\r\n";
}
int i = 0;
foreach (string option in title_tmp)
{
bool is_tl = false; i++;
foreach (string tl in title)
{
if (option == tl)
{
is_tl = true;
break;
}
}
if (!is_tl)
{
title.Add(option);
}
if (i == shift)
{
/*title.Add("PROIZVODITEL"); */
title.Add("NAME"); title.Add("FULL_NAME"); title.Add("EKSPORT");
title.Add("DESCRIPTION"); title.Add("LENGTH_PACK"); title.Add("WIDTH_PACK"); title.Add("HEIGHT_PACK"); title.Add("WEIGHT_V"); title.Add("WEIGHT");
title.Add("DELIVERY_PACKAGE_TYPE"); title.Add("DELIVERY_PACKAGE");
}
}
// -------------------------------------------- Заголовок --------------------------------------------
title = title.Distinct().ToList();
foreach (string item in title_tmp)
{
normal_file.Append(item + ";");
}
normal_file.Append("\r\n"); // файл с правильным заголовком
Regex manual_get_line = new Regex("https(.*)", RegexOptions.Multiline);
MatchCollection lines = get_line.Matches(fileText);
StringBuilder str_bl = new StringBuilder();
string buf;
// ---------------------------------- Удаление символов новои строки ---------------------------------
for (i = 1; i < lines.Count; i++)
{
if (i == lines.Count - 1)
{
str_bl.Append(lines[i] + "\r\n"); break;
}
if (manual_get_line.IsMatch(lines[i + 1].Value))
{
str_bl.Append(lines[i] + "\r\n");
}
else
{
buf = lines[i].Value;
buf = buf.Replace("\r\n", ""); buf = buf.Replace("\r", ""); buf = buf.Replace("\n", "");
buf += "__";
str_bl.Append(buf);
}
}
// ---------------------------------- Удаление символов новои строки ---------------------------------
lines = get_line.Matches(str_bl.ToString());
Regex r_celas = new Regex(";");
string rn;
foreach (Match line in lines)
{
string[] cells = r_celas.Split(line.Value);
buf = "";
for (i = 0; i < cells.Length; i++)
{
if (i == shift)
{
buf += ";;;;;;;;;;;";
}
if (sets.equal(i, not_found_index)) // - пропуск не наиденных столбцов
{
continue;
}
buf += cells[i] + ";";
}
normal_file.Append(buf);
rn = normal_file[normal_file.Length - 3].ToString() + normal_file[normal_file.Length - 2];
if (rn != "\r\n")
{
normal_file.Append("\r\n");
}
normal_file.Remove(normal_file.Length - 1, 1);
}
MatchCollection time = get_line.Matches(normal_file.ToString());
/*if (save_uload != "")
* {
* File.WriteAllText("unload.txt", save_uload);
* //MessageBox.Show("Не все поля заголовка были найденны.\r\nНедостающие свойства сохнаненны в файл unload.txt");
* }*/
//File.WriteAllText("normal_file.csv", normal_file.ToString(), Encoding.Default);
//MessageBox.Show("hi");
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
Delimiter = ";",
HeaderValidated = null,
MissingFieldFound = null,
Encoding = Encoding.GetEncoding(1251),
//var info = new List<string>();
BadDataFound = data => {
//info.Add(data.RawRecord);
},
};
List <Options> options_values = new List <Options>();
StreamReader reader = new StreamReader(new MemoryStream(Encoding.GetEncoding(1251).GetBytes(normal_file.ToString())), Encoding.GetEncoding(1251));
using (var csv = new CsvReader(reader, config))
{
var li = csv.GetRecords <Options>();
options_values = li.ToList();
options.AddRange(options_values);
options_values = null;
}
}
foreach (var tl in title)
{
sb.Append(tl + ";");
}
sb.Remove(sb.Length - 1, 1); // удаление последнего разделительного символа
sb.Append("\r\n");
// // удаление кавычек
foreach (Options option in options)
{
if (option.id == "2624611")
{
//
}
}
foreach (Options option in options)
{
option.id = Regex.Replace(option.id, "\"", "");
}
// --------------------------- добавление в список индексов ---------------------------
Regex r_id = new Regex("(.*)\\/(\\d*)");
foreach (Options option in options)
{
try
{
Match m_id = r_id.Match(option.id);
int id = Convert.ToInt32(m_id.Groups[2].Value);
index.Add(id);
option.artnumber = id.ToString();
}
catch
{
}
}
// --------------------------- добавление в список индексов ---------------------------
// получение данных из хмл файла учитывая только индексы которые есть в списке options
Get_xml xml_data = new Get_xml(xml, index);
// --------------------------- формирование габаритов и веса --------------------------
foreach (Options option in options)
{
option.get_abc_weight(sets.cfg.coefficients_volume_and_mass, ref xml_data.get_xml_data);
}
// --------------------------- формирование габаритов и веса --------------------------
// --------------------------- выборка из массива классов свойств в string bufer для сохранения в текстовый файл ---------------------------
foreach (Options option in options)
{
Xml_offer time_xml_line = xml_data.get_xml_data.Find(data => data.id == option.artnumber);
time_xml_line.to_asci(sim_to_ch);
if (time_xml_line != null)
{
option.proizvoditel = time_xml_line.vendor;
}
else
{
continue;
}
char[] se = { '_', '_' };
// --------------------------- формироание описания ---------------------------
Dictionary <string, string> words_key = new Dictionary <string, string>();
if (key_words == null)
{
key_words = new string[0];
}
foreach (var key in key_words)
{
if (functions_stl.get_property(key, option) != "" && functions_stl.get_property(key, option) != null)
{
words_key.Add(key, functions_stl.get_property(key, option));
}
}
if (words_key.ContainsKey("SOSTAV"))
{
words_key["SOSTAV"] = words_key["SOSTAV"].Split(se)[0];
}
if (words_key.ContainsKey("SERIYA"))
{
words_key["SERIYA"] = words_key["SERIYA"].Split(se)[0];
}
if (words_key.ContainsKey("MATERIAL"))
{
string material = option.material != "" ? option.material : option.sostav;
if (material == "")
{
material = time_xml_line.composition;
}
words_key["MATERIAL"] = material;
}
if (key_words.Contains("NAME"))
{
words_key["NAME"] = time_xml_line.name_short(time_xml_line.name, sets.cfg.prepositions, sets.cfg.stop_words);
}
if (key_words.Contains("FULL_NAME"))
{
words_key["FULL_NAME"] = time_xml_line.name;
}
if (key_words.Contains("PRICE"))
{
words_key["PRICE"] = Convert.ToString(time_xml_line.price * sets.get_coefficient(time_xml_line.price));
}
if (key_words.Contains("ID_CATEGORY"))
{
words_key["ID_CATEGORY"] = sets.get_name_of_category(time_xml_line.category);
}
option.description = classes.functions_stl.make_description(tmpl_description, words_key);
// --------------------------- формироание описания ---------------------------
foreach (string tl in title)
{
string value = functions_stl.get_property(tl.ToLower(), option);
if (tl == "WEIGHT_V_GR" && option.WEIGHT_V_GR != "")
{
}
// ------------------------------------------- игнорирование дубля -------------------------------------------
string[] cut_double = { "" };
if (tl == "SERIYA" || tl == "PRICE_FOR_THE_ONE" || tl == "PRICE_FOR" || tl == "PRICE_FOR_" || tl == "SOSTAV" || tl == "SIZE_2")
{
//words = get_line.Match(option.get_property(tl.ToLower(), option)).Groups[1].Value;
if (value != "")
{
cut_double = value.Split(se);
}
sb.Append(cut_double[0] + ";");
}
// ------------------------------------------- игнорирование дубля -------------------------------------------
else if (tl == "LENGTH_PACK" || tl == "WIDTH_PACK" || tl == "HEIGHT_PACK" || tl == "WEIGHT_V" || tl == "WEIGHT")
{
if (value == "0")
{
sb.Append(";");
}
else
{
sb.Append(value + ";");
}
}
else if (tl == "DIAMETR_PISHUSHCHEGO_UZLA_MM")
{
value = value.Replace(".", ",");
sb.Append(value + ";");
}
else
{
sb.Append(value + ";");
}
}
sb.Remove(sb.Length - 1, 1); // удаление последнего разделительного символа
sb.Append("\r\n");
//string hi = nameof(option);
}
options.Clear();
List <Options_stl> options_last = new List <Options_stl>();
List <Options_stl> options_new = new List <Options_stl>();
string[] last_artnumbers, new_artnumbers, new_id, equal;
string file_last_option = Directory.GetFiles(save).FirstOrDefault();
if (file_last_option != null)
{
// ---------------------------------------------------- загрузка нового фаила с описанием -----------------------------------------------------
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
Delimiter = ";",
HeaderValidated = null,
MissingFieldFound = null,
Encoding = Encoding.GetEncoding(1251),
//var info = new List<string>();
BadDataFound = data => {
//info.Add(data.RawRecord);
},
};
using (var reader = new StringReader(sb.ToString()))
using (var csv = new CsvReader(reader, config))
{
var li = csv.GetRecords <Options_stl>();
options_new = li.ToList();
}
// ---------------------------------------------------- загрузка нового фаила с описанием -----------------------------------------------------
// -------------------------------------------------- загрузка предидущего фаила с описанием --------------------------------------------------
using (var reader = new StreamReader(file_last_option, Encoding.GetEncoding(1251)))
using (var csv = new CsvReader(reader, config))
{
var li = csv.GetRecords <Options_stl>();
options_last = li.ToList();
}
// -------------------------------------------------- загрузка предидущего фаила с описанием --------------------------------------------------
new_artnumbers = Options_stl.get_artbumbers(options_new);
last_artnumbers = Options_stl.get_artbumbers(options_last);
new_id = new_artnumbers.Except(last_artnumbers).ToArray(); // нахождение новых позиции
//equal = new_artnumbers.Intersect(last_artnumbers).ToArray(); // нахождение совпадении
// добавление новых элементов
Options_stl new_op = new Options_stl();
foreach (string st in new_id)
{
new_op = options_new.Find(l => l.artnumber == st);
options_last.Add(new_op);
}
// ------------------------------------------------------------ формирование фаила ------------------------------------------------------------
// - заголовок
sb.Clear();
foreach (string item in title)
{
sb.Append(item + ";");
}
sb.Remove(sb.Length - 1, 1);
sb.Append("\r\n");
// - заголовок
string value;
foreach (Options_stl op in options_last)
{
foreach (string tl in title)
{
value = op.get_property(tl.ToLower(), op);
sb.Append(value + ";");
}
sb.Remove(sb.Length - 1, 1);
sb.Append("\r\n");
}
// ------------------------------------------------------------ формирование фаила ------------------------------------------------------------
}
// --------------------------- выборка из массива классов свойств в string bufer для созранения в текстовый файл ---------------------------
//сохраняем говый файл
File.WriteAllText(save + "\\" + Path.GetFileNameWithoutExtension(xml) + ".csv", sb.ToString(), Encoding.GetEncoding(1251));
// удаление файлов парсера
foreach (string file_option in files_opions)
{
File.Delete(file_option);
}
}
static void Main(string[] args)
{
facebook _facebook = new facebook();
instagram _instagram = new instagram();
twitter _twitter = new twitter();
tags _tags = new tags();
settings _settings = new settings();
stats _stats = new stats();
Int32 facebook_count = 0;
Int32 instagram_count = 0;
Int32 twitter_count = 0;
Int32 total_count = 0;
Int32 fetch_count = _settings.refresh_count();
overrideSocial.events _events = new overrideSocial.events();
Console.WriteLine("######################## BEGINNING UPDATE SEQUENCE ########################");
Console.WriteLine("");
Console.WriteLine("######################## CHECKING FOR EVENTS THAT ARE READY FOR UPDATE ########################");
Console.WriteLine("");
// loop through EVENTS that are DUE and UPDATE
foreach (Event ev in _events.ready_for_pull())
{
Console.WriteLine(ev.title + " with last update time of: " + ev.last_update.ToShortDateString() + " @ " + ev.last_update.ToShortTimeString());
Console.WriteLine("");
Console.WriteLine("Checking for Active Tags & Usernames to Import...");
Console.WriteLine("");
instagram_count = 0;
twitter_count = 0;
facebook_count = 0;
total_count = 0;
foreach (Tag t in _tags.select(ev.id, true))
{
Console.WriteLine("Beginning Evaluation for Term: " + t.value);
Console.WriteLine("");
if (t.instagram)
{
Console.WriteLine("###################### INSTAGRAM PULL #########################");
Console.WriteLine("");
if (t.is_tag)
{
Console.WriteLine("Importing Records from Instagram for Hashtag #" + t.value);
instagram_count = instagram_count + _instagram.fetch2(t.value, ev.id, t.id);
}
else
{
Console.WriteLine("Importing Records from Instagram for Username @" + t.value);
instagram_count = instagram_count + _instagram.fetch_by_username(t.value, ev.id, t.id);
}
}
if (t.twitter)
{
Console.WriteLine("");
Console.WriteLine("###################### TWITTER PULL #########################");
Console.WriteLine("");
if (t.is_tag)
{
Console.WriteLine("Importing Records from Twitter for Hashtag #" + t.value);
twitter_count = twitter_count + _twitter.fetch(t.value, fetch_count, ev.id, t.id);
}
else
{
Console.WriteLine("Importing Records from Twitter for Username @" + t.value);
twitter_count = twitter_count + _twitter.fetch(t.value, fetch_count, true, ev.id, t.id);
}
}
}
total_count = instagram_count + twitter_count + facebook_count;
Statistic s = new Statistic();
s.facebook = facebook_count;
s.instagram = instagram_count;
s.pulldate = DateTime.Now;
s.total = total_count;
s.twitter = twitter_count;
s.event_id = ev.id;
_stats.add(s);
ev.last_update = DateTime.Now;
_events.update(ev);
Console.WriteLine("");
Console.WriteLine("######################## ENDING UPDATE FOR EVENT " + ev.title + " ########################");
}
Console.WriteLine("");
Console.WriteLine("######################## ENDING UPDATE SEQUENCE ########################");
}
TestDatabaseSettings.TestDatabaseType.LocalDb => CreateLocalDb(settings, loggerFactory, dbFactory),
void Load_XML_Preferences()
{
// Loading preferences from XML file
pref = new settings();
string str_xml = Application.StartupPath + "\\WZextract_settings.xml";
// We have to check if the file exists or else it will crash
if (File.Exists(str_xml) == true)
{
XmlReader XML = XmlReader.Create(str_xml);
XML.Read();
XML.ReadStartElement("Settings");
XML.ReadStartElement("WZ_Files"); pref.wz_file_path = XML.ReadString(); XML.ReadEndElement();
XML.ReadStartElement("PNGs"); pref.pngs_path = XML.ReadString(); XML.ReadEndElement();
XML.ReadStartElement("Map_Renders"); pref.render_path = XML.ReadString(); XML.ReadEndElement();
XML.ReadStartElement("MP3s"); pref.mp3s_path = XML.ReadString(); XML.ReadEndElement();
XML.ReadStartElement("Resolve_UOLs"); pref.resolve_uols = XML.ReadContentAsBoolean(); XML.ReadEndElement();
XML.ReadStartElement("Language"); pref.language = XML.ReadContentAsInt(); XML.ReadEndElement();
XML.Close();
if (pref.wz_file_path == "None") { pref.wz_file_path = ""; }
if (pref.pngs_path == "None") { pref.pngs_path = ""; }
if (pref.render_path == "None") { pref.render_path = ""; }
if (pref.mp3s_path == "None") { pref.mp3s_path = ""; }
}
else
{
// File not existing so we create a new one with default options
XmlWriter XML = new XmlTextWriter(str_xml, Encoding.Default);
XML.WriteStartDocument();
XML.WriteStartElement("Settings");
XML.WriteStartElement("WZ_Files");
XML.WriteString("None"); pref.wz_file_path = "";
XML.WriteEndElement();
XML.WriteStartElement("PNGs");
XML.WriteString("None"); pref.pngs_path = "";
XML.WriteEndElement();
XML.WriteStartElement("Map_Renders");
XML.WriteString("None"); pref.render_path = "";
XML.WriteEndElement();
XML.WriteStartElement("MP3s");
XML.WriteString("None"); pref.mp3s_path = "";
XML.WriteEndElement();
XML.WriteStartElement("Resolve_UOLs");
XML.WriteValue(false); pref.resolve_uols = false;
XML.WriteEndElement();
XML.WriteStartElement("Language");
XML.WriteValue(0); pref.language = 0;
XML.WriteEndElement();
XML.WriteEndElement();
XML.WriteEndDocument();
XML.Close();
}
}
return(AutoFit(context, trainData, label, validationData, settings,
purposeOverrides, cancellationToken, iterationCallback, null));
new MethodFunctionFactory(settings, api, "Toggle Flag as picked", "ToggleFlagAsPicked", a =>
private void settingsToolStripMenuItem_Click(object sender, EventArgs e)
{
settings settingspage = new settings();
settingspage.ShowDialog(); // Shows settings page
}
new MethodFunctionFactory(settings, api, "Flag as picked", "FlagAsPicked", a => a.LrSelection.FlagAsPick()),
internal override object serialize(settings.OkuriganaType okType)
{
return text;
}
public void get_Settings(ref settings.Calibration_status cal_Status, ref settings.Fusion_Values fus_Values, ref settings.MRFT_Values mrft_Values, ref settings.PID_Values pid_Values)
{
load_UI();
cal_Status = calibration_Status_Settings;
fus_Values = fusion_Values_Settings;
mrft_Values = MRFT_Values_Settings;
pid_Values = PID_Values_Settings;
}
private void button1_Click(object sender, EventArgs e)
{
settings setts = new settings();
setts.Show();
}
static void Main(string[] args)
{
log.log("ROBOTO", logging.loglevel.critical, ConsoleColor.White, false, true);
log.log("Telegram Bot Startup", logging.loglevel.low);
argtype mode = argtype.def;
//parse arguments
foreach(string arg in args)
{
switch (mode)
{
case argtype.def:
switch (arg)
{
case "-context":
mode = argtype.context;
break;
case "-plugin":
mode = argtype.plugin;
break;
}
break;
case argtype.context:
context = arg;
mode = argtype.def;
break;
case argtype.plugin:
pluginFilter.Add(arg);
mode = argtype.def;
break;
}
}
if (context != null)
{
log.setTitle(Roboto.context);
log.log( context + " context", logging.loglevel.high,ConsoleColor.White,false,true,false,true);
}
Console.CancelKeyPress += new ConsoleCancelEventHandler(closeHandler);
settings.loadPlugins();
log.log( "Loading Settings", logging.loglevel.high);
Settings = settings.load();
Settings.validate();
log.initialise();
log.log("I am " + Settings.botUserName, logging.loglevel.critical, ConsoleColor.White, false, true);
Settings.startupChecks();
//test
if (!Settings.isFirstTimeInitialised)
{
log.log( "Starting main thread", logging.loglevel.high);
Roboto.Process();
}
else
{
log.log( @"New XML file created in %appdata%\Roboto\ . Enter your API key in there and restart.", logging.loglevel.critical, ConsoleColor.White, false, true);
Settings.save();
}
log.log( "Saving & exiting", logging.loglevel.high);
Settings.save();
log.finalise();
log.log( "Exiting", logging.loglevel.high, ConsoleColor.White, false, true, true);
}
/// <summary>
/// Changes the settings file at AppData/Local/WallpaperClock/WallpaperClockSettings.
/// </summary>
/// <param name="settingIndex">Index of the setting to be changed.</param>
/// <param name="setting">Content of the setting.</param>
public static void ChangeSetting(settings settingIndex, string setting) // As of now, it doesn't check the validity of the setting.For example, if the passed value is bool or not for isShuffle.
{
string[] originalSettings = File.ReadAllLines(settingsDirectory);
originalSettings[(int)settingIndex] = setting;
File.WriteAllLines(settingsDirectory, originalSettings);
}
public TestInitialize(settings settings)
{
_settings = settings;
}
public static void serialize(settings datamodel, string sXMLfile)
{
XmlSerializer xs = new XmlSerializer(typeof(settings));
//omit xmlns:xsi from xml output
//Create our own namespaces for the output
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
//Add an empty namespace and empty value
ns.Add("", "");
//StreamWriter sw = new StreamWriter("./SystemHealth.out.xml");
StreamWriter sw = new StreamWriter(sXMLfile);
xs.Serialize(sw, datamodel, ns);
sw.Flush();
sw.Close();
}
private void pictureBox3_Click(object sender, EventArgs e)
{
var f = new settings();
f.Show();
}
new MethodFunctionFactory(settings, api, "Undo", "Undo", a =>
public void set_Settings(settings.Calibration_status cal_Status, settings.Fusion_Values fus_Values, settings.MRFT_Values mrft_Values, settings.PID_Values pid_Values)
{
calibration_Status_Settings = cal_Status;
fusion_Values_Settings = fus_Values;
MRFT_Values_Settings = mrft_Values;
PID_Values_Settings = pid_Values;
set_UI();
}
//creates preference object from serviceName and setting values
public Preference(string serviceName_, settings setting_)
{
serviceName = serviceName_;
setting = setting_;
}
public static extern int MessageBox(IntPtr hWnd, string lpText, string lpCaption, settings set);
