Added the initials features for the manage of the short links

Author: jeancarlo13

.gitignore

@@ -0,0 +1,2 @@
+bin/Debug
+obj

Controllers/ShortenerController.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using JCTools.Shortener.Models;
+using JCTools.Shortener.Settings;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.AspNetCore.Authorization;
+
+namespace JCTools.Shortener.Controllers
+{
+    [Authorize(Settings.Options.PolicyName)]
+    public class ShortenerController<TDatabaseContext> : Controller
+        where TDatabaseContext : DbContext, IDatabaseContext
+    {
+        /// <summary>
+        /// The logger instance to be use for log the application messages
+        /// </summary>
+        private readonly ILogger<ShortenerController<TDatabaseContext>> _logger;
+        /// <summary>
+        /// the database context instance to be use
+        /// </summary>
+        private readonly TDatabaseContext _context;
+
+        public ShortenerController(
+            ILogger<ShortenerController<TDatabaseContext>> logger,
+            TDatabaseContext context
+        )
+        {
+            _logger = logger;
+            this._context = context;
+        }
+
+        /// <summary>
+        /// Valid and redirect from a shorted link to the related url
+        /// </summary>
+        /// <param name="token">The token to be use for the redirection</param>
+        /// <returns>The task to be execute</returns>
+        [HttpGet]
+        [Route("/{token}")]
+        public async Task<IActionResult> RedirectTo(string token)
+        {
+            var link = await _context.ShortLinks.FirstOrDefaultAsync(sl => sl.Token == token);
+            if (link == null)
+                return NotFound();
+
+            return Redirect(link.RelatedUrl);
+        }
+    }
+}

JCTools.Shortener.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <OutputType>Library</OutputType>
+    <IsPackable>true</IsPackable>
+    <PackageId>JCTools.Shortener</PackageId>
+    <Version>1.0.4</Version>
+    <Authors>JeanCarlo13</Authors>
+    <Company>JCTools</Company>
+    <PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
+    <Description>A simple links shortener for include in .net core projects</Description>
+    <Copyright></Copyright>
+
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+
+    <PackageProjectUrl>https://github.com/jeancarlo13/JCTools.Shortener</PackageProjectUrl>
+    <RepositoryUrl>https://github.com/jeancarlo13/JCTools.Shortener</RepositoryUrl>
+    <PackageTags>.Net Core, Asp.Net Core, MVC, link, links, shortener, links shortener</PackageTags>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.1.1" />
+  </ItemGroup>
+
+</Project>

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 jeancarlo13
+Copyright (c) 2020 JCTools
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Models/ShortLink.cs

@@ -0,0 +1,19 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace JCTools.Shortener.Models
+{
+    [Table("Short_Link")]
+    public class ShortLink
+    {
+        /// <summary>
+        /// The random unique token to be used 
+        /// </summary>
+        [Key]
+        public string Token { get; set; }
+        /// <summary>
+        /// the url was shorted
+        /// </summary>
+        public string RelatedUrl { get; set; }
+    }
+}

README.md

@@ -1,2 +1,2 @@
 # JCTools.Shortener
-A simple link shortener for include in .net core projects 
+A simple links shortener for include in .net core projects 

Services/ILinkGenerator.cs

@@ -0,0 +1,40 @@
+using System.Threading.Tasks;
+using JCTools.Shortener.Models;
+
+namespace JCTools.Shortener.Services
+{
+    public interface ILinkGenerator
+    {
+
+        /// <summary>
+        /// Generate and save a short link with a random token
+        /// </summary>
+        /// <param name="relatedTo">the related url to be short</param>
+        /// <returns>The task to be execute</returns>
+        Task<ShortLink> GenerateAndSaveAsync(string relatedTo);
+
+        /// <summary>
+        /// Generate a short url with an random unique token
+        /// </summary>
+        /// <param name="relatedTo">the related url to be short</param>
+        /// <returns>The generate shorted link</returns>
+        Task<ShortLink> GenerateAsync(string relatedTo);
+        /// <summary>
+        /// Generate a random unique string token, with a configured length.
+        /// </summary>
+        /// <returns>The generate token</returns>
+        Task<string> GenerateTokenAsync();
+        /// <summary>
+        /// Allows get the absolute Url for the specified short link
+        /// </summary>
+        /// <param name="link">The short link to be use for generate the absolute Url</param>
+        /// <returns>The generated absolute url</returns>
+        string GetAbsoluteUrl(ShortLink link);
+        /// <summary>
+        /// Allows get the absolute Url for the specified toke string
+        /// </summary>
+        /// <param name="token">The toke to be use for generate the absolute Url</param>
+        /// <returns>The generated absolute url</returns>
+        string GetAbsoluteUrl(string token);
+    }
+}

