Exemplo n.º 1
0
        protected override void Command()
        {
            try
            {
                var ListeComposants = MdlBase.ListerComposants(false);

                eTypeCorps Filtre = eTypeCorps.Barre | eTypeCorps.Tole;

                var Dic = new HashSet <String>();

                Boolean Erreur = false;

                Predicate <Feature> Test =
                    f =>
                {
                    BodyFolder dossier = f.GetSpecificFeature2();
                    if (dossier.IsRef() && dossier.eNbCorps() > 0 && Filtre.HasFlag(dossier.eTypeDeDossier()))
                    {
                        var RefDossier = dossier.eProp(CONSTANTES.REF_DOSSIER);
                        if (String.IsNullOrWhiteSpace(RefDossier))
                        {
                            return(true);
                        }
                    }

                    return(false);
                };

                foreach (var mdl in ListeComposants.Keys)
                {
                    mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);

                    foreach (var t in ListeComposants[mdl])
                    {
                        var cfg   = t.Key;
                        var nbCfg = t.Value;
                        mdl.ShowConfiguration2(cfg);
                        mdl.EditRebuild3();
                        var Piece = mdl.ePartDoc();

                        foreach (var fDossier in Piece.eListeDesFonctionsDePiecesSoudees(Test))
                        {
                            WindowLog.EcrireF("{0} \"{1}\"", mdl.eNomSansExt(), cfg);
                            WindowLog.EcrireF("  {0} : Pas de reference", fDossier.Name);
                            Erreur = true;
                        }
                    }

                    mdl.eFermerSiDifferent(MdlBase);
                }

                if (!Erreur)
                {
                    WindowLog.Ecrire("Aucune erreur\n");
                }
            }
            catch (Exception e)
            {
                this.LogErreur(new Object[] { e });
            }
        }
