コード例 #1
0
ファイル: MarcDiff.cs プロジェクト: renyh1013/dp2
        // 按照字段修改权限定义,合并新旧两个 MARC 记录
        // parameters:
        //      strDefaultOperation   insert/replace/delete 之一或者逗号间隔组合
        // return:
        //      -1  出错
        //      0   成功
        //      1   有部分修改要求被拒绝
        public static int MergeOldNew(
            string strDefaultOperation,
            string strFieldNameList,
            string strOldMarc,
            ref string strNewMarc,
            out string strComment,
            out string strError)
        {
            strError = "";
            strComment = "";
            int nRet = 0;

            if (string.IsNullOrEmpty(strOldMarc) == true && string.IsNullOrEmpty(strNewMarc) == true)
                return 0;

#if NO
            bool bNew = false;
            bool bDelete = false;
            bool bChange = false;

            if (string.IsNullOrEmpty(strAction) == true)
            {
                bNew = true;
                bDelete = true;
                bChange = true;
            }
            else
            {
                bNew = StringUtil.IsInList("new", strAction);
                bDelete = StringUtil.IsInList("delete", strAction);
                bChange = StringUtil.IsInList("change", strAction);
            }
#endif

            string strOldHeader = "";
            string strNewHeader = "";
            string strOldBody = "";
            string strNewBody = "";

            SplitMarc(strOldMarc,
                out strOldHeader,
                out strOldBody);
            SplitMarc(strNewMarc,
                out strNewHeader,
                out strNewBody);

            if (strOldHeader.Length < 24)
                strOldHeader = strOldHeader.PadRight(24, '?');
            if (strNewHeader.Length < 24)
                strNewHeader = strNewHeader.PadRight(24, '?');

#if NO
            FieldNameList list = new FieldNameList();
            nRet = list.Build(strFieldNameList, out strError);
            if (nRet == -1)
            {
                strError = "字段权限定义 '" + strFieldNameList + "' 不合法: " + strError;
                return -1;
            }
#endif
            
            OperationRights rights_table = new OperationRights();
            nRet = rights_table.Build(strFieldNameList,
                strDefaultOperation,
                out strError);
            if (nRet == -1)
            {
                strError = "字段权限定义 '" + strFieldNameList + "' 不合法: " + strError;
                return -1;
            }

            var differ = new MarcDiffer();
            var builder = new MarcDiffBuilder(differ);
            var result = builder.BuildDiffModel(strOldBody, strNewBody);

            Debug.Assert(result.OldText.Lines.Count == result.NewText.Lines.Count, "");

            /*
    public enum ChangeType
    {
        Unchanged,
        Deleted,
        Inserted,
        Imaginary,
        Modified
    }
             * */
            // 字段名如果最后增加了一个 ! 字符,表示这是因为 856 权限原因被拒绝操作的字段。如果 856 字段名后面没有 ! 字符,则表示是因为 fieldnamelist 定义缘故被拒绝的
            // 被拒绝插入的字段名
            List<string> denied_insert_fieldnames = new List<string>();
            // 被拒绝删除的字段名
            List<string> denied_delete_fieldnames = new List<string>();
            // 被拒绝修改的字段名
            List<string> denied_change_fieldnames = new List<string>();

            bool bNotAccepted = false;
            List<string> fields = new List<string>();
            for (int index = 0; index < result.NewText.Lines.Count; index ++ )
            {
                var newline = result.NewText.Lines[index];
                var oldline = result.OldText.Lines[index];

                // 2013/11/18
                if (string.IsNullOrEmpty(newline.Text) == true
    && string.IsNullOrEmpty(oldline.Text) == true)
                    continue;

                string strNewFieldName = GetFieldName(newline.Text);
                // string strOldFieldName = GetFieldName(oldline.Text);

                if (newline.Type == ChangeType.Unchanged)
                {
                    fields.Add(RemoveMask(newline.Text));
                }
                else if (newline.Type == ChangeType.Inserted)
                {
                    Debug.Assert(strNewFieldName != null, "");

                    // 注:有标记的字段不允许插入
                    bool bMask = HasMask(newline.Text);

                    if (rights_table.InsertFieldNames.Contains(strNewFieldName) == true
                        && bMask == false)
                        fields.Add(newline.Text);
                    else
                    {
                        denied_insert_fieldnames.Add(strNewFieldName 
                            + (bMask ? "!" : ""));
                        bNotAccepted = true;
                    }
                }
                else if (newline.Type == ChangeType.Modified)
                {
                    Debug.Assert(strNewFieldName != null, "");

                    Debug.Assert(oldline.Type == ChangeType.Modified, "");

                    // 看新旧字段名是否都在可修改范围内
                    string strOldFieldName = GetFieldName(oldline.Text);
                    Debug.Assert(strOldFieldName != null, "");

                    // 注:如果 new 有标记,说明如果替换后,前端看不到这种替换,所以不允许替换
                    //  如果 old 有标记,则替换会超越权限,等于删除了不应删除的 856
                    //  等于前端只能将能管辖的 856 改成新的也能管辖的状态才被允许
                    bool bMaskNew = HasMask(newline.Text);
                    bool bMaskOld = HasMask(oldline.Text);

                    bool bReserveOld = false;

                    if (rights_table.ReplaceFieldNames.Contains(strNewFieldName) == true
                        && rights_table.ReplaceFieldNames.Contains(strOldFieldName) == true
                        )
                    {
                        if (bMaskNew == false && bMaskOld == false)
                            fields.Add(newline.Text);
                        if (bMaskNew == true && bMaskOld == false)
                        {
                            bReserveOld = true;
                        }
                        if (bMaskNew == false && bMaskOld == true)
                        {
                            // 有时候这种情况:
                            //    111 -> 删除
                            //    222 -> 2222 (修改内容)
                            // 会被识别成
                            //    111 -> 2222 (修改内容)
                            //    222 -> 删除
                            // 这样,第一个修改动作应该不接受。循环到后面,第二个修改正好被接受,所以总体上不会造成 222 重复
                            // 所以,第一个修改此时操作办法:old new 都进去
                            fields.Add(RemoveMask(oldline.Text));
                            fields.Add(newline.Text);
                        }
                        if (bMaskNew == true && bMaskOld == true)
                        {
                            bReserveOld = true;
                        }
                    }
                    
                    if (bReserveOld)
                    {
                        fields.Add(RemoveMask(result.OldText.Lines[index].Text));    // 依然采用修改前的值
                        bNotAccepted = true;

                        denied_change_fieldnames.Add(strOldFieldName
                            + (bMaskNew ? "!" : ""));
                    }
                }
                else if (oldline.Type == ChangeType.Deleted)
                {
                    string strOldFieldName = GetFieldName(oldline.Text);
                    Debug.Assert(strOldFieldName != null, "");

                    // 注:有标记的字段不允许用于删除
                    bool bMask = HasMask(oldline.Text);

                    if (rights_table.DeleteFieldNames.Contains(strOldFieldName) == false
                        || bMask == true)
                    {
                        fields.Add(RemoveMask(oldline.Text));   // 不允许删除

                        // 当具有标记的时候,表示这是因为旧记录中的字段权限禁止当前用户获取,造成前端得不到这个字段,然后在提交保存的时候也就没有这个字段,并不是前端故意要删除这个字段,因而也就不要做 partial_denied 提示了
                        if (bMask == false)
                        {
                            bNotAccepted = true;

                            denied_delete_fieldnames.Add(strOldFieldName
                                + (bMask ? "!" : ""));
                        }
                    }
                    else
                    {
                        // bNotAccepted = true; // BUG
                    }
                }
            }

            StringBuilder text = new StringBuilder(4096);
            if (rights_table.ReplaceFieldNames.Contains("###") == true
                || rights_table.InsertFieldNames.Contains("###") == true)
                text.Append(strNewHeader);
            else
            {
                if (strNewHeader != strOldHeader)
                {
                    bNotAccepted = true;
                    denied_change_fieldnames.Add("###");    // ### 表示头标区
                }
                text.Append(strOldHeader);
            }

            foreach (string s in fields)
            {
                if (string.IsNullOrEmpty(s) == true)
                    continue;
                text.Append(s);
                text.Append((char)30);
            }

            if (denied_insert_fieldnames.Count > 0)
                strComment += "字段 " + StringUtil.MakePathList(denied_insert_fieldnames)+ " 被拒绝插入";

            if (denied_delete_fieldnames.Count > 0)
            {
                if (string.IsNullOrEmpty(strComment) == false)
                    strComment += " ; ";
                strComment += "字段 " + StringUtil.MakePathList(denied_delete_fieldnames) + " 被拒绝删除";
            }

            if (denied_change_fieldnames.Count > 0)
            {
                if (string.IsNullOrEmpty(strComment) == false)
                    strComment += " ; ";
                strComment += "字段 " + StringUtil.MakePathList(denied_change_fieldnames) + " 被拒绝修改";
            }

            strNewMarc = text.ToString();
            if (bNotAccepted == true)
                return 1;
            return 0;
        }
