Beispiel #1
0
 public string GetHeaders(ListStr lHeaders)
 {
     if (conf.overrideHeaders)
     {
         return(conf.lCustomHeaders.ToStr(conf.separator));
     }
     return(lHeaders.ToStr(conf.separator));
 }
Beispiel #2
0
            /// <summary>
            /// List all custom properties available for mappings
            /// </summary>
            /// <param name="l">List of properties</param>
            protected override void AddPropertyNamesToList(ListStr l)
            {
                //add custom properties (slack.channel.*) of channel for Log 20
                l.Add(channel.EltKeys(), "slack.channel.");

                //add custom properties (slack.message.*) of message for Log 20
                l.Add(file.EltKeys(), "slack.file.");

                //default properties
                base.AddPropertyNamesToList(l);
            }
Beispiel #3
0
 /// <summary>
 /// Constructor to reconstruct a comment object based on the content of the index.
 /// </summary>
 /// <param name="cursor">The cursor from which to retrieve the comment data</param>
 /// <param name="currentUserId">Current user requesting this comment</param>
 public Comment(Cursor cursor, string currentUserId)
 {
     commentid   = cursor.GetColumn("id");
     docid       = cursor.GetColumn("docid");
     message     = cursor.GetColumn("message");
     userid      = cursor.GetColumn("userid");
     username    = cursor.GetColumn("username");
     creation    = Sys.ToDat(cursor.GetColumn("creation")); // Dates in the index are UTC dates!
     modified    = Sys.ToDat(cursor.GetColumn("modified"));
     likes       = ListStr.ListFromStr(cursor.GetColumn("likes"), ';');
     likedByUser = likes.Contains(currentUserId);
     replyto     = cursor.GetColumn("replyto") ?? "";
     deleted     = Sys.ToBoo(cursor.GetColumn("deleted"));
 }
Beispiel #4
0
 /// <summary>
 /// Constructor to initialize a new comment based on its minimal required inputs
 /// Other fields like the comment id and dates are initialized based on those inputs.
 /// </summary>
 /// <param name="docid">id of the document to which the comment is attached</param>
 /// <param name="message">textual content of the comment</param>
 /// <param name="user">principal of the author of the comment</param>
 /// <param name="replyto">optional id of the parent comment, if this is a reply</param>
 public Comment(string docid, string message, CCPrincipal user, string replyto)
 {
     creation     = Dat.ToUtc(DateTime.Now);
     commentid    = $"{docid}|{Str.Md5(user.UserId + creation.ToBinary())}";
     this.docid   = docid;
     this.message = message;
     userid       = user.UserId;
     username     = user.FullName;
     if (Str.IsEmpty(username))
     {
         username = user.Name;
     }
     modified     = creation;
     likes        = new ListStr();
     likedByUser  = false;
     this.replyto = replyto;
     deleted      = false;
 }
Beispiel #5
0
        /// <summary>
        /// Get the number of comments for a given document or multiple documents
        /// at once if a list of ids is provided
        /// </summary>
        /// <param name="client"></param>
        /// <param name="docid"></param>
        private void Count(EngineClient client, string docid)
        {
            ListStr docids = Method.JsonRequest.ValueListStr("docids");

            if (docids != null && docids.Count > 0)
            {
                var sep = dynamicSeparator("=", docids.ToStr(' ')); // Since document ids potentially contains ';', we have to look for a custom separator dynamically
                var sql = $"SELECT DISTRIBUTION('docid,SEPARATOR=\"{sep}\"') AS ids FROM {indexname} WHERE {Sql.In("docid", docids)} LIMIT 1";

                Cursor cursor = client.ExecCursor(sql);
                if (cursor != null)
                {
                    // Write JSON
                    var counts = Json.NewObject();
                    var pairs  = cursor.GetAttribute("ids").Split(new [] { sep }, StringSplitOptions.None);
                    foreach (var pair in pairs)
                    {
                        int i = pair.LastIndexOf(';');
                        counts.Set(pair.Substring(0, i), int.Parse(pair.Substring(i + 1)));
                    }
                    JsonResponse.Set("counts", counts);
                }
                else
                {
                    throw new Exception("Cursor is null!");
                }
            }
            else
            {
                var sql = $"SELECT id FROM {indexname} WHERE docid={Str.SqlValue(docid)} ORDER BY modified LIMIT 1";

                Cursor cursor = client.ExecCursor(sql);
                if (cursor != null)
                {
                    // Write JSON
                    JsonResponse.Set("count", cursor.TotalRowCount);
                }
                else
                {
                    throw new Exception("Cursor is null!");
                }
            }
        }