Exemplo n.º 2
0
        protected override void Command()
        {
            try
            {
                // On liste les composants
                var ListeComposants = MdlBase.pListerComposants();

                // On boucle sur les modeles
                foreach (var mdl in ListeComposants.Keys)
                {
                    mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
                    foreach (var nomCfg in ListeComposants[mdl].Keys)
                    {
                        mdl.ShowConfiguration2(nomCfg);
                        mdl.EditRebuild3();
                        var piece        = mdl.ePartDoc();
                        var ListeDossier = piece.eListeDesFonctionsDePiecesSoudees(
                            swD =>
                        {
                            BodyFolder Dossier = swD.GetSpecificFeature2();

                            // Si le dossier est la racine d'un sous-ensemble soudé, il n'y a rien dedans
                            if (Dossier.IsRef() && (Dossier.eEstExclu() == false) && (Dossier.eNbCorps() > 0) &&
                                (eTypeCorps.Barre).HasFlag(Dossier.eTypeDeDossier()))
                            {
                                return(true);
                            }

                            return(false);
                        }
                            );

                        var NbConfig = ListeComposants[mdl][nomCfg];

                        foreach (var fDossier in ListeDossier)
                        {
                            BodyFolder Dossier       = fDossier.GetSpecificFeature2();
                            var        SwCorps       = Dossier.ePremierCorps();
                            var        NomCorps      = SwCorps.Name;
                            var        MateriauCorps = SwCorps.eGetMateriauCorpsOuPiece(piece, nomCfg);
                            var        NbCorps       = Dossier.eNbCorps() * NbConfig;
                            var        Profil        = Dossier.eProfilDossier();
                            var        Longueur      = Dossier.eLongueurProfilDossier().eToDouble();

                            for (int i = 0; i < NbCorps; i++)
                            {
                                var LgTmp = Longueur;

                                while (LgTmp > LgMax)
                                {
                                    RassemblerBarre(MateriauCorps, Profil, LgMax);
                                    LgTmp -= LgMax;
                                }

                                RassemblerBarre(MateriauCorps, Profil, LgTmp);
                            }
                        }
                    }

                    mdl.eFermerSiDifferent(MdlBase);
                }

                // On fait la mise en barre
                foreach (var Materiau in DicBarres.Keys)
                {
                    WindowLog.SautDeLigne();
                    WindowLog.EcrireF("{0}", Materiau);;
                    foreach (var Profil in DicBarres[Materiau].Keys)
                    {
                        WindowLog.SautDeLigne();
                        WindowLog.EcrireF("  {0}", Profil);
                        var lst = DicBarres[Materiau][Profil];
                        lst.Sort();
                        lst.Reverse();

                        foreach (var lg in lst)
                        {
                            WindowLog.EcrireF("  - {0}", lg);
                        }

                        int i = 0;
                        while (true)
                        {
                            var lg = lst[i];
                            if (AjouterBarre(Materiau, Profil, lg))
                            {
                                lst.RemoveAt(i);
                                if (lst.Count == 0)
                                {
                                    break;
                                }
                            }
                            else
                            {
                                i++;
                            }

                            if (i >= lst.Count)
                            {
                                i = 0;
                                NouvelleBarre(Materiau, Profil);
                            }
                        }
                    }
                }

                String Resume = "";
                foreach (var Materiau in DicMateriau.Keys)
                {
                    Resume += System.Environment.NewLine;
                    Resume += String.Format("{0}", Materiau);
                    foreach (var Profil in DicMateriau[Materiau].Keys)
                    {
                        var Ligne = DicMateriau[Materiau][Profil];
                        Resume += System.Environment.NewLine;
                        Resume += String.Format("   {1,4}×  {0,-25}  [{2:N0}]", Profil, Ligne.NbBarre, Ligne.Reste);
                    }
                }
                WindowLog.SautDeLigne();
                WindowLog.Ecrire("A commander");
                WindowLog.Ecrire(Resume);
                WindowLog.SautDeLigne();
                File.WriteAllText(Path.Combine(MdlBase.eDossier(), "CommandeProfil.txt"), Resume);
            }
            catch (Exception e)
            {
                this.LogErreur(new Object[] { e });
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// Pour pouvoir obtenir une référence unique pour chaque dossier de corps, identiques
        /// dans l'assemblage, on passe par la création d'une propriété dans chaque dossier.
        /// Cette propriété est liée à une cote dans une esquisse dont la valeur est égale au repère.
        /// Suivant la configuration, la valeur de la cote peut changer et donc le repère du dossier.
        /// C'est le seul moyen pour avoir un lien entre les dossiers et la configuration du modèle.
        /// Les propriétés des dossiers ne sont pas configurables.
        /// </summary>
        protected override void Command()
        {
            try
            {
                App.Sw.CommandInProgress = true;

                // Si aucun corps n'a déjà été repéré, on reinitialise tout
                if (ListeCorps.Count == 0)
                {
                    // On supprime tout les fichiers
                    foreach (FileInfo file in new DirectoryInfo(MdlBase.pDossierPiece()).GetFiles())
                    {
                        file.Delete();
                    }
                }

                if (ReinitCampagneActuelle && (ListeCorps.Count > 0))
                {
                    // On supprime les repères de la campagne actuelle

                    // On recherche les repères appartenant aux campagnes précédentes
                    // pour ne pas supprimer les fichiers
                    // Si la somme des quantités des campagnes précédente est superieure à 0
                    // on garde le repère
                    ListeSortedCorps FichierAsauvegarder = new ListeSortedCorps();
                    FichierAsauvegarder.CampagneDepartDecompte = ListeCorps.CampagneDepartDecompte;

                    foreach (var corps in ListeCorps.Values)
                    {
                        int nb = 0;
                        foreach (var camp in corps.Campagne)
                        {
                            if (camp.Key < IndiceCampagne)
                            {
                                nb += camp.Value;
                            }
                            else
                            {
                                break;
                            }
                        }

                        if (nb > 0)
                        {
                            FichierAsauvegarder.Add(corps.Repere, corps);
                        }
                    }

                    // On nettoie les fichiers précedement crées
                    foreach (var corps in ListeCorps.Values)
                    {
                        if (FichierAsauvegarder.ContainsKey(corps.Repere))
                        {
                            continue;
                        }

                        corps.SupprimerFichier();
                    }

                    ListeCorps = FichierAsauvegarder;
                }

                // On supprime les campagnes superieures à l'indice actuelle
                foreach (var corps in ListeCorps.Values)
                {
                    for (int i = IndiceCampagne; i < corps.Campagne.Keys.Max(); i++)
                    {
                        if (corps.Campagne.ContainsKey(i + 1))
                        {
                            corps.Campagne.Remove(i + 1);
                        }
                    }
                }


                WindowLog.SautDeLigne();
                WindowLog.EcrireF("Campagne de départ : {0}", ListeCorps.CampagneDepartDecompte);

                // On charge les corps existant à partir des fichiers
                // et seulement ceux dont la quantité pour CampagneDepartDecompte est supérieure à 0
                if (CombinerCorpsIdentiques && (ListeCorps.Count > 0))
                {
                    var FiltreCampagne = IndiceCampagne;

                    if (CombinerAvecCampagnePrecedente)
                    {
                        FiltreCampagne = ListeCorps.CampagneDepartDecompte;
                    }

                    WindowLog.SautDeLigne();
                    WindowLog.Ecrire("Chargement des corps existants :");

                    foreach (var corps in ListeCorps.Values)
                    {
                        // On additionne les quantités pour les corps supperieur à filtreCampagne
                        // S
                        if (corps.Campagne.ContainsKey(FiltreCampagne) &&
                            corps.Campagne.Sum(d => d.Key >= FiltreCampagne? d.Value : 0) > 0 &&
                            File.Exists(corps.CheminFichierRepere)
                            )
                        {
                            WindowLog.EcrireF(" - {0}", corps.RepereComplet);
                            corps.ChargerCorps();
                        }
                    }
                }

                // On reinitialise la quantité pour la campagne actuelle à 0
                foreach (var corps in ListeCorps.Values)
                {
                    corps.InitCampagne(IndiceCampagne);
                }

                ////////////////////////////////// DEBUT DU REPERAGE ////////////////////////////////////////////////////

                MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);

                MdlBase.eActiverManager(false);

                WindowLog.SautDeLigne();
                WindowLog.Ecrire("Debut du repérage");

                // On recherche l'indice de repere max
                if (ListeCorps.Count > 0)
                {
                    _GenRepereDossier = ListeCorps.Keys.Max();
                }

                // On liste les composants
                var ListeComposants = MdlBase.pListerComposants();

                // On boucle sur les modeles
                foreach (var mdl in ListeComposants.Keys)
                {
                    mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);

                    mdl.eActiverManager(false);

                    // On met à jour les options
                    mdl.Extension.SetUserPreferenceToggle(((int)(swUserPreferenceToggle_e.swDisableDerivedConfigurations)), 0, false);
                    mdl.Extension.SetUserPreferenceToggle(((int)(swUserPreferenceToggle_e.swWeldmentRenameCutlistDescriptionPropertyValue)), 0, true);
                    mdl.Extension.SetUserPreferenceToggle(((int)(swUserPreferenceToggle_e.swWeldmentCollectIdenticalBodies)), 0, true);
                    mdl.Extension.SetUserPreferenceString(((int)(swUserPreferenceStringValue_e.swSheetMetalDescription)), 0, "Tôle");

                    if (mdl.ePartDoc().eDossierListeDesPiecesSoudees().GetAutomaticUpdate() == false)
                    {
                        mdl.ePartDoc().eMajListeDesPiecesSoudeesAuto(true);
                        mdl.EditRebuild3();
                    }

                    // On crée l'esquisse pour le reperage des dossiers
                    mdl.pEsquisseRepere();

                    // Si le modele est a repérer complètement
                    Boolean InitModele = true;
                    // On recherche l'index de la dimension maximum
                    int IndexDimension = 0;
                    // On liste les dossiers déja traité pour l'attribution des nouveaux index de dimension
                    HashSet <int> HashPieceIdDossiers = new HashSet <int>();

                    // Les données sont stockées dans des propriétés du modèle
                    // Le nom du modèle est stocké dans une propriété, si le modèle est copié
                    // la propriété n'est plus valable, on force le repérage
                    // On récupère également le dernier indice de la dimension utilisée
                    if (mdl.ePropExiste(CONST_PRODUCTION.ID_PIECE) && (mdl.eGetProp(CONST_PRODUCTION.ID_PIECE) == mdl.eNomSansExt()))
                    {
                        InitModele = false;
                        if (mdl.ePropExiste(CONST_PRODUCTION.MAX_INDEXDIM))
                        {
                            IndexDimension = mdl.eGetProp(CONST_PRODUCTION.MAX_INDEXDIM).eToInteger();
                        }

                        if (mdl.ePropExiste(CONST_PRODUCTION.PIECE_ID_DOSSIERS))
                        {
                            var tab = mdl.eGetProp(CONST_PRODUCTION.PIECE_ID_DOSSIERS).Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                            foreach (var id in tab)
                            {
                                HashPieceIdDossiers.Add(id.eToInteger());
                            }
                        }
                    }

                    ////////////////////////////////// BOUCLE SUR LES CONFIGS ////////////////////////////////////////////////////
                    foreach (var nomCfg in ListeComposants[mdl].Keys)
                    {
                        mdl.ShowConfiguration2(nomCfg);
                        mdl.EditRebuild3();
                        WindowLog.SautDeLigne();
                        WindowLog.EcrireF("{0} \"{1}\"", mdl.eNomSansExt(), nomCfg);

                        HashSet <int> HashConfigIdDossiers = new HashSet <int>();

                        Boolean InitConfig = true;

                        int IdCfg = mdl.GetConfigurationByName(nomCfg).GetID();

                        // Idem modèle, on stock l'id de la config dans une propriété.
                        // Si une nouvelle config est crée, la valeur de cette propriété devient caduc,
                        // on repère alors les dossiers
                        // On en profite pour récupérer la liste des ids de dossiers déjà traité dans les précédentes
                        // campagne de repérage
                        if (!InitModele && mdl.ePropExiste(CONST_PRODUCTION.ID_CONFIG, nomCfg) && (mdl.eGetProp(CONST_PRODUCTION.ID_CONFIG, nomCfg) == IdCfg.ToString()))
                        {
                            InitConfig = false;
                            if (mdl.ePropExiste(CONST_PRODUCTION.CONFIG_ID_DOSSIERS, nomCfg))
                            {
                                var tab = mdl.eGetProp(CONST_PRODUCTION.CONFIG_ID_DOSSIERS, nomCfg).Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                                foreach (var id in tab)
                                {
                                    HashConfigIdDossiers.Add(id.eToInteger());
                                }
                            }
                        }

                        var piece        = mdl.ePartDoc();
                        var ListeDossier = piece.eListeDesFonctionsDePiecesSoudees(
                            swD =>
                        {
                            BodyFolder Dossier = swD.GetSpecificFeature2();

                            // Si le dossier est la racine d'un sous-ensemble soudé, il n'y a rien dedans
                            if (Dossier.IsRef() && (Dossier.eNbCorps() > 0) && !Dossier.eEstExclu() &&
                                FiltrerCorps.HasFlag(Dossier.eTypeDeDossier()))
                            {
                                return(true);
                            }

                            return(false);
                        }
                            );

                        var NbConfig = ListeComposants[mdl][nomCfg];

                        ////////////////////////////////// BOUCLE SUR LES DOSSIERS ////////////////////////////////////////////////////
                        foreach (var fDossier in ListeDossier)
                        {
                            BodyFolder Dossier   = fDossier.GetSpecificFeature2();
                            int        IdDossier = fDossier.GetID();

                            Dimension param = null;

                            if (!HashPieceIdDossiers.Contains(IdDossier))
                            {
                                param = CreerParam(mdl, fDossier, nomCfg, ++IndexDimension);
                            }
                            else
                            {
                                param = GetParam(mdl, fDossier, nomCfg);
                            }

                            var        SwCorps       = Dossier.ePremierCorps();
                            var        NomCorps      = SwCorps.Name;
                            var        MateriauCorps = SwCorps.eGetMateriauCorpsOuPiece(piece, nomCfg);
                            eTypeCorps TypeCorps     = Dossier.eTypeDeDossier();
                            var        nbCorps       = Dossier.eNbCorps() * NbConfig;

                            int Repere = -1;

                            if (CombinerCorpsIdentiques)
                            {
                                // On recherche s'il existe des corps identiques
                                // Si oui, on applique le même repère au parametre

                                foreach (var CorpsTest in ListeCorps.Values)
                                {
                                    if (CorpsTest.SwCorps.IsRef() &&
                                        (CombinerAvecCampagnePrecedente || CorpsTest.Campagne.ContainsKey(IndiceCampagne)) &&
                                        (MateriauCorps == CorpsTest.Materiau) &&
                                        (TypeCorps == CorpsTest.TypeCorps) &&
                                        SwCorps.eComparerGeometrie(CorpsTest.SwCorps) == Sw.Comparaison_e.Semblable)
                                    {
                                        Repere = CorpsTest.Repere;
                                        SetRepere(param, CorpsTest.Repere, nomCfg);
                                        break;
                                    }
                                }
                            }

                            // Initialisation du repère
                            if (Repere.eEstNegatif())
                            {
                                // A tester
                                // Si on est mode "MajCampagnePrecedente", ça évite de repérer une seconde fois les pièces

                                // Si on est pas en mode "Combiner les corps"
                                // on recupère le repère du dossier
                                // Sinon c'est forcément un nouveau repère
                                if (!CombinerCorpsIdentiques)
                                {
                                    Repere = GetRepere(param, nomCfg);
                                }

                                // Création d'un nouveau repère suivant conditions
                                // Dans tous les cas, si la clé est négative, on crée un nouveau repère
                                if (Repere.eEstNegatif() ||
                                    InitConfig ||
                                    !HashConfigIdDossiers.Contains(IdDossier) ||
                                    !ListeCorps.ContainsKey(Repere))
                                {
                                    Repere = GenRepereDossier;
                                    SetRepere(param, Repere, nomCfg);
                                }
                            }

                            // Initialisation du corps
                            Corps corps = null;
                            if (!ListeCorps.ContainsKey(Repere))
                            {
                                corps = new Corps(SwCorps, TypeCorps, MateriauCorps, MdlBase);
                                corps.InitCampagne(IndiceCampagne);
                                ListeCorps.Add(Repere, corps);
                            }
                            else
                            {
                                corps = ListeCorps[Repere];
                            }

                            corps.Campagne[IndiceCampagne] += nbCorps;
                            corps.Repere = Repere;
                            corps.InitCaracteristiques(Dossier, SwCorps);
                            corps.AjouterModele(mdl, nomCfg, IdDossier, NomCorps);

                            HashPieceIdDossiers.Add(IdDossier);
                            HashConfigIdDossiers.Add(IdDossier);

                            WindowLog.EcrireF(" - {1} -> {0}", fDossier.Name, corps.RepereComplet);
                        }
                        mdl.ePropAdd(CONST_PRODUCTION.ID_CONFIG, IdCfg, nomCfg);
                        mdl.ePropAdd(CONST_PRODUCTION.CONFIG_ID_DOSSIERS, String.Join(" ", HashConfigIdDossiers), nomCfg);
                    }
                    mdl.ePropAdd(CONST_PRODUCTION.ID_PIECE, mdl.eNomSansExt());
                    mdl.ePropAdd(CONST_PRODUCTION.PIECE_ID_DOSSIERS, String.Join(" ", HashPieceIdDossiers));
                    mdl.ePropAdd(CONST_PRODUCTION.MAX_INDEXDIM, IndexDimension);

                    mdl.eActiverManager(true);
                    mdl.eSauver();
                    mdl.eFermerSiDifferent(MdlBase);
                }

                MdlBase.eActiverManager(true);
                MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
                MdlBase.EditRebuild3();
                MdlBase.eSauver();

                ////////////////////////////////// FIN DU REPERAGE ////////////////////////////////////////////////////

                // On fermer les fichiers chargé
                foreach (var corps in ListeCorps.Values)
                {
                    Sw.eFermer(corps.CheminFichierRepere);
                }

                WindowLog.SautDeLigne();
                if (ListeCorps.Count > 0)
                {
                    WindowLog.EcrireF("Nb de repères : {0}", ListeCorps.Keys.Max());
                }
                else
                {
                    WindowLog.Ecrire("Aucun corps repéré");
                }

                // S'il n'y a aucun corps, on se barre
                if (ListeCorps.Count == 0)
                {
                    return;
                }

                ////////////////////////////////// EXPORTER LES CORPS /////////////////////////////////////////////////

                WindowLog.SautDeLigne();
                WindowLog.Ecrire("Export des corps :");

                foreach (var corps in ListeCorps.Values)
                {
                    if (corps.Modele.IsNull())
                    {
                        continue;
                    }

                    // Si on est pas en mode "Combiner corps identique" et que le fichier existe
                    // on le supprime pour le mettre à jour, sinon on peut se retrouver
                    // avec des fichiers ne correpondants pas au corps
                    if (!CombinerCorpsIdentiques)
                    {
                        corps.SupprimerFichier();
                    }

                    // Si le fichier existe, on passe au suivant
                    if (File.Exists(corps.CheminFichierRepere))
                    {
                        continue;
                    }

                    WindowLog.EcrireF("- {0} exporté", CONSTANTES.PREFIXE_REF_DOSSIER + corps.Repere);

                    corps.SauverRepere(CreerDvp);
                }

                ////////////////////////////////// RECAP /////////////////////////////////////////////////

                // Petit récap
                WindowLog.SautDeLigne();
                WindowLog.EcrireF("Nb de corps unique : {0}", ListeCorps.Count);

                int nbtt = 0;

                foreach (var corps in ListeCorps.Values)
                {
                    nbtt += corps.Campagne[IndiceCampagne];
                    if (corps.Campagne[IndiceCampagne] > 0)
                    {
                        WindowLog.EcrireF("{2} P{0} ×{1}", corps.Repere, corps.Campagne[IndiceCampagne], IndiceCampagne);
                    }
                }

                WindowLog.EcrireF("Nb total de corps : {0}", nbtt);

                ////////////////////////////////// SAUVEGARDE DE LA NOMENCLATURE /////////////////////////////////////////////

                ListeCorps.EcrireNomenclature(MdlBase.pDossierPiece(), IndiceCampagne);

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////

                MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);

                App.Sw.CommandInProgress = false;

                var aff = new AffichageElementWPF(ListeCorps, IndiceCampagne);
                aff.ShowDialog();

                ListeCorps      = null;
                ListeComposants = null;
            }
            catch (Exception e) { this.LogErreur(new Object[] { e }); }
        }
