public static int AddUrlRule(UrlRuleInfo objUrlRule)
        {
            object result = DotNetNuke.Data.DataProvider.Instance().ExecuteScalar(ModuleQualifier + "AddUrlRule",
                                                                                  objUrlRule.DateTime,
                                                                                  objUrlRule.UserId,
                                                                                  objUrlRule.RuleType,
                                                                                  GetNull(objUrlRule.CultureCode),
                                                                                  objUrlRule.PortalId,
                                                                                  GetNull(objUrlRule.TabId),
                                                                                  GetNull(objUrlRule.Parameters),
                                                                                  objUrlRule.RemoveTab,
                                                                                  objUrlRule.RuleAction,
                                                                                  GetNull(objUrlRule.Url),
                                                                                  GetNull(objUrlRule.RedirectDestination),
                                                                                  GetNull(objUrlRule.RedirectStatus)
                                                                                  );

            if (result == DBNull.Value)
            {
                return(0);
            }
            else
            {
                return(Convert.ToInt32(result));
            }
        }
        protected void lbSave_Click(object sender, EventArgs e)
        {
            UrlRuleInfo rule = new UrlRuleInfo()
            {
                RuleType = int.Parse(ddlRuleType.SelectedValue),
                PortalId = PortalId,
                //CultureCode = ddlCultureCode.SelectedValue,
                TabId = int.Parse(ddlTab.SelectedValue),
                Parameters = tbParameters.Text,
                RuleAction = int.Parse(ddlAction.SelectedValue),
                RemoveTab = cbRemoveTab.Checked,
                Url = tbUrl.Text,
                RedirectDestination = tbRedirectDestination.Text,
                RedirectStatus = int.Parse(ddlRedirectStatus.SelectedValue),
                UserId = UserId,
                DateTime = DateTime.Now
            };
            if (ItemId == Null.NullInteger)
            {
                var UrlRule = UrlRuleController.AddUrlRule(rule);
            }
            else
            {
                rule.UrlRuleId = ItemId;
                UrlRuleController.UpdateUrlRule(rule);
            }

            DataCache.ClearCache();

            this.Response.Redirect(Globals.NavigateURL(this.TabId), true);
        }
        public static int AddUrlRule(UrlRuleInfo objUrlRule)
        {
            return Convert.ToInt32(DotNetNuke.Data.DataProvider.Instance().ExecuteScalar(ModuleQualifier+"AddUrlRule",
                                          objUrlRule.DateTime,
                                          objUrlRule.UserId,

                                          objUrlRule.RuleType,
                                          GetNull(objUrlRule.CultureCode),
                                          objUrlRule.PortalId,
                                          GetNull(objUrlRule.TabId),
                                          GetNull(objUrlRule.Parameters),
                                          objUrlRule.RemoveTab,
                                          objUrlRule.RuleAction,
                                          GetNull(objUrlRule.Url),
                                          GetNull(objUrlRule.RedirectDestination),
                                          GetNull(objUrlRule.RedirectStatus)
                                        ));
        }
        public static void UpdateUrlRule(UrlRuleInfo objUrlRule)
        {
            DotNetNuke.Data.DataProvider.Instance().ExecuteNonQuery(ModuleQualifier + "UpdateUrlRule",
                                                                    objUrlRule.UrlRuleId,
                                                                    objUrlRule.DateTime,
                                                                    objUrlRule.UserId,
                                                                    objUrlRule.PortalId,
                                                                    objUrlRule.RuleType,
                                                                    GetNull(objUrlRule.CultureCode),
                                                                    GetNull(objUrlRule.TabId),
                                                                    GetNull(objUrlRule.Parameters),
                                                                    objUrlRule.RemoveTab,
                                                                    objUrlRule.RuleAction,
                                                                    GetNull(objUrlRule.Url),
                                                                    GetNull(objUrlRule.RedirectDestination),
                                                                    GetNull(objUrlRule.RedirectStatus)

                                                                    );
        }
        public static void UpdateUrlRule(UrlRuleInfo objUrlRule)
        {
            DotNetNuke.Data.DataProvider.Instance().ExecuteNonQuery(ModuleQualifier + "UpdateUrlRule",
                                          objUrlRule.UrlRuleId,
                                          objUrlRule.DateTime,
                                          objUrlRule.UserId,
                                          objUrlRule.PortalId,
                                          objUrlRule.RuleType,
                                          GetNull(objUrlRule.CultureCode),
                                          GetNull(objUrlRule.TabId),
                                          GetNull(objUrlRule.Parameters),
                                          objUrlRule.RemoveTab,
                                          objUrlRule.RuleAction,
                                          GetNull(objUrlRule.Url),
                                          GetNull(objUrlRule.RedirectDestination),
                                          GetNull(objUrlRule.RedirectStatus)

                );
        }
        public static UrlRuleConfiguration GenerateConfig(int portalId)
        {
            //string cacheKey = "UrlRuleConfig" + portalId;

            var config = new UrlRuleConfiguration();
            config.Rules = new List<UrlRule>();

            try
            {
                // 1 cache by portal
                //DnnLog.Trace("Get cache " + portalId );
                //config = (UrlRuleConfiguration)DataCache.GetCache(cacheKey);

                //if ((config == null))
                {
                    Stopwatch timer = new Stopwatch();
                    timer.Start();
                    Logger.Info("Rebuild cache start " + portalId);

                    //config = new UrlRuleConfiguration { Rules = new List<UrlRule>() };

                    // generate admin page
                    GenerateAdminTab(portalId);
                    //if (false)
                    {

                        var builder = new UrlBuilder();
                        var Rules = builder.BuildUrlMap(portalId);
                        config.Rules.AddRange(Rules);

                        var storedRules = UrlRuleController.GetUrlRules(portalId);
                        foreach (UrlRuleInfo storedRule in storedRules)
                        {
                            if (storedRule.CultureCode == "") storedRule.CultureCode = null;
                            if (storedRule.RedirectDestination == "") storedRule.RedirectDestination = null;
                            if (storedRule.RedirectDestination != null) storedRule.RedirectDestination = storedRule.RedirectDestination.Trim();
                            if (storedRule.Url != null) storedRule.Url = storedRule.Url.Trim();
                        }

                        // add custom rules to cache
                        foreach (UrlRuleInfo storedRule in storedRules.Where(r => r.RuleType == (int)UrlRuleType.Custom /* && r.RuleAction == (int)UrlRuleAction.Redirect */)) // custom rule
                        {
                            UrlRule rule = new UrlRule()
                            {
                                RuleType = (UrlRuleType)storedRule.RuleType,
                                CultureCode = storedRule.CultureCode,
                                TabId = storedRule.TabId,
                                Parameters = storedRule.Parameters,
                                Action = (UrlRuleAction)storedRule.RuleAction,
                                RemoveTab = storedRule.RemoveTab,
                                RedirectDestination = storedRule.RedirectDestination,
                                RedirectStatus = storedRule.RedirectStatus,
                                Url = storedRule.Url
                            };
                            config.Rules.Add(rule);
                        }

                        // add rule for sitemap.xml rewrite to sitemap.aspx
                        /* replaced by a handler
                        UrlRule sitemapRule = new UrlRule()
                        {
                            RuleType = UrlRuleType.Custom,
                            Action = UrlRuleAction.Rewrite,
                            RedirectDestination = "~/Sitemap.aspx",
                            Url = ".*sitemap.xml"
                        };
                        config.Rules.Add(sitemapRule);
                        */
                        foreach (UrlRule rule in config.Rules)
                        {
                            if (rule.CultureCode == "") rule.CultureCode = null;
                            if (rule.RedirectDestination == "") rule.RedirectDestination = null;
                            rule.Url = rule.Url.ToLower();
                            // set RedirectDestination for automatic redirections corresponding to rewrite rule
                            if (rule.RuleType == UrlRuleType.Module && rule.Action == UrlRuleAction.Rewrite && string.IsNullOrEmpty(rule.RedirectDestination))
                            {
                                rule.RedirectDestination = rule.Parameters.Replace('=', '/').Replace('&', '/');
                            }
                            else if (rule.RuleType == UrlRuleType.Module && rule.Action == UrlRuleAction.Redirect && string.IsNullOrEmpty(rule.RedirectDestination))
                            {
                                var rewriteRule = config.Rules.FirstOrDefault(r => r.RuleType == UrlRuleType.Module && r.Parameters == rule.Parameters && r.Action == UrlRuleAction.Rewrite);
                                if (rewriteRule != null)
                                {
                                    rule.RedirectDestination = rewriteRule.Url;
                                }
                            }
                            if (rule.RedirectDestination != null)
                            {
                                rule.RedirectDestination = rule.RedirectDestination.ToLower();
                            }
                        }

                        var OldRules = new List<UrlRuleInfo>(storedRules);

                        var DistuctRules = config.Rules.Where(r => r.RuleType != UrlRuleType.Custom)
                                                        .GroupBy(r => new { r.RuleType, r.CultureCode, r.TabId, r.Url })
                                                        .Select(g => g.First());

                        foreach (UrlRule rule in DistuctRules)
                        {
                            var ruleInfoLst = storedRules.Where(r => r.RuleType == (int)rule.RuleType &&
                                                                                r.CultureCode == rule.CultureCode &&
                                                                                r.TabId == rule.TabId &&
                                                                                r.Url == rule.Url);

                            UrlRuleInfo ruleInfo = ruleInfoLst.FirstOrDefault();
                            if (ruleInfo == null)
                            {
                                ruleInfo = new UrlRuleInfo()
                                {
                                    PortalId = portalId,
                                    DateTime = DateTime.Now,
                                    RuleType = (int)rule.RuleType,
                                    CultureCode = rule.CultureCode,
                                    TabId = rule.TabId,
                                    Url = rule.Url,

                                    Parameters = rule.Parameters,
                                    RuleAction = (int)rule.Action,
                                    RemoveTab = rule.RemoveTab,
                                    RedirectDestination = rule.RedirectDestination,
                                    RedirectStatus = rule.RedirectStatus
                                };
                                ruleInfo.UrlRuleId = UrlRuleController.AddUrlRule(ruleInfo);
                                Logger.Info("AddUrlRule (UrlRuleId=" + ruleInfo.UrlRuleId + ")");
                                storedRules.Add(ruleInfo);
                            }
                            else
                            {
                                bool FirstOne = true; // for auto correction of double stored rules
                                foreach (var r in ruleInfoLst)
                                {
                                    OldRules.Remove(r);
                                    if (FirstOne)
                                    {
                                        if (ruleInfo.Parameters != rule.Parameters ||
                                            ruleInfo.RuleAction != (int)rule.Action ||
                                            ruleInfo.RemoveTab != rule.RemoveTab ||
                                            ruleInfo.RedirectDestination != rule.RedirectDestination ||
                                            ruleInfo.RedirectStatus != rule.RedirectStatus)
                                        {
                                            Logger.Info("UpdateUrlRule (UrlRuleId=" + ruleInfo.UrlRuleId +

                                                (ruleInfo.Parameters == rule.Parameters) + "/" +
                                                (ruleInfo.RuleAction == (int)rule.Action) + "/" +
                                                (ruleInfo.RemoveTab == rule.RemoveTab) + "/" +
                                                (ruleInfo.RedirectDestination == rule.RedirectDestination) + "/" +
                                                (ruleInfo.RedirectStatus == rule.RedirectStatus) + "-" +

                                                ruleInfo.Parameters + "/" + rule.Parameters + "/" +
                                                ruleInfo.RuleAction + "/" + (int)rule.Action + "/" +
                                                ruleInfo.RemoveTab + "/" + rule.RemoveTab + "/" +
                                                ruleInfo.RedirectDestination + "/" + rule.RedirectDestination + "/" +
                                                ruleInfo.RedirectStatus + "/" + rule.RedirectStatus +

                                                ")");

                                            ruleInfo.Parameters = rule.Parameters;
                                            ruleInfo.RuleAction = (int)rule.Action;
                                            ruleInfo.RemoveTab = rule.RemoveTab;
                                            ruleInfo.RedirectDestination = rule.RedirectDestination;
                                            ruleInfo.RedirectStatus = rule.RedirectStatus;
                                            UrlRuleController.UpdateUrlRule(ruleInfo);

                                        }
                                    }
                                    else
                                    {
                                        UrlRuleController.DeleteUrlRule(ruleInfo.UrlRuleId);
                                        Logger.Info("DeleteUrlRule (UrlRuleId=" + ruleInfo.UrlRuleId + ")");
                                    }

                                    FirstOne = false;
                                }
                            }
                        }

                        foreach (var storedRule in OldRules.Where(r => r.RuleType == (int)UrlRuleType.Tab ||
                                                                        r.RuleType == (int)UrlRuleType.Module))
                        {
                            if (storedRule.RuleAction == (int)UrlRuleAction.Rewrite)
                            {
                                var actualRule = Rules.FirstOrDefault(r => r.RuleType == (UrlRuleType)storedRule.RuleType &&
                                                                            r.CultureCode == storedRule.CultureCode &&
                                                                            r.TabId == storedRule.TabId &&
                                                                            r.Parameters == storedRule.Parameters);

                                if (actualRule != null)
                                {
                                    UrlRule rule = new UrlRule()
                                    {
                                        RuleType = (UrlRuleType)storedRule.RuleType,
                                        CultureCode = storedRule.CultureCode,
                                        TabId = storedRule.TabId,
                                        Parameters = storedRule.Parameters,
                                        Action = UrlRuleAction.Redirect,
                                        RemoveTab = storedRule.RemoveTab,
                                        RedirectDestination = actualRule.Url,
                                        RedirectStatus = storedRule.RedirectStatus,
                                        Url = storedRule.Url
                                    };
                                    config.Rules.Add(rule);
                                }
                            }
                        }
                    }
                    //DnnLog.MethodExit();
                    //DataCache.SetCache("UrlRuleConfig", config, TimeSpan.FromDays(1));
                    //int intCacheTimeout = 20 * Convert.ToInt32(DotNetNuke.Entities.Host.Host.PerformanceSetting);

                    timer.Stop();
                    double responseTime = timer.ElapsedMilliseconds / 1000.0;

                    Logger.Info("Rebuild cache " + portalId + " (" + responseTime + ")");
                    //DataCache.SetCache(cacheKey, config, TimeSpan.FromMinutes(intCacheTimeout));

                    //var onRemove = new CacheItemRemovedCallback(config.RemovedCallBack);

                    //DateTime absoluteExpiration = DateTime.UtcNow.Add(TimeSpan.FromMinutes(intCacheTimeout));

                    //DataCache.SetCache(cacheKey, config, null, absoluteExpiration, Cache.NoSlidingExpiration, CacheItemPriority.AboveNormal, onRemove, false);

                }
            }
            catch (Exception ex)
            {
                //log it
                var objEventLog = new EventLogController();
                var objEventLogInfo = new LogInfo() { LogTypeKey = "GENERAL_EXCEPTION" };
                objEventLogInfo.AddProperty("UrlRewriter.UrlRuleConfig", "GetConfig Failed");
                objEventLogInfo.AddProperty("ExceptionMessage", ex.Message);
                objEventLogInfo.AddProperty("PortalId", portalId.ToString());
                //objEventLogInfo.LogTypeKey = EventLogController.EventLogType.HOST_ALERT.ToString();

                objEventLogInfo.AddProperty("Exception Type", ex.GetType().ToString());
                objEventLogInfo.AddProperty("Message", ex.Message);
                objEventLogInfo.AddProperty("Stack Trace", ex.StackTrace);
                if (ex.InnerException != null)
                {
                    objEventLogInfo.AddProperty("Inner Exception Message", ex.InnerException.Message);
                    objEventLogInfo.AddProperty("Inner Exception Stacktrace", ex.InnerException.StackTrace);
                }
                objEventLogInfo.BypassBuffering = true;

                objEventLog.AddLog(objEventLogInfo);
                Logger.Error(ex);
                //DataCache.SetCache(cacheKey, config, TimeSpan.FromMinutes(60));
            }

            return config;
        }