コード例 #2
0
ファイル: MarcDiff.cs プロジェクト: renyh1013/dp2
        // 根据字段权限定义过滤出允许的内容
        // return:
        //      -1  出错
        //      0   成功
        //      1   有部分字段被修改或滤除
        public static int FilterFields(string strFieldNameList,
            ref string strMarc,
            out string strError)
        {
            strError = "";
            int nRet = 0;
            bool bChanged = false;

            if (string.IsNullOrEmpty(strMarc) == true)
                return 0;

            string strHeader = "";
            string strBody = "";

            SplitMarc(strMarc,
                out strHeader,
                out strBody);

            if (strHeader.Length < 24)
            {
                strHeader = strHeader.PadRight(24, '?');
                bChanged = true;
            }

            FieldNameList list = new FieldNameList();
            nRet = list.Build(strFieldNameList, out strError);
            if (nRet == -1)
            {
                strError = "字段权限定义 '"+strFieldNameList+"' 不合法: " + strError;
                return -1;
            }

            StringBuilder text = new StringBuilder(4096);
            if (list.Contains("###") == true)
                text.Append(strHeader);
            else
            {
                bChanged = true;
                text.Append(new string('?', 24));
            }

            string[] fields = strBody.Split(new char[] {(char)30}, StringSplitOptions.RemoveEmptyEntries);
            foreach (string s in fields)
            {
                if (string.IsNullOrEmpty(s) == true)
                    continue;

                string strFieldName = GetFieldName(s);
                if (list.Contains(strFieldName) == false)
                {
                    bChanged = true;
                    continue;
                }

                text.Append(s);
                text.Append((char)30);
            }

            strMarc = text.ToString();
            if (bChanged == true)
                return 1;
            return 0;
        }
