コード例 #1
0
 /*
  * Création de la liste de tous les nœuds de l'arbre
  * */
 protected void getNodesList(ContainsNode startNode, List <ContainsNode> lstNodes)
 {
     foreach (ContainsNode curNode in startNode.childrens)
     {
         lstNodes.Add(curNode);
         getNodesList(curNode, lstNodes);
     }
 }
コード例 #2
0
 public SedaSummaryRngGenerator()
     : base()
 {
     // rootContainsNode est marqué avec l'ID "root"
     rootContainsNode = new ContainsNode("root", null, true);
     currentContainsNode = rootContainsNode;
     currentPass = 1;
 }
コード例 #3
0
 public void C10_rootContainsTest()
 {
     ContainsNode root = new ContainsNode("root", null, true);
     Assert.AreNotEqual(null, root);
     Assert.AreEqual(0, root.getNbDocuments());
     Assert.AreEqual(null, root.next());
     Assert.AreEqual("root", root.getName());
     Assert.AreEqual(null, root.getParent());
 }
コード例 #4
0
        private String tabs; // pour l'indentation des traces

        #endregion Fields

        #region Constructors

        /*
         * Le premier nœud doit être créé avec un parentNode null
         * */
        public ContainsNode(String nodeId, ContainsNode parentNode, bool bContainsIsMandatory)
        {
            objectIdentifier = nodeId;
            nbDocuments = 0;
            childrens = new List<ContainsNode>();
            parent = parentNode;
            if (parentNode == null) {
                tabs = "\t";
            } else {
                tabs = parentNode.tabs + "\t";
            }
            mandatory = bContainsIsMandatory;
        }
コード例 #5
0
 /*
  * Le premier nœud doit être créé avec un parentNode null
  * */
 public ContainsNode(String nodeId, ContainsNode parentNode, bool bContainsIsMandatory)
 {
     objectIdentifier = nodeId;
     nbDocuments      = 0;
     childrens        = new List <ContainsNode>();
     parent           = parentNode;
     if (parentNode == null)
     {
         tabs = "\t";
     }
     else
     {
         tabs = parentNode.tabs + "\t";
     }
     mandatory = bContainsIsMandatory;
 }
コード例 #6
0
        /*
         * Permet de récupérer le chemin relatif du nœud courant
         * retourne le nom du tag précédé des tags numérotés de ses ancètres
         * les tags non numérotés sont exclus de cette liste
         * exemple :
         *    /TAG_A[#1]/TAG_B/TAG_C[#2]/TAG_D/THIS_TAG
         * a pour chemin relatif
         *    TAG_A[#1]//TAG_C[#2]//THIS_TAG
         *
         * TODO: à optimiser, attribut chemin relatif, calcul des chemins
         * relatifs déclenché par exemple à computeNbDocuments
         * */
        public String getRelativeContext()
        {
            String       context = String.Empty;
            ContainsNode node    = this;

            while ((node = node.getParent()) != null)
            {
                String          parentName = node.getName();
                Regex           r          = new Regex(@"\[#(\d+)\]");
                MatchCollection matches    = r.Matches(parentName);
                if (matches.Count != 0)
                {
                    context = parentName + "//" + context;
                }
            }
            context += this.getName();
            return(context);
        }
コード例 #7
0
        public void C11_rootChildrensContainsTest()
        {
            ContainsNode root = new ContainsNode("root", null, true);
            ContainsNode child1 = new ContainsNode("child1", root, true);
            ContainsNode child11 = new ContainsNode("child11", child1, true);
            ContainsNode child2 = new ContainsNode("child2", root, true);
            ContainsNode child21 = new ContainsNode("child21", child2, true);
            ContainsNode child22 = new ContainsNode("child22", child2, true);

            Assert.AreEqual("child11", child11.getName(), "child11.getDocumentName()");
            Assert.AreEqual("child1", child11.getParent().getName(), "child11.getParent()");

            Assert.AreEqual("child22", child22.getName(), "child22.getDocumentName()");
            Assert.AreEqual("child2", child22.getParent().getName(), "child22.getParent()");

            Assert.AreEqual("child2", child2.getName(), "child2.getDocumentName()");
            Assert.AreEqual("root", child2.getParent().getName(), "child2.getParent()");
        }
