Episerver - Handle Canonical Links

   /// <summary>
        /// Handle Canonical
        /// </summary>
        public static string SetupCanonicalUrl(SitePageData currentPage, HttpContext cont)
        {
            if (currentPage == null) { return string.Empty; }

            var externalUrl = currentPage.PageLink.GetExternalUrl();

            //Is Simple URL: Check
            if (!string.IsNullOrEmpty(currentPage.ExternalURL) &&
                String.Compare(currentPage.ExternalURL, cont.Request.Url.Segments.Last().Replace("/", ""),
                    StringComparison.OrdinalIgnoreCase) == 0)
            {
                //If 404 page no canoncial otherwise canonical
                var baseType = currentPage.GetType().BaseType;
                if (baseType != null && (!string.IsNullOrEmpty(externalUrl) && baseType.Name != typeof(NotFoundPage).Name))
                {
                    return WriteCanonicalLink(externalUrl);
                }
            }

            else
            {
                //Set Canonical if SEO override is set.
                if (currentPage.SetUniqueCanoncial != null)
                {
                    return WriteCanonicalLink(currentPage.SetUniqueCanoncial);
                }

                //Ordinary Canonical
                return WriteCanonicalLink(externalUrl);
            }
            return string.Empty;
        }

        private static string WriteCanonicalLink(String externalUrl)
        {
            HtmlLink canonicalLink = new HtmlLink();
            canonicalLink.Attributes.Add("rel", "canonical");
            canonicalLink.Href = externalUrl.TrimAndLower();
            return canonicalLink.Href;
        }+

  public static string GetExternalUrl(this PageData pageData)
        {

            var urlString = UrlResolver.Current.GetUrl(pageData.ContentLink, ((ILocalizable)pageData).Language.Name, new VirtualPathArguments { ForceCanonical = true });
            if (string.IsNullOrEmpty(urlString))
            {
                return urlString;
            }

            var uri = new Uri(urlString, UriKind.RelativeOrAbsolute);
            if (uri.IsAbsoluteUri)
            {
                return urlString;
            }

            if (!uri.IsAbsoluteUri)
            {
                var siteDefResolver = ServiceLocator.Current.GetInstance<ISiteDefinitionResolver>();
                SiteDefinition siteDefinition = siteDefResolver.GetByContent(
                    contentLink: pageData.ContentLink,
                    fallbackToWildcard: true,
                    fallbackToEmpty: true);

                return new Uri(siteDefinition.SiteUrl, uri).ToString();
            }

            return urlString;
        }

Episerver Rest API and Routing Example

    /// <summary>
    /// The REST WEB API Configuration class
    /// </summary>
    [InitializableModule]
    [ModuleDependency(typeof(FrameworkInitialization))]
    public class WebApiConfig : IInitializableModule
    {
        public static string ApiRoute = "api";

        public void Initialize(InitializationEngine contextd)
        {
            // Enable Web API routing
            GlobalConfiguration.Configure(config =>
            {
                // Attribute routing
                config.MapHttpAttributeRoutes();

                var formatters = GlobalConfiguration.Configuration.Formatters;
                var jsonFormatter = formatters.JsonFormatter;
                var settings = jsonFormatter.SerializerSettings;

                var enumConverter = new Newtonsoft.Json.Converters.StringEnumConverter();
                jsonFormatter.SerializerSettings.Converters.Add(enumConverter);

                settings.Formatting = Formatting.Indented;

                config.Formatters.Remove(config.Formatters.XmlFormatter);

                // config.MapHttpAttributeRoutes();

                config.Routes.MapHttpRoute(
                    name: "RestAPI",
                    routeTemplate: ApiRoute + "/{controller}/{id}",
                    defaults: new {id = RouteParameter.Optional});
            });


        }

        public void Uninitialize(InitializationEngine context)
        {
            throw new NotImplementedException();
        }
    }

[RoutePrefix("api")]
    public class RestApiController : ApiController
    {


  [HttpGet]
        [Route("methods")]
        public string MethodsIndex()
        { //do something
        }

}

c# - Memory Cache example and call to async method.

  public static T GetRestObjectFromServiceOrCache<T>(string cacheItemName, Func<int, T> objectMethod, int id)
        {
            var expiration = CommonFactory.GetSettingsPage().RewardCategoryCacheTime == 0 ? DateTime.Now.AddHours(24) : DateTime.Now.AddHours(CommonFactory.GetSettingsPage().RewardCategoryCacheTime);

            ObjectCache cache = MemoryCache.Default;
            var cachedObject = (T)cache[cacheItemName];
            if (cachedObject == null)
            {
                CacheItemPolicy policy = new CacheItemPolicy
                {
                    AbsoluteExpiration = expiration
                };
                cachedObject = objectMethod(id);
                cache.Set(cacheItemName, cachedObject, policy);
            }

            return cachedObject;
        }

And Use it with this:

 var rewards = Task.Run(async () => await RestApiHelper.GetShopGroup(RestApiHelper.PartnerSe, id)).Result;

Http errors - Error Handling Custom

errorMode meaning

custom - means a special page overrriding the default error message. Use this to see the 404 error messages.

detailedlocalonly - will show ordinary error messages but only locally. 

<httpErrors errorMode="Custom" existingResponse="Replace">

      <remove statusCode="404" />

      <error statusCode="404" path="/404" responseMode="ExecuteURL" />

    </httpErrors>

EPiServer - Set Root Page Restrictions

 [InitializableModule]
    [ModuleDependency(typeof(EPiServer.Web.InitializationModule))]
    public class RootPageRestrictions : IInitializableModule
    {
        public void Initialize(InitializationEngine context)
        {
            var typeRepo = ServiceLocator.Current.GetInstance<IContentTypeRepository>();
            var sysRoot = typeRepo.Load("SysRoot") as PageType;


            var setting = new AvailableSetting {Availability = Availability.Specific};
            setting.AllowedContentTypeNames.Add(startPage.Name);
            setting.AllowedContentTypeNames.Add(settingsPage.Name);

            var availabilityRepository = ServiceLocator.Current.GetInstance<IAvailableSettingsRepository>();
            availabilityRepository.RegisterSetting(sysRoot, setting);

        }

        public void Preload(string[] parameters) { }

        public void Uninitialize(InitializationEngine context)
        {
            //Add uninitialization logic
        }
    }

CMD - Simple Find duplicated keys in XML file

 class XmlDuplicateCleaner
    {
        static void Main(string[] args)
        {
            Console.WriteLine("In what node should we search for duplicates?");
            var nodeToLookFor  = Console.ReadLine();
            Console.WriteLine("Provide filename for the file we should search");
            var filnamn = Console.ReadLine();
             var xmlDoc =  XDocument.Load(String.IsNullOrEmpty(filnamn) ? "xmlfile.xml" : filnamn);

             if (xmlDoc.Root != null)
             {
                 var grouped = xmlDoc.Root.Elements().Descendants(nodeToLookFor);
                 List<string> resultList = grouped.Select(groupItem => groupItem.Value).ToList();

                 var duplicateKeys = resultList.GroupBy(x => x)
                     .Where(group => @group.Count() > 1)
                     .Select(group => @group.Key);
                 foreach (var duplicateKey in duplicateKeys)
                 {
                     Console.WriteLine(duplicateKey);
                 }
             }

             Console.ReadLine();
        }
    }

CMD, GIT - Push Simple files to repository

1. Git init
2. Git Add *
3. Git commit -m "Added jadda"
4. git remote add origin "URL" to git repository that you just created in github.
5. git push --set-upstream origin master (branch)