Ejemplo n.º 1
0
        public void DeleteTabUrl(TabUrlInfo tabUrl, int portalId, bool clearCache)
        {
            DataProvider.Instance().DeleteTabUrl(tabUrl.TabId, tabUrl.SeqNum);

            if (clearCache)
            {
                DataCache.RemoveCache(String.Format(DataCache.TabUrlCacheKey, portalId));
                var tab = GetTab(tabUrl.TabId, portalId);
                tab.ClearTabUrls();
            }
        }
Ejemplo n.º 2
0
        protected void gvCustomUrls_InsertCommand(object sender, GridCommandEventArgs e)
        {
            GridEditableItem editedItem = e.Item as GridEditableItem;

            DropDownList ddlPortalAliasId    = editedItem.FindControl("ddlPortalAliasId") as DropDownList;
            DropDownList ddlPortalAliasUsage = editedItem.FindControl("ddlPortalAliasUsage") as DropDownList;
            DropDownList ddlHttpStatus       = editedItem.FindControl("ddlHttpStatus") as DropDownList;

            Hashtable ht = new Hashtable();

            editedItem.ExtractValues(ht);

            // increment existing tabUrls
            List <TabUrlInfo> tabUrls = DotNetNuke.Entities.Tabs.Internal.TestableTabController.Instance.GetTabUrls(ddlPage.SelectedItemValueAsInt, PortalId);

            foreach (TabUrlInfo tu in tabUrls)
            {
                tu.SeqNum++;
                DotNetNuke.Entities.Tabs.Internal.TestableTabController.Instance.SaveTabUrl(tu, PortalId, false);
            }

            // create new tabUrl
            TabUrlInfo tabUrl = new TabUrlInfo();

            tabUrl.TabId       = ddlPage.SelectedItemValueAsInt;
            tabUrl.SeqNum      = 0;
            tabUrl.CultureCode = this.PortalSettings.CultureCode;
            if (!string.IsNullOrEmpty(ddlPortalAliasId.SelectedValue))
            {
                tabUrl.PortalAliasId = int.Parse(ddlPortalAliasId.SelectedValue);
            }

            if (!string.IsNullOrWhiteSpace(ddlPortalAliasUsage.SelectedValue))
            {
                tabUrl.PortalAliasUsage = (PortalAliasUsageType)Enum.Parse(typeof(PortalAliasUsageType), ddlPortalAliasUsage.SelectedValue);
            }

            if (ht["Url"] != null)
            {
                tabUrl.Url = FriendlyUrlController.EnsureLeadingChar("/", ht["Url"].ToString());
            }
            if (ht["QueryString"] != null)
            {
                tabUrl.QueryString = ht["QueryString"].ToString();
            }
            tabUrl.HttpStatus = ddlHttpStatus.SelectedValue;
            tabUrl.IsSystem   = false;

            DotNetNuke.Entities.Tabs.Internal.TestableTabController.Instance.SaveTabUrl(tabUrl, PortalId, true);
            DotNetNuke.Common.Utilities.DataCache.ClearCache();
        }
Ejemplo n.º 3
0
        public PageUrlResult DeleteCustomUrl(int id, TabInfo tab)
        {
            PortalSettings portalSettings = PortalController.Instance.GetCurrentSettings() as PortalSettings;
            TabUrlInfo     tabUrl         = tab.TabUrls.SingleOrDefault(u => u.SeqNum == id);

            TabController.Instance.DeleteTabUrl(tabUrl, portalSettings.PortalId, true);
            DataCache.RemoveCache(string.Format(DataCache.TabUrlCacheKey, portalSettings.PortalId));
            DataCache.ClearCache("url_CustomAliasList");
            TabController.Instance.ClearCache(portalSettings.PortalId);
            return(new PageUrlResult
            {
                Success = true
            });
        }
Ejemplo n.º 4
0
        public void SaveTabUrl(TabUrlInfo tabUrl, int portalId, bool clearCache)
        {
            var portalAliasId = (tabUrl.PortalAliasUsage == PortalAliasUsageType.Default)
                                  ? Null.NullInteger
                                  : tabUrl.PortalAliasId;

            DataProvider.Instance().SaveTabUrl(tabUrl.TabId, tabUrl.SeqNum, portalAliasId, (int)tabUrl.PortalAliasUsage, tabUrl.Url, tabUrl.QueryString, tabUrl.CultureCode, tabUrl.HttpStatus, tabUrl.IsSystem);

            if (clearCache)
            {
                DataCache.RemoveCache(String.Format(DataCache.TabUrlCacheKey, portalId));
                _legacyController.ClearCache(portalId);
                var tab = GetTab(tabUrl.TabId, portalId);
                tab.ClearTabUrls();
            }
        }
Ejemplo n.º 5
0
        public void DeleteTabUrl(TabUrlInfo tabUrl, int portalId, bool clearCache)
        {
            DataProvider.Instance().DeleteTabUrl(tabUrl.TabId, tabUrl.SeqNum);

            var objEventLog = new EventLogController();

            objEventLog.AddLog("tabUrl.TabId",
                               tabUrl.TabId.ToString(),
                               PortalController.GetCurrentPortalSettings(),
                               UserController.GetCurrentUserInfo().UserID,
                               EventLogController.EventLogType.TABURL_DELETED);
            if (clearCache)
            {
                DataCache.RemoveCache(String.Format(DataCache.TabUrlCacheKey, portalId));
                var tab = GetTab(tabUrl.TabId, portalId);
                tab.ClearTabUrls();
            }
        }
