/// <summary>
/// Des the serialise.
/// </summary>
/// <param name="filename">The filename.</param>
/// <returns></returns>
public static SymbolIdentity DeSerialise(string filename)
{
var ret = new SymbolIdentity();
try
{
var text = FileExtras.LoadFile(filename);
var t1 = text.Split(new[] { v }, StringSplitOptions.RemoveEmptyEntries);
var w = int.Parse(t1[0]);
var h = int.Parse(t1[1]);
var letters = new List <HistogramLetter>();
for (var a = 2; a < t1.Count(); a++)
{
var ltext = t1[a];
var l = HistogramLetter.DeSerialise(ltext);
if (letters.Any(s => s.Letter.Equals(l.Letter)) == false)
{
letters.Add(l);
}
}
ret.HistogramHeight = h;
ret.HistogramWidth = w;
ret.Letters = letters;
}
catch (ArgumentException)
{
}
return(ret);
}
/// <summary>
/// Initializes a new instance of the <see cref="LocalJSONCache"/> class.
/// </summary>
/// <param name="filename">The filename.</param>
public LocalJSONCache(string filename)
{
if (filename.EndsWith(".json") == false)
{
filename += ".json";
}
this.filename = filename;
lock (@lock)
{
bool ok;
do
{
FileExtras.CreateFile(filename);
using (var fs = new FileStream(filename, FileMode.Open))
{
try
{
Storage = DictionaryExtras.Deserialize(fs) ?? new Dictionary <string, object>();
ok = true;
}
catch (Exception)
{
ok = false;
File.Delete(filename);
}
}
} while (ok == false);
}
js = new JsonSerializer();
}
/// <summary>
/// Exports to a file
/// </summary>
/// <param name="path">The path.</param>
/// <param name="header">if set to <c>true</c> [header].</param>
/// <param name="uniqueColumn">The unique column.</param>
public void ExportToFile(string path, bool header, int?uniqueColumn)
{
var e = Export(header);
//check unique
if (uniqueColumn != null)
{
if (File.Exists(path))
{
var f = CSVTransform.LoadFile(path);
if (f != null)
{
var exist = f.Select(s => s[(int)uniqueColumn]).ToList();
var toadd = e.Select(s => s[(int)uniqueColumn]).ToList();
if (exist.Any(s => toadd.Any(s2 => s2 == s)))
{
return;
}
}
}
}
var c = string.Join("\r\n", e.Select(s1 => string.Join(",", s1)));
FileExtras.SaveToFile(path, c, true);
}
/// <summary>
///
/// </summary>
/// <param name="filename"></param>
/// <param name="options"></param>
/// <returns>return null if no error, and return an error string if there was one</returns>
public static string LoadFiles(List <string> filename, textoptions options)
{
var files = "";
foreach (var f in filename)
{
var s = FileExtras.LoadFile(f);
if (s == null)
{
return(f);
}
if (string.IsNullOrEmpty(s))
{
continue;
}
files += "\n" + s;
}
if (string.IsNullOrWhiteSpace(files))
{
return(null);
}
M = new model(SanatiseFile(files, options), filename);
return(null);
}
/// <summary>
/// Serialises the specified filename.
/// </summary>
/// <param name="filename">The filename.</param>
public void Serialise(string filename)
{
var ret = HistogramWidth + v.ToString(CultureInfo.InvariantCulture) + HistogramHeight +
v.ToString(CultureInfo.InvariantCulture).ToString(CultureInfo.InvariantCulture);
var text = Letters.Aggregate("", (a, b) => a + (b.Serialise() + v.ToString(CultureInfo.InvariantCulture)));
ret += text;
FileExtras.SaveToFile(filename, ret);
}
public static void SaveChartCSV(Chart c, string filename)
{
String save = "text,count\r\n";
foreach (var dp in c.Series[0].Points.Reverse())
{
save += dp.AxisLabel + "," + dp.YValues[0] + "\r\n";
}
FileExtras.SaveToFile(StringExtras.ReplaceAllChars(filename, ":", "_"), save);
}
/// <summary>
/// Loads the specified filename.
/// </summary>
/// <param name="filename">The filename.</param>
/// <returns></returns>
public static string[][] LoadFile(string filename)
{
var str = FileExtras.LoadFile(filename);
if (str == null)
{
return(null);
}
return(LoadContent(str));
}
/// <summary>
/// serialise an object to a file
/// </summary>
/// <param name="classInstance">The class instance.</param>
/// <param name="filename">The filename.</param>
/// <returns></returns>
public static bool SerialiseObject(object classInstance, string filename)
{
if (File.Exists(filename) == false)
{
FileExtras.CreateFile(filename);
}
var r = SerialiseObject(classInstance);
FileExtras.SaveToFile(filename, r);
return(true);
}
/// <summary>
/// save controls, tool strips, and manually saved strings
/// call this on form load
/// </summary>
/// <param name="baseform">The baseform.</param>
/// <param name="filename">The filename.</param>
/// <param name="saveControls">a list of form controlls to save, except tool strip items</param>
/// <param name="saveToolStripItems">list of tool strip menu items which the checked value should be saved for</param>
/// <param name="literalStrings">a list of tuple string/strings to manually save</param>
/// <returns></returns>
public static bool SaveConfig(Form baseform, string filename, IEnumerable <Control> saveControls = null,
IEnumerable <ToolStripItem> saveToolStripItems = null,
IEnumerable <Tuple <string, string> > literalStrings = null)
{
try
{
if (File.Exists(filename))
{
File.Delete(filename);
}
var output = "";
if (saveControls != null)
{
foreach (var c in saveControls)
{
SaveProperty(ref output, c);
}
}
if (saveToolStripItems != null)
{
foreach (var tsi in saveToolStripItems)
{
SaveProperty(ref output, tsi);
}
}
output += TypeSep;
if (literalStrings != null)
{
foreach (var s in literalStrings)
{
output += s.Item1 + Separator + s.Item2 + NewLine;
}
}
FileExtras.SaveToFile(filename, output);
}
catch (Exception)
{
return(false);
}
return(true);
}
/// <summary>
/// deserialise a file to an object from a file
/// </summary>
/// <param name="filename">The filename.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="ignoreErrors">if set to <c>true</c> [ignore errors].</param>
/// <returns></returns>
public static object DeserialiseObject(string filename, Type objectType, bool ignoreErrors = true)
{
if (File.Exists(filename) == false)
{
return(null);
}
var s = FileExtras.LoadFile(filename);
if (string.IsNullOrEmpty(s))
{
return(null);
}
var instance = DeserialiseObject(objectType, s, ignoreErrors);
return(instance);
}
private void LoadFile(String fn)
{
var t = FileExtras.LoadFile(fn);
var s1 = t.Split(new[] { '\f' }, StringSplitOptions.None);
if (!s1.Any())
{
MessageBox.Show("Error loading file");
return;
}
encryptedtext.Text = s1[0];
if (s1.Count() >= 1)
{
decryptedtext.Text = s1[1];
}
}
public void Generate(string table, string @where, bool openFile, bool alphaHeaderCols)
{
var cs = new DataTableExporter();
var ts = new List <string>();
var headers = new List <string>();
if (alphaHeaderCols)
{
GetHeaderRows(ref cs, ref headers, table, ref ts, @where);
//order
headers = headers.OrderBy(s => s).ToList();
//init
cs.HeaderRows = headers;
ts = new List <string>();
}
AddRows(ref cs, table, ref ts, @where, alphaHeaderCols);
//output
cs.ExportXLS("SQLAUTOJOIN" + FileExtras.GenerateRandomFileName("xlsx"), openFile);
}
private void SaveToFile(String filename)
{
var o = encryptedtext.Text + '\f' + decryptedtext.Text;
FileExtras.SaveToFile(filename, o);
}
/// <summary>
/// perform the merging of a vanilla df zip file, a mod zip file, an output dir, and whether to merge save and init dirs
/// </summary>
/// <param name="vanilla">vanilla df zip file</param>
/// <param name="mod">mod df zip file</param>
/// <param name="realoutput">output dir</param>
/// <param name="mergesave">whether to persist save dir from orig output dir</param>
/// <param name="mergeinit">whether to persist init dir from orig output dir</param>
/// <param name="sf">a delegate to change status text</param>
public static bool MergeOp(String vanilla, String mod, String realoutput, bool mergesave, bool mergeinit, ChangeStatusTextDel sf = null)
{
string vantemp = Directory.GetCurrentDirectory() + "\\vanillatemp";
string modtemp = Directory.GetCurrentDirectory() + "\\modtemp";
const string raw = "\\raw";
const string art = "\\data\\art";
const string init = "\\data\\init\\init.txt";
const string initd = "\\data\\init\\d_init.txt";
const string datainot = "\\data\\init";
const string dsave = "\\data\\save";
string outputtemp = Directory.GetCurrentDirectory() + "\\df";
string outputtempsave = outputtemp + dsave;
string outputtempinit = outputtemp + datainot;
string outputinit = outputtemp + init;
string outputdinit = outputtemp + initd;
string realsavedir = realoutput + dsave;
string realsaveinit = realoutput + datainot;
string modinit = modtemp + init;
string moddinit = modtemp + init;
//delete temps if already exist
FileExtras.DeleteDirectory(vantemp);
FileExtras.DeleteDirectory(modtemp);
FileExtras.DeleteDirectory(outputtemp);
ChangeStatusText(sf, Resources.start_exct_van_zip);
try
{
//unpack vanilla
ZipExtras.ExtractZipFile(vanilla, vantemp);
ChangeStatusText(sf, Resources.fin_exct_van_zip);
}
catch (Exception ex)
{
MessageBox.Show(Resources.error_van_zip + ex);
return(false);
}
try
{
//unpack mod
ZipExtras.ExtractZipFile(mod, modtemp);
ChangeStatusText(sf, Resources.fin_exct_mod_zip);
}
catch (Exception ex)
{
MessageBox.Show(Resources.error_mod_zip + ex);
return(false);
}
try
{
//move vanilla
FileExtras.MergeDirectories(outputtemp, vantemp);
//delete raw and art
FileExtras.DeleteDirectory(outputtemp + raw);
FileExtras.DeleteDirectory(outputtemp + art);
//move mod raw and art
FileExtras.MergeDirectories(outputtemp + raw, modtemp + raw);
FileExtras.MergeDirectories(outputtemp + art, modtemp + art);
//copy init/init.d
if (File.Exists(modinit))
{
File.Copy(modinit, outputinit, true);
}
if (File.Exists(moddinit))
{
File.Copy(moddinit, outputdinit, true);
}
ChangeStatusText(sf, Resources.fin_merge);
//get save games if required
if (mergesave && Directory.Exists(realsavedir))
{
FileExtras.CreateDirectory(outputtempsave);
FileExtras.MergeDirectories(outputtempsave, realsavedir);
}
//get init dir if required
if (mergeinit && Directory.Exists(realsaveinit))
{
FileExtras.MergeDirectories(outputtempinit, realsaveinit);
}
//delete temps
FileExtras.DeleteDirectory(vantemp);
FileExtras.DeleteDirectory(modtemp);
//move temp to real
FileExtras.DeleteDirectory(realoutput);
FileExtras.MergeDirectories(realoutput, outputtemp);
FileExtras.DeleteDirectory(outputtemp);
ChangeStatusText(sf, Resources.ready);
}
catch (Exception ex)
{
MessageBox.Show("An error occured:" + ex);
return(false);
}
return(true);
}
/// <summary>
/// load the saved config file. will automatically load all the control values, and return the manual strings
/// </summary>
/// <param name="baseform">pass the base form</param>
/// <param name="filename">the saved config flename</param>
/// <returns>
/// returns null on error, and a list of tuples of saved literal strings otherwise
/// </returns>
public static List <Tuple <string, string> > LoadConfig(Form baseform, string filename)
{
var ret = new List <Tuple <string, string> >();
try
{
if (File.Exists(filename) == false)
{
return(null);
}
var f = FileExtras.LoadFile(filename);
var parts = StringExtras.SplitString(f, TypeSep);
//first part is controls and stuff
var controls = StringExtras.SplitString(parts[0], NewLine);
foreach (var line in controls)
{
var split = StringExtras.SplitString(line, Separator);
if (split.Length < 2)
{
continue;
}
string v = null;
if (split.Length >= 3)
{
v = split[2];
}
LoadProperty(baseform, split[0], split[1], v);
}
//second part is literal strings
if (parts.Length >= 2)
{
var strings = StringExtras.SplitString(parts[1], NewLine);
foreach (var line in strings)
{
var split = StringExtras.SplitString(line, Separator);
if (split.Length < 2)
{
continue;
}
ret.Add(new Tuple <string, string>(split[0], split[1]));
}
}
return(ret);
}
catch (Exception)
{
//on error, delete the config
try
{
File.Delete(filename);
}
catch
{
}
return(null);
}
}