Beispiel #6
0
        public override Return OnExecute()
        {
            string           indexes;
            HashSet <string> hsMD5       = new HashSet <string>();
            int     emptyLinesCount      = 0;
            int     duplicatesLinesCount = 0;
            int     writtenLinesCount    = 0;
            int     rowProcessed         = 0;
            ListStr lHeaders             = new ListStr();

            EngineClient _client = null;

            Sinequa.Engine.Client.Cursor _cursor = null;

            //do not use StreamWriter in a using statement. In simulate mode the file is not created so this will trigger an exception.
            StreamWriter sw = null;

            try
            {
                _client = EngineClientsPool.FromPoolByIndexList(conf.listIndexes, out indexes, conf.engine, false);
            }
            catch (Exception ex)
            {
                Sys.LogError("Cannot get Engine Client from pool for indexes [" + conf.listIndexes + "]");
                Sys.LogError(ex);
                return(Return.Error);
            }
            Sys.Log("Using Engine client  [" + _client.Name + "]");

            try
            {
                Sys.Log("Execute query [" + conf.GetSQL() + "]");

                _cursor = _client.ExecCursor(conf.GetSQL());

                if (_cursor == null)
                {
                    Sys.LogError("Cannot get cursor for query [" + conf.GetSQL() + "]");
                    return(Return.Error);
                }

                DocExportIndexToCsv doc = new DocExportIndexToCsv(this, _cursor, conf.dColumnColumnAlias);
                var context             = new IDocContext {
                    Doc = doc
                };

                Sys.Log("Query processingtime [" + _cursor.GetAttribute("processingtime") + "]");
                Sys.Log("Query row count [" + _cursor.TotalRowCount + "]");
                int globalTimer = Sys.TimerStart();

                if (!conf.simulate)
                {
                    sw = new StreamWriter(conf.destinationFilePath, false, Encoding.UTF8);
                }

                int localTimer = Sys.TimerStart();
                while (!_cursor.End())
                {
                    rowProcessed++;
                    if (rowProcessed % logStatsEveryNRows == 0)
                    {
                        Sys.Log("----------------------------------------------------");
                        Sys.Log("Number of rows processed [" + rowProcessed + "] ");
                        Sys.Log("Number of lines exported [" + writtenLinesCount + "] ");
                        Sys.Log("Number of empty lines removed [" + emptyLinesCount + "] ");
                        Sys.Log("Number of duplicated lines removed [" + duplicatesLinesCount + "] ");
                        Sys.Log("Processing [" + logStatsEveryNRows + "] rows in [", Sys.TimerGetText(Sys.TickDuration(localTimer)), "]");
                        localTimer = Sys.TimerStart();
                    }

                    ListStr l       = new ListStr();
                    bool    isEmpty = true;

                    for (int i = 0; i < _cursor.ColumnCount; i++)
                    {
                        if (conf.addHeaders && rowProcessed == 1)   //headers
                        {
                            string header = _cursor.GetColumnName(i);
                            if (conf.useDblQuote)
                            {
                                header = "\"" + header + "\"";
                            }
                            lHeaders.Add(header);
                        }

                        string colValue = Str.Empty;
                        //cursor column match column mapping column name ?
                        if (conf.lColumnMapping.Exists(x => Str.EQNC(x.columnName, _cursor.GetColumnName(i))))
                        {
                            //get all matching column mapping for current column
                            List <ColumnMapping> lColumnMapping = conf.lColumnMapping.FindAll(x => Str.EQNC(x.columnName, _cursor.GetColumnName(i)));
                            foreach (ColumnMapping columnMapping in lColumnMapping)
                            {
                                if (columnMapping.slectionQuery.IsSelected(context, doc))  //match selection query ? if so, apply value pattern
                                {
                                    Sys.Log2(40, "Column [" + columnMapping.columnName + "] match selection query [" + columnMapping.slectionQuery.Sql + "]");

                                    colValue = IDocHelper.GetValue(context, doc, columnMapping.valueExpression);
                                    Sys.Log2(40, "Column [" + columnMapping.columnName + "] use value pattern [" + columnMapping.valueExpression + "] = [" + colValue + "]");
                                    break;  //stop mapping when selection query match
                                }
                                else
                                {
                                    Sys.Log2(40, "Column [" + columnMapping.columnName + "] don't match selection query [" + columnMapping.slectionQuery.Sql + "]");
                                    continue;   //go to next expression
                                }
                            }
                        }
                        //no column mapping, get value from cursor
                        else
                        {
                            colValue = _cursor.GetColumn(i);
                        }
                        if (!Str.IsEmpty(colValue))
                        {
                            isEmpty = false;
                        }
                        if (conf.useReplaceSeparator)
                        {
                            colValue = colValue.Replace(conf.separator, conf.replaceSeparator);                            //replace separator in values
                        }
                        if (conf.useDblQuote)
                        {
                            colValue = "\"" + colValue + "\"";                      //use double quote
                        }
                        l.Add(colValue);
                    }

                    string line = l.ToStr(conf.separator);

                    if (conf.removeDuplicates)  //remove duplicates
                    {
                        string MD5 = Str.Md5(line);
                        if (!hsMD5.Add(MD5))
                        {
                            duplicatesLinesCount++;
                            _cursor.MoveNext();
                            continue;
                        }
                    }

                    if (conf.removeEmptyLines && isEmpty)   //remove empty lines
                    {
                        emptyLinesCount++;
                        _cursor.MoveNext();
                        continue;
                    }

                    writtenLinesCount++;
                    if (conf.simulate)  //simulate, add headers and line into logs
                    {
                        if (conf.addHeaders && rowProcessed == 1)
                        {
                            Sys.Log(GetHeaders(lHeaders)); // write headers
                        }
                        Sys.Log(line);                     //write line
                        if (writtenLinesCount >= conf.simulateCount)
                        {
                            break;
                        }
                    }
                    else
                    {
                        if (conf.addHeaders && rowProcessed == 1)
                        {
                            sw.WriteLine(GetHeaders(lHeaders)); // write headers
                        }
                        sw.WriteLine(line);                     //write line
                    }

                    _cursor.MoveNext();
                }

                if (sw != null)
                {
                    sw.Close();             //dispose stream writer
                }
                Sys.Log("----------------------------------------------------");
                if (conf.removeEmptyLines)
                {
                    Sys.Log("Number of empty lines removed [" + emptyLinesCount + "]");
                }
                if (conf.removeDuplicates)
                {
                    Sys.Log("Number of duplicated lines removed [" + duplicatesLinesCount + "]");
                }
                Sys.Log("[" + writtenLinesCount + "] lines exported into file [" + conf.destinationFilePath + "]");
                Sys.Log("Processing [" + rowProcessed + "] rows in [", Sys.TimerGetText(Sys.TickDuration(globalTimer)), "]");
            }
            catch (Exception ex)
            {
                Sys.LogError("Select index Cursor error : ", ex);
                try
                {
                    if (_client != null)
                    {
                        EngineClientsPool.ToPool(_client);
                    }
                }
                catch (Exception exe)
                {
                    Sys.LogError("EngineClientsPool ToPool : ", exe);
                    Sys.Log(exe.StackTrace);
                }
            }
            finally
            {
                try
                {
                    if (_cursor != null)
                    {
                        _cursor.Close();
                    }
                }
                catch (Exception ex)
                {
                    Sys.LogError("Close cursor error : ", ex);
                    Sys.Log(ex.StackTrace);
                }
                EngineClientsPool.ToPool(_client);
            }

            return(base.OnExecute());
        }