コード例 #3
0
ファイル: AppBiblio.cs プロジェクト: paopaofeng/dp2
        // 根据允许的字段名列表,合并新旧两条书目记录
        // 列表中不允许的字段,沿用旧记录中的原始字段内容
        // 算法等于在 new 中复原了那些不让修改的 MARC 字段
        static int MergeOldNewBiblioByFieldNameList(
            string strFieldNameList,
            string strOldBiblioXml,
            ref string strNewBiblioXml,
            out string strError)
        {
            strError = "";
            int nRet = 0;

            XmlDocument domNew = new XmlDocument();
            if (String.IsNullOrEmpty(strNewBiblioXml) == true)
                strNewBiblioXml = "<root />";
            try
            {
                domNew.LoadXml(strNewBiblioXml);
            }
            catch (Exception ex)
            {
                strError = "strNewBiblioXml装入XMLDOM时出错: " + ex.Message;
                return -1;
            }

            string strNewSave = domNew.OuterXml;

            XmlDocument domOld = new XmlDocument();
            if (String.IsNullOrEmpty(strOldBiblioXml) == true
                || (string.IsNullOrEmpty(strOldBiblioXml) == false && strOldBiblioXml.Length == 1))
                strOldBiblioXml = "<root />";
            try
            {
                domOld.LoadXml(strOldBiblioXml);
            }
            catch (Exception ex)
            {
                strError = "strOldBiblioXml装入XMLDOM时出错: " + ex.Message;
                return -1;
            }

            string strMarcSyntax = "";

            // 探测MARC格式
            // return:
            //      -1  error
            //      0   无法探测
            //      1   探测到了
            nRet = DetectMarcSyntax(domNew,
            out strMarcSyntax,
            out strError);
            if (nRet == -1)
                return -1;
            if (nRet == 0)
            {
                nRet = DetectMarcSyntax(domOld,
out strMarcSyntax,
out strError);
                if (nRet == -1)
                    return -1;
                if (nRet == 0)
                {
                    strError = "无法探测到 MARC 格式";
                    return -1;
                }
            }

            FieldNameList list = new FieldNameList();
            nRet = list.Build(strFieldNameList, out strError);
            if (nRet == -1)
                return -1;

            XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());
            nsmgr.AddNamespace("unimarc", Ns.unimarcxml);
            nsmgr.AddNamespace("usmarc", Ns.usmarcxml);

            XmlNode old_root = domOld.DocumentElement.SelectSingleNode("//" + strMarcSyntax + ":record", nsmgr);
            if (old_root == null)
            {
                // 对 new 过滤出全部可以修改的字段即可
                XmlNodeList new_nodes = domNew.DocumentElement.SelectNodes("//" + strMarcSyntax + ":leader | //" + strMarcSyntax + ":controlfield | //" + strMarcSyntax + ":datafield",
nsmgr);
                foreach (XmlNode node in new_nodes)
                {
                    XmlElement element = (XmlElement)node;
                    string strTag = GetTag(element);

                    // TODO:如果连头标区也要滤除,要保留一个缺省值的头标区
                    if (list.Contains(strTag) == false && strTag != "###")
                        node.ParentNode.RemoveChild(node);

                }
                strNewBiblioXml = domNew.DocumentElement.OuterXml;
                return 0;
            }

            XmlNode new_root = domNew.DocumentElement.SelectSingleNode("//" + strMarcSyntax + ":record", nsmgr);
            if (new_root == null)
            {
                // new 里面没有任何 MARC 字段,因此不必作了
                return 0;
            }

            // 1) 把 new 中的 不允许修改的字段标记出来
            List<XmlNode> reserve_nodes = new List<XmlNode>();
            {
                XmlNodeList new_nodes = domNew.DocumentElement.SelectNodes("//" + strMarcSyntax + ":leader | //" + strMarcSyntax + ":controlfield | //" + strMarcSyntax + ":datafield",
                    nsmgr);
                foreach (XmlNode node in new_nodes)
                {
                    XmlElement element = (XmlElement)node;
                    string strTag = GetTag(element);

                    if (list.Contains(strTag) == false)
                        reserve_nodes.Add(element);
                }
            }

            // 2) 从 old 中把全部不允许修改的字段对应位置一个一个覆盖 new 中的对应字段。如果在 new 中没有找到对应字段,在插入在最后一个同名字段后面,如果没有同名字段,则插入到适当的顺序位置
            XmlNodeList old_nodes = domOld.DocumentElement.SelectNodes("//" + strMarcSyntax + ":leader | //" + strMarcSyntax + ":controlfield | //" + strMarcSyntax + ":datafield",
    nsmgr);
            foreach (XmlNode node in old_nodes)
            {
                XmlElement element = (XmlElement)node;
                string strTag = GetTag(element);

                if (list.Contains(strTag) == true)
                    continue;

                XmlElement last_same_name_node = null;
                // 在另一边(nodes内)寻找对应的字段元素
                // parameters:
                //      last_same_name_node 最后一个同tag名的元素
                XmlElement target = FindElement(element,
                    new_root,
                    out last_same_name_node);
                if (target != null)
                {
                    target.InnerXml = element.InnerXml;
                    if (target.LocalName == "datafield")
                    {
                        // 还要修改 ind1 ind2 属性
                        target.SetAttribute("ind1", element.GetAttribute("ind1"));
                        target.SetAttribute("ind2", element.GetAttribute("ind2"));
                    }
                    reserve_nodes.Remove(target);
                    continue;
                }

                if (last_same_name_node != null)
                {
                    last_same_name_node.InsertAfter(domNew.ImportNode(element, true), last_same_name_node);
                    continue;
                }

                // 找到一个合适的位置插入
                insertSequence(element, new_root);
            }

            // 3) 在 new 中把没有被覆盖的标记了的字段全部删除
            foreach (XmlNode node in reserve_nodes)
            {
                node.ParentNode.RemoveChild(node);
            }

            strNewBiblioXml = domNew.DocumentElement.OuterXml;
            return 0;
        }