Ejemplo n.º 6
0
        protected void gvCustomUrls_ItemDataBound(object sender, GridItemEventArgs e)
        {
            if (e.Item is GridDataItem && (e.Item.DataItem.GetType() != typeof(GridInsertionObject)))
            {
                GridDataItem dataItem = (GridDataItem)e.Item;
                TabUrlInfo   item     = (TabUrlInfo)dataItem.DataItem;

                DropDownList ddlPortalAliasId   = (DropDownList)dataItem.FindControl("ddlPortalAliasId");
                DropDownList ddlPortalAliasUage = (DropDownList)dataItem.FindControl("ddlPortalAliasUsage");
                DropDownList ddlHttpStatus      = (DropDownList)dataItem.FindControl("ddlHttpStatus");

                if (ddlPortalAliasId != null)
                {
                    ListItem liPortalAliasId = ddlPortalAliasId.Items.FindByValue(item.PortalAliasId.ToString());
                    if (liPortalAliasId != null)
                    {
                        ddlPortalAliasId.ClearSelection();
                        liPortalAliasId.Selected = true;
                    }
                }

                if (ddlPortalAliasUage != null)
                {
                    int portalAliasUage = (int)item.PortalAliasUsage;

                    ListItem liPortalAliasUage = ddlPortalAliasUage.Items.FindByValue(portalAliasUage.ToString());
                    if (liPortalAliasUage != null)
                    {
                        ddlPortalAliasUage.ClearSelection();
                        liPortalAliasUage.Selected = true;
                    }
                }

                if (ddlHttpStatus != null)
                {
                    ListItem liHttpStatus = ddlHttpStatus.Items.FindByValue(item.HttpStatus);
                    if (liHttpStatus != null)
                    {
                        ddlHttpStatus.ClearSelection();
                        liHttpStatus.Selected = true;
                    }
                }
            }
        }
Ejemplo n.º 7
0
        public void SaveTabUrl(TabUrlInfo tabUrl, int portalId, bool clearCache)
        {
            var portalAliasId = (tabUrl.PortalAliasUsage == PortalAliasUsageType.Default)
                                  ? Null.NullInteger
                                  : tabUrl.PortalAliasId;

            var saveLog = EventLogController.EventLogType.TABURL_CREATED;

            if (tabUrl.HttpStatus == "200")
            {
                saveLog = EventLogController.EventLogType.TABURL_CREATED;
            }
            else
            {
                //need to see if sequence number exists to decide if insert or update
                List <TabUrlInfo> t = GetTabUrls(portalId, tabUrl.TabId);
                var existingSeq     = t.FirstOrDefault(r => r.SeqNum == tabUrl.SeqNum);
                if (existingSeq == null)
                {
                    saveLog = EventLogController.EventLogType.TABURL_CREATED;
                }
            }

            DataProvider.Instance().SaveTabUrl(tabUrl.TabId, tabUrl.SeqNum, portalAliasId, (int)tabUrl.PortalAliasUsage, tabUrl.Url, tabUrl.QueryString, tabUrl.CultureCode, tabUrl.HttpStatus, tabUrl.IsSystem, UserController.GetCurrentUserInfo().UserID);

            var objEventLog = new EventLogController();

            objEventLog.AddLog("tabUrl",
                               tabUrl.ToString(),
                               PortalController.GetCurrentPortalSettings(),
                               UserController.GetCurrentUserInfo().UserID,
                               saveLog);

            if (clearCache)
            {
                DataCache.RemoveCache(String.Format(DataCache.TabUrlCacheKey, portalId));
                CacheController.ClearCustomAliasesCache();
                _legacyController.ClearCache(portalId);
                var tab = GetTab(tabUrl.TabId, portalId);
                tab.ClearTabUrls();
            }
        }
        public static void SaveTabUrl(TabUrlInfo tabUrl, int portalId, bool clearCache)
        {
            //var portalAliasId = (tabUrl.PortalAliasUsage == PortalAliasUsageType.Default) ? Null.NullInteger : tabUrl.PortalAliasId;
            int portalAliasId = tabUrl.PortalAliasId;

            if (portalAliasId > 0)
            {
                tabUrl.CultureCode = PortalAliasController.Instance.GetPortalAliasByPortalAliasID(portalAliasId).CultureCode;
            }

            EventLogController.EventLogType saveLog = EventLogController.EventLogType.TABURL_CREATED;

            if (tabUrl.HttpStatus == "200")
            {
                saveLog = EventLogController.EventLogType.TABURL_CREATED;
            }
            else
            {
                //need to see if sequence number exists to decide if insert or update
                List <TabUrlInfo> t           = TabController.Instance.GetTabUrls(portalId, tabUrl.TabId);
                TabUrlInfo        existingSeq = t.FirstOrDefault(r => r.SeqNum == tabUrl.SeqNum);
                if (existingSeq == null)
                {
                    saveLog = EventLogController.EventLogType.TABURL_CREATED;
                }
            }

            DataProvider.Instance().SaveTabUrl(tabUrl.TabId, tabUrl.SeqNum, portalAliasId, (int)tabUrl.PortalAliasUsage, tabUrl.Url, tabUrl.QueryString, tabUrl.CultureCode, tabUrl.HttpStatus, tabUrl.IsSystem, UserController.Instance.GetCurrentUserInfo().UserID);

            EventLogController.Instance.AddLog("tabUrl",
                                               tabUrl.ToString(),
                                               PortalController.Instance.GetCurrentSettings() as IPortalSettings,
                                               UserController.Instance.GetCurrentUserInfo().UserID,
                                               saveLog);

            if (clearCache)
            {
                DataCache.RemoveCache(string.Format(DataCache.TabUrlCacheKey, portalId));
                TabController.Instance.ClearCache(portalId);
            }
        }
