//------------------------------------------------
        public CResultAErreur ImportTable(
            DataTable table,
            CContexteImportDonnee contexteImport,
            IIndicateurProgression indicateur)
        {
            CResultAErreur result = CResultAErreur.True;

            Dictionary <DataRow, DataRow> m_dicSourceToDest = new Dictionary <DataRow, DataRow>();

            contexteImport.TableSource = table;
            int nNbDoTo = table.Rows.Count;

            if (contexteImport.StartLine != null)
            {
                nNbDoTo -= contexteImport.StartLine.Value;
            }
            if (contexteImport.EndLine != null)
            {
                nNbDoTo -= (table.Rows.Count - contexteImport.EndLine.Value) - 1;
            }
            int nNbDone = 0;

            if (indicateur != null)
            {
                indicateur.SetBornesSegment(0, nNbDoTo);
            }
            int nStart = contexteImport.StartLine == null ? 0 : contexteImport.StartLine.Value;
            int nEnd   = contexteImport.EndLine == null ? table.Rows.Count - 1 : Math.Min(contexteImport.EndLine.Value, table.Rows.Count - 1);

            for (int nRowIndex = nStart; nRowIndex <= nEnd; nRowIndex++)
            {
                DataRow row = table.Rows[nRowIndex];
                if (indicateur != null)
                {
                    indicateur.SetInfo(I.T("Import line @1|20106", nRowIndex.ToString()));
                }
                contexteImport.StartImportRow(row, nRowIndex);
                result = ImportRow(row, contexteImport, null, false);
                nNbDone++;
                if (indicateur != null)
                {
                    indicateur.SetValue(nNbDone);
                }
                if (!result)
                {
                    contexteImport.AddLog(new CLigneLogImport(
                                              ETypeLigneLogImport.Error,
                                              row,
                                              null,
                                              contexteImport,
                                              I.T("Error on line import|20102")));
                    if (!contexteImport.BestEffort)
                    {
                        return(result);
                    }
                    result = CResultAErreur.True;
                }
            }
            return(result);
        }