コード例 #8
0
        /*
         * Pour la détection de doublons, doit être appelé sur
         * le nœud racine pour une évaluation complète
         * */
        public StringCollection checkDuplicates(ContainsNode rootNode, String excluded)
        {
            Dictionary <String, Int32> identifiers = new Dictionary <String, Int32>();
            List <ContainsNode>        lstNodes    = new List <ContainsNode>();

            getNodesList(rootNode, lstNodes);
            foreach (ContainsNode checkedNode in lstNodes)
            {
                checkedNode.findDuplicates(lstNodes, checkedNode, excluded, identifiers);
            }
            StringCollection duplicates = new StringCollection();

            Dictionary <String, int> .KeyCollection keys = identifiers.Keys;
            foreach (String key in keys)
            {
                if (identifiers[key] > 1)
                {
                    duplicates.Add("L'identifiant " + key + " n'est pas unique, il est utilisé " + identifiers[key] + " fois.");
                }
            }
            return(duplicates);
        }
コード例 #9
0
        public void C12_treeNbDocumentsTest()
        {
            ContainsNode root = new ContainsNode("root", null, true);
            ContainsNode n1 = root.addNewNode("n1", true);
            ContainsNode n11 = n1.addNewNode("n11", true);
            n11.incNbDocs(2);
            ContainsNode n12 = n1.addNewNode("n12", true);
            n11.incNbDocs(1);
            ContainsNode n2 = root.addNewNode("n2", true);
            n2.incNbDocs(1);
            ContainsNode n21 = n2.addNewNode("n21", true);
            n21.incNbDocs(5);
            ContainsNode n22 = n2.addNewNode("n22", true);

            Assert.AreEqual(9, root.computeNbDocuments(), "root.computeNbDocuments()");
            Assert.AreEqual(9, root.getNbDocuments(), "root.getNbDocuments()");
            int nbNodes = 1; // Au moins root
            ContainsNode node = root;
            while ((node = node.next()) != null) {
                nbNodes++;
            }
            Assert.AreEqual(7, nbNodes, "next()");
        }
コード例 #10
0
        public void C13_treeNonMandatoryButNotEmptyTest()
        {
            ContainsNode root = new ContainsNode("root", null, true);
            ContainsNode n1 = root.addNewNode("n1", true);
            ContainsNode n11 = n1.addNewNode("n11", false);
            n11.incNbDocs(2);
            ContainsNode n12 = n1.addNewNode("n12", true);
            n11.incNbDocs(1);
            ContainsNode n2 = root.addNewNode("n2", false);
            n2.incNbDocs(1);
            ContainsNode n21 = n2.addNewNode("n21", true);
            n21.incNbDocs(5);
            ContainsNode n22 = n2.addNewNode("n22", true);

            Assert.AreEqual(9, root.computeNbDocuments(), "root.computeNbDocuments()");
            Assert.AreEqual(9, root.getNbDocuments(), "root.getNbDocuments()");
            root.trunkChildrenOfEmptyBranches();
            int nbNodes = 1; // Au moins root
            ContainsNode node = root;
            while ((node = node.next()) != null) {
                nbNodes++;
            }
            Assert.AreEqual(7, nbNodes, "next()");
        }
コード例 #11
0
        /*
         * Ajoute un nœud au nœud courant
         * */
        public ContainsNode addNewNode(String newNodeId, bool bContainsIsMandatory)
        {
            int numeroTag = 0;

            if (newNodeId.EndsWith("+"))
            {
                numeroTag++;
                String nodeName = newNodeId.Substring(0, newNodeId.Length - 1);
                foreach (ContainsNode child in this.childrens)
                {
                    // Le nom des frères peut commener par nodeName
                    // Le nom du frère est donc de la forme nodeName[numero]
                    String brotherName = child.getName();
                    Regex  r           = new Regex(nodeName + @"\[#(\d+)\]");
                    Match  m           = r.Match(brotherName);
                    if (m.Success)
                    {
                        try {
                            int newNumeroTag = Convert.ToInt32(m.Groups[1].ToString()) + 1;
                            if (newNumeroTag > numeroTag)
                            {
                                numeroTag = newNumeroTag;
                            }
                        } catch (Exception e) { e.ToString(); }
                    }
                }
            }
            if (numeroTag > 0)
            {
                newNodeId = newNodeId.Substring(0, newNodeId.Length - 1) + "[#" + numeroTag + "]";
            }
            ContainsNode newNode = new ContainsNode(newNodeId, this, bContainsIsMandatory);

            this.childrens.Add(newNode);
            return(newNode);
        }