Ejemplo n.º 9
0
        protected void gvCustomUrls_DeleteCommand(object sender, Telerik.Web.UI.GridCommandEventArgs e)
        {
            try
            {
                int tabID  = ddlPage.SelectedItemValueAsInt;
                int seqnum = (int)((GridDataItem)e.Item).GetDataKeyValue("SeqNum");

                List <TabUrlInfo> tabUrls = DotNetNuke.Entities.Tabs.Internal.TestableTabController.Instance.GetTabUrls(tabID, PortalId);
                TabUrlInfo        tabUrl  = tabUrls.Where(i => i.SeqNum == seqnum).FirstOrDefault();

                if (tabUrl != null)
                {
                    DotNetNuke.Entities.Tabs.Internal.TestableTabController.Instance.DeleteTabUrl(tabUrl, PortalId, true);
                }

                gvCustomUrls.Rebind();
            }
            catch (Exception exc)
            {
                Exceptions.ProcessModuleLoadException(this, exc);
            }
        }
Ejemplo n.º 10
0
        protected void gvCustomUrls_UpdateCommand(object sender, GridCommandEventArgs e)
        {
            GridEditableItem editedItem = e.Item as GridEditableItem;
            var SeqNum = (int)editedItem.GetDataKeyValue("SeqNum");

            DropDownList ddlPortalAliasId    = editedItem.FindControl("ddlPortalAliasId") as DropDownList;
            DropDownList ddlPortalAliasUsage = editedItem.FindControl("ddlPortalAliasUsage") as DropDownList;
            DropDownList ddlHttpStatus       = editedItem.FindControl("ddlHttpStatus") as DropDownList;

            List <TabUrlInfo> tabUrls = DotNetNuke.Entities.Tabs.TabController.Instance.GetTabUrls(ddlPage.SelectedItemValueAsInt, PortalId);
            TabUrlInfo        tabUrl  = tabUrls.Where(i => i.SeqNum == SeqNum).FirstOrDefault();

            Hashtable ht = new Hashtable();

            editedItem.ExtractValues(ht);

            if (!string.IsNullOrEmpty(ddlPortalAliasId.SelectedValue))
            {
                tabUrl.PortalAliasId = int.Parse(ddlPortalAliasId.SelectedValue);
            }
            if (!string.IsNullOrWhiteSpace(ddlPortalAliasUsage.SelectedValue))
            {
                tabUrl.PortalAliasUsage = (PortalAliasUsageType)Enum.Parse(typeof(PortalAliasUsageType), ddlPortalAliasUsage.SelectedValue);
            }
            if (ht["Url"] != null)
            {
                tabUrl.Url = FriendlyUrlController.EnsureLeadingChar("/", ht["Url"].ToString());
            }
            if (ht["QueryString"] != null)
            {
                tabUrl.QueryString = ht["QueryString"].ToString();
            }
            tabUrl.HttpStatus = ddlHttpStatus.SelectedValue;

            DotNetNuke.Entities.Tabs.TabController.Instance.SaveTabUrl(tabUrl, PortalId, true);
            DotNetNuke.Common.Utilities.DataCache.ClearCache();
        }
Ejemplo n.º 11
0
 public void SaveTabUrl(TabUrlInfo tabUrl, int portalId, bool clearCache)
 {
     TabController.Instance.SaveTabUrl(tabUrl, portalId, clearCache);
 }