Beispiel #2
0
        //--------------------------------------------------------
        public virtual bool ShouldImport(DataRow row, CContexteImportDonnee contexte)
        {
            switch (m_optionImport)
            {
            case EOptionImport.OnCreate:
                if (row.RowState != DataRowState.Added)
                {
                    return(false);
                }
                break;

            case EOptionImport.Never:
                return(false);
            }
            if (Condition != null && !(Condition is C2iExpressionVrai))
            {
                CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(row);
                CResultAErreur result             = Condition.Eval(ctx);
                if (!result)
                {
                    result.EmpileErreur(I.T("Error on condition formula '@1'|20103",
                                            Condition.GetString()));
                    contexte.AddLog(new CLigneLogImport(ETypeLigneLogImport.Error,
                                                        row,
                                                        "",
                                                        contexte,
                                                        result.Erreur.ToString()));
                    return(false);
                }
                return(CUtilBool.BoolFromObject(result.Data));
            }
            return(true);
        }
        //------------------------------------------------
        public CResultAErreur ImportRow(DataRow row, CContexteImportDonnee contexteImport, CObjetDonnee parent)
        {
            CResultAErreur result = CResultAErreur.True;

            if (MappagesEntitesFilles.Count() == 0)
            {
                return(result);
            }
            CResultAErreurType <CValeursImportFixe> resFixe = GetValeursFixesPourFilles(parent);

            if (!resFixe)
            {
                result.EmpileErreur(resFixe.Erreur);
                return(resFixe);
            }
            foreach (CMappageEntiteFille mappage in MappagesEntitesFilles)
            {
                if (mappage.Source != null && mappage.ConfigMappage != null)
                {
                    if (!mappage.Source.ShouldImport(row, contexteImport))
                    {
                        contexteImport.AddLog(new CLigneLogImport(ETypeLigneLogImport.Error,
                                                                  row,
                                                                  mappage.Source.LibelleSource,
                                                                  contexteImport,
                                                                  I.T("Line was not imported due to import options or condition|20104")));
                    }
                    else
                    {
                        result = mappage.ConfigMappage.ImportRow(row, contexteImport, resFixe.DataType, false);
                        if (!result)
                        {
                            return(result);
                        }
                    }
                }
            }
            return(result);
        }
        //------------------------------------------------
        private CResultAErreur UpdateObjet(
            DataRow row,
            CObjetDonnee objet,
            bool bIsNewObject,
            CContexteImportDonnee contexteImport,
            CValeursImportFixe valeursFixes)
        {
            CResultAErreur result = CResultAErreur.True;

            foreach (CMappageChampSimple mappage in MappagesChampsSimples)
            {
                if (mappage.Source != null && mappage.Source.ShouldImport(row, contexteImport))
                {
                    try
                    {
                        contexteImport.PushChamp(mappage.Propriete);
                        result = mappage.GetValue(row, contexteImport);
                        if (!result)
                        {
                            contexteImport.AddLog(new CLigneLogImport(
                                                      ETypeLigneLogImport.Error,
                                                      row,
                                                      mappage.Source.LibelleSource,
                                                      contexteImport,
                                                      result.Erreur.ToString()));
                            return(result);
                        }

                        try
                        {
                            CInterpreteurProprieteDynamique.SetValue(objet, mappage.Propriete, result.Data);

                            //Stockage valeur témoin
                            CSourceSmartImportField sourceField = mappage.Source as CSourceSmartImportField;
                            if (sourceField != null)
                            {
                                result = CInterpreteurProprieteDynamique.GetValue(objet, mappage.Propriete);
                                if (result)
                                {
                                    contexteImport.SetValeurTemoin(sourceField.NomChampSource, result.Data);
                                }
                                result = CResultAErreur.True;
                            }
                        }
                        catch (Exception e)
                        {
                            result.EmpileErreur(new CErreurException(e));
                            result.EmpileErreur(I.T("Error while affecting value @1 to field @2|20097",
                                                    result.Data == null ? "null" : result.Data.ToString()));
                            contexteImport.AddLog(new CLigneLogImport(
                                                      ETypeLigneLogImport.Error,
                                                      row,
                                                      mappage.Source.LibelleSource,
                                                      contexteImport,
                                                      result.Erreur.ToString()));
                            return(result);
                        }
                    }
                    finally
                    {
                        contexteImport.PopChamp();
                    }
                }
            }

            foreach (CMappageEntiteParente mapParent in MappagesEntitesParentes)
            {
                if (mapParent.Source != null && mapParent.Source.ShouldImport(row, contexteImport))
                {
                    try
                    {
                        contexteImport.PushChamp(mapParent.Propriete);

                        CResultAErreurType <CObjetDonnee> resObjet = mapParent.GetObjetAssocie(row, contexteImport, true);
                        if (!resObjet)
                        {
                            contexteImport.AddLog(new CLigneLogImport(
                                                      ETypeLigneLogImport.Error,
                                                      row,
                                                      mapParent.Source.LibelleSource,
                                                      contexteImport,
                                                      resObjet.MessageErreur));
                        }
                        else
                        {
                            try
                            {
                                if (mapParent.AlternativeSetMethodInfo != null)
                                {
                                    mapParent.AlternativeSetMethodInfo.Invoke(objet, new object[] { resObjet.DataType });
                                }
                                else
                                {
                                    result = CInterpreteurProprieteDynamique.SetValue(objet, mapParent.Propriete, resObjet.DataType);
                                    if (!result && mapParent.Propriete is CDefinitionProprieteDynamiqueDotNet)
                                    {
                                        //Tente affectation via fonction spécifique
                                        PropertyInfo info = objet.GetType().GetProperty(mapParent.Propriete.NomProprieteSansCleTypeChamp);
                                        if (info != null)
                                        {
                                            SpecificImportSetAttribute spec = info.GetCustomAttribute <SpecificImportSetAttribute>(true);
                                            if (spec != null)
                                            {
                                                MethodInfo method = objet.GetType().GetMethod(spec.NomMethodeSetSpecifique);
                                                if (method != null)
                                                {
                                                    method.Invoke(objet, new object[] { resObjet.DataType });
                                                }
                                                mapParent.AlternativeSetMethodInfo = method;
                                            }
                                        }
                                    }
                                }
                            }
                            catch (Exception e)
                            {
                                result.EmpileErreur(new CErreurException(e));
                                result.EmpileErreur(I.T("Error while affecting value @1 to field @2|20097",
                                                        result.Data == null ? "null" : result.Data.ToString()));
                                contexteImport.AddLog(new CLigneLogImport(
                                                          ETypeLigneLogImport.Error,
                                                          row,
                                                          mapParent.Source.LibelleSource,
                                                          contexteImport,
                                                          result.Erreur.ToString()));
                                return(result);
                            }
                        }
                    }
                    finally
                    {
                        contexteImport.PopChamp();
                    }
                }
            }

            if (valeursFixes != null)
            {
                foreach (KeyValuePair <string, object> kv in valeursFixes.ValeursFixes)
                {
                    objet.Row[kv.Key] = kv.Value == null ? DBNull.Value : kv.Value;
                }
            }

            foreach (CMappageEntitesFilles mapFille in m_listeMappagesFilles)
            {
                try
                {
                    contexteImport.PushChamp(mapFille.Propriete);
                    result = mapFille.ImportRow(row, contexteImport, objet);
                    if (!result)
                    {
                        contexteImport.AddLog(new CLigneLogImport(
                                                  ETypeLigneLogImport.Error,
                                                  row,
                                                  "",
                                                  contexteImport,
                                                  result.Erreur.ToString()));
                        result = CResultAErreur.True;
                    }
                }
                finally
                {
                    contexteImport.PopChamp();
                }
            }

            return(result);
        }
        //------------------------------------------------
        public CResultAErreur ImportRow(
            DataRow row,
            CContexteImportDonnee contexteImport,
            CValeursImportFixe valeursFixes,
            bool bIsRoot)
        {
            CResultAErreur result = CResultAErreur.True;

            contexteImport.PushIdConfigMappage(IdMappage);
            try
            {
                string strFiltre = "";
                CResultAErreurType <CObjetDonnee> resObjet = FindObjet(row, contexteImport, valeursFixes, ref strFiltre);
                if (!resObjet)
                {
                    contexteImport.AddLog(new CLigneLogImport(
                                              ETypeLigneLogImport.Error,
                                              row,
                                              "",
                                              contexteImport,
                                              resObjet.Erreur.ToString()));
                    result.EmpileErreur(resObjet.Erreur);
                    return(result);
                }
                if (resObjet.DataType == null && this.OptionCreation == EOptionCreationElementImport.None)
                {
                    contexteImport.AddLog(new CLigneLogImport(
                                              ETypeLigneLogImport.Alert,
                                              row,
                                              "",
                                              contexteImport,
                                              I.T("Line not imported because creation is forbidden for this element|20095")));
                    return(result);
                }

                CObjetDonnee objet  = resObjet.DataType;
                bool         bIsNew = false;
                if (objet == null)
                {
                    bIsNew = true;
                    //Création
                    try
                    {
                        objet = Activator.CreateInstance(TypeEntite, new object[] { contexteImport.ContexteDonnee }) as CObjetDonnee;
                    }
                    catch { }
                    if (objet == null)
                    {
                        result.EmpileErreur(I.T("Error while creating object @1|20096", DynamicClassAttribute.GetNomConvivial(TypeEntite)));
                        contexteImport.AddLog(new CLigneLogImport(
                                                  ETypeLigneLogImport.Error,
                                                  row,
                                                  null,
                                                  contexteImport,
                                                  result.Erreur.ToString()));
                        return(result);
                    }
                    if (objet is CObjetDonneeAIdNumeriqueAuto)
                    {
                        ((CObjetDonneeAIdNumeriqueAuto)objet).CreateNewInCurrentContexte();
                    }
                    else
                    {
                        objet.CreateNewInCurrentContexte(null);
                    }
                    contexteImport.AddElementQuiAEteAjoute(objet);
                    contexteImport.SetEntiteForFiltre(strFiltre, objet);
                }

                if (bIsRoot)
                {
                    contexteImport.SetElementPourLigne(contexteImport.CurrentRowIndex, objet);
                }

                contexteImport.SetObjetImporteForIdMappage(IdMappage, objet);

                result = UpdateObjet(row, objet, bIsNew, contexteImport, valeursFixes);
                if (!result)
                {
                    contexteImport.AddLog(new CLigneLogImport(
                                              ETypeLigneLogImport.Error,
                                              row,
                                              "",
                                              contexteImport,
                                              result.Erreur.ToString()));
                    return(result);
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }
            finally
            {
                contexteImport.PopIdConfigMappage();
            }
            return(result);
        }