コード例 #12
0
        protected void recurseContainsDefine(String defineNodeName, String context, bool isRepeatable)
        {
            if (traceActions) tracesWriter.WriteLine("recurseContainsDefine ('" + defineNodeName + "', '" + context + "', '" + currentDocumentTypeId + "')");
            String xPath;

            // Récupérer l'attribut schemeID de la balise ArchivalAgencyObjectIdentifier
            // et la mettre dans un arbre
            currentDocumentTypeId = missingString;
            if (context.Equals(String.Empty)) {
                currentDocumentTypeId = "root";
            } else {
                // Tester la présence de ArchivalAgencyObjectIdentifier dans l'unité documentaire
                xPath = "rng:define[@name='" + defineNodeName + "']/rng:element[@name='ArchivalAgencyObjectIdentifier']/rng:ref";
                XmlNode aaoirefNode = grammarNode.SelectSingleNode(xPath, docInXmlnsManager);
                if (aaoirefNode == null) {
                    xPath = "rng:define[@name='" + defineNodeName + "']/rng:optional/rng:element[@name='ArchivalAgencyObjectIdentifier']/rng:ref";
                    aaoirefNode = grammarNode.SelectSingleNode(xPath, docInXmlnsManager);
                    if (aaoirefNode != null) {
                        String ret = getSchemeIdValue(aaoirefNode, xPath, context);
                        if (ret != null) {
                            errorsList.Add("La balise ArchivalAgencyObjectIdentifier de l'unité documentaire '" + ret + "' est optionnelle. Il faut la rendre obligatoire.");
                        }
                    }
                    else
                        errorsList.Add("La balise ArchivalAgencyObjectIdentifier de l'unité documentaire '" + currentDocumentTypeId + "' n'existe pas. Il faut la créer et la rendre obligatoire.");
                } else {
                    String ret = getSchemeIdValue(aaoirefNode, xPath, context);
                    if (ret != null)
                        currentDocumentTypeId = ret;
                }

                checkForMultipleDocument(defineNodeName, context);
                checkForContentDescription(defineNodeName, context);
                checkForFilename(defineNodeName, context);
                checkForDocType(defineNodeName, context);
                // TODO: Désactivation du contrôle de la langue en attendant une meilleure gestion
                // checkForLanguage(defineNodeName, context);
                checkForDescriptionLevel(defineNodeName, context);

            }
            if (currentDocumentTypeId == "root") {
                rootContainsNode = new ContainsNode(currentDocumentTypeId, null, true);
                currentContainsNode = rootContainsNode;
            } else {
                currentContainsNode = currentContainsNode.addNewNode(currentDocumentTypeId, true);
                if (  isRepeatable && ! currentDocumentTypeId.EndsWith("+"))
                    errorsList.Add("L'unité documentaire '" + currentDocumentTypeId + "' peut être répétée, mais elle ne possède pas de TAG répétable (TAG+). Il faut ajouter un '+' au tag ou changer les cardinalités");
                if (! isRepeatable &&   currentDocumentTypeId.EndsWith("+"))
                    errorsList.Add("L'unité documentaire '" + currentDocumentTypeId + "' est unique ou optionnelle, mais elle possède un TAG répétable (TAG+). Il faut supprimer le '+' du tag ou changer les cardinalités");
                loadExpectedTagsInContainsNode(defineNodeName, currentDocumentTypeId);
            }

            xPath = "rng:define[@name='" + defineNodeName + "']";
            XmlNode containsNode = grammarNode.SelectSingleNode(xPath, docInXmlnsManager);
            if (containsNode == null) {
                errorsList.Add("Le nœud '" + xPath + "' n'a pas été trouvé dans le profil '" + profileFile + "'");
            } else {
                // Parcourir récursivement toutes les balises Contains filles
                xPath = "descendant::rng:element[@name='" + descendantContains + "']/rng:ref";
                XmlNodeList containsNodesList = containsNode.SelectNodes(xPath, docInXmlnsManager);
                if (containsNodesList != null) {
                    foreach (XmlNode node in containsNodesList) {
                        String nodeName = node.Attributes.GetNamedItem("name").Value;
                        if (nodeName == null) {
                            errorsList.Add("Le nœud '" + xPath + "' n'a pas d'attribut name.");
                        } else {
                            bool bRepeatableContains = false;
                            //<rng:element name="Contains">
                            //    <rng:ref name="Contains_N68245"/>
                            //</rng:element>
                            //<rng:zeroOrMore>
                            //    <rng:element name="Contains">
                            //        <rng:ref name="Contains_N68650"/>
                            //    </rng:element>
                            //</rng:zeroOrMore>
                            // on est sur le rng:ref, on remonte sur le parent rng:element
                            // et on regarde si on a un parent nommé rng:zeroOrMore ou rng:oneOrMore
                            xPath = "../..";
                            XmlNode parentNode = node.SelectSingleNode(xPath);
                            String parentNodeStr = parentNode.Name;
                            if (parentNodeStr == "rng:zeroOrMore" || parentNodeStr == "rng:oneOrMore")
                                bRepeatableContains = true;
                            recurseContainsDefine(nodeName, context + "/Contains", bRepeatableContains);
                        }
                    }
                }
                currentContainsNode = currentContainsNode.getParent();
            }
        }