Ejemplo n.º 12
0
        public PageUrlResult UpdateCustomUrl(SaveUrlDto dto, TabInfo tab)
        {
            var  portalSettings = PortalController.Instance.GetCurrentPortalSettings();
            var  urlPath        = dto.Path.ValueOrEmpty().TrimStart('/');
            bool modified;
            //Clean Url
            var options =
                UrlRewriterUtils.ExtendOptionsForCustomURLs(
                    UrlRewriterUtils.GetOptionsFromSettings(new FriendlyUrlSettings(portalSettings.PortalId)));

            //now clean the path
            urlPath = FriendlyUrlController.CleanNameForUrl(urlPath, options, out modified);
            if (modified)
            {
                return(new PageUrlResult
                {
                    Success = false,
                    ErrorMessage = Localization.GetString("CustomUrlPathCleaned.Error"),
                    SuggestedUrlPath = "/" + urlPath
                });
            }

            //Validate for uniqueness
            urlPath = FriendlyUrlController.ValidateUrl(urlPath, tab.TabID, portalSettings, out modified);
            if (modified)
            {
                return(new PageUrlResult
                {
                    Success = false,
                    ErrorMessage = Localization.GetString("UrlPathNotUnique.Error"),
                    SuggestedUrlPath = "/" + urlPath
                });
            }

            var cultureCode = LocaleController.Instance.GetLocales(portalSettings.PortalId)
                              .Where(l => l.Value.KeyID == dto.LocaleKey)
                              .Select(l => l.Value.Code)
                              .SingleOrDefault() ?? portalSettings.DefaultLanguage;

            var statusCodeKey = dto.StatusCodeKey.ToString(CultureInfo.InvariantCulture);
            var tabUrl        = tab.TabUrls.SingleOrDefault(t => t.SeqNum == dto.Id && t.HttpStatus == statusCodeKey);

            if (statusCodeKey == "200")
            {
                //We need to check if we are updating a current url or creating a new 200
                if (tabUrl == null)
                {
                    //Just create Url
                    tabUrl = new TabUrlInfo
                    {
                        TabId            = tab.TabID,
                        SeqNum           = dto.Id,
                        PortalAliasId    = dto.SiteAliasKey,
                        PortalAliasUsage = (PortalAliasUsageType)dto.SiteAliasUsage,
                        QueryString      = dto.QueryString.ValueOrEmpty(),
                        Url         = dto.Path.ValueOrEmpty(),
                        CultureCode = cultureCode,
                        HttpStatus  = "200",
                        IsSystem    = dto.IsSystem // false
                    };
                    TabController.Instance.SaveTabUrl(tabUrl, portalSettings.PortalId, true);
                }
                else
                {
                    if (!tabUrl.Url.Equals("/" + urlPath, StringComparison.InvariantCultureIgnoreCase))
                    {
                        //Change the original 200 url to a redirect
                        tabUrl.HttpStatus = "301";
                        tabUrl.SeqNum     = dto.Id;
                        TabController.Instance.SaveTabUrl(tabUrl, portalSettings.PortalId, true);

                        //Add new custom url
                        tabUrl.Url              = dto.Path.ValueOrEmpty();
                        tabUrl.HttpStatus       = "200";
                        tabUrl.SeqNum           = tab.TabUrls.Max(t => t.SeqNum) + 1;
                        tabUrl.CultureCode      = cultureCode;
                        tabUrl.PortalAliasId    = dto.SiteAliasKey;
                        tabUrl.PortalAliasUsage = (PortalAliasUsageType)dto.SiteAliasUsage;
                        tabUrl.QueryString      = dto.QueryString.ValueOrEmpty();
                        TabController.Instance.SaveTabUrl(tabUrl, portalSettings.PortalId, true);
                    }
                    else
                    {
                        //Update the original 200 url
                        tabUrl.CultureCode      = cultureCode;
                        tabUrl.PortalAliasId    = dto.SiteAliasKey;
                        tabUrl.PortalAliasUsage = (PortalAliasUsageType)dto.SiteAliasUsage;
                        tabUrl.QueryString      = dto.QueryString.ValueOrEmpty();
                        TabController.Instance.SaveTabUrl(tabUrl, portalSettings.PortalId, true);
                    }
                }
            }
            else
            {
                //Update the original non 200 url
                if (tabUrl == null)
                {
                    tabUrl = new TabUrlInfo
                    {
                        TabId            = tab.TabID,
                        SeqNum           = dto.Id,
                        PortalAliasId    = dto.SiteAliasKey,
                        PortalAliasUsage = (PortalAliasUsageType)dto.SiteAliasUsage,
                        QueryString      = dto.QueryString.ValueOrEmpty(),
                        Url         = dto.Path.ValueOrEmpty(),
                        CultureCode = cultureCode,
                        HttpStatus  = statusCodeKey,
                        IsSystem    = dto.IsSystem // false
                    };
                    TabController.Instance.SaveTabUrl(tabUrl, portalSettings.PortalId, true);
                }
                else
                {
                    tabUrl.CultureCode      = cultureCode;
                    tabUrl.PortalAliasId    = dto.SiteAliasKey;
                    tabUrl.PortalAliasUsage = (PortalAliasUsageType)dto.SiteAliasUsage;
                    tabUrl.Url         = dto.Path.ValueOrEmpty();
                    tabUrl.HttpStatus  = statusCodeKey;
                    tabUrl.QueryString = dto.QueryString.ValueOrEmpty();
                    TabController.Instance.SaveTabUrl(tabUrl, portalSettings.PortalId, true);
                }
            }


            return(new PageUrlResult
            {
                Success = true
            });
        }
        private Outcome UpdateTabUrl(TabInfo tab, int portalId, string fieldValue)
        {
            var portalSettings = new PortalSettings(portalId);

            var urlPath = fieldValue.ValueOrEmpty().TrimStart('/');

            bool modified;
            // Clean Url
            var options = UrlRewriterUtils.ExtendOptionsForCustomURLs(UrlRewriterUtils.GetOptionsFromSettings(new FriendlyUrlSettings(portalSettings.PortalId)));

            urlPath = FriendlyUrlController.CleanNameForUrl(urlPath, options, out modified);
            if (modified)
            {
                return(new Outcome()
                {
                    Success = false,
                    ErrorMessage = Constants.ERROR_PAGE_URL_VALUE, //CustomUrlPathCleaned
                    Suggestion = string.Concat(Constants.SLASH, urlPath)
                });
            }

            // Validate for uniqueness
            urlPath = FriendlyUrlController.ValidateUrl(urlPath, -1, portalSettings, out modified);
            if (modified)
            {
                return(new Outcome()
                {
                    Success = false,
                    ErrorMessage = Constants.ERROR_PAGE_URL_NOT_UNIQUE, //UrlPathNotUnique
                    Suggestion = string.Concat(Constants.SLASH, urlPath)
                });
            }


            if (tab.TabUrls.Any(u => u.Url.ToLowerInvariant() == urlPath.ValueOrEmpty().ToLowerInvariant() &&
                                (u.PortalAliasId == portalSettings.PrimaryAlias.PortalAliasID || u.PortalAliasId == -1)))
            {
                return(new Outcome
                {
                    Success = false,
                    ErrorMessage = Constants.ERROR_PAGE_URL_DUPLICATE, //DuplicateUrl
                    Suggestion = string.Concat(Constants.SLASH, urlPath)
                });
            }

            var seqNum = (tab.TabUrls.Count > 0) ? tab.TabUrls.Max(t => t.SeqNum) + 1 : 1;

            var tabUrl = new TabUrlInfo
            {
                TabId            = tab.TabID,
                SeqNum           = seqNum,
                PortalAliasId    = portalSettings.PrimaryAlias.PortalAliasID,
                PortalAliasUsage = PortalAliasUsageType.Default,
                QueryString      = string.Empty,
                Url         = urlPath.ValueOrEmpty(),
                CultureCode = portalSettings.CultureCode,
                HttpStatus  = Constants.RESPONSE_STATUS_200,
                IsSystem    = false,
            };

            TabController.Instance.SaveTabUrl(tabUrl, portalSettings.PortalId, true);
            //tab.Url = fieldValue;
            return(new Outcome
            {
                Success = true,
                ErrorMessage = string.Empty,
                Suggestion = string.Empty
            });
        }
