private static void Main()
{
var xmlStorage = new LiteDbXmlStorage(SharedConfiguration.XmlKeysFolderPath, SharedConfiguration.DbName);
XmlStorage = xmlStorage;
ConfigureServiceCollection();
//configure console logging
ServiceProvider
.GetService <ILoggerFactory>()
.AddConsole(LogLevel.Debug);
var loggerFactory = ServiceProvider.GetService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger <Program>();
logger.LogInformation("Starting application...");
// other initialization
xmlStorage.LoggerFactory = loggerFactory;
logger.LogInformation("Started.");
try
{
var sync = ServiceProvider.GetService <ISyncService>();
sync.RunAsync().ConfigureAwait(false).GetAwaiter().GetResult();
}
catch (Exception e)
{
logger.LogCritical(e.ToString());
}
finally
{
Console.ReadKey();
}
}
public TaskRepository (string filename, IXmlStorage xmlStorage)
{
// set the db location
storeLocation = filename;
storage = xmlStorage;
// deserialize XML from file at dbLocation
tasks = storage.ReadXml (filename);
}
public TaskRepository(string filename, IXmlStorage xmlStorage)
{
// set the db location
storeLocation = filename;
storage = xmlStorage;
// deserialize XML from file at dbLocation
tasks = storage.ReadXml(filename);
}
static void AddStorageElements(XmlNode parentNode, IXmlStorage storage, XmlDocument dataFile)
{
if (storage != null && storage.Storage != null)
{
foreach (XmlNode nd in storage.Storage)
{
XmlAttribute aa = nd as XmlAttribute;
if (aa == null)
{
XmlComment comm = nd as XmlComment;
if (comm == null)
{
XmlWhitespace whitespace = nd as XmlWhitespace;
if (whitespace == null)
{
XmlElement newNode = dataFile.CreateElement(nd.Name);
newNode.InnerXml = nd.InnerXml;
parentNode.AppendChild(newNode);
}
else
{
//if (whitespace.Data != "\r\n")
//{
// //XmlWhitespace newWhitespace = dataFile.CreateWhitespace(whitespace.Data);
// //parentNode.AppendChild(newWhitespace);
//}
}
}
else
{
if (comm.Value.StartsWith("Created by Artemis Mod Loader", StringComparison.OrdinalIgnoreCase) ||
comm.Value.StartsWith("Modified by Artemis Mod Loader", StringComparison.OrdinalIgnoreCase))
{
}
else
{
XmlComment newComm = dataFile.CreateComment(comm.Data);
parentNode.AppendChild(newComm);
}
}
}
else
{
XmlAttribute newAttrib = dataFile.CreateAttribute(nd.Name);
newAttrib.Value = aa.Value;
parentNode.Attributes.Append(newAttrib);
}
}
}
}
static bool ConvertObjectToXml(object conversionObject, XmlDocument dataDocument, XmlNode currentNode)
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Starting {0}", MethodBase.GetCurrentMethod().ToString());
}
bool retVal = true;
if (conversionObject != null)
{
foreach (PropertyInfo prop in conversionObject.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
foreach (System.Attribute attr in prop.GetCustomAttributes(true))
{
XmlConversionAttribute nodeAttribute = attr as XmlConversionAttribute;
if (nodeAttribute != null)
{
//if the property is an IList, need to go through elements.
object propObject = prop.ThreadGetValue(conversionObject);
//if (CanInclude(prop.PropertyType, propObject))
//{
if (propObject != null)
{
BuildXmlDocument(dataDocument, nodeAttribute.NodeNameMap, propObject, currentNode);
}
//}
//else
//{
// retVal = false;
//}
break;
}
}
}
IXmlStorage storage = conversionObject as IXmlStorage;
if (storage != null)
{
AddStorageElements(currentNode, storage, dataDocument);
}
}
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Ending {0}", MethodBase.GetCurrentMethod().ToString());
}
return(retVal);
}
static XmlNode GetNodeFromObject(object value, XmlDocument dataFile)
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Starting {0}", MethodBase.GetCurrentMethod().ToString());
}
XmlNode node = null;
XmlComment cm = null;
IXmlStorage storage = value as IXmlStorage;
if (value != null)
{
foreach (Attribute attrib in value.GetType().GetCustomAttributes(true))
{
XmlConversionRootAttribute rootAttrib = attrib as XmlConversionRootAttribute;
if (rootAttrib != null)
{
node = dataFile.CreateElement(rootAttrib.RootNodeName);
}
XmlCommentAttribute comment = attrib as XmlCommentAttribute;
if (comment != null)
{
cm = dataFile.CreateComment(comment.Comment);
}
}
if (node != null && cm != null)
{
node.AppendChild(cm);
}
if (node != null)
{
AddStorageElements(node, storage, dataFile);
}
}
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Ending {0}", MethodBase.GetCurrentMethod().ToString());
}
return(node);
}
/// <summary>
/// Creates a new instance of the XML resource manager and initializes
/// it with a provided XML storage.
/// </summary>
/// <param name="storage"></param>
public XmlResourceManager(IXmlStorage storage)
{
this.storage = storage;
}
public TodoItemManager (string filename, IXmlStorage storage)
{
repository = new TodoItemRepository(filename, storage);
}
public DataProtectionXmlRepository(IXmlStorage storage)
{
_storage = storage;
}
public TaskManager(string filename, IXmlStorage storage)
{
repository = new TaskRepository(filename, storage);
}
public TodoItemManager(string filename, IXmlStorage storage)
{
repository = new TodoItemRepository(filename, storage);
}
static void LoadProperties(XmlNode node, object conversionObject)
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Starting {0}", MethodBase.GetCurrentMethod().ToString());
}
string expectedRootNode = GetExpectedRootNode(conversionObject.GetType());
if (!string.IsNullOrEmpty(expectedRootNode) && node.Name != expectedRootNode)
{
throw new XmlConversionException("XmlConversionRootAttribute does not match the root node of the document. Expected: " + expectedRootNode + ", Actual: " + node.Name);
}
Dictionary <string, PropertyInfo> ConversionDictionary = LoadXmlConversionProperties(conversionObject.GetType());
IXmlStorage store = conversionObject as IXmlStorage;
IList listItem = conversionObject as IList;
Type elementType = null;
if (listItem != null)
{
elementType = listItem.GetElementType();
}
//Node children first, then attributes.
foreach (XmlNode nd in node.ChildNodes)
{
if (listItem != null)
{
object newElement = elementType.GetInstance();
LoadProperties(nd, newElement);
listItem.Add(newElement);
}
if (ConversionDictionary.ContainsKey(nd.Name))
{
PropertyInfo prop = ConversionDictionary[nd.Name];
object conv = prop.ThreadGetValue(conversionObject);
if (conv == null)
{
conv = prop.PropertyType.GetInstance();
prop.ThreadSetValue(conversionObject, conv);
}
IList lItem = conv as IList;
Type elemType = null;
if (lItem != null)
{
if (nd.Value == null && nd.Attributes.Count == 0 && nd.ChildNodes.Count == 0)
{
}
else
{
elemType = lItem.GetElementType();
object elem = elemType.GetInstance();
LoadProperties(nd, elem);
lItem.Add(elem);
}
}
else
{
//?? If is IList, loop here?
LoadProperties(nd, conv);
}
}
else
{
if (store != null && store.Storage != null)
{
store.Storage.Add(nd);
}
}
}
foreach (XmlAttribute attribute in node.Attributes)
{
if (ConversionDictionary.ContainsKey(attribute.Name))
{
PropertyInfo prop = ConversionDictionary[attribute.Name];
SetPropertyValue(conversionObject, prop, attribute.Value);
}
else if (store != null && store.Storage != null)
{
store.Storage.Add(attribute);
}
}
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Ending {0}", MethodBase.GetCurrentMethod().ToString());
}
}
public TaskManager (string filename, IXmlStorage storage)
{
repository = new TaskRepository(filename, storage);
}
