public string GetFileName(EnumFileConstant enumFileConstant)
{
string fileName = "";
if (enumFileConstant == EnumFileConstant.BOOKCONSTANT)
{
fileName = FileConstant.BookJson;
}
else if (enumFileConstant == EnumFileConstant.ENTERTAINMENTCONSTANT)
{
fileName = FileConstant.EntertainmentJson;
}
else if (enumFileConstant == EnumFileConstant.QUOTESCONSTANT)
{
fileName = FileConstant.QuotesJson;
}
else if (enumFileConstant == EnumFileConstant.EVENTINYEAR)
{
fileName = FileConstant.EntertainmentJson;
}
else if (enumFileConstant == EnumFileConstant.USERLOGIN)
{
fileName = FileConstant.UserJson;
}
else if (enumFileConstant == EnumFileConstant.BOOK)
{
fileName = FileConstant.BookJson;
}
else if (enumFileConstant == EnumFileConstant.ENTERTAINMENT)
{
fileName = FileConstant.EntertainmentJson;
}
return(fileName);
}
public static string GetPathOfFile(EnumFileConstant chooseModelForPath)
{
Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory; // Set current directory
var pathAtSlnFile = "";
var directoryInfo = Directory.GetParent(Directory.GetCurrentDirectory());
if (directoryInfo.Parent != null && !directoryInfo.Parent.FullName.EndsWith("BigRememberGit"))
{
var getFromToEnd = directoryInfo.FullName.Split('\\');
foreach (var item in getFromToEnd)
{
if (item == "BigRememberGit")
{
pathAtSlnFile += item + "\\";
break;
}
pathAtSlnFile += item + "\\";
}
}
else
{
pathAtSlnFile = directoryInfo.Parent?.FullName;
}
var combinePath = "";
if (chooseModelForPath == EnumFileConstant.BOOKCONSTANT && pathAtSlnFile != null)
{
combinePath = Path.Combine(pathAtSlnFile,
FileConstant.BookConstantPath);
}
else if (chooseModelForPath == EnumFileConstant.ENTERTAINMENTCONSTANT && pathAtSlnFile != null)
{
combinePath = Path.Combine(pathAtSlnFile,
FileConstant.EntertainmentConstantPath);
}
else if (chooseModelForPath == EnumFileConstant.EVENTINYEAR && pathAtSlnFile != null)
{
combinePath = Path.Combine(pathAtSlnFile,
FileConstant.EventInYearConstantPath);
}
else if (chooseModelForPath == EnumFileConstant.QUOTESCONSTANT && pathAtSlnFile != null)
{
combinePath = Path.Combine(pathAtSlnFile,
FileConstant.QuotesConstantPath);
}
else if (chooseModelForPath == EnumFileConstant.USERLOGIN && pathAtSlnFile != null)
{
combinePath = Path.Combine(pathAtSlnFile,
FileConstant.UserLoginPath);
}
return(combinePath);
}
public static void ZipFile(EnumFileConstant zipEnumFile)
{
try
{
var fileUtil = new FileHandlerUtil();
var currentFile = Directory.GetCurrentDirectory() + @"\JsonDb\" + fileUtil.GetFileName(zipEnumFile);
var names = zipEnumFile.ToString();
var placeToArchive = Directory.GetCurrentDirectory() + @"\BackupDb\";
var saveZipTo = placeToArchive + names + ".zip";
using (ZipFile zip = new ZipFile())
{
zip.AddFile(currentFile, names);
zip.Save(saveZipTo);
}
}
catch (Exception a)
{
Logs.Error($"[ZipFile] Error while saving zip file: {a.Message}");
}
}
public void BackupDatabase(EnumFileConstant enumFile, string backupFolder)
{
_fileHandlerUtil.BackUpFileWithFolder(enumFile, backupFolder);
}
/*
* 1. check if file exist and read json file -> OK
* 2. If doesn't, create and read json file -> OK
* 3. Write as normal -> OK
* 4. Save file -> OK
*/
public void CreateOrReadJsonDb(EnumFileConstant enumFileConstant)
{
var fileName = GetFileName(enumFileConstant);
var currentFileFolder = Directory.GetCurrentDirectory() + @"\JsonDb\" + fileName;
if (File.Exists(currentFileFolder))
{
var stopwatch = Stopwatch.StartNew();
if (currentFileFolder.EndsWith(".json") && currentFileFolder.Split('.')[0] != "")
{
// Use bufferedstream for performance reading file
using (var fs = File.Open(currentFileFolder, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (var bs = new BufferedStream(fs))
using (var sr = new StreamReader(bs, true))
{
var reader = sr.ReadToEnd();
if (reader != "")
{
JsonModel = JsonConvert.DeserializeObject <ConfigModel>(reader, new JsonSerializerSettings
{
Formatting = Formatting.Indented,
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new NullToEmptyStringResolver()
});
CheckModelValue(JsonModel);
}
else // reader == ""
{
Logger.Warn($"There's no element in '{GetFileName(enumFileConstant)}'.");
CheckModelValue(JsonModel);
}
// SaveFile(enumFileConstant);
}
}
stopwatch.Stop();
Logger.Info($"[CreateOrReadJsonDb] End reading existed file: {stopwatch.ElapsedMilliseconds} ms.");
}
else // filePath doesn't exist (included folder)
{
// Use Document document user folder
var currentFolder = Directory.GetCurrentDirectory() + @"\JsonDb";
var jsonConfigModel = JsonConvert.SerializeObject(new ConfigModel(), Formatting.Indented);
if (fileName.EndsWith(".json") && fileName.Split('.')[0] != "")
{
// Create a json db file
Directory.CreateDirectory(currentFolder);
File.AppendAllText(currentFolder + "\\" + fileName, jsonConfigModel);
using (var fs = File.Open(currentFileFolder, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (var bs = new BufferedStream(fs))
using (var sr = new StreamReader(bs, true))
{
var reader = sr.ReadToEnd();
JsonModel = JsonConvert.DeserializeObject <ConfigModel>(reader);
}
// If null -> Create model as List<object>()
CheckModelValue(JsonModel);
}
else
{
// Create a json db file
Directory.CreateDirectory(currentFolder);
File.AppendAllText(currentFolder + "\\" + fileName + ".json", jsonConfigModel);
}
}
}
/// <summary>
/// Backup database every time starting a WPF Windows.
/// </summary>
/// <param name="saveEnumFile">An enum option</param>
/// <param name="backUpFolder">Folder where want to backup place</param>
public void BackUpFileWithFolder(EnumFileConstant saveEnumFile, string backUpFolder)
{
try
{
if (saveEnumFile == EnumFileConstant.CONFIGMODEL)
{
_jsonObject = JsonConvert.SerializeObject(JsonModel, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new NullToEmptyStringResolver()
});
}
var currentFolder = Directory.GetCurrentDirectory() + @"\JsonDb\" + GetFileName(saveEnumFile);
if (File.Exists(currentFolder)) // check file db
{
Logger.Info($"[BackUpFileWithFolder] Starting backup dabatase...");
var folderBackUp = Directory.GetCurrentDirectory() + $@"\{backUpFolder}\";
if (!Directory.Exists(folderBackUp)) // Check backup folder
{
Logger.Warn($"[BackUpFileWithFolder] '{backUpFolder}' doesn't exist.");
Directory.CreateDirectory(Directory.GetCurrentDirectory() + $@"\{backUpFolder}\");
}
folderBackUp += GetFileName(saveEnumFile);
if (saveEnumFile == EnumFileConstant.BOOKCONSTANT)
{
_jsonObject = JsonConvert.SerializeObject(JsonModel, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new NullToEmptyStringResolver()
});
File.WriteAllText(folderBackUp, string.Empty, Encoding.Unicode);
using (var sw = new StreamWriter(File.Open(folderBackUp, FileMode.Open, FileAccess.Write, FileShare.Read), Encoding.Unicode))
{
sw.WriteLine(_jsonObject);
}
}
else if (saveEnumFile == EnumFileConstant.ENTERTAINMENTCONSTANT)
{
_jsonObject = JsonConvert.SerializeObject(JsonModel, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new NullToEmptyStringResolver()
});
File.WriteAllText(folderBackUp, string.Empty, Encoding.Unicode);
using (var sw = new StreamWriter(File.Open(folderBackUp, FileMode.Open, FileAccess.Write, FileShare.Read), Encoding.Unicode))
{
sw.WriteLine(_jsonObject);
}
}
else if (saveEnumFile == EnumFileConstant.QUOTESCONSTANT)
{
_jsonObject = JsonConvert.SerializeObject(JsonModel, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new NullToEmptyStringResolver()
});
File.WriteAllText(folderBackUp, string.Empty, Encoding.Unicode);
using (var sw = new StreamWriter(File.Open(folderBackUp, FileMode.Open, FileAccess.Write, FileShare.Read), Encoding.Unicode))
{
sw.Write(_jsonObject);
}
}
else if (saveEnumFile == EnumFileConstant.EVENTINYEAR)
{
_jsonObject = JsonConvert.SerializeObject(JsonModel, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new NullToEmptyStringResolver()
});
File.WriteAllText(folderBackUp, string.Empty, Encoding.Unicode);
using (var sw = new StreamWriter(File.Open(folderBackUp, FileMode.Open, FileAccess.Write, FileShare.Read), Encoding.Unicode))
{
sw.Write(_jsonObject);
}
}
else if (saveEnumFile == EnumFileConstant.USERLOGIN)
{
_jsonObject = JsonConvert.SerializeObject(JsonModel, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new NullToEmptyStringResolver()
});
File.WriteAllText(folderBackUp, string.Empty, Encoding.Unicode);
using (var sw = new StreamWriter(File.Open(folderBackUp, FileMode.Open, FileAccess.Write, FileShare.Read), Encoding.Unicode))
{
sw.Write(_jsonObject);
}
}
Logger.Info($"[BackUpFileWithFolder] Backup '{GetFileName(saveEnumFile)}' successful.");
}
else // database doesn't exist
{
Logger.Warn($"[BackUpFileWithFolder] '{GetFileName(saveEnumFile)}' Database doesn't exist.");
}
}
catch (Exception e)
{
Logger.Error($"[BackUpFileWithFolder] Unexpected error: '{e.Message}'.");
Logger.Error($"[BackUpFileWithFolder] Name of error type: '{e.GetType().FullName}'.");
}
}
public void SaveFile(EnumFileConstant saveEnumFile)
{
try
{
if (saveEnumFile == EnumFileConstant.CONFIGMODEL)
{
_jsonObject = JsonConvert.SerializeObject(JsonModel, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new NullToEmptyStringResolver()
});
}
var currentFolder = Directory.GetCurrentDirectory() + @"\JsonDb\" + GetFileName(saveEnumFile);
if (saveEnumFile == EnumFileConstant.BOOKCONSTANT)
{
_jsonObject = JsonConvert.SerializeObject(JsonModel, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new NullToEmptyStringResolver()
});
File.WriteAllText(currentFolder, string.Empty, Encoding.Unicode);
using (var sw = new StreamWriter(File.Open(currentFolder, FileMode.Open, FileAccess.Write, FileShare.Read), Encoding.Unicode))
{
sw.WriteLine(_jsonObject);
}
}
else if (saveEnumFile == EnumFileConstant.ENTERTAINMENTCONSTANT)
{
_jsonObject = JsonConvert.SerializeObject(JsonModel, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new NullToEmptyStringResolver()
});
File.WriteAllText(currentFolder, string.Empty, Encoding.Unicode);
using (var sw = new StreamWriter(File.Open(currentFolder, FileMode.Open, FileAccess.Write, FileShare.Read), Encoding.Unicode))
{
sw.WriteLine(_jsonObject);
}
}
else if (saveEnumFile == EnumFileConstant.QUOTESCONSTANT)
{
_jsonObject = JsonConvert.SerializeObject(JsonModel, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new NullToEmptyStringResolver()
});
File.WriteAllText(currentFolder, string.Empty, Encoding.Unicode);
using (var sw = new StreamWriter(File.Open(currentFolder, FileMode.Open, FileAccess.Write, FileShare.Read), Encoding.Unicode))
{
sw.Write(_jsonObject);
}
}
else if (saveEnumFile == EnumFileConstant.EVENTINYEAR)
{
_jsonObject = JsonConvert.SerializeObject(JsonModel, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new NullToEmptyStringResolver()
});
File.WriteAllText(currentFolder, string.Empty, Encoding.Unicode);
using (var sw = new StreamWriter(File.Open(currentFolder, FileMode.Open, FileAccess.Write, FileShare.Read), Encoding.Unicode))
{
sw.Write(_jsonObject);
}
}
else if (saveEnumFile == EnumFileConstant.USERLOGIN)
{
_jsonObject = JsonConvert.SerializeObject(JsonModel, Formatting.Indented, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new NullToEmptyStringResolver()
});
File.WriteAllText(currentFolder, string.Empty, Encoding.Unicode);
using (var sw = new StreamWriter(File.Open(currentFolder, FileMode.Open, FileAccess.Write, FileShare.Read), Encoding.Unicode))
{
sw.Write(_jsonObject);
}
}
CheckModelValue(JsonModel);
}
catch (Exception e)
{
Logger.Error($"[SaveFile] Unexpected error: '{e.Message}'.");
Logger.Error($"[SaveFile] Name of error type: '{e.GetType().FullName}'.");
}
}
public bool CreateJsonDb(EnumFileConstant enumFileConstant)
{
_fileHandlerUtil.CreateOrReadJsonDb(enumFileConstant);
return(true);
}