Services/LinkGenerator.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using JCTools.Shortener.Models;
+using JCTools.Shortener.Settings;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+using Microsoft.AspNetCore.Mvc.Routing;
+using Microsoft.EntityFrameworkCore;
+
+
+namespace JCTools.Shortener.Services
+{
+    internal class LinkGenerator<TDatabaseContext> : ILinkGenerator
+        where TDatabaseContext : DbContext, IDatabaseContext
+    {
+        /// <summary>
+        /// the database context to be use
+        /// </summary>
+        private readonly TDatabaseContext _context;
+        private readonly IUrlHelper _urlHelper;
+        public LinkGenerator(
+            TDatabaseContext context,
+            IUrlHelperFactory urlHelperFactory,
+            IActionContextAccessor actionContextAccessor
+        )
+        {
+            this._context = context;
+            this._urlHelper = urlHelperFactory.GetUrlHelper(actionContextAccessor.ActionContext);
+        }
+
+        /// <summary>
+        /// Generate a random unique string token, with a configured length.
+        /// </summary>
+        /// <returns>The generate token</returns>
+        public async Task<string> GenerateTokenAsync()
+        {
+            var random = new Random();
+            var token = string.Empty;
+            var isValid = false;
+
+            while (!isValid)
+            {
+                var chars = Enumerable.Range(0, StartupExtensors.Options.ValidCharacters.Length - 1)
+                  .OrderBy(o => random.Next())
+                  .Select(i => StartupExtensors.Options.ValidCharacters[i])
+                  .ToList();
+
+                token = string.Join("", chars);
+                var length = random.Next(StartupExtensors.Options.MinLength, StartupExtensors.Options.MaxLength);
+                var start = random.Next(0, token.Length - length - 1);
+
+                token = token.Substring(start, length);
+
+                isValid = !await _context.ShortLinks.AnyAsync(sl => sl.Token == token);
+            }
+
+            return token;
+        }
+
+        /// <summary>
+        /// Generate a short url with an random unique token
+        /// </summary>
+        /// <param name="relatedTo">the related url to be short</param>
+        /// <returns>The generate shorted link</returns>
+        public async Task<ShortLink> GenerateAsync(string relatedTo)
+        {
+            var tokenEntry = new ShortLink()
+            {
+                Token = await GenerateTokenAsync(),
+                RelatedUrl = relatedTo
+            };
+
+            return tokenEntry;
+        }
+
+        /// <summary>
+        /// Generate and save a short link with a random token
+        /// </summary>
+        /// <param name="relatedTo">the related url to be short</param>
+        /// <returns>The task to be execute</returns>
+        public async Task<ShortLink> GenerateAndSaveAsync(string relatedTo)
+        {
+            var link = await GenerateAsync(relatedTo);
+            await _context.AddAsync(link);
+            await _context.SaveChangesAsync();
+            return link;
+        }
+        /// <summary>
+        /// Allows get the absolute Url for the specified short link
+        /// </summary>
+        /// <param name="link">The short link to be use for generate the absolute Url</param>
+        /// <returns>The generated absolute url</returns>
+        public string GetAbsoluteUrl(ShortLink link) => GetAbsoluteUrl(link.Token);
+
+        /// <summary>
+        /// Allows get the absolute Url for the specified toke string
+        /// </summary>
+        /// <param name="token">The toke to be use for generate the absolute Url</param>
+        /// <returns>The generated absolute url</returns>
+        public string GetAbsoluteUrl(string token)
+        {
+            return this._urlHelper.Action(
+                nameof(Controllers.ShortenerController<TDatabaseContext>.RedirectTo),
+                nameof(Controllers.ShortenerController<TDatabaseContext>).Replace("Controller", ""),
+                new { token = token },
+                this._urlHelper.ActionContext.HttpContext.Request.Scheme
+            );
+        }
+    }
+}

Settings/IDatabaseContext.cs

@@ -0,0 +1,17 @@
+using JCTools.Shortener.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace JCTools.Shortener.Settings
+{
+    /// <summary>
+    /// Allows acccess to the database of the third-part application
+    /// </summary>
+    public interface IDatabaseContext
+    {
+        /// <summary>
+        /// The collection of the generated short links 
+        /// </summary>
+        DbSet<ShortLink> ShortLinks { get; set; }
+
+    }
+}

Settings/Options.cs

@@ -0,0 +1,63 @@
+using System;
+using Microsoft.AspNetCore.Authorization;
+
+namespace JCTools.Shortener.Settings
+{
+    public class Options
+    {
+        /// <summary>
+        /// The police name used for add security to the controller access
+        /// </summary>
+        public const string PolicyName = "JCTools.Shortener.Policy";
+
+        /// <summary>
+        /// String with the collection of allowed characters 
+        /// to be use for the generation fo the short links.
+        /// The default characters are "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+        /// Using the full English alphabet plus all numerals from 0-9 that gives us 62 available characters, meaning we have: 
+        /// (62^2) + (62^3) + (62^4) + (62^5) + (62^6) possible unique tokens which equals: `57 billion 731 million 386 thousand 924´.
+        /// </summary>
+        public string ValidCharacters { get; set; } = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+        /// <summary>
+        /// The minimum length (default = 2) of the generated random unique token.
+        /// </summary>
+        private int _minLength = 2;
+        /// <summary>
+        /// The minimum length (default = 2) of the generated random unique token.
+        /// </summary>
+        public int MinLength
+        {
+            get => _minLength;
+            set
+            {
+                if (value >= MaxLength)
+                    throw new ArgumentException($"The {nameof(MinLength)} must be less that the {nameof(MaxLength)}. {value} < {MaxLength}?");
+                else
+                    _minLength = value;
+            }
+        }
+        /// <summary>
+        /// The maximum length (default = 6) of the generated random unique token.
+        /// </summary>
+        private int _maxLength = 6;
+        /// <summary>
+        /// The maximum length (default = 6) of the generated random unique token.
+        /// </summary>
+        public int MaxLength
+        {
+            get => _maxLength;
+            set
+            {
+                if (value <= MinLength)
+                    throw new ArgumentException($"The {nameof(MaxLength)} must be greater that the {nameof(MinLength)}. {value} > {MinLength}?");
+                else
+                    _maxLength = value;
+            }
+        }
+        /// <summary>
+        /// Use this property for manage the authorization policy according to you needs.
+        /// By default, it's configured with the anonymous access, and the redirection url can implement the adequate authorization.
+        /// </summary>
+        public Action<AuthorizationPolicyBuilder> ConfigurePolicy { get; set; } = p => p.RequireAssertion(a => true);
+    }
+}