Exemplo n.º 4
0
            private void IndiceMax()
            {
                eTypeCorps Filtre = eTypeCorps.Barre | eTypeCorps.Tole;

                var ListeComposants = MdlBase.ListerComposants(false);

                Func <Feature, Tuple <String, String> > ExtractRef = delegate(Feature dossier)
                {
                    CustomPropertyManager PM = dossier.CustomPropertyManager;
                    String val, result = ""; Boolean wasResolved, link;
                    var    r = PM.Get6(CONSTANTES.REF_DOSSIER, false, out val, out result, out wasResolved, out link);

                    return(new Tuple <String, String>(result.Replace(CONSTANTES.PREFIXE_REF_DOSSIER, ""), val));
                };

                Predicate <Feature> Test = delegate(Feature f)
                {
                    BodyFolder dossier = f.GetSpecificFeature2();
                    if (dossier.IsRef() && dossier.eNbCorps() > 0 && Filtre.HasFlag(dossier.eTypeDeDossier()))
                    {
                        CustomPropertyManager PM = f.CustomPropertyManager;

                        String val, result = ""; Boolean wasResolved, link;
                        var    r = PM.Get6(CONSTANTES.REF_DOSSIER, false, out val, out result, out wasResolved, out link);

                        var RefDossier = ExtractRef(f).Item1;
                        if (RefDossier.eIsInteger())
                        {
                            return(true);
                        }
                    }

                    return(false);
                };

                foreach (var mdl in ListeComposants.Keys)
                {
                    mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);

                    foreach (var t in ListeComposants[mdl])
                    {
                        var cfg   = t.Key;
                        var nbCfg = t.Value;
                        mdl.ShowConfiguration2(cfg);
                        mdl.EditRebuild3();
                        var Piece = mdl.ePartDoc();

                        foreach (var f in Piece.eListeDesFonctionsDePiecesSoudees(Test))
                        {
                            var RefDossier = ExtractRef(f);

                            indice = Math.Max(indice, RefDossier.Item1.eToInteger());
                            var hashDossier = HashDossier(mdl, f);
                            DossierTraite.Add(hashDossier);

                            // On recherche l'index max pour chaque modele
                            var NomParam = ExtractNomParam(RefDossier.Item2);
                            var dim      = NomParam.Split('@')[0].CleanStringOfNonDigits().eToInteger();
                            var hashMdl  = mdl.GetPathName();
                            if (IndexDimension.ContainsKey(hashMdl))
                            {
                                IndexDimension[hashMdl] = Math.Max(IndexDimension[hashMdl], dim);
                            }
                            else
                            {
                                IndexDimension[hashMdl] = dim;
                            }
                        }
                    }

                    mdl.eFermerSiDifferent(MdlBase);
                }

                WindowLog.EcrireF("Indice Max : {0}", indice);
            }