コード例 #13
0
 void doContains(XmlNode currentNode, ref int bGenererElement, ref bool boucleTags, int numeroTag, bool bContainsIsMandatory)
 {
     currentDocumentTypeId = lookupForContainsIdentifier(currentNode);
     if (traceActions) tracesWriter.WriteLineFlush("lookupForContainsIdentifier trouve currentDocumentTypeId " + currentDocumentTypeId + " en passe " + currentPass);
     if (currentDocumentTypeId.EndsWith("+")) {
         boucleTags = true;
         currentDocumentTypeId = formatContainsIdentifier(currentDocumentTypeId, numeroTag);
         if (traceActions) tracesWriter.WriteLineFlush("currentDocumentTypeId à répétition : " + currentDocumentTypeId);
     }
     bGenererElement = 1;
     // si on est sur une boucleTags, il faut s'arrêter au nombre maximum d'itérations
     // donc demander à ArchiveDocuments si il y a des références à e TAG numéroté
     if (boucleTags)
         if (archiveDocuments.IsThereDocumentsReferringToType(currentDocumentTypeId) == false) {
             bGenererElement = 0;
             boucleTags = false;
         }
     if (currentPass == 2) {
         if (bGenererElement > 0 && currentContainsNode != null) {
             if (currentDocumentTypeId == "root")
                 currentContainsNode = rootContainsNode;
             else
                 currentContainsNode = currentContainsNode.next();
             if (currentContainsNode != null) { // Tant qu'on est pas rrivés au bout de l'arbre
                 if (traceActions) tracesWriter.WriteLineFlush("Selecting next currentContainsNode " + currentContainsNode.getName() + " that contains " + currentContainsNode.getNbDocuments() + " documents");
                 int nbDocs = currentContainsNode.getNbDocuments();
                 bGenererElement = nbDocs > 0 ? 1 : 0;
                 if (traceActions) tracesWriter.WriteLineFlush("DOCLIST docs " + currentDocumentTypeId + " contains " + nbDocs + " documents");
             }
         }
     } else {
         if (bGenererElement != 0) {
             if (currentDocumentTypeId == "root") {
                 currentContainsNode = rootContainsNode;
             } else {
                 if (traceActions) tracesWriter.WriteLineFlush("création nouveau containsNode(" + currentDocumentTypeId + ")");
                 currentContainsNode = currentContainsNode.addNewNode(currentDocumentTypeId, bContainsIsMandatory);
             }
             int nbDocs = archiveDocuments.prepareListForType(currentContainsNode.getRelativeContext());
             currentContainsNode.incNbDocs(nbDocs);
         }
     }
 }
