/// <summary>
/// Obtenir/Convertir en Bool NULLABLE
/// </summary>
/// <param name="dataAccessor"></param>
/// <param name="nameValue"></param>
/// <param name="AccesOptions"></param>
/// <param name="defaultvalue"></param>
/// <returns></returns>
public static bool?GetBoolean(this IDataAccessor dataAccessor, string nameValue, DataAccessorOptionEnum AccesOptions, bool?defaultvalue)
{
try
{
object obj = dataAccessor.GetObject(nameValue, AccesOptions);
if (obj == DBNull.Value || obj == null)
{
return(null);
}
else if (AccesOptions.HasFlag(DataAccessorOptionEnum.AdvancedConverter))
{
return(ConvertPlus.ToBoolean(obj));
}
else
{
return(Convert.ToBoolean(obj));
}
}
catch (Exception ex)
{
if (!AccesOptions.HasFlag(DataAccessorOptionEnum.Safe))
{
throw new DataAccessorException("GetString " + ex.Message, ex);
}
throw;
}
}
/// <summary>
/// Obtenir un string
/// </summary>
/// <param name="dataAccessor"></param>
/// <param name="nameValue"></param>
/// <param name="AccesOptions"></param>
/// <returns></returns>
public static string GetString(this IDataAccessor dataAccessor, string nameValue, DataAccessorOptionEnum AccesOptions)
{
try
{
if (AccesOptions.HasFlag(DataAccessorOptionEnum.Safe) && dataAccessor == null)
{
return(null);
}
object obj = dataAccessor.GetObject(nameValue, AccesOptions);
if ((obj == null || obj == DBNull.Value)) // retourne pas null par default
{
if (AccesOptions.HasFlag(DataAccessorOptionEnum.Nullable))
{
return(null);
}
else
{
return(string.Empty);
}
}
return(obj.ToString());
//DATA.MANIPULATE.TEXT.TextTreatment.Transform
//return str;
}
catch (Exception ex)
{
if (!AccesOptions.HasFlag(DataAccessorOptionEnum.Safe))
{
throw new DataAccessorException("GetString " + ex.Message, ex);
}
return(string.Empty);
}
}
/// <summary>
/// Obtenir/Convertir en DateTime
/// </summary>
/// <param name="dataAccessor"></param>
/// <param name="nameValue"></param>
/// <param name="DefaultValue"></param>
/// <param name="AccesOptions"></param>
/// <returns></returns>
public static DateTime GetDateTime(this IDataAccessor dataAccessor, string nameValue, DateTime DefaultValue, DataAccessorOptionEnum AccesOptions = 0)
{
try
{
object obj = dataAccessor.GetObject(nameValue, AccesOptions);
if (obj == DBNull.Value || obj == null)
{
return(DefaultValue);
}
if (obj is string && string.IsNullOrWhiteSpace((string)obj))
{
return(DefaultValue);
}
else if (AccesOptions.HasFlag(DataAccessorOptionEnum.AdvancedConverter))
{
return(ConvertPlus.ToDateTime(obj));
}
else
{
return(Convert.ToDateTime(obj));
}
}
catch (Exception ex)
{
if (!AccesOptions.HasFlag(DataAccessorOptionEnum.Safe))
{
throw new DataAccessorException("GetString " + ex.Message, ex);
}
throw;
}
}
/// <summary>
/// Obtenir une valeur, methode standard DataAccessor
/// </summary>
public object GetObject(string nameValue, DataAccessorOptionEnum AccesOptions)
{
try
{
if (string.IsNullOrWhiteSpace(nameValue))
{
return(null);
}
//int positionPartWant = GetPosition(nameValue);
if (!this.ContainsKey(nameValue))
{
return(null);
}
object valstring = base[nameValue];
// if(AccesOptions.HasFlag( BASICS.DataAccessorOptionEnum.Dynamise))
return(valstring);
}
catch (Exception)
{
if (AccesOptions.HasFlag(DataAccessorOptionEnum.Safe))
{
return(null);
}
throw;
}
}
public bool SetData(object obj, DataAccessorOptionEnum AccesOptions)
{
if (!AccesOptions.HasFlag(DataAccessorOptionEnum.IgnoreChange))
{
this.isChangedValue = true;
}
this.Value = obj;
return(true);
}
public virtual object EncryptObjectValue(IDataAccessor dataAccessor, string nameValue, object value, DataAccessorOptionEnum options)
{
if (!options.HasFlag(DataAccessorOptionEnum.Encrypted) || dataAccessor == null || value == null) return value; // rien à faire
if (this.OptionForEncrypt == null) throw new NullReferenceException($"DataAccessorEncrypt OptionForEncrypt NULL (objectType: {dataAccessor.GetType().Name})");
if (value.GetType().IsArray) return EncryptArrayValue(dataAccessor, nameValue, value, options); // spécifique pour gérer les array
string strvalue = value.ToString(); // la valeur en base sera forcément un string
string encryptedVal = Nglib.FORMAT.CryptHashTools.Encrypt(strvalue, this.OptionForEncrypt);
return encryptedVal;
}
protected virtual object EncryptArrayValue(IDataAccessor dataAccessor, string nameValue, object value, DataAccessorOptionEnum options)
{
if (!options.HasFlag(DataAccessorOptionEnum.Encrypted) || dataAccessor == null || value == null) return value; // rien à faire
if (this.OptionForEncrypt == null) throw new NullReferenceException($"DataAccessorEncrypt OptionForEncrypt NULL (objectType: {dataAccessor.GetType().Name})");
string[] adata = DataAccessorTools.ConvertoArrayString(value);
for (int i = 0; i < adata.Length; i++) // on encrypte les valeurs une par une
adata[i] = Nglib.FORMAT.CryptHashTools.Encrypt(adata[i], this.OptionForEncrypt);
return adata;
}
public static string[] GetStringArray(this IDataAccessor dataAccessor, string nameValue, DataAccessorOptionEnum AccesOptions = DataAccessorOptionEnum.None)
{
if (AccesOptions.HasFlag(DataAccessorOptionEnum.Safe) && dataAccessor == null)
{
return(null);
}
object obj = dataAccessor.GetObject(nameValue, AccesOptions);
string[] retour = obj as string[];
return(retour);
}
protected virtual object DecryptArrayValue(IDataAccessor dataAccessor, string nameValue, object valuecc, DataAccessorOptionEnum options)
{
if (!options.HasFlag(DataAccessorOptionEnum.Encrypted) || dataAccessor == null || valuecc == null) return valuecc; // rien à faire
if (this.OptionForDecrypt == null) throw new NullReferenceException($"DataAccessorDecrypt OptionForDecrypt NULL (objectType: {dataAccessor.GetType().Name})");
if (valuecc == null) return null;
string[] adata = valuecc as string[];
if (adata == null) throw new Exception("DecryptArrayValue Only string[] input allowed");
for (int i = 0; i < adata.Length; i++) //une par une
adata[i] = Nglib.FORMAT.CryptHashTools.Decrypt(adata[i], this.OptionForDecrypt);
return adata;
}
public static long[] GetLongArray(this IDataAccessor dataAccessor, string nameValue, DataAccessorOptionEnum AccesOptions = DataAccessorOptionEnum.None, long DefaultValue = 0)
{
if (AccesOptions.HasFlag(DataAccessorOptionEnum.Safe) && dataAccessor == null)
{
return(null);
}
object obj = dataAccessor.GetObject(nameValue, AccesOptions);
long[] retour = obj as long[];
if (retour == null && obj is string[])
{
retour = (obj as string[]).Select(item => (string.IsNullOrWhiteSpace(item)) ? DefaultValue : Convert.ToInt64(item)).ToArray();
}
return(retour);
}
public static DateTime[] GetDateTimeArray(this IDataAccessor dataAccessor, string nameValue, DataAccessorOptionEnum AccesOptions = DataAccessorOptionEnum.None)
{
if (AccesOptions.HasFlag(DataAccessorOptionEnum.Safe) && dataAccessor == null)
{
return(null);
}
object obj = dataAccessor.GetObject(nameValue, AccesOptions);
DateTime[] retour = obj as DateTime[];
if (retour == null && obj is string[])
{
retour = (obj as string[]).Select(item => (string.IsNullOrWhiteSpace(item)) ? new DateTime() : Convert.ToDateTime(item)).ToArray();
}
return(retour);
}
public static bool[] GetBooleanArray(this IDataAccessor dataAccessor, string nameValue, DataAccessorOptionEnum AccesOptions = DataAccessorOptionEnum.None, bool defaultvalue = false)
{
if (AccesOptions.HasFlag(DataAccessorOptionEnum.Safe) && dataAccessor == null)
{
return(null);
}
object obj = dataAccessor.GetObject(nameValue, AccesOptions);
bool[] retour = obj as bool[];
if (retour == null && obj is string[])
{
retour = (obj as string[]).Select(item => (string.IsNullOrWhiteSpace(item)) ? defaultvalue : Convert.ToBoolean(item)).ToArray();
}
return(retour);
}
/// <summary>
/// Définir une donnée
/// </summary>
public static bool SetObject(this IDataAccessor dataAccessor, string nameValue, object obj, DataAccessorOptionEnum AccesOptions)
{
object adata = obj;
// Cryptage
if (obj != null && AccesOptions.HasFlag(DataAccessorOptionEnum.Encrypted))
{
var cryptoctx = dataAccessor.GetCryptoContext();
if (cryptoctx != null)
{
adata = cryptoctx.EncryptObjectValue(dataAccessor, nameValue, adata, AccesOptions);
}
}
if (adata == null)
{
adata = DBNull.Value; // les nul son interdit en base
}
return(dataAccessor.SetData(nameValue, adata, AccesOptions));
}
/// <summary>
/// Obtenir la données
/// </summary>
public static object GetObject(this IDataAccessor dataAccessor, string nameValue, DataAccessorOptionEnum AccesOptions)
{
//Obtenir la données la donnée
object adata = dataAccessor.GetData(nameValue, AccesOptions);
//Cryptage
if (adata != null && AccesOptions.HasFlag(DataAccessorOptionEnum.Encrypted))
{
var cryptoctx = dataAccessor.GetCryptoContext();
if (cryptoctx != null)
{
adata = cryptoctx.DecryptObjectValue(dataAccessor, nameValue, adata, AccesOptions);
}
}
return(adata);
}
public static TEnum?GetEnum <TEnum>(this IDataAccessor dataAccessor, string fieldname, TEnum?defaultValue, DataAccessorOptionEnum AccesOptions = 0) where TEnum : struct
{
TEnum? foo = defaultValue;
Object obj = dataAccessor.GetObject(fieldname, AccesOptions);
try
{
if (obj == null || obj == DBNull.Value || obj is System.DBNull)
{
foo = defaultValue;
}
else if (obj is string)
{
string objTypeIn = obj.ToString();
if (!string.IsNullOrWhiteSpace(objTypeIn))
{
foo = (TEnum)Enum.Parse(typeof(TEnum), objTypeIn);
if (!Enum.IsDefined(typeof(TEnum), foo) && !foo.ToString().Contains(","))
{
throw new InvalidOperationException(string.Format("{0} is not an underlying value of the YourEnum enumeration.", objTypeIn));
}
}
}
else if (obj is int || obj is short)
{
foo = (TEnum)obj;
}
else
{
throw new NotImplementedException(string.Format("Type {0} non géré", obj.GetType().ToString()));
}
}
catch (Exception ex)
{
if (!AccesOptions.HasFlag(DataAccessorOptionEnum.Safe))
{
throw new Exception("GetEnum " + ex.Message, ex);
}
}
return(foo);
}
public static string DynamicValues(this IDataAccessor dataAccessor, string formatingValues, Dictionary <string, string> transformFuctions = null, DataAccessorOptionEnum AccesOptions = DataAccessorOptionEnum.None)
{
try
{
// dynamisation de la chaine de caratère
string retour = FORMAT.StringTransform.DynamiseWithAccessor(formatingValues, dataAccessor);
// Transformation de la chaine finale selon une série d'instruction de transformation
if (transformFuctions != null)
{
retour = FORMAT.StringTransform.Transform(retour, transformFuctions);
}
return(retour);
}
catch (Exception ex)
{
if (!AccesOptions.HasFlag(DataAccessorOptionEnum.Safe))
{
throw new DataAccessorException("FormatingMultiValues " + ex.Message, ex);
}
return(string.Empty);
}
}
public static void FromDictionaryValues(this IDataAccessor dataAccessor, Dictionary <string, object> Values, DataAccessorOptionEnum AccesOptions = 0)
{
try
{
DataAccessorOptionEnum options = DataAccessorOptionEnum.None;
foreach (string itemkey in Values.Keys)
{
dataAccessor.SetObject(itemkey, Values[itemkey], options);
}
}
catch (Exception)
{
if (AccesOptions.HasFlag(DataAccessorOptionEnum.Safe))
{
return;
}
else
{
throw;
}
}
}
/// <summary>
/// Obtenir/Convertir en Double NULLABLE
/// </summary>
/// <param name="dataAccessor"></param>
/// <param name="nameValue"></param>
/// <param name="AccesOptions"></param>
/// <param name="defaultvalue"></param>
/// <returns></returns>
public static double?GetDouble(this IDataAccessor dataAccessor, string nameValue, DataAccessorOptionEnum AccesOptions, double?defaultvalue)
{
try
{
object obj = dataAccessor.GetObject(nameValue, AccesOptions);
if (obj == DBNull.Value || obj == null)
{
return(null);
}
else
{
return(Convert.ToDouble(obj));
}
}
catch (Exception ex)
{
if (!AccesOptions.HasFlag(DataAccessorOptionEnum.Safe))
{
throw new DataAccessorException("GetString " + ex.Message, ex);
}
throw;
}
}
/// <summary>
/// Défini un objet
/// </summary>
/// <returns></returns>
public bool SetData(string nameValue, object obj, DataAccessorOptionEnum AccesOptions)
{
try
{
if (string.IsNullOrWhiteSpace(nameValue))
{
return(false);
}
nameValue = nameValue.Trim();
if (nameValue.Contains(":"))
{ // Obtenir la valeur dans un datapo join à celui-ci
throw new Exception("DataPo In SubObject non géré");
}
else if (nameValue.StartsWith("/"))
{ // Obtenir la valeur dans le flux nosql lié
string fieldName = nameValue.Split('/')[1]; // le nom du champ est équivalent au nom du root
IDataPOFlow flow = this.GetFlow(fieldName);
if (flow == null)
{
return(false);
}
//bool iset = flow.SetObject(nameValue, obj, AccesOptions);
//if (iset) this.localRow.SetModified();
//return iset;
//!!!!!!!!!!!!
return(false);
}
else
{ // Obtien la valeur normalement dans le datarow local
if (this.localRow == null)
{
this.DefineSchemaPO(); // si pas de datarow, on l'initialiser (identique à GetRow())
}
System.Data.DataColumn realColumn = this.localRow.Table.Columns[nameValue];
if (realColumn == null)
{
if (AccesOptions.HasFlag(DataAccessorOptionEnum.NotCreateColumn)) // création de la colonne interdite
{
if (AccesOptions.HasFlag(DataAccessorOptionEnum.Safe))
{
return(false);
}
else
{
throw new Exception("Colonne Introuvable dans le DataRow (NotCreateColumn = true)");
}
}
else if (obj == null || obj == DBNull.Value) // si la valeur est null et que la valeur existe pas c'est pas la peine de créer une colone
{
return(false);
//if (AccesOptions.HasFlag(DataAccessorOptionEnum.Safe)) return false;
//else throw new Exception("Colonne Introuvable dans le DataRow (Impossible de déterminer le type à partir d'un null pour créer la colonne)");
}
// Création de la colone
Type typetocreate = obj.GetType();
realColumn = this.localRow.Table.CreateColumn(nameValue.ToLower(), typetocreate); // Création d'une nouvelle colonne dans la table pour stoker la valeur (toujours en minuscule)
}
object orgnobj = this.localRow[realColumn];
if (obj == null && orgnobj == null)
{
return(false); // inutile si pas modifié
}
if (obj != null && obj.Equals(orgnobj))
{
return(false); // inutile si pas modifié
}
if (AccesOptions.HasFlag(DataAccessorOptionEnum.IgnoreChange)) // il faut tromper le datarow pour lui faire croire que la donnée n'a pas été modifié
{
Dictionary <string, object> prechanged = DataSetTools.GetChangedValues(this.localRow); // on obtien les changements précédents
if (prechanged.Count > 0)
{
this.localRow.RejectChanges(); // on les rejetents pour les remettre après
}
this.localRow[realColumn] = obj; // on met à jours la données
this.localRow.AcceptChanges(); // on approuve la mise à jours
if (prechanged.Count > 0)
{
prechanged.Keys.ToList().ForEach(k => this.localRow[k] = prechanged[k]); // on remet les anciennes modifications
}
}
else
{
this.localRow[realColumn] = obj; // on met à jours la données dans le datarow , l'objet passera au statut modified
}
return(true);
}
}
catch (Exception ex)
{
if (AccesOptions.HasFlag(DataAccessorOptionEnum.Safe))
{
return(false);
}
else
{
throw new Exception("SetObject DataRow " + nameValue + " : " + ex.Message, ex);
}
}
finally
{
}
}