Ejemplo n.º 14
0
        public PageUrlResult CreateCustomUrl(SaveUrlDto dto, TabInfo tab)
        {
            var  portalSettings = PortalController.Instance.GetCurrentPortalSettings();
            var  urlPath        = dto.Path.ValueOrEmpty().TrimStart('/');
            bool modified;
            //Clean Url
            var options = UrlRewriterUtils.ExtendOptionsForCustomURLs(UrlRewriterUtils.GetOptionsFromSettings(new FriendlyUrlSettings(portalSettings.PortalId)));

            urlPath = FriendlyUrlController.CleanNameForUrl(urlPath, options, out modified);
            if (modified)
            {
                return(new PageUrlResult {
                    Success = false,
                    ErrorMessage = Localization.GetString("CustomUrlPathCleaned.Error"),
                    SuggestedUrlPath = "/" + urlPath
                });
            }

            //Validate for uniqueness
            urlPath = FriendlyUrlController.ValidateUrl(urlPath, -1, portalSettings, out modified);
            if (modified)
            {
                return(new PageUrlResult {
                    Success = false,
                    ErrorMessage = Localization.GetString("UrlPathNotUnique.Error"),
                    SuggestedUrlPath = "/" + urlPath
                });
            }

            if (tab.TabUrls.Any(u => u.Url.ToLowerInvariant() == dto.Path.ValueOrEmpty().ToLowerInvariant() &&
                                (u.PortalAliasId == dto.SiteAliasKey || u.PortalAliasId == -1)))
            {
                return(new PageUrlResult {
                    Success = false,
                    ErrorMessage = Localization.GetString("DuplicateUrl.Error")
                });
            }

            var seqNum        = (tab.TabUrls.Count > 0) ? tab.TabUrls.Max(t => t.SeqNum) + 1 : 1;
            var portalLocales = LocaleController.Instance.GetLocales(portalSettings.PortalId);
            var cultureCode   = portalLocales.Where(l => l.Value.KeyID == dto.LocaleKey)
                                .Select(l => l.Value.Code)
                                .SingleOrDefault();

            var portalAliasUsage = (PortalAliasUsageType)dto.SiteAliasUsage;

            if (portalAliasUsage == PortalAliasUsageType.Default)
            {
                var alias = PortalAliasController.Instance.GetPortalAliasesByPortalId(portalSettings.PortalId)
                            .SingleOrDefault(a => a.PortalAliasID == dto.SiteAliasKey);

                if (string.IsNullOrEmpty(cultureCode) || alias == null)
                {
                    return(new PageUrlResult
                    {
                        Success = false,
                        ErrorMessage = Localization.GetString("InvalidRequest.Error")
                    });
                }
            }
            else
            {
                var cultureAlias = PortalAliasController.Instance.GetPortalAliasesByPortalId(portalSettings.PortalId)
                                   .FirstOrDefault(a => a.CultureCode == cultureCode);

                if (portalLocales.Count > 1 && !portalSettings.ContentLocalizationEnabled && (string.IsNullOrEmpty(cultureCode) || cultureAlias == null))
                {
                    return(new PageUrlResult
                    {
                        Success = false,
                        ErrorMessage = Localization.GetString("InvalidRequest.Error")
                    });
                }
            }

            var tabUrl = new TabUrlInfo
            {
                TabId            = tab.TabID,
                SeqNum           = seqNum,
                PortalAliasId    = dto.SiteAliasKey,
                PortalAliasUsage = portalAliasUsage,
                QueryString      = dto.QueryString.ValueOrEmpty(),
                Url         = dto.Path.ValueOrEmpty(),
                CultureCode = cultureCode,
                HttpStatus  = dto.StatusCodeKey.ToString(CultureInfo.InvariantCulture),
                IsSystem    = false
            };

            TabController.Instance.SaveTabUrl(tabUrl, portalSettings.PortalId, true);

            return(new PageUrlResult
            {
                Success = true,
                Id = seqNum // returns Id of the created Url
            });
        }