コード例 #14
0
        /*
         * C'est le fichier de sortie qui contient le bordereau de transfert construit avec :
         * Exceptions :
         * - SedaSumGenNoInformationsException
         * - SedaSumGenNoArchiveDocumentsException
         * - SedaSumGenNoProfileException
         *
         * La séquence d'appels pour une production de bordereau est la suivante :
         *
         *      SedaSummaryGenerator ssg = new SedaSummaryRngGenerator();
         *      ssg.setTracesWriter(streamWriter);
         *
         *      ssg.prepareInformationsWithDatabase(informationsDatabase, accordVersement);
         *
         *      ssg.prepareArchiveDocumentsWithFile("liste-fichiers.txt");
         *
         *      ssg.generateSummaryFile("bordereau.xml");
         *
         *      ssg.close();
         *
         *      errors = ssg.getErrorsList();
         *
         * */
        public override void generateSummaryFile(String summaryFile)
        {
            if (archiveDocumentsLoaded == false || profileLoaded == false || informationsLoaded == false)
                return;
            if (currentPass == 1) {
                if (traceActions) tracesWriter.WriteLineFlush("\n-----------------------------------------\n");
                if (traceActions) tracesWriter.WriteLineFlush("Début de l'évaluation du nombre de documents");
                if (traceActions) tracesWriter.WriteLineFlush("\n-----------------------------------------\n");
                Console.WriteLine("Début de l'évaluation du nombre de documents");
            }
            if (currentPass == 2) {
                if (traceActions) tracesWriter.WriteLineFlush("\n-----------------------------------------\n");
                if (traceActions) tracesWriter.WriteLineFlush("Début de génération du bordereau");
                if (traceActions) tracesWriter.WriteLineFlush("\n-----------------------------------------\n");
                Console.WriteLine("Début de génération du bordereau");
                // Create the XmlDocument.
                XmlWriterSettings settings = new XmlWriterSettings();
                settings.Indent = true;
                docOut = XmlWriter.Create(summaryFile, settings);
            }

            try {
                if (currentPass == 2) docOut.WriteStartDocument();
                grammarNode = docIn.SelectSingleNode("rng:grammar", docInXmlnsManager);
                XmlNode startNode = docIn.SelectSingleNode("rng:grammar/rng:start/rng:ref", docInXmlnsManager);
                if (grammarNode != null && startNode != null) {
                    // SEDA 1.0 "fr:gouv:culture:archivesdefrance:seda:v1.0"
                    // SEDA 0.2 "fr:gouv:ae:archive:draft:standard_echange_v0.2"
                    String sTestSeda = grammarNode.Attributes.GetNamedItem("ns").Value;
                    if (sTestSeda == "fr:gouv:ae:archive:draft:standard_echange_v0.2") {
                        SEDA_version = "0.2";
                    } else
                        if (sTestSeda == "fr:gouv:culture:archivesdefrance:seda:v1.0") {
                            SEDA_version = "1.0";
                        } else {
                            SEDA_version = "Version du SEDA inconnue";
                            errorsList.Add("Version du SEDA inconnue : '" + sTestSeda + "'");
                        }
                    recurseDefine(startNode.Attributes.GetNamedItem("name").Value, "");
                } else {
                    if (currentPass == 2) {
                        if (grammarNode == null) {
                            errorsList.Add("Le nœud '" + "rng:grammar" + "' n'a pas été trouvé dans le profil '" + profileFile + "'");
                        } else {
                            errorsList.Add("Le nœud '" + "rng:grammar/rng:start/rng:ref" + "' n'a pas été trouvé dans le profil '" + profileFile + "'");
                        }
                    }
                }
            }
            catch (XPathException e) {
                if (traceActions) tracesWriter.WriteLineFlush("Exception XPath...");
                if (traceActions) tracesWriter.WriteLineFlush(e.Message);
                if (currentPass == 2) errorsList.Add("generateSummaryFile :" + e.GetType().Name + " " + e.Message);
            }
            if (currentPass == 2) {
                docOut.WriteEndDocument();
                docOut.Close();
            }

            if (currentPass == 1)  {
                if (traceActions) tracesWriter.WriteLineFlush("\n-----------------------------------------\n");
                if (traceActions) tracesWriter.WriteLineFlush("Fin de l'évaluation du nombre de documents");
                if (traceActions) tracesWriter.WriteLineFlush("\n-----------------------------------------\n");
                Console.WriteLine("Fin de l'évaluation du nombre de documents");
                rootContainsNode.computeNbDocuments();
                if (traceActions) tracesWriter.WriteLineFlush(rootContainsNode.dump());
                bool bAllMandatoryContainsHaveDocuments = true;
                String sListMandatoryContainsInError = String.Empty;
                if (traceActions) {
                    ContainsNode node = rootContainsNode;
                    while (node != null) {
                        if (node.getMandatory() == true && node.getNbDocuments() == 0) {
                            bAllMandatoryContainsHaveDocuments = false;
                            sListMandatoryContainsInError += node.getName();
                            sListMandatoryContainsInError += "\t";
                        }
                        tracesWriter.WriteLineFlush("next node = " + node.getName() + " docs = " + node.getNbDocuments() + " mandatory = " + node.getMandatory() );
                        node = node.next();
                    }
                }
                if (bAllMandatoryContainsHaveDocuments == false) {
                    if (traceActions) tracesWriter.WriteLineFlush("Il existe des unités documentaires obligatoires sans documents : " + sListMandatoryContainsInError);
                    errorsList.Add("Il existe des unités documentaires obligatoires sans documents : " + sListMandatoryContainsInError);

                } else {
                    currentPass = 2;
                    rootContainsNode.trunkChildrenOfEmptyBranches();
                    if (traceActions) tracesWriter.WriteLineFlush(rootContainsNode.dump());
                    currentContainsNode = rootContainsNode;
                    firstContainsNode = true; // Indique que le prochain nœud Contains est le premier
                    currentDocumentTypeId = "root";
                    generateSummaryFile(summaryFile);
                }
            } else {
                if (traceActions) tracesWriter.WriteLineFlush("\n-----------------------------------------\n");
                if (traceActions) tracesWriter.WriteLineFlush("Fin de génération du bordereau");
                if (traceActions) tracesWriter.WriteLineFlush("\n-----------------------------------------\n");
                Console.WriteLine("Fin de génération du bordereau");
            }
        }
