internal static ParamValuesNode FromXml(XElement element)
{
if (element == null)
{
return(null);
}
ParamValuesNode model = new ParamValuesNode();
model.Name = element.BaseUri;
foreach (XElement delm in element.Descendants())
{
if (delm.HasElements)
{
continue;
}
if (delm.Parent.HasElements && delm.Parent != element)
{
continue;
}
if (model.Attributs.ContainsKey(delm.Name.ToString()))
{
continue; // déja présent (multible attribut interdit)
}
model.Attributs.Add(delm.Name.ToString().ToLower(), delm.Value);
}
return(model);
}
public int CompareTo(object obj)
{
ParamValuesNode Compare = (ParamValuesNode)obj;
if (!string.IsNullOrEmpty(Compare["dataorder"]) && !string.IsNullOrEmpty(this["dataorder"]))
{
try
{
int orderCompare = Convert.ToInt32(Compare["dataorder"]);
int orderthis = Convert.ToInt32(this["dataorder"]);
int resulti = orderthis.CompareTo(orderCompare);
if (resulti == 0)
{
resulti = orderthis.CompareTo(orderCompare);
}
return(resulti);
}
catch (Exception) { }
}
int result = this.Name.CompareTo(Compare.Name);
if (result == 0)
{
result = this.Name.CompareTo(Compare.Name);
}
return(result);
}
internal static System.Xml.Linq.XElement ToXml(ParamValuesNode model)
{
if (model == null)
{
return(null);
}
XElement element = new XElement(model.Name);
element.Value = model.GetString(null);
//if (!string.IsNullOrEmpty(model.IssuerElementId)) element.Add(new XAttribute("id", model.IssuerElementId));
//element.Add(new XAttribute("type", "ComplexType"));
if (model.Attributs != null)
{
foreach (var attributeKey in model.Attributs.Keys)
{
string val = model.GetString(attributeKey, DataAccessorOptionEnum.None);
if (string.IsNullOrEmpty(val))
{
continue; // cela sert à rien d'écrire un attribut vide
}
XAttribute nodeAttribute = new XAttribute(attributeKey, val);
element.Add(nodeAttribute);
}
}
return(element);
}
/// <summary>
/// Obtient tous les data qui contien l'attribut 'attributname'
/// </summary>
/// <param name="attributname"></param>
/// <param name="replacenameparattribut"></param>
/// <returns></returns>
public ParamValues GetDatasWithAttribut(string attributname, bool replacenameparattribut = false)
{
try
{
ParamValues retour = new ParamValues();
WaitMutex();
foreach (ParamValuesNode datb in this.dataStore.Values)
{
if (datb[attributname] != "")
{
ParamValuesNode ee = datb.Clone();
if (replacenameparattribut)
{
ee.Name = datb[attributname];
}
retour.Add(ee);
}
}
return(retour);
}
catch (Exception e)
{
throw new Exception("Impossible d'obtenir des datas avec l'attribut " + attributname + " " + e.Message);
}
finally
{
ReleaseMutex();
}
}
/// <summary>
/// Obtenir l'Attribut d'un paramètre
/// </summary>
/// <param name="ise"></param>
/// <param name="nameAttribut"></param>
/// <returns></returns>
public string this[string ise, string nameAttribut]
{
get
{
ise = this.PrepareNameNode(ise);
ParamValuesNode retour = this.Get(ise);
if (retour == null)
{
return(null);
}
else
{
return(retour[nameAttribut]);
}
}
set
{
ise = this.PrepareNameNode(ise);
ParamValuesNode retour = this.Get(ise);
if (retour == null)
{
retour = new ParamValuesNode(ise);
Add(retour);
}
retour[nameAttribut] = value;
}
}
/// <summary>
/// Ajouter un objet
/// </summary>
/// <param name="nameValue"></param>
/// <param name="obj"></param>
/// <param name="AccesOptions"></param>
/// <returns></returns>
public bool SetData(string nameValue, object obj, DataAccessorOptionEnum AccesOptions)
{
try
{
//if (!AccesOptions.HasFlag(BASICS.DataAccessorOptionEnum.NotReplace)) this.DelData(nameValue);
// mutex déja pris
object orgnobj = this.GetObject(nameValue, DataAccessorOptionEnum.None);
if ((orgnobj == null || (orgnobj is string && string.IsNullOrEmpty(orgnobj.ToString()))) && (obj == null || (obj is string && string.IsNullOrEmpty(obj.ToString()))))
{
return(false);
}
if (obj != null && orgnobj != null && obj.Equals(orgnobj))
{
return(false); // inutile si pas modifié
}
nameValue = this.PrepareNameNode(nameValue);
ParamValuesNode retour = this.Get(nameValue);
if (retour == null)
{
retour = new ParamValuesNode(nameValue);
Add(retour);
}
retour.SetObject(null, obj);
return(true);
}
catch (Exception ex)
{
throw;
}
}
private ParamValuesNode GenerateNewNodeFromXML(ParamValues datavalue, string lastpath, XmlNode xChild)
{
ParamValuesNode bufliste = new ParamValuesNode();
try
{
bufliste.datavalues_parent = datavalue;
bufliste.Name = lastpath.ToLower();
if (bufliste.Name.Substring(bufliste.Name.Length - 1) == "/")
{
bufliste.Name = bufliste.Name.Substring(0, bufliste.Name.Length - 1);
}
if (bufliste.Name.Length > 9 && bufliste.Name.Substring(0, 9) == "/noparam/")
{
bufliste.Name.Replace("/noparam/", "");
}
// GESTION DES ATTRIBUTS
// on tente d'obtenir les attributs (Il sont stockées sur le noeud parent)
XmlAttributeCollection sattributs = null;
XmlNode xParentElement = null;
if (xChild.NodeType == XmlNodeType.Element)
{
xParentElement = xChild; // il n'avait déja pas d'enfant.
}
else
{
xParentElement = xChild.ParentNode;
}
if (xParentElement != null && xParentElement.NodeType == XmlNodeType.Element)
{
sattributs = xParentElement.Attributes;
}
if (sattributs != null && sattributs.Count > 0)
{
foreach (XmlAttribute item in sattributs)
{
string nameatr = item.LocalName.ToLower();
bufliste[nameatr] = item.Value;
}
}
// dyna
//if (bufliste.value != null && bufliste.value is string && bufliste.value.ToString().Contains("{!"));
// Affectation de la données
bufliste.SetObject(null, xChild.Value);
}
catch (Exception)
{
bufliste["datatype_error"] = "true";
}
return(bufliste);
}
/// <summary>
/// Clone dans de nouveaux objets
/// </summary>
public ParamValuesNode Clone()
{
ParamValuesNode clona = new ParamValuesNode();
clona.Value = this.Value;
clona.Name = this.Name;
clona.datavalues_parent = this.datavalues_parent;
foreach (var bifdata in this.Attributs) // cloner dictionary !!!
{
clona.Attributs.Add(bifdata.Key, bifdata.Value);
}
return(clona);
}
private XmlTextWriter savewritenode(XmlTextWriter XmlTextWriter, ParamValuesNode datatab, string item)
{
if (datatab.Value == null)
{
datatab.Value = ""; //Attention aux noeuds null...
}
XmlTextWriter.WriteStartElement(item);
foreach (var attribut in datatab.Attributs)
{
XmlTextWriter.WriteAttributeString(attribut.Key, Convert.ToString(attribut.Value));
}
XmlTextWriter.WriteValue(datatab.GetString(null));
return(XmlTextWriter);
}
public ParamValuesNode Get(string ise, bool CreateIfNotExist = true)
{
ise = this.PrepareNameNode(ise);
ParamValuesNode retour = null;
if (!this.dataStore.ContainsKey(ise))
{
return(null);
}
retour = this.dataStore[ise];
if (retour == null && CreateIfNotExist)
{
retour = new ParamValuesNode(ise);
Add(retour);
}
return(retour);
}
/// <summary>
/// Attention ne copie pas le nom
/// </summary>
/// <param name="dataext"></param>
/// <param name="ecraser"></param>
public void Fusion(ParamValuesNode dataext, bool ecraser = false)
{
if (ecraser || this._value == null)
{
if (ChangedState == System.Data.DataRowState.Unchanged && this._value != dataext._value)
{
ChangedState = System.Data.DataRowState.Modified;
}
this._value = dataext._value;
}
foreach (var itemd in dataext.Attributs)
{
if (ecraser || this[itemd.Key] == "")
{
this.SetObject(itemd.Key, itemd.Value);
}
}
}
public void Fusion(ParamValues dataext, bool ecraser = false)
{
foreach (ParamValuesNode itemd in dataext.GetList())
{
ParamValuesNode itemsearch = this.Get(itemd.Name);
if (itemsearch != null && itemsearch.Name != "")
{
if (ecraser)
{
this.Add(itemd.Clone());
}
}
else
{
this.Add(itemd.Clone());
}
}
}
public object GetData(string nameValue, DataAccessorOptionEnum AccesOptions)
{
try
{
ParamValuesNode dat = this.Get(nameValue);
if (dat == null)
{
return(null);
}
else
{
return(dat.Value);
}
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// ajoute une donnée pure
/// </summary>
/// <param name="name">nom de l'élément</param>
public void Add(ParamValuesNode data)
{
try
{
WaitMutex();
data.datavalues_parent = this;
ParamValuesNode bufliste = this.Get(data.Name);
if (bufliste != null)
{
this.Remove(data.Name);
}
this.dataStore.Add(data.Name, data);
}
catch (Exception)
{
}
finally
{
ReleaseMutex();
}
}
private void FromJsonSub(ParamValues datavalue, System.Text.Json.JsonProperty elem, string lastpath)
{
if (elem.Value.ValueKind == System.Text.Json.JsonValueKind.Array)
{
// Array invalids
}
else if (elem.Value.ValueKind == System.Text.Json.JsonValueKind.Object)
{
string newlastpath = lastpath + elem.Name + "/";
foreach (var jsubitem in elem.Value.EnumerateObject().ToList())
{
FromJsonSub(datavalue, jsubitem, newlastpath);
}
}
else
{
string fullname = lastpath + elem.Name;
ParamValuesNode dataelement = new ParamValuesNode();
dataelement.Name = fullname;
dataelement.Value = Nglib.DATA.KEYVALUES.KeyValuesSerializerJson.ReadValue(elem.Value);
datavalue.Add(dataelement);
}
}
private void getdataXMLChild(ParamValues datavalue, XmlNode xdot, string pathac, XmlAttributeCollection sattributs)
{
string lastpath = pathac;
ParamValuesNode bufliste = new ParamValuesNode();
XmlAttributeCollection sauvattributs = null;
foreach (XmlNode xChild in xdot.ChildNodes)
{
//System.Console.WriteLine(xChild.Name);
if (xChild.NodeType == XmlNodeType.Element)
{
lastpath = pathac + xChild.Name.ToLower() + "/";
if (xChild.Attributes.Count > 0)
{
sauvattributs = xChild.Attributes;
}
else
{
sauvattributs = null;
}
}
if (xChild.NodeType == XmlNodeType.Text || (xChild.NodeType == XmlNodeType.Element && !xChild.HasChildNodes && xChild.Value == null))
{
bufliste = GenerateNewNodeFromXML(datavalue, lastpath, xChild); // Ajout d'une nouvelle clef/valeur
if (bufliste != null)
{
datavalue.Add(bufliste);
}
}
else if (xChild.HasChildNodes)
{
getdataXMLChild(datavalue, xChild, lastpath, sauvattributs);
}
}
}