Beispiel #7
0
        public bool LoadConfig()
        {
            string value   = Str.Empty;
            string dataTag = Str.Empty;

            Sys.Log2(20, "----------------------------------------------------");
            Sys.Log2(20, "Load configuration");
            Sys.Log2(20, "----------------------------------------------------");

            if (_XMLConf == null)
            {
                Sys.LogError("Cannot read configuration");
                return(false);
            }

            //index list
            dataTag = "CMD_INDEX_LIST";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            listIndexes = CC.Current.Indexes.CleanAliasList(_XMLConf.Value(dataTag, Str.Empty));
            if (String.IsNullOrEmpty(listIndexes))
            {
                Sys.LogError("Invalid configuration property: index list is empty");
                return(false);
            }

            //list columns
            dataTag = "CMD_SELECT";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            value = _XMLConf.Value(dataTag, "*");

            //if only one index and index type is audit => do not resolve column aliases
            CCIndex idx = CC.Current.Indexes.Get(listIndexes);

            isAuditIndex = idx != null && (idx.IndexType == CCIndexType.Audit || idx.IndexType == CCIndexType.AuditReplicated) ? true : false;
            ListStr lcolunmOrColumnAlias = ListStr.ListFromStr(value, ',');

            foreach (string s in lcolunmOrColumnAlias)
            {
                string colunmOrColumnAlias = s.Trim();
                if (!isAuditIndex)
                {
                    dColumnColumnAlias.Add(colunmOrColumnAlias, CC.Current.Global.ResolveColumn(colunmOrColumnAlias));
                }
                else
                {
                    dColumnColumnAlias.Add(colunmOrColumnAlias, colunmOrColumnAlias);
                }
            }

            //where clause
            dataTag = "CMD_WHERE";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            whereCluase = _XMLConf.Value(dataTag, "");
            whereCluase = IDocHelper.GetValuePattern(_ctxt, whereCluase);

            //group by
            dataTag = "CMD_GROUPBY";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            grouBy = _XMLConf.Value(dataTag, "");

            //order by
            dataTag = "CMD_ORDERBY";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            orderBy = _XMLConf.Value(dataTag, "");

            //count
            dataTag = "CMD_COUNT";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            count = _XMLConf.ValueInt(dataTag, -1);

            //Engine
            dataTag = "CMD_ENGINE";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            engine = CC.Current.Engines.CleanAlias(_XMLConf.Value(dataTag, ""));

            //add headers
            dataTag = "CMD_HEADERS";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            addHeaders = _XMLConf.ValueBoo(dataTag, false);

            //Field separator
            dataTag = "CMD_SEPARATOR";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            separator = _XMLConf.ValueChar(dataTag, ',');

            //override headers
            dataTag = "CMD_HEADERS_OVERRIDE";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            overrideHeaders = _XMLConf.ValueBoo(dataTag, false);

            //custom headers
            dataTag = "CMD_HEADERS_CUSTOM";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            string sCustomHeaders = _XMLConf.Value(dataTag, "");

            if (addHeaders && overrideHeaders) //check override header has same number of elements than select statement
            {
                lCustomHeaders = ListStr.ListFromStr2(sCustomHeaders, separator);
                if (lCustomHeaders.Count != dColumnColumnAlias.Count)
                {
                    Sys.LogError("Override headers does not have the same number of elements as select statement");
                    return(false);
                }
            }

            //use replace separator
            dataTag = "CMD_USE_REPLACE";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            useReplaceSeparator = _XMLConf.ValueBoo(dataTag, false);

            //Replace separator in values
            dataTag = "CMD_SEPARATOR_REPLACE";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            replaceSeparator = _XMLConf.ValueChar(dataTag, '/');

            //Enclose fields in double quote
            dataTag = "CMD_DBL_QUOTES";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            useDblQuote = _XMLConf.ValueBoo(dataTag, false);

            //Destination file path
            dataTag = "CMD_FILE_PATH";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            destinationFilePath = CC.Current.EnvVars.Resolve(_XMLConf.Value(dataTag, ""));
            destinationFilePath = IDocHelper.GetValuePattern(_ctxt, destinationFilePath);
            if (Str.IsEmpty(destinationFilePath))
            {
                Sys.LogError("Export file path is empty");
                return(false);
            }

            //Remove duplicate lines
            dataTag = "CMD_DEDUPLICATE";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            removeDuplicates = _XMLConf.ValueBoo(dataTag, false);

            //Remove empty lines
            dataTag = "CMD_REMOVE_EMPTY_LINES";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            removeEmptyLines = _XMLConf.ValueBoo(dataTag, false);

            //Enable simulate mode
            dataTag = "CMD_SIMULATE";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            simulate = _XMLConf.ValueBoo(dataTag, false);

            //Simulate count
            dataTag = "CMD_NB_LINE_SIMULATE";
            if (!DatatagExist(dataTag))
            {
                return(false);
            }
            simulateCount = _XMLConf.ValueInt(dataTag, 1000);

            //Mapping Grid - do not check if DatatagExist - grid is optionnal
            dataTag = "CMD_MAPPING";
            ListOf <XDoc> mappingGridElts = _XMLConf.EltList("CMD_MAPPING");

            for (int i = 0; i < mappingGridElts.Count; i++)
            {
                XDoc   mappingElt          = mappingGridElts.Get(i);
                string columnOrAliasColumn = mappingElt.Value("Column");
                if (String.IsNullOrEmpty(columnOrAliasColumn) || String.IsNullOrWhiteSpace(columnOrAliasColumn))
                {
                    Sys.LogError("Column Mapping - Column cannot be empty");
                    return(false);
                }

                string val = mappingElt.Value("Value");
                if (String.IsNullOrEmpty(val) || String.IsNullOrWhiteSpace(val))
                {
                    Sys.LogError("Column Mapping - Value Pattern cannot be empty for column [" + columnOrAliasColumn + "]");
                    return(false);
                }

                string         squery         = mappingElt.Value("SelectionQuery");
                SelectionQuery selectionQuery = SelectionQuery.FromStr(squery, out string errorMessage);
                if (!Str.IsEmpty(errorMessage))
                {
                    Sys.LogError("Column Mapping - Invalid selection query [" + squery + "] for column [" + columnOrAliasColumn + "] - ", errorMessage);
                    return(false);
                }

                if (!dColumnColumnAlias.TryGetValue(columnOrAliasColumn, out string columnName))
                {
                    columnName = null;
                }
                ColumnMapping columnMapping = new ColumnMapping(columnName, columnOrAliasColumn, val, selectionQuery);
                lColumnMapping.AddUnique(columnMapping);
            }

            Sys.Log2(20, "Load configuration OK");
            LogConfig();

            return(true);
        }
        // es-4959 - new syntax for security clause -- called iff (Sys.SecurityInEngine() == true) --
        // _RightsAsSqlStrXb ::= CHECKACLS('AccessLists="accesslist1,accesslist2,...", DeniedLists="deniedlist1,..."{%F%}') FOR('identity1',...) OPTIONAL('opt_identity1',...) VIRTUAL('virt_identity1',...)
        // where {%F%} is the placeholder for ",FieldRightsAsTextPartWeights="true""
        // when Query.RespectFieldPermissions or Session.Profile.RespectFieldPermissions are true
        private static string RightsAsSqlStrXb(string userId, ListStr otherIdentities, ListStr otherVirtualIdentities)
        {
            if (Str.IsEmpty(userId))
            {
                return(null);
            }
            int deniedcount = CC.Current.Global.DeniedListCount;
            int accesscount = CC.Current.Global.AccessListCount;

            if (accesscount + deniedcount == 0)
            {
                return(null);
            }

            StringBuilder sb = new StringBuilder();

            sb.Append("CHECKACLS('");
            if (accesscount > 0)
            {
                sb.Append("accesslists=\"");
                // accesslist1,accesslist2...
                for (int accessindex = 1; accessindex <= accesscount; accessindex++)
                {
                    if (accessindex > 1)
                    {
                        sb.Append(',');
                    }
                    sb.Append("accesslist"); sb.Append(Sys.ToStr(accessindex));
                }
                sb.Append('"');
            }

            if (deniedcount > 0)
            {
                if (accesscount > 0)
                {
                    sb.Append(',');
                }
                sb.Append("deniedlists=\"");
                // deniedlist1,deniedlist2...
                for (int deniedindex = 1; deniedindex <= deniedcount; deniedindex++)
                {
                    if (deniedindex > 1)
                    {
                        sb.Append(',');
                    }
                    sb.Append("deniedlist"); sb.Append(Sys.ToStr(deniedindex));
                }
                sb.Append('"');
            }

            //sb.Append("{%F%}"); // either ",FieldRightsAsTextPartWeights=\"true\"" or ""

            // add userId.... (required) ; es-5480 - quote ids with Str.SqlValue()
            sb.Append("') FOR ("); sb.Append(Str.SqlValue(userId)); sb.Append(")");

            // add other identities (optional) ....
            int nOptional = ListStr.GetCount(otherIdentities);

            if (nOptional > 0)
            {
                sb.Append(" OPTIONAL("); sb.Append(Str.SqlValue(otherIdentities)); sb.Append(')');
            }

            // add virtualIdentities ...
            int nVirtual = otherVirtualIdentities?.Count ?? 0;

            if (nVirtual > 0)
            {
                sb.Append(" VIRTUAL("); sb.Append(Str.SqlValue(otherVirtualIdentities)); sb.Append(')');
            }

            return(sb.ToString());
        }