コード例 #15
0
 /*
  * Ajoute un nœud au nœud courant
  * */
 public ContainsNode addNewNode(String newNodeId, bool bContainsIsMandatory)
 {
     int numeroTag = 0;
     if (newNodeId.EndsWith("+")) {
         numeroTag++;
         String nodeName = newNodeId.Substring(0,newNodeId.Length-1);
         foreach (ContainsNode child in this.childrens) {
             // Le nom des frères peut commener par nodeName
             // Le nom du frère est donc de la forme nodeName[numero]
             String brotherName = child.getName();
             Regex r = new Regex(nodeName + @"\[#(\d+)\]");
             Match m = r.Match(brotherName);
             if (m.Success) {
                 try {
                     int newNumeroTag = Convert.ToInt32(m.Groups[1].ToString()) + 1;
                     if (newNumeroTag > numeroTag)
                         numeroTag = newNumeroTag;
                 } catch (Exception e) { e.ToString(); }
             }
         }
     }
     if (numeroTag > 0)
             newNodeId = newNodeId.Substring(0, newNodeId.Length - 1) + "[#" + numeroTag + "]";
     ContainsNode newNode = new ContainsNode(newNodeId, this, bContainsIsMandatory);
     this.childrens.Add(newNode);
     return newNode;
 }
