/// <summary> /// Permet de définir directement la structure de la table pour ce datarow, création d'une nouvelle si elle existe pas /// Ne fonctionnera /// </summary> /// <param name="nameTable"></param> /// <param name="ColsKeys"></param> public static void DefineSchemaPO(DataPO po, string nameTable, System.Data.DataColumn[] Cols, System.Data.DataColumn[] ColsKeys) { System.Data.DataTable table = null; table = DataSetTools.DefineDataTable(nameTable, Cols, ColsKeys); DefineSchemaPO(po, table); // itemcc.ReadOnly = false; // pas de readonly dans les bulles, sinon on ne peut plus modifier }
/// <summary> /// Permet de définir directement la structure du PO (Un nouveau Row a partir de la nouvelle table) /// </summary> /// <param name="po"></param> /// <param name="table"></param> /// <param name="AllowKeepOriginalRow">Si il y as déja un datarow avec des données, on préserve les données dans la nouvelle Table</param> public static void DefineSchemaPO(DataPO po, DataTable tableSchema, bool AllowKeepOriginalRow = true, bool CloneNewTable = true) { try { bool rowexisting = false; if (po.localRow != null && po.localRow.ItemArray != null && po.localRow.ItemArray.Length > 0) { rowexisting = true; // il y as des données dans le datarow existant } if (rowexisting && AllowKeepOriginalRow) //Clone un nouveau datarow dans la nouvelle table avec des données d'origine { po.localRow.Table.MergeAddSchema(tableSchema); // il suffit juste de vérifier que le shémas est bien identique } //po.localRow = DataSetTools.ReplaceRowInOtherTable(po.localRow, table); // premet de recopier les données orgininal dans la nouvelle table else { DataTable tabledata = CloneNewTable ? tableSchema.Clone() : tableSchema; // il faut clonner la table pour eviter les erreurs sur autoincrement, !!! voir si possible d'améliorer car multipli le temps de traitement x10 po.localRow = tabledata.NewRow(); // init simple } po._isDefined = true; } catch (Exception ex) { throw new Exception(string.Format("DefineSchemaPO {0}", ex.Message)); } }
public static Dictionary <string, object> GetChangedValues(this DataPO po) { bool refreshflow = (po.flows != null && po.flows.Count(f => f.IsChanges()) > 0); System.Data.DataRow row = po.GetRow(refreshflow); return(DataSetTools.GetChangedValues(row)); }
/// <summary> /// Présence de changements /// </summary> /// <returns></returns> public static bool IsChanges(this DataPO item) { // On regarde si il y as eu un changement dans les flow if (item.flows != null && item.flows.Count(f => f.IsChanges()) > 0) { return(true); } // on regarde si il y as eu un changement dans le datarow if (item.localRow == null) { return(false); } else if (item.localRow.RowState.HasFlag(System.Data.DataRowState.Modified)) { return(true); } else if (item.localRow.RowState.HasFlag(System.Data.DataRowState.Detached)) { return(true); // on considere que les datarow Detached nécesite un Insert donc ils nécessiteront un traitement } else { return(false); } }
//(System.Data.DataTable ret, object paramconstructeur = null) where Tobj : DATA.DATAPO.DataPO, new() /// <summary> /// Désérialisation des données /// </summary> /// <param name="SerialInputData">Données sérialisé</param> /// <returns></returns> public DataPO DeserializationDatas(string SerialInputData, DataPO orgnPo = null) { if (string.IsNullOrWhiteSpace(SerialInputData)) { return(null); } DataPO retour = orgnPo; try { System.Data.DataTable ret = new DataTable(); //if(retour==null)retour = new //string[] orgstringT = orgstring.Split(new string[] { "[[!!" }, StringSplitOptions.RemoveEmptyEntries); //foreach (string orgstringTitem in orgstringT) //{ // string nameValue = orgstringTitem.Substring(0, orgstringTitem.IndexOf("!!]]") + 1); // string value = orgstringTitem.Substring((nameValue.Length + 4) - 1); // retour.Add(nameValue, value); //} //return retour; return(retour); } catch (Exception ex) { throw new Exception("DeserializationDatas " + ex.Message, ex); } }
/// <summary> /// Obtientir les données du DataPO /// </summary> /// <returns></returns> public static Dictionary <string, object> GetValues(this DataPO po, bool returnKeys, bool returnValues) { System.Data.DataRow row = po.GetRow(returnValues);// Si les valeurs sont demandé on refresh les flow if (returnKeys && !IsDefinedSchema(po)) { DefineSchemaPO(po); // Si l'objet est pas définis il faut le daire } return(DataSetTools.GetValues(row, returnKeys, returnValues)); }
/// <summary> /// Obtient toute les valeurs des propriétées déclarées dans la classe (PAR REFLEXION) /// </summary> /// <returns></returns> public static Dictionary <string, object> GetDeclaredValues(this DataPO po) { Dictionary <string, object> dict = new Dictionary <string, object>(); foreach (PropertyInfo prp in APP.CODE.PropertiesTools.GetProperties(po.GetType())) { object value = prp.GetValue(po, new object[] { }); dict.Add(prp.Name, value); } return(dict); }
/// <summary> /// Savoir si le datapo à été correctement défini pour des actions SQL /// </summary> /// <param name="po"></param> /// <returns></returns> public static bool IsDefinedSchema(this DataPO po) { if (po == null) { return(false); } if (po.GetRow() == null) { return(false); } if (!po._isDefined) { return(false); } return(true); }
//public static System.Data.DataTable CreateSchemaOnPO(DataPO po) //{ // System.Data.DataTable tableStd = null; // if (tableStd == null) tableStd = po.InitSchema(); // sinon on tente avec la prédéinition hérité // if (tableStd == null) tableStd = CreateSchemaWithAttributes(po);// sinon on tente de mettre l'objet en cache avec les attributs // return tableStd; //} public static System.Data.DataTable CreateSchemaOnPO(Type potype) { System.Data.DataTable tableStd = null; if (tableStd == null) // La structure est defini dans une methode hérité. { // sinon on tente avec la prédéinition hérité, mais pour cela il faut instancier un objet (!!! gérer si constructeur non vide) DataPO pofictif = APP.CODE.ReflectionTools.NewInstance(potype) as DataPO; tableStd = pofictif.InitSchema(); } // sinon on tente de voir si l'objet dispose d'attributs spécifiant sa structure if (tableStd == null) { tableStd = CreateSchemaWithAttributes(potype); } return(tableStd); }
/// <summary> /// Obtientir les données du DataPO /// </summary> /// <returns></returns> public static Dictionary <string, object> GetValues(this DataPO po, params string[] ColNames) { if (ColNames == null || ColNames.Length == 0) { return(new Dictionary <string, object>()); } bool refreshflow = false; if (po.flows != null && po.flows.Count > 0) { refreshflow = po.flows.Select(f => f.GetFieldName()).Where(fn => !string.IsNullOrWhiteSpace(fn)).Any(fn => ColNames.Any(eq => fn.Equals(eq, StringComparison.OrdinalIgnoreCase))); } System.Data.DataRow row = po.GetRow(refreshflow); return(DataSetTools.GetValues(row, ColNames)); }
private List <DATAPO.DataPO> GetAllInternal(DataPO po) { Type typepo = po.GetType(); PropertyInfo[] properties = typepo.GetProperties(BindingFlags.Public | BindingFlags.Instance); List <DATAPO.DataPO> retour = new List <DataPO>(); foreach (PropertyInfo prp in properties) { // Only work with strings //if (prp.DeclaringType != typeof(DATAPO.DataPO)) { continue; } // If not writable then cannot null it; if not readable then cannot check it's value if (!prp.CanWrite || !prp.CanRead) { continue; } //if(prp.) object objval = null; try { objval = prp.GetValue(po, new object[] { }); } catch (Exception) // fnc a revoir { continue; } if (!(objval is DATAPO.DataPO)) { continue; } DATAPO.DataPO value = objval as DATAPO.DataPO; if (value == null) { continue; } //dict.Add(prp.Name, value); retour.Add(value); } return(retour); }
/// <summary> /// Permet de preparer l'objet (notament définir le datarow et son schema) /// C'est nécessaire pour les opérations SQL, ou l'instanciation vide d'un DATAPO /// </summary> /// <param name="po"></param> /// <returns></returns> public static void DefineSchemaPO(this DataPO po, bool allowCache = true) { try { if (po == null) { return; } Type potype = po.GetType(); System.Data.DataTable tableStd = DataPOTools.GetSchemaOnPO(potype, allowCache); // on prend un clone de la table DefineSchemaPO(po, tableStd, true); // voir si il est possible d'améliorer pour ne pas prendre de clone !!! (faire le clone que si il y as modification des colonnes) } catch (Exception ex) { throw new Exception(string.Format("InitalizeDataPo {0}", ex.Message)); } }
/// <summary> /// Sérialiser le Datapo /// </summary> /// <param name="po">Objet racine à sérialiser</param> /// <param name="includeInternalPO">Inclure les sous objets</param> /// <param name="fromProperty">Pour les sérialisations en boucles</param> /// <returns>string sérialiser custom</returns> public static string SerializeDatas(DataPO po, bool includeInternalPO = true, PropertyInfo fromProperty = null) { try { StringBuilder retour = new StringBuilder(); retour.Append("[[$"); System.Data.DataRow rowd = po.GetRow(); string strd = MANIPULATE.DATASET.DataTableTools.SerializeDataRow(rowd); if (!string.IsNullOrEmpty(strd)) { retour.Append("[[!dataxml!]]"); retour.Append(strd); retour.AppendLine(); } if (!includeInternalPO) { return(retour.ToString()); } Type typepo = po.GetType(); PropertyInfo[] properties = typepo.GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (PropertyInfo propertie in properties) { string strproper = ToDatasXMLProperty(propertie, po); if (string.IsNullOrWhiteSpace(strproper)) { continue; } retour.AppendFormat("[[!{0}!]]", propertie.Name); retour.Append(strproper); retour.AppendLine(); } retour.Append("$]]"); return(retour.ToString()); } catch (Exception ex) { throw new Exception("GetDatasXML" + ex.Message, ex); } }
/// <summary> /// Définit les valeur dans le datarow dans l'objet /// </summary> /// <param name="row">L'objet de données</param> public static void SetValues(this DataPO po, Dictionary <string, object> DicDataRow) { try { if (po.localRow == null) { po.DefineSchemaPO(); // si pas de datarow, on l'initialise (identique à GetRow()) } foreach (var item in DicDataRow) { po.SetObject(item.Key, item.Value); } //po._isLoaded = false; // N'a pas été chargé depuis une base de données !!! voir comment on fait } catch (Exception ex) { throw new Exception("SetValues " + ex.Message, ex); } }
private string ToDatasXMLProperty(PropertyInfo property, DataPO po) { if (property == null || po == null) { return(null); } try { // !!! filtrer les types innutiles object val = property.GetValue(po, null); if (val == null) { return(null); } if (val is DataPO) { string str = this.SerializeDatas((DataPO)val, true, property); return(str); } var attributes = property.GetCustomAttributes(true); foreach (var item in attributes) { if (item is DATAPO.JoinPOAttribute) { if (val is List <DataPO> ) // si c'est une liste { return(this.ToDatasXMLMultiPos(property, (List <DataPO>)val)); } } } return(null); } catch (Exception) { return(null); throw; } }
public DataPO GetOrInstanciateInternalPO(DataPO poOrgn, string propName, bool allowInstanciate = true) //where Tobj : DATA.DATAPO.DataPO, new() { DataPO retour = null; Type poType = poOrgn.GetType(); PropertyInfo poProperty = poType.GetProperty(propName); object poino = poProperty.GetValue(poOrgn, null); if (poino != null) { if (poino is DataPO) { retour = (DataPO)poino; } else { return(null); // erreur dans les types } } if (retour == null) { retour = (DataPO)Activator.CreateInstance(poProperty.PropertyType); } return(retour); }
private static System.Data.DataTable CreateSchemaWithAttributes(DataPO po) { Type potype = po.GetType(); return(CreateSchemaWithAttributes(potype)); }
public IEnumerable <Tobj> GetOrInstanciateInternalPOs <Tobj>(DataPO poOrgn, string propName, bool allowInstanciate = true) where Tobj : DATAPO.DataPO, new() { return(null); }