Exemplo n.º 5
0
            /// <summary>
            /// Pour pouvoir obtenir une référence unique pour chaque dossier de corps, identiques
            /// dans l'assemblage, on passe par la création d'une propriété dans chaque dossier.
            /// Cette propriété est liée à une cote dans une esquisse dont la valeur est égale au repère.
            /// Suivant la configuration, la valeur de la cote peut changer et donc le repère du dossier.
            /// C'est le seul moyen pour avoir un lien entre les dossiers et la configuration du modèle.
            /// Les propriétés des dossiers ne sont pas configurables.
            /// </summary>
            protected override void Command()
            {
                try
                {
                    if (MajDossiers)
                    {
                        IndiceMax();
                    }

                    var ListeCorps = new List <Corps>();

                    var lst = MdlBase.ListerComposants(false);

                    foreach (var mdl in lst.Keys)
                    {
                        mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
                        EsquisseRepere(mdl);

                        foreach (var cfg in lst[mdl].Keys)
                        {
                            mdl.ShowConfiguration2(cfg);
                            mdl.EditRebuild3();
                            WindowLog.SautDeLigne();
                            WindowLog.EcrireF("{0} \"{1}\"", mdl.eNomSansExt(), cfg);

                            var piece        = mdl.ePartDoc();
                            var NbConfig     = lst[mdl][cfg];
                            var ListeDossier = piece.eListeDesFonctionsDePiecesSoudees(
                                swD =>
                            {
                                BodyFolder Dossier = swD.GetSpecificFeature2();

                                // Si le dossier est la racine d'un sous-ensemble soudé, il n'y a rien dedans
                                if (Dossier.IsRef() && Dossier.eNbCorps() > 0 &&
                                    (eTypeCorps.Barre | eTypeCorps.Tole).HasFlag(Dossier.eTypeDeDossier()))
                                {
                                    return(true);
                                }

                                return(false);
                            }
                                );

                            foreach (var fDossier in ListeDossier)
                            {
                                BodyFolder            Dossier = fDossier.GetSpecificFeature2();
                                CustomPropertyManager PM      = fDossier.CustomPropertyManager;

                                // Si MajDossier et PropExiste, ne pas mettre à jour
                                Boolean Maj = !(MajDossiers && PM.ePropExiste(CONSTANTES.REF_DOSSIER));

                                String NomParam = "";

                                WindowLog.EcrireF("     {0}", fDossier.Name);

                                // On recherche si le dossier à déjà été traité.
                                //      Si non, on ajoute le dossier à la liste
                                //          On met à jour la liste des index des dimensions :
                                //              On ajoute le nom du modele et on itiniatile l'index à 1
                                //              Ou, puisque c'est un nouveau dossier, on ajoute un à l'index existant.
                                //          On créer le nom du paramètre
                                //          On ajoute la propriété au dossier selon le modèle suivant :
                                //              P"D1@REPERAGE_DOSSIER@Nom_de_la_piece.SLDPRT"
                                //      Si oui, on récupère le nom du paramètre
                                var clef = HashDossier(mdl, fDossier);

                                if (!DossierTraite.Contains(clef))
                                {
                                    DossierTraite.Add(clef);

                                    IndexDimension.AddIfNotExistOrPlus(mdl.GetPathName());

                                    NomParam = String.Format("D{0}@{1}", IndexDimension[mdl.GetPathName()]++, CONSTANTES.NOM_ESQUISSE_NUMEROTER);
                                    var propVal = String.Format("{0}\"{1}@{2}\"", CONSTANTES.PREFIXE_REF_DOSSIER, NomParam, mdl.eNomAvecExt());
                                    var r       = PM.ePropAdd(CONSTANTES.REF_DOSSIER, propVal);

                                    if (r > 0)
                                    {
                                        WindowLog.EcrireF("{0}-{1}-{2} : Pas de propriété ajoutée {3}", mdl.eNomSansExt(), cfg, fDossier.Name, (swCustomInfoAddResult_e)r);
                                    }

                                    PM.ePropAdd(CONSTANTES.DESC_DOSSIER, propVal);
                                }
                                else
                                {
                                    String val, result = ""; Boolean wasResolved, link;
                                    var    r = PM.Get6(CONSTANTES.REF_DOSSIER, false, out val, out result, out wasResolved, out link);

                                    if (r == 1)
                                    {
                                        WindowLog.EcrireF("{0}-{1}-{2} : Pas de propriété {3}", mdl.eNomSansExt(), cfg, fDossier.Name, (swCustomInfoGetResult_e)r);
                                    }

                                    NomParam = ExtractNomParam(val);
                                }

                                {
                                    String val, result = ""; Boolean wasResolved, link;
                                    var    r = PM.Get6(CONSTANTES.REF_DOSSIER, false, out val, out result, out wasResolved, out link);

                                    PM.ePropAdd(CONSTANTES.DESC_DOSSIER, val);
                                }

                                // On ajoute la propriété NomDossier
                                // permettant de récupérer le nom du dossier dans la mise en plan
                                if (!PM.ePropExiste(CONSTANTES.NOM_DOSSIER))
                                {
                                    var propVal = String.Format("\"SW-CutListItemName@@@{0}@{1}\"", fDossier.Name, mdl.eNomAvecExt());
                                    PM.ePropAdd(CONSTANTES.NOM_DOSSIER, propVal);
                                }

                                var SwCorps = Dossier.ePremierCorps();

                                Boolean Ajoute = false;

                                var       MateriauCorps = SwCorps.eGetMateriauCorpsOuPiece(piece, cfg);
                                var       nbCorps       = Dossier.eNbCorps() * NbConfig;
                                Dimension param         = mdl.Parameter(NomParam);

                                eTypeCorps TypeCorps = Dossier.eTypeDeDossier();

                                if (CombinerCorpsIdentiques)
                                {
                                    // On recherche s'il existe des corps identiques
                                    // Si oui, on applique le même repère au parametre
                                    foreach (var CorpsTest in ListeCorps)
                                    {
                                        if ((MateriauCorps != CorpsTest.Materiau) || (TypeCorps != CorpsTest.TypeCorps))
                                        {
                                            continue;
                                        }

                                        if (SwCorps.eComparerGeometrie(CorpsTest.SwCorps) == Sw.Comparaison_e.Semblable)
                                        {
                                            CorpsTest.Nb += nbCorps;

                                            if (Maj)
                                            {
                                                var errors = param.SetSystemValue3(CorpsTest.Repere * 0.001, (int)swSetValueInConfiguration_e.swSetValue_InSpecificConfigurations, cfg);
                                                if (errors > 0)
                                                {
                                                    WindowLog.EcrireF(" Erreur de mise à jour {0}", (swSetValueReturnStatus_e)errors);
                                                }
                                            }

                                            CorpsTest.AjouterModele(mdl, cfg, fDossier.GetID());
                                            Ajoute = true;
                                            break;
                                        }
                                    }
                                }

                                if ((Ajoute == false) && Maj)
                                {
                                    var rep    = GenRepereDossier;
                                    var errors = param.SetSystemValue3(rep * 0.001, (int)swSetValueInConfiguration_e.swSetValue_InSpecificConfigurations, cfg);

                                    if (errors > 0)
                                    {
                                        WindowLog.EcrireF(" Erreur de mise à jour {0}", (swSetValueReturnStatus_e)errors);
                                    }

                                    var corps = new Corps(SwCorps, TypeCorps, MateriauCorps);
                                    corps.Nb     = nbCorps;
                                    corps.Repere = rep;
                                    corps.AjouterModele(mdl, cfg, fDossier.GetID());
                                    ListeCorps.Add(corps);
                                }
                            }
                        }

                        mdl.eFermerSiDifferent(MdlBase);
                    }

                    MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);


                    int Errors = 0, Warnings = 0;
                    MdlBase.Save3((int)swSaveAsOptions_e.swSaveAsOptions_SaveReferenced + (int)swSaveAsOptions_e.swSaveAsOptions_Silent, ref Errors, ref Warnings);
                    MdlBase.EditRebuild3();

                    // Petit récap
                    WindowLog.SautDeLigne();
                    WindowLog.EcrireF("Nb de corps unique : {0}", ListeCorps.Count);

                    int nbtt = 0;

                    foreach (var corps in ListeCorps)
                    {
                        nbtt += corps.Nb;
                        WindowLog.EcrireF("P{0} ×{1}", corps.Repere, corps.Nb);
                    }

                    WindowLog.EcrireF("Nb total de corps : {0}", nbtt);
                }
                catch (Exception e)
                {
                    this.LogErreur(new Object[] { e });
                }
            }