コード例 #16
0
        /*
         * Écriture des balisesUniques d'un rng:element
         * Si le contenu fait appel à des rng:define peut appeler recurseDefine
         *
         * */
        protected bool genElement(XmlNode elemNode, String tagToWrite, String context)
        {
            String dataString = null;
            int counter = 1;
            bool callNextDocument = false;
            if (tagToWrite == "Document") {
                if (currentDocumentTypeId != null) {
                    String typeId = currentContainsNode.getRelativeContext();
                    String documentIdentification = lookupForDocumentIdentification(elemNode);
                    bool withDocumentIdentification = documentIdentification != String.Empty;
                    if (withDocumentIdentification) {
                        typeId += "{" + documentIdentification + "}";
                    }
                    counter = archiveDocuments.prepareListForType(typeId, withDocumentIdentification);
                    if (traceActions) tracesWriter.WriteLineFlush("genElement Document : typeId " + typeId + " has " + counter + " documents");
                    callNextDocument = true;
                }
            }

            for (int bcl = 0; bcl < counter; ++bcl) {
                if (callNextDocument)
                    archiveDocuments.nextDocument();

                if (traceActions) tracesWriter.WriteLineFlush("genElement (" + elemNode.Name + ", " + tagToWrite + ", " + context + ")");
                try {
                    if (currentPass == 2) {
                        if (tagToWrite == "ArchiveTransfer") {
                            // SEDA 1.0 "fr:gouv:culture:archivesdefrance:seda:v1.0"
                            // SEDA 0.2 "fr:gouv:ae:archive:draft:standard_echange_v0.2"
                            docOut.WriteStartElement(tagToWrite, grammarNode.Attributes.GetNamedItem("ns").Value);

                        }
                        else
                            docOut.WriteStartElement(tagToWrite);
                    }
                }
                catch (InvalidOperationException e) {
                    if (traceActions) tracesWriter.WriteLineFlush("Unable to write start element " + tagToWrite);
                    if (traceActions) tracesWriter.WriteLineFlush(e.Message);
                }

                if (elemNode.HasChildNodes) {
                    foreach (XmlNode node in elemNode.ChildNodes) {
                        switch (node.Name) {
                            case "rng:ref":
                                String newContext = context + "/" + tagToWrite;
                                if (node.Attributes != null) {
                                    if (node.Attributes.GetNamedItem("name").Value.Equals("anyElement"))
                                        dataString = getTag(tagToWrite, context);
                                    else
                                        recurseDefine(node.Attributes.GetNamedItem("name").Value, newContext);
                                }
                                break;
                            case "rng:value":
                                dataString = node.InnerText;
                                break;
                            case "rng:data":
                                dataString = getTag(tagToWrite, context);
                                break;
                            default:
                                if (traceActions) tracesWriter.WriteLineFlush("genElement  ----  !!!! currentNode.Name Unhandled '" + node.Name + "' in context '" + context + "' for tag2write '" + tagToWrite + "'");
                                break;
                        }
                    }
                }
                try {
                    if (dataString != null)
                        if (currentPass == 2) docOut.WriteString(dataString);
                }
                catch (InvalidOperationException e) {
                    if (traceActions) tracesWriter.WriteLineFlush("Unable to write string content " + dataString);
                    if (traceActions) tracesWriter.WriteLineFlush(e.Message);
                }
                try {
                    if (currentPass == 1) {
                        // On redescend dans l'arbre des ContainsNode
                        // en passe 2 on utilise la méthode next qui permet de parcurir l'arbre comme un vecteur
                        if ((tagToWrite == "Contains" // SEDA 0.2
                            || tagToWrite == "ArchiveObject" || tagToWrite == "Archive") // SEDA 1.0
                            && currentContainsNode != rootContainsNode)
                            currentContainsNode = currentContainsNode.getParent();
                    }
                    if (currentPass == 2) docOut.WriteEndElement();
                }
                catch (InvalidOperationException e) {
                    if (traceActions) tracesWriter.WriteLineFlush("Unable to write end element " + tagToWrite);
                    if (traceActions) tracesWriter.WriteLineFlush(e.Message);
                }
            }
            return true;
        }
コード例 #17
0
 /*
  * Création de la liste de tous les nœuds de l'arbre
  * */
 protected void getNodesList(ContainsNode startNode, List<ContainsNode> lstNodes)
 {
     foreach (ContainsNode curNode in startNode.childrens) {
         lstNodes.Add(curNode);
         getNodesList(curNode, lstNodes);
     }
 }
