public void SetContexteDonnee(CContexteDonnee contexte)
{
m_contexteDonnee = contexte;
//Crée une nouvelle baseplanning dans ce contexte;
CFournisseurEntreesPlanning newBase = new CFournisseurEntreesPlanning(contexte);
if (m_basePlanning != null)
{
foreach (IElementAIntervention elt in m_basePlanning.ElementsAIntervention)
{
if (elt is CObjetDonnee)
{
CObjetDonnee newElt = (CObjetDonnee)Activator.CreateInstance(elt.GetType(), contexte);
if (newElt.ReadIfExists(((CObjetDonnee)elt).GetValeursCles()))
{
newBase.AddElementAIntervention((IElementAIntervention)newElt);
}
}
}
foreach (IRessourceEntreePlanning ressource in m_basePlanning.Ressources)
{
if (ressource is CObjetDonnee)
{
CObjetDonnee newElt = (CObjetDonnee)Activator.CreateInstance(ressource.GetType(), contexte);
if (newElt.ReadIfExists(((CObjetDonnee)ressource).GetValeursCles()))
{
newBase.AddRessource((IRessourceEntreePlanning)newElt);
}
}
}
}
m_basePlanning = newBase;
m_controlePlanning.BaseAffichee = m_basePlanning;
FillListeInterventionsAPlanifier();
}
//--------------------------------------------
public static bool SetParentViaPropriete(CAssociationTiag associationTiag, object obj, object[] valeursCles)
{
if (valeursCles.Length != 1)
{
return(false);
}
CObjetDonnee objet = obj as CObjetDonnee;
if (objet == null)
{
return(false);
}
PropertyInfo info = objet.GetType().GetProperty(associationTiag.Propriete);
if (info != null)
{
MethodInfo method = info.GetSetMethod();
if (method != null)
{
CObjetDonnee parent = Activator.CreateInstance(associationTiag.TypeParent, new object[] { objet.ContexteDonnee }) as CObjetDonnee;
if (parent.ReadIfExists(valeursCles))
{
method.Invoke(obj, new object[] { parent });
return(true);
}
}
}
return(false);
}
//----------------------------------------------------
public static CObjetDonnee GetObjet(this CDbKey key, CContexteDonnee contexte, Type typeObjet)
{
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(typeObjet, new object[] { contexte });
if (objet.ReadIfExists(key))
{
return(objet);
}
return(null);
}
/// ///////////////////////////////////////
public virtual CObjetDonnee GetObjet(CContexteDonnee contexte)
{
CObjetDonnee obj = (CObjetDonnee)Activator.CreateInstance(m_typeObjet, new object[] { contexte });
if (m_keyObjet != null)
{
if (obj.ReadIfExists(m_keyObjet))
{
return(obj);
}
}
// Modif YK 10/10/2008: Utiliser le ReadIfExiste c'est meiux que le PointeSurLigne
//obj.PointeSurLigne ( m_cles );
if (m_cles != null && m_cles.Length > 0 && obj.ReadIfExists(m_cles))
{
return(obj);
}
return(null);
}
//-------------------------------------------------
public CObjetDonnee GetObjet(CContexteDonnee ctx)
{
if (m_typeObjet != null && m_keyObjet != null)
{
CObjetDonnee objet = Activator.CreateInstance(m_typeObjet, new object[] { ctx }) as CObjetDonnee;
if (objet != null && objet.ReadIfExists(m_keyObjet))
{
return(objet);
}
}
return(null);
}
/// <summary>
/// retourne l'objet donné sélectionné à partir de la valeur retournée
/// </summary>
/// <remarks>
/// Ne fonctionne pas toujours, ça ne fonctionne que si la valeur retournée
/// est un champ DOTNET de l'entité sélectionnée
/// </remarks>
/// <param name="valeurRetournee"></param>
/// <param name="contexte"></param>
/// <returns></returns>
public CReferenceObjetDonnee GetObjetFromValeurRetournee(object valeurRetournee)
{
if (valeurRetournee == null)
{
return(null);
}
C2iExpressionChamp exp = ExpressionRetournee as C2iExpressionChamp;
if (exp != null)
{
CDefinitionProprieteDynamique propDyn = exp.DefinitionPropriete;
CDefinitionProprieteDynamiqueDotNet defDotNet = propDyn as CDefinitionProprieteDynamiqueDotNet;
if (defDotNet != null)
{
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(m_filtreSelection.TypeElements, new object[] { CContexteDonneeSysteme.GetInstance() });
CStructureTable structure = CStructureTable.GetStructure(m_filtreSelection.TypeElements);
CInfoChampTable info = structure.GetChampFromPropriete(defDotNet.NomProprieteSansCleTypeChamp);
if (info != null)
{
CResultAErreur result = m_filtreSelection.GetFiltreData();
CFiltreData filtre = null;
if (result && result.Data is CFiltreData)
{
filtre = result.Data as CFiltreData;
}
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(info.NomChamp + "=@1",
valeurRetournee));
if (objet.ReadIfExists(filtre))
{
return(new CReferenceObjetDonnee(objet));
}
}
}
}
return(null);
}
//------------------------------------
private CResultAErreur ImporteRow(DataRow row, CFiltreData filtreCle, CContexteDonnee contexteDestination)
{
CResultAErreur result = CResultAErreur.True;
Dictionary <CDefinitionProprieteDynamique, object> dicValeurs = new Dictionary <CDefinitionProprieteDynamique, object>();
List <object> lstValeurs = new List <object>();
if (filtreCle != null)
{
filtreCle.Parametres.Clear();
}
foreach (CMappageChampImport mappage in Mappages)
{
object valeur = mappage.Origine.GetValeur(row);
if (mappage.IsCle && filtreCle != null)
{
if (valeur == null)
{
result.EmpileErreur("Can not import field @1 as key, because imported value is null|20045", mappage.ProprieteDestination.Nom);
return(result);
}
filtreCle.Parametres.Add(valeur);
}
dicValeurs[mappage.ProprieteDestination] = valeur;
}
CObjetDonnee objet = Activator.CreateInstance(m_typeCible, new object[] { contexteDestination }) as CObjetDonnee;
bool bCreate = true;
//Cherche si l'objet exite
if (filtreCle != null)
{
bCreate = !objet.ReadIfExists(filtreCle, !m_bChargerTouteLaCible);
}
if (bCreate && (OptionImport & EOptionImport.Create) != EOptionImport.Create)
{
return(result);
}
if (!bCreate && (OptionImport & EOptionImport.Update) != EOptionImport.Update)
{
return(result);
}
if (bCreate)
{
objet.CreateNewInCurrentContexte(null);
}
bool bUpdate = false;
foreach (KeyValuePair <CDefinitionProprieteDynamique, object> kv in dicValeurs)
{
object val = kv.Value;
if (kv.Value is int && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(kv.Key.TypeDonnee.TypeDotNetNatif))
{
CObjetDonneeAIdNumerique obj = Activator.CreateInstance(kv.Key.TypeDonnee.TypeDotNetNatif, new object[] { contexteDestination }) as CObjetDonneeAIdNumerique;
if (!obj.ReadIfExists((int)kv.Value, !m_bChargerTouteLaCible))
{
obj = null;
}
val = obj;
}
result = CInterpreteurProprieteDynamique.GetValue(objet, kv.Key);
if (result)
{
object valeurOrigine = result.Data;
if ((val == null && valeurOrigine != null) ||
(valeurOrigine == null && val != null) ||
(val != null && valeurOrigine != null && !val.Equals(valeurOrigine)))
{
result = CInterpreteurProprieteDynamique.SetValue(objet, kv.Key, val);
if (!result)
{
return(result);
}
bUpdate = true;
}
}
}
if (bCreate)
{
m_nNbCreated++;
}
else if (bUpdate)
{
m_nNbUpdated++;
}
return(result);
}
//------------------------------------------------
public CResultAErreurType <CObjetDonnee> FindObjet(
DataRow rowSource,
CContexteImportDonnee contexteImport,
CValeursImportFixe valeursFixes,
ref string strFiltre)
{
CResultAErreurType <CObjetDonnee> resObjet = new CResultAErreurType <CObjetDonnee>();
CResultAErreur res = CResultAErreur.True;
StringBuilder blFiltre = new StringBuilder();
if (valeursFixes != null)
{
foreach (KeyValuePair <string, object> kv in valeursFixes.ValeursFixes)
{
blFiltre.Append(kv.Key);
blFiltre.Append("=");
blFiltre.Append(kv.Value == null ? "null" : kv.Value.ToString());
blFiltre.Append(";");
}
}
//Création du filtre
CComposantFiltreDynamiqueEt compoPrincipal = new CComposantFiltreDynamiqueEt();
//Recherche à partir des champs simples
foreach (CMappageChampSimple mapSimple in MappagesChampsSimples)
{
if (mapSimple.UseAsKey)
{
res = mapSimple.GetValue(rowSource, contexteImport);
if (!res)
{
res.EmpileErreur(I.T("Erreur while searching object|20093"));
resObjet.EmpileErreur(res.Erreur);
return(resObjet);
}
//Stockage valeur témoin
CSourceSmartImportField sourceField = mapSimple.Source as CSourceSmartImportField;
if (sourceField != null)
{
contexteImport.SetValeurTemoin(sourceField.NomChampSource, res.Data);
}
blFiltre.Append(mapSimple.Propriete.NomPropriete);
if (res.Data == null)
{
CComposantFiltreDynamiqueTestNull testNull = new CComposantFiltreDynamiqueTestNull();
testNull.Champ = mapSimple.Propriete;
testNull.TestNull = true;
compoPrincipal.AddComposantFils(testNull);
blFiltre.Append("=null;");
}
else
{
CComposantFiltreDynamiqueValeurChamp testValeur = new CComposantFiltreDynamiqueValeurChamp();
testValeur.Champ = mapSimple.Propriete;
testValeur.IdOperateur = CComposantFiltreOperateur.c_IdOperateurEgal;
testValeur.ExpressionValeur = new C2iExpressionConstante(res.Data);
compoPrincipal.AddComposantFils(testValeur);
blFiltre.Append("=");
blFiltre.Append(res.Data.ToString());
blFiltre.Append(";");
}
}
}
//Recherche à partir des objets parents
foreach (CMappageEntiteParente mapParent in m_listeMappagesParents)
{
if (mapParent.UseAsKey)
{
CResultAErreurType <CObjetDonnee> resParent = mapParent.GetObjetAssocie(rowSource, contexteImport, false);
if (!resParent)
{
resObjet.EmpileErreur(resParent.Erreur);
return(resObjet);
}
CObjetDonneeAIdNumerique objetId = resParent.DataType as CObjetDonneeAIdNumerique;
CDefinitionProprieteDynamique defId = null;
object valeurTest = null;
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(mapParent.Propriete.TypeDonnee.TypeDotNetNatif))
{
defId = new CDefinitionProprieteDynamiqueDotNet(
"Id",
"Id",
new CTypeResultatExpression(typeof(int), false),
false,
true, "");
defId.InsereParent(mapParent.Propriete);
valeurTest = objetId != null?objetId.Id:-1;
}
else if (CObjetDonnee.TypeManageIdUniversel(mapParent.Propriete.TypeDonnee.TypeDotNetNatif))
{
defId = new CDefinitionProprieteDynamiqueDotNet("Universal id",
"IdUniversel",
new CTypeResultatExpression(typeof(string), false),
false, true, "");
defId.InsereParent(mapParent.Propriete);
valeurTest = resParent.DataType != null ? resParent.DataType.IdUniversel : null;
}
else
{
resObjet.EmpileErreur(I.T("Can not search objet of type @1|20094",
DynamicClassAttribute.GetNomConvivial(mapParent.Propriete.TypeDonnee.TypeDotNetNatif)));
return(resObjet);
}
blFiltre.Append(defId.NomPropriete);
if (resParent.DataType == null)
{
CComposantFiltreDynamiqueTestNull testNull = new CComposantFiltreDynamiqueTestNull();
testNull.Champ = defId;
testNull.TestNull = true;
compoPrincipal.AddComposantFils(testNull);
blFiltre.Append("=null;");
}
else
{
CComposantFiltreDynamiqueValeurChamp testValeur = new CComposantFiltreDynamiqueValeurChamp();
testValeur.Champ = defId;
testValeur.IdOperateur = CComposantFiltreOperateur.c_IdOperateurEgal;
testValeur.ExpressionValeur = new C2iExpressionConstante(valeurTest);
compoPrincipal.AddComposantFils(testValeur);
blFiltre.Append("=");
blFiltre.Append(valeurTest.ToString());
blFiltre.Append(";");
}
}
}
if (blFiltre.Length == 0)//Pas de filtre
{
return(resObjet);
}
strFiltre = blFiltre.ToString();
CObjetDonnee objet = contexteImport.GetEntiteForFiltre(TypeEntite, strFiltre);
if (objet != null)
{
resObjet.DataType = objet;
return(resObjet);
}
CFiltreDynamique filtre = new CFiltreDynamique(contexteImport.ContexteDonnee);
filtre.TypeElements = TypeEntite;
filtre.ComposantPrincipal = compoPrincipal;
res = filtre.GetFiltreData();
if (res && res.Data is CFiltreDataAvance)
{
if (valeursFixes != null)
{
CFiltreDataAvance filtreData = res.Data as CFiltreDataAvance;
StringBuilder blAdd = new StringBuilder();
int nParam = filtreData.Parametres.Count + 1;
foreach (KeyValuePair <string, object> kv in valeursFixes.ValeursFixes)
{
if (kv.Value == null)
{
blAdd.Append("HasNo(");
blAdd.Append(kv.Key);
blAdd.Append(") and ");
}
else
{
blAdd.Append(kv.Key);
blAdd.Append("=@");
blAdd.Append((nParam++));
blAdd.Append(" and ");
filtreData.Parametres.Add(kv.Value);
}
}
blAdd.Remove(blAdd.Length - 5, 5);
if (filtreData.Filtre.Length > 0)
{
blAdd.Insert(0, " and ");
}
filtreData.Filtre += blAdd;
}
objet = Activator.CreateInstance(TypeEntite, new object[] { contexteImport.ContexteDonnee }) as CObjetDonnee;
if (objet.ReadIfExists(((CFiltreData)res.Data)))
{
contexteImport.SetEntiteForFiltre(strFiltre, objet);
resObjet.DataType = objet;
return(resObjet);
}
}
else
{
res.EmpileErreur(I.T("Erreur while searching object|20093"));
resObjet.EmpileErreur(res.Erreur);
return(resObjet);
}
return(resObjet);
}