Ejemplo n.º 15
0
        public void SaveTabUrl(TabInfo tab, PageSettings pageSettings)
        {
            if (!pageSettings.CustomUrlEnabled)
            {
                return;
            }

            if (tab.IsSuperTab)
            {
                return;
            }

            var url    = pageSettings.Url;
            var tabUrl = tab.TabUrls.SingleOrDefault(t => t.IsSystem &&
                                                     t.HttpStatus == "200" &&
                                                     t.SeqNum == 0);

            var portalSettings = PortalController.Instance.GetCurrentPortalSettings();

            if (!String.IsNullOrEmpty(url) && url != "/")
            {
                url = CleanTabUrl(url);

                string currentUrl          = String.Empty;
                var    friendlyUrlSettings = new FriendlyUrlSettings(portalSettings.PortalId);
                if (tab.TabID > -1)
                {
                    var baseUrl = Globals.AddHTTP(portalSettings.PortalAlias.HTTPAlias) + "/Default.aspx?TabId=" + tab.TabID;
                    var path    = AdvancedFriendlyUrlProvider.ImprovedFriendlyUrl(tab,
                                                                                  baseUrl,
                                                                                  Globals.glbDefaultPage,
                                                                                  portalSettings.PortalAlias.HTTPAlias,
                                                                                  false,
                                                                                  friendlyUrlSettings,
                                                                                  Guid.Empty);

                    currentUrl = path.Replace(Globals.AddHTTP(portalSettings.PortalAlias.HTTPAlias), "");
                }

                if (url == currentUrl)
                {
                    return;
                }

                if (tabUrl == null)
                {
                    //Add new custom url
                    tabUrl = new TabUrlInfo
                    {
                        TabId            = tab.TabID,
                        SeqNum           = 0,
                        PortalAliasId    = -1,
                        PortalAliasUsage = PortalAliasUsageType.Default,
                        QueryString      = String.Empty,
                        Url         = url,
                        HttpStatus  = "200",
                        CultureCode = String.Empty,
                        IsSystem    = true
                    };
                    //Save url
                    _tabController.SaveTabUrl(tabUrl, portalSettings.PortalId, true);
                }
                else
                {
                    //Change the original 200 url to a redirect
                    tabUrl.HttpStatus = "301";
                    tabUrl.SeqNum     = tab.TabUrls.Max(t => t.SeqNum) + 1;
                    _tabController.SaveTabUrl(tabUrl, portalSettings.PortalId, true);

                    //Add new custom url
                    tabUrl.Url        = url;
                    tabUrl.HttpStatus = "200";
                    tabUrl.SeqNum     = 0;
                    _tabController.SaveTabUrl(tabUrl, portalSettings.PortalId, true);
                }


                //Delete any redirects to the same url
                foreach (var redirecturl in _tabController.GetTabUrls(tab.TabID, tab.PortalID))
                {
                    if (redirecturl.Url == url && redirecturl.HttpStatus != "200")
                    {
                        _tabController.DeleteTabUrl(redirecturl, tab.PortalID, true);
                    }
                }
            }
            else
            {
                if (url == "/" && tabUrl != null)
                {
                    _tabController.DeleteTabUrl(tabUrl, portalSettings.PortalId, true);
                }
            }
        }
Ejemplo n.º 16
0
        public void SaveTabUrl(TabUrlInfo tabUrl, int portalId, bool clearCache)
        {
            var portalAliasId = (tabUrl.PortalAliasUsage == PortalAliasUsageType.Default)
                                  ? Null.NullInteger
                                  : tabUrl.PortalAliasId;

            var saveLog = EventLogController.EventLogType.TABURL_CREATED;

            if (tabUrl.HttpStatus == "200")
            {
                saveLog = EventLogController.EventLogType.TABURL_CREATED;
               
            }
            else
            {
                //need to see if sequence number exists to decide if insert or update
                List<TabUrlInfo> t = GetTabUrls(portalId, tabUrl.TabId);
                var existingSeq = t.FirstOrDefault(r => r.SeqNum == tabUrl.SeqNum);
                if (existingSeq == null)
                {
                    saveLog = EventLogController.EventLogType.TABURL_CREATED;
                }
            }

            DataProvider.Instance().SaveTabUrl(tabUrl.TabId, tabUrl.SeqNum, portalAliasId, (int)tabUrl.PortalAliasUsage, tabUrl.Url, tabUrl.QueryString, tabUrl.CultureCode, tabUrl.HttpStatus, tabUrl.IsSystem,UserController.GetCurrentUserInfo().UserID);

            var objEventLog = new EventLogController();
            objEventLog.AddLog("tabUrl",
                               tabUrl.ToString(),
                               PortalController.GetCurrentPortalSettings(),
                               UserController.GetCurrentUserInfo().UserID,
                               saveLog);

            if (clearCache)
            {
                DataCache.RemoveCache(String.Format(DataCache.TabUrlCacheKey, portalId));
                _legacyController.ClearCache(portalId);
                var tab = GetTab(tabUrl.TabId, portalId);                
                tab.ClearTabUrls();
            }
        }