Exemplo n.º 6
0
        /// <summary>
        /// Renvoi la liste des modeles avec la liste des configurations, des dossiers
        /// et les quantites de chaque dossier dans l'assemblage
        /// Modele : ModelDoc2
        ///     |-Config1 : Nom de la configuration
        ///     |     |-Dossier1 : Comparaison avec la propriete RefDossier, référence à l'Id de la fonction pour pouvoir le selectionner plus tard
        ///     |     |      |- Nb : quantite de corps identique dans le modele complet
        ///     |     |
        ///     |     |-Dossier2
        ///     |            |- Nb
        ///     |-Config 2
        ///     | etc...
        /// </summary>
        /// <param name="mdlBase"></param>
        /// <param name="composantsExterne"></param>
        /// <param name="filtreDossier"></param>
        /// <returns></returns>
        public static SortedDictionary <ModelDoc2, SortedDictionary <String, SortedDictionary <int, int> > > DenombrerDossiers(this ModelDoc2 mdlBase, Boolean composantsExterne, Predicate <Feature> filtreDossier = null, Boolean fermerFichier = false)
        {
            SortedDictionary <ModelDoc2, SortedDictionary <String, SortedDictionary <int, int> > > dic = new SortedDictionary <ModelDoc2, SortedDictionary <String, SortedDictionary <int, int> > >(new CompareModelDoc2());

            try
            {
                var ListeComposants = mdlBase.ListerComposants(composantsExterne);

                var ListeDossiers = new Dictionary <String, Dossier>();

                Predicate <Feature> Test = delegate(Feature fDossier)
                {
                    BodyFolder SwDossier = fDossier.GetSpecificFeature2();
                    if (SwDossier.IsRef() && SwDossier.eNbCorps() > 0 && !SwDossier.eEstExclu() && (filtreDossier.IsNull() || filtreDossier(fDossier)))
                    {
                        return(true);
                    }

                    return(false);
                };

                foreach (var mdl in ListeComposants.Keys)
                {
                    mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);

                    foreach (var t in ListeComposants[mdl])
                    {
                        var cfg   = t.Key;
                        var nbCfg = t.Value;
                        mdl.ShowConfiguration2(cfg);
                        mdl.EditRebuild3();
                        var Piece = mdl.ePartDoc();

                        foreach (var fDossier in Piece.eListeDesFonctionsDePiecesSoudees(Test))
                        {
                            BodyFolder SwDossier  = fDossier.GetSpecificFeature2();
                            var        RefDossier = SwDossier.eProp(CONSTANTES.REF_DOSSIER);

                            if (ListeDossiers.ContainsKey(RefDossier))
                            {
                                ListeDossiers[RefDossier].Nb += SwDossier.eNbCorps() * nbCfg;
                            }
                            else
                            {
                                var dossier = new Dossier(RefDossier, mdl, cfg, fDossier.GetID());
                                dossier.Nb = SwDossier.eNbCorps() * nbCfg;

                                ListeDossiers.Add(RefDossier, dossier);
                            }
                        }
                    }

                    if (fermerFichier)
                    {
                        mdl.eFermerSiDifferent(mdlBase);
                    }
                    ;
                }

                // Conversion d'une liste de dossier
                // en liste de modele
                foreach (var dossier in ListeDossiers.Values)
                {
                    if (dic.ContainsKey(dossier.Mdl))
                    {
                        var lcfg = dic[dossier.Mdl];
                        if (lcfg.ContainsKey(dossier.Config))
                        {
                            var ldossier = lcfg[dossier.Config];
                            ldossier.Add(dossier.Id, dossier.Nb);
                        }
                        else
                        {
                            var ldossier = new SortedDictionary <int, int>();
                            ldossier.Add(dossier.Id, dossier.Nb);
                            lcfg.Add(dossier.Config, ldossier);
                        }
                    }
                    else
                    {
                        var ldossier = new SortedDictionary <int, int>();
                        ldossier.Add(dossier.Id, dossier.Nb);
                        var lcfg = new SortedDictionary <String, SortedDictionary <int, int> >(new WindowsStringComparer());
                        lcfg.Add(dossier.Config, ldossier);
                        dic.Add(dossier.Mdl, lcfg);
                    }
                }
            }
            catch (Exception e) { Log.LogErreur(new Object[] { e }); }

            return(dic);
        }