コード例 #18
0
 protected void findDuplicates(List<ContainsNode> lstNodes, ContainsNode checkedNode, String excluded, Dictionary<String, Int32> identifiers)
 {
     // on ne teste que si on a atteint l'identifiant pour éviter de traiter tout l'arbre avec chaque identifiant
     bool bTester = false;
     foreach (ContainsNode curNode in lstNodes) {
         if (curNode != checkedNode) {
             if (bTester != false)
                 continue;
             if (curNode.objectIdentifier.Equals(checkedNode.objectIdentifier))
                 if (!curNode.objectIdentifier.Equals(excluded)) {
                     if (identifiers.ContainsKey(curNode.objectIdentifier)) {
                         identifiers[curNode.objectIdentifier] = identifiers[curNode.objectIdentifier] + 1;
                     }
                 }
         } else {
             if (!identifiers.ContainsKey(curNode.objectIdentifier)) {
                 identifiers.Add(curNode.objectIdentifier, 1);
             }
             bTester = true;
         }
     }
 }
コード例 #19
0
 /*
  * Pour la détection de doublons, doit être appelé sur
  * le nœud racine pour une évaluation complète
  * */
 public StringCollection checkDuplicates(ContainsNode rootNode, String excluded)
 {
     Dictionary<String, Int32> identifiers = new Dictionary<String, Int32>();
     List<ContainsNode> lstNodes = new List<ContainsNode>();
     getNodesList(rootNode, lstNodes);
     foreach (ContainsNode checkedNode in lstNodes) {
         checkedNode.findDuplicates(lstNodes, checkedNode, excluded, identifiers);
     }
     StringCollection duplicates = new StringCollection();
     Dictionary<String, int>.KeyCollection keys = identifiers.Keys;
     foreach (String key in keys) {
         if (identifiers[key] > 1) {
             duplicates.Add ("L'identifiant " + key + " n'est pas unique, il est utilisé " + identifiers[key] + " fois.");
         }
     }
     return duplicates;
 }
コード例 #20
0
        public void C15_getRelativeContextTest()
        {
            ContainsNode root = new ContainsNode("root", null, true);
            ContainsNode A_1 = root.addNewNode("A[#1]", true);
            ContainsNode AA_1 = A_1.addNewNode("AA", false);
                                AA_1.addNewNode("AAA[#1]", true);
                                AA_1.addNewNode("AAA[#2]", true);
            ContainsNode tst_1 = AA_1.addNewNode("AAA[#3]", true);

            ContainsNode BB_1 = A_1.addNewNode("BB", true);
                                BB_1.addNewNode("BBB[#1]", true);
            ContainsNode tst_2 = BB_1.addNewNode("BBB[#2]", true);
                                BB_1.addNewNode("BBB[#3]", true);

            ContainsNode A_2 = root.addNewNode("A[#2]", false);
            ContainsNode AA_2 = A_2.addNewNode("AA", false);
            ContainsNode tst_3 = AA_2.addNewNode("AAA[#1]", true);
                                AA_2.addNewNode("AAA[#2]", true);
                                AA_2.addNewNode("AAA[#3]", true);

            ContainsNode BB_2 = A_2.addNewNode("BB", true);
                                BB_2.addNewNode("BBB[#1]", true);
                                BB_2.addNewNode("BBB[#2]", true);
                                BB_2.addNewNode("BBB[#3]", true);
            ContainsNode tst_4 = BB_2.addNewNode("BBB[#4]", true);

            Assert.AreEqual("A[#1]//AAA[#3]", tst_1.getRelativeContext(), false, "tst_1.getRelativeContext()");
            Assert.AreEqual("A[#1]//BBB[#2]", tst_2.getRelativeContext(), false, "tst_2.getRelativeContext()");
            Assert.AreEqual("A[#2]//AAA[#1]", tst_3.getRelativeContext(), false, "tst_3.getRelativeContext()");
            Assert.AreEqual("A[#2]//BBB[#4]", tst_4.getRelativeContext(), false, "tst_4.getRelativeContext()");
        }