Ejemplo n.º 17
0
        public void DeleteTabUrl(TabUrlInfo tabUrl, int portalId, bool clearCache)
        {
            DataProvider.Instance().DeleteTabUrl(tabUrl.TabId, tabUrl.SeqNum);

            var objEventLog = new EventLogController();
            objEventLog.AddLog("tabUrl.TabId",
                               tabUrl.TabId.ToString(),
                               PortalController.GetCurrentPortalSettings(),
                               UserController.GetCurrentUserInfo().UserID,
                               EventLogController.EventLogType.TABURL_DELETED);
            if (clearCache)
            {
                DataCache.RemoveCache(String.Format(DataCache.TabUrlCacheKey, portalId));
                var tab = GetTab(tabUrl.TabId, portalId);
                tab.ClearTabUrls();
            }
        }
Ejemplo n.º 18
0
        public HttpResponseMessage UpdateCustomUrl(SaveUrlDto dto)
        {
            var tab     = PortalSettings.ActiveTab;
            var urlPath = dto.Path.ValueOrEmpty().TrimStart('/');
            HttpResponseMessage response;

            if (string.IsNullOrEmpty(urlPath))
            {
                var tabUrl = new TabUrlInfo
                {
                    TabId  = tab.TabID,
                    SeqNum = dto.Id,
                };
                TestableTabController.Instance.DeleteTabUrl(tabUrl, PortalId, true);

                response = Request.CreateResponse(HttpStatusCode.OK, new { Success = true, });
            }
            else
            {
                bool modified;
                //Clean Url
                var options = UrlRewriterUtils.GetOptionsFromSettings(new FriendlyUrlSettings(PortalSettings.PortalId));
                //custom urls are special in that they can contain the / character to create path levels
                options.ReplaceChars = options.ReplaceChars.Replace("/", "");
                options.IllegalChars = options.IllegalChars.Replace("/", "");
                options.RegexMatch   = options.RegexMatch.Replace("[^", "[^/");
                //now clean the path
                urlPath = FriendlyUrlController.CleanNameForUrl(urlPath, options, out modified);
                if (modified)
                {
                    return(Request.CreateResponse(HttpStatusCode.OK,
                                                  new
                    {
                        Success = false,
                        ErrorMessage = Localization.GetString("UrlPathCleaned.Error", Localization.GlobalResourceFile),
                        SuggestedUrlPath = "/" + urlPath
                    }));
                }

                //Validate for uniqueness
                urlPath = FriendlyUrlController.ValidateUrl(urlPath, -1, PortalSettings, out modified);
                if (modified)
                {
                    return(Request.CreateResponse(HttpStatusCode.OK,
                                                  new
                    {
                        Success = false,
                        ErrorMessage = Localization.GetString("UrlPathNotUnique.Error", Localization.GlobalResourceFile),
                        SuggestedUrlPath = "/" + urlPath
                    }));
                }

                var cultureCode = LocaleController.Instance.GetLocales(PortalId)
                                  .Where(l => l.Value.KeyID == dto.LocaleKey)
                                  .Select(l => l.Value.Code)
                                  .SingleOrDefault();

                var tabUrl = new TabUrlInfo
                {
                    TabId            = tab.TabID,
                    SeqNum           = dto.Id,
                    PortalAliasId    = dto.SiteAliasKey,
                    PortalAliasUsage = (PortalAliasUsageType)dto.SiteAliasUsage,
                    QueryString      = dto.QueryString.ValueOrEmpty(),
                    Url         = dto.Path.ValueOrEmpty(),
                    CultureCode = cultureCode,
                    HttpStatus  = dto.StatusCodeKey.ToString(CultureInfo.InvariantCulture),
                    IsSystem    = dto.IsSystem // false
                };

                TestableTabController.Instance.SaveTabUrl(tabUrl, PortalId, true);

                response = Request.CreateResponse(HttpStatusCode.OK, new { Success = true, });
            }

            return(response);
        }