Beispiel #9
0
        // Load Peran
        private void listBoxControl2_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (OnAddRole)
            {
                return;
            }

            if (listBoxControl2.SelectedIndex == 0)
            {
                groupControl2.Text    = "Peran Baru :";
                textEdit4.Text        = string.Empty;
                checkEdit4.Checked    = true;
                checkEdit5.Checked    = false;
                simpleButton3.Enabled = false;
                foreach (UserSelection pu in ListUser)
                {
                    pu.Select = false;
                }
                UserGrid.RefreshDataSource();
                CurrentRole        = string.Empty;
                dateEdit3.DateTime = DateTime.Today;
                dateEdit4.DateTime = DateTime.Today;

                //if (sender == null || XtraMessageBox.Show(
                //    "Masukkan Data Hak Akses Peran Lama ke Peran Baru ?",
                //    "Konfirmasi Penyalinan Data Hak Akses ke Peran Baru",
                //    MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)

                foreach (clsModule mdl in ListModule.Values)
                {
                    mdl.Ma.Variables.Clear();
                    mdl.Node.SetValue(treeListColumn2, string.Empty);
                    foreach (List <string> ListStr in mdl.ListKey.Values)
                    {
                        ListStr.Clear();
                    }
                }

                textEdit4.Focus();
            }
            else
            {
                simpleButton3.Enabled = true;
                groupControl2.Text    = "Edit Peran";
                Role Role = BaseSecurity.CurrentLogin.Admin.Role
                            .QueryRole(listBoxControl2.Text);
                if (Role == null)
                {
                    XtraMessageBox.Show(string.Concat("Peran ", listBoxControl2.Text,
                                                      " sudah dihapus dari database !"), "Error Baca Peran",
                                        MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    RemoveSelectedRole();
                }
                else
                {
                    textEdit4.Text     = Role.RoleName;
                    checkEdit4.Checked = Role.IsActive;
                    checkEdit5.Checked = Role.UseDateLimit;
                    dateEdit4.DateTime = Role.StartDate;
                    dateEdit3.DateTime = Role.EndDate;
                    foreach (UserSelection s in ListUser)
                    {
                        s.Select = Role.ListUser.IndexOf(s.UserName) >= 0;
                    }
                    UserGrid.RefreshDataSource();
                    CurrentRole = Role.RoleName;

                    treeList1.BeginUpdate();

                    foreach (clsModule mdl in ListModule.Values)
                    {
                        mdl.Ma.Variables.Clear();
                        mdl.Node.SetValue(treeListColumn2, string.Empty);
                    }

                    // Isi Variabel...
                    IDataReader Rdr = BaseSecurity.CurrentLogin.Admin
                                      .RoleModule.OpenDataReader(Role.RoleName);
                    try
                    {
                        clsModule mdl;
                        while (Rdr.Read())
                        {
                            if (ListModule.TryGetValue(Rdr.GetString(0), out mdl))
                            {
                                BaseUtility.String2Dictionary(Rdr.GetString(1),
                                                              mdl.Ma.Variables);
                                mdl.Node.SetValue(treeListColumn2, mdl.Ma.ToString());
                                mdl.AllDocumentData = Rdr.GetBoolean(2);
                            }
                        }
                    }
                    finally
                    {
                        Rdr.Close();
                        treeList1.EndUpdate();
                    }
                    foreach (clsModule mdl in ListModule.Values)
                    {
                        foreach (List <string> ListStr in mdl.ListKey.Values)
                        {
                            ListStr.Clear();
                        }
                        foreach (ModuleDataField mdf in mdl.Ma.ListDataField)
                        {
                            Rdr = BaseSecurity.CurrentLogin.Admin.RoleModule.GetListDocumentVariable(
                                Role.RoleName, mdl.Ma.ModuleName,
                                mdf.DataFieldName);
                            try
                            {
                                List <string> ListKey = mdl.ListKey[mdf.DataFieldName];
                                ListKey.Clear();
                                while (Rdr.Read())
                                {
                                    ListKey.Add((string)Rdr[0]);
                                }
                            }
                            finally
                            {
                                Rdr.Close();
                            }
                        }
                    }
                }
            }
        }