Ejemplo n.º 19
0
        public void SaveTabUrl(TabUrlInfo tabUrl, int portalId, bool clearCache)
        {
            var portalAliasId = (tabUrl.PortalAliasUsage == PortalAliasUsageType.Default)
                                  ? Null.NullInteger
                                  : tabUrl.PortalAliasId;
            DataProvider.Instance().SaveTabUrl(tabUrl.TabId, tabUrl.SeqNum, portalAliasId, (int)tabUrl.PortalAliasUsage, tabUrl.Url, tabUrl.QueryString, tabUrl.CultureCode, tabUrl.HttpStatus, tabUrl.IsSystem);

            if (clearCache)
            {
                DataCache.RemoveCache(String.Format(DataCache.TabUrlCacheKey, portalId));
                _legacyController.ClearCache(portalId);
                var tab = GetTab(tabUrl.TabId, portalId);                
                tab.ClearTabUrls();
            }
        }
        public HttpResponseMessage UpdateCustomUrl(SaveUrlDto dto)
        {
            var  urlPath = dto.Path.ValueOrEmpty().TrimStart('/');
            bool modified;
            //Clean Url
            var options = UrlRewriterUtils.ExtendOptionsForCustomURLs(UrlRewriterUtils.GetOptionsFromSettings(new FriendlyUrlSettings(PortalSettings.PortalId)));

            //now clean the path
            urlPath = FriendlyUrlController.CleanNameForUrl(urlPath, options, out modified);
            if (modified)
            {
                return(Request.CreateResponse(HttpStatusCode.OK,
                                              new
                {
                    Success = false,
                    ErrorMessage = Localization.GetString("CustomUrlPathCleaned.Error", Localization.GlobalResourceFile),
                    SuggestedUrlPath = "/" + urlPath
                }));
            }

            //Validate for uniqueness
            urlPath = FriendlyUrlController.ValidateUrl(urlPath, -1, PortalSettings, out modified);
            if (modified)
            {
                return(Request.CreateResponse(HttpStatusCode.OK,
                                              new
                {
                    Success = false,
                    ErrorMessage = Localization.GetString("UrlPathNotUnique.Error", Localization.GlobalResourceFile),
                    SuggestedUrlPath = "/" + urlPath
                }));
            }

            var tab         = PortalSettings.ActiveTab;
            var cultureCode = LocaleController.Instance.GetLocales(PortalId)
                              .Where(l => l.Value.KeyID == dto.LocaleKey)
                              .Select(l => l.Value.Code)
                              .SingleOrDefault();

            if (dto.StatusCodeKey.ToString(CultureInfo.InvariantCulture) == "200")
            {
                //We need to check if we are updating a current url or creating a new 200
                var tabUrl = tab.TabUrls.SingleOrDefault(t => t.SeqNum == dto.Id &&
                                                         t.HttpStatus == "200");
                if (tabUrl == null)
                {
                    //Just create Url
                    tabUrl = new TabUrlInfo
                    {
                        TabId            = tab.TabID,
                        SeqNum           = dto.Id,
                        PortalAliasId    = dto.SiteAliasKey,
                        PortalAliasUsage = (PortalAliasUsageType)dto.SiteAliasUsage,
                        QueryString      = dto.QueryString.ValueOrEmpty(),
                        Url         = dto.Path.ValueOrEmpty(),
                        CultureCode = cultureCode,
                        HttpStatus  = dto.StatusCodeKey.ToString(CultureInfo.InvariantCulture),
                        IsSystem    = dto.IsSystem              // false
                    };
                    TabController.Instance.SaveTabUrl(tabUrl, PortalId, true);
                }
                else
                {
                    //Change the original 200 url to a redirect
                    tabUrl.HttpStatus = "301";
                    tabUrl.SeqNum     = dto.Id;
                    TabController.Instance.SaveTabUrl(tabUrl, PortalId, true);

                    //Add new custom url
                    tabUrl.Url        = dto.Path.ValueOrEmpty();
                    tabUrl.HttpStatus = "200";
                    tabUrl.SeqNum     = tab.TabUrls.Max(t => t.SeqNum) + 1;
                    TabController.Instance.SaveTabUrl(tabUrl, PortalId, true);
                }
            }
            else
            {
                //Just update the url
                var tabUrl = new TabUrlInfo
                {
                    TabId            = tab.TabID,
                    SeqNum           = dto.Id,
                    PortalAliasId    = dto.SiteAliasKey,
                    PortalAliasUsage = (PortalAliasUsageType)dto.SiteAliasUsage,
                    QueryString      = dto.QueryString.ValueOrEmpty(),
                    Url         = dto.Path.ValueOrEmpty(),
                    CultureCode = cultureCode,
                    HttpStatus  = dto.StatusCodeKey.ToString(CultureInfo.InvariantCulture),
                    IsSystem    = dto.IsSystem                  // false
                };
                TabController.Instance.SaveTabUrl(tabUrl, PortalId, true);
            }


            var response = new
            {
                Success = true,
            };

            return(Request.CreateResponse(HttpStatusCode.OK, response));
        }
Ejemplo n.º 21
0
        public void DeleteTabUrl(TabUrlInfo tabUrl, int portalId, bool clearCache)
        {
            DataProvider.Instance().DeleteTabUrl(tabUrl.TabId, tabUrl.SeqNum);

            if (clearCache)
            {
                DataCache.RemoveCache(String.Format(DataCache.TabUrlCacheKey, portalId));
                var tab = GetTab(tabUrl.TabId, portalId);
                tab.ClearTabUrls();
            }
        }