Added Authentication (#29)

* added basic stats #5

* Revert "added basic stats #5"

This reverts commit e2a4c57.

* Added customizable graphiql interface

* fixing interface

* I committed all changes?

* Fixinf graphql js src or removing non existent file from csproj

* Nesting built in Umbraco properties under a ContentData field

* Renaming BuildInContentDataGraphType to PublishedContentDataGraphType

* Renaming the type ContentData to PublishedContentData

* Added permissions information to meta data

* Inlcuding missing file

* fixing the graphiql script

* correcting permission strings

* Renamed UmbracoEvents to Events\BuildSchemaEventHandler

* Added Migrations for creating the permissions tables (Accounts, AccountSettings)

* Added VS2017 build folder to ignore file

* Got authentication tables created via Migrations and Claims being generated, #10

* Updating how we setup the database tables so we're able to create and insert within the same method

* Added validation rule to throw an error if we try to request fields we don't have access to
Got the read permissions correctly setting in the meta data

* Created endpoints for saving and accessing account permissionms

* Tidying up API logic for setting and getting permissions

* Got permissions working for content nested uner _contentData

* Corrected SQL queries for the Umbraco permissions endpoints

* Removing error message when using default permissions

* Removing redundant method from auth extensions and renaming CanAccess to HasPermission

* Reverting changes for a customizable graphiql interface so we can move it into its own branch

* Reverting additional changes for a customizable graphiql interface so we can move it into its own branch

Author: JackPenney

.gitignore

@@ -6,15 +6,14 @@
 *.bak
 *.orig
 *.zip
-
 .vs/
 .idea/
-
 /build/
 /packages/
 /artifacts/
 bower_components/
 node_modules/
-
 [Bb]in/
-[Oo]bj/
+[Oo]bj/
+CurrentSettings.vssettings
+Visual Studio 2017/*

Our.Umbraco.GraphQL.sln

@@ -8,6 +8,9 @@ EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Website", "samples\Website\Website.csproj", "{C2001952-0774-4BFA-AF30-043B3B16D275}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{BE019E17-BF39-443C-8D62-74940D3B6560}"
+	ProjectSection(SolutionItems) = preProject
+		samples\Website\Web.config.template = samples\Website\Web.config.template
+	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Our.Umbraco.GraphQL", "src\Our.Umbraco.GraphQL\Our.Umbraco.GraphQL.csproj", "{59294783-3A17-479B-90C5-A3A2967176DE}"
 EndProject

src/Our.Umbraco.GraphQL/Controllers/GraphQLPermissionsController.cs

@@ -0,0 +1,94 @@
+using Newtonsoft.Json;
+using Our.Umbraco.GraphQL.Models;
+using Our.Umbraco.GraphQL.Models.ApiModels;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web.Mvc;
+using Umbraco.Core;
+using Umbraco.Core.Persistence;
+using Umbraco.Web.WebApi;
+
+namespace Our.Umbraco.GraphQL.Controllers
+{
+    public class GraphQLPermissionsController : UmbracoAuthorizedApiController
+    {
+        private readonly UmbracoDatabase _database = ApplicationContext.Current.DatabaseContext.Database;
+
+        // TODO: Lock down the ability to set/view permissions to a User Group
+
+        /// <summary>
+        /// Sets the GraphQL permisisons for what fields are accessible for the specified account
+        /// </summary>
+        /// <param name="accountPermissions">The set permissions request</param>
+        /// <remarks>
+        /// Default endpoint for the request: /umbraco/backoffice/api/GraphQLPermissions/SetPermissions
+        /// </remarks>
+        [HttpPost]
+        public void SetPermissions(SetAccountPermissionsRequest accountPermissions)
+        {
+            var entries = new List<AccountSettings>();
+            foreach (var permission in accountPermissions.Permissions)
+            {
+                var accountSettingEntry = new AccountSettings();
+                // Always default to empty for niw
+                accountSettingEntry.Notes = ""; 
+                // Default to read until we have functionality for other permissions
+                accountSettingEntry.Permission = Permissions.Read; // TODO: functionality for Write permissions
+                accountSettingEntry.AccountId = accountPermissions.AccountId;
+                accountSettingEntry.PropertyTypeAlias = permission.PropertyAlias;
+                accountSettingEntry.DocTypeAlias = permission.DoctypeAlias;
+                accountSettingEntry.IsBuiltInProperty = permission.IsBuiltInProperty;
+                accountSettingEntry.CreatedOn = DateTime.UtcNow;
+                accountSettingEntry.UpdatedOn = DateTime.UtcNow;
+
+                entries.Add(accountSettingEntry);
+            }
+
+            // Clear existing settings
+            var sql = new Sql("DELETE FROM GraphQL_AccountSettings WHERE AccountId=@0", accountPermissions.AccountId);
+            _database.Execute(sql);
+
+            // Insert in bulk so it's handled within a single query
+            _database.BulkInsertRecords(entries, ApplicationContext.Current.DatabaseContext.SqlSyntax);
+        }
+
+        /// <summary>
+        /// Gets a list of the current GraphQL permissions for the specified account
+        /// </summary>
+        /// <param name="accountId">The GraphQL account id</param>
+        /// <returns>
+        /// Example request endpoint: /umbraco/backoffice/api/GraphQLPermissions/GetPermissions?accountId=1
+        /// </returns>
+        [HttpGet]
+        public string GetPermissions(int accountId)
+        {
+            var sql = new Sql("SELECT * FROM GraphQL_AccountSettings WHERE AccountId=@0", accountId);
+            var settings = _database.Query<AccountSettings>(sql);
+
+            if (settings != null)
+            {
+                var accountPermissions = new List<AccountPermission>();
+                foreach (var permission in settings)
+                {
+                    var accountPermission = new AccountPermission();
+                    accountPermission.Notes = permission.Notes; 
+                    accountPermission.Permission = permission.Permission.ToString(); 
+                    accountPermission.PropertyAlias = permission.PropertyTypeAlias;
+                    accountPermission.DoctypeAlias = permission.DocTypeAlias;
+                    accountPermission.IsBuiltInProperty = permission.IsBuiltInProperty;
+
+                    accountPermissions.Add(accountPermission);
+                }
+
+                var results = JsonConvert.SerializeObject(accountPermissions);
+                return results;
+            }
+
+            return null;
+        }
+    }
+}

src/Our.Umbraco.GraphQL/UmbracoEvents.cs …raphQL/Events/BuildSchemaEventHandler.cssrc/Our.Umbraco.GraphQL/UmbracoEvents.cs renamed to src/Our.Umbraco.GraphQL/Events/BuildSchemaEventHandler.cs src/Our.Umbraco.GraphQL/UmbracoEvents.cs renamed to src/Our.Umbraco.GraphQL/Events/BuildSchemaEventHandler.cs

@@ -0,0 +1,56 @@
+using Semver;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+using Umbraco.Core;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.Migrations;
+
+namespace Our.Umbraco.GraphQL.Events
+{
+    /// <summary>
+    /// Runs our DB Migrations on startup.
+    /// 
+    /// Thank you to the wonderful Kevin Jump for pointers on how to get this as slick as it is
+    /// See: https://github.com/KevinJump/UmbracoMigrationsDemo for details
+    /// </summary>
+    public class MigrationEventHandler : ApplicationEventHandler
+    {
+        protected override void ApplicationStarted(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
+        {
+            // Update the version number as we deploy new DB changes to run any new Migrations
+            ApplyMigrations(applicationContext, "GraphQL", new SemVersion(1, 0, 0));
+        }
+
+        private void ApplyMigrations(ApplicationContext applicationContext, string productName, SemVersion targetVersion)
+        {
+            var currentVersion = new SemVersion(0);
+
+            var migrations = applicationContext.Services.MigrationEntryService.GetAll(productName);
+            var latest = migrations.OrderByDescending(x => x.Version).FirstOrDefault();
+            if (latest != null)
+                currentVersion = latest.Version;
+
+            if (targetVersion == currentVersion)
+                return;
+
+            var migrationRunner = new MigrationRunner(
+                applicationContext.Services.MigrationEntryService,
+                applicationContext.ProfilingLogger.Logger,
+                currentVersion,
+                targetVersion,
+                productName);
+
+            try
+            {
+                migrationRunner.Execute(applicationContext.DatabaseContext.Database);
+            }
+            catch (Exception ex)
+            {
+                applicationContext.ProfilingLogger
+                    .Logger.Error<MigrationEventHandler>("Error running " + productName + " Migration", ex);
+            }
+        }
+    }
+}

src/Our.Umbraco.GraphQL/Events/MigrationEventHandler.cs

@@ -0,0 +1,104 @@
+using GraphQL;
+using GraphQL.Builders;
+using GraphQL.Types;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Our.Umbraco.GraphQL
+{
+    // Based on the example used here https://graphql-dotnet.github.io/docs/getting-started/authorization
+    public static class GraphQLAuthenticationExtensions
+    {
+        public static readonly string PermissionsKey = "permissions";
+
+        /// <summary>
+        /// Checks if this field has any permissions set or not, if not then anyone can view it
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public static bool RequiresPermissions(this IProvideMetadata type)
+        {
+            var permissions = type.GetMetadata<IEnumerable<string>>(PermissionsKey, new List<string>());
+            return permissions.Any();
+        }
+
+        public static bool HasPermission(this IProvideMetadata type, string docTypeAlias, IEnumerable<string> claims)
+        {
+            var permissionsData = type.GetMetadata<IEnumerable<string>>(PermissionsKey, new List<string>());
+            var permissions = new List<string>();
+
+            foreach (var permissionKey in permissionsData)
+            {
+                var permission = permissionKey;
+
+                // if it starts with : we don't know what doctype it belongs to on the point of creating the field metadat
+                // So we work it out when required and pass it in here
+                if (permissionKey.StartsWith(":"))
+                {
+                    permission = $"{docTypeAlias}{permissionKey}";
+                }
+
+                permissions.Add(permission);
+            }
+            
+            return permissions.All(x => claims?.Contains(x) ?? false);
+        }
+
+        public static bool HasPermission(this IProvideMetadata type, IEnumerable<string> claims)
+        {
+            var permissions = type.GetMetadata<IEnumerable<string>>(PermissionsKey, new List<string>());
+            return permissions.All(x => claims?.Contains(x) ?? false);
+        }
+
+        public static void RequirePermission(this IProvideMetadata type, string permission)
+        {
+            var permissions = type.GetMetadata<List<string>>(PermissionsKey);
+
+            if (permissions == null)
+            {
+                permissions = new List<string>();
+                type.Metadata[PermissionsKey] = permissions;
+            }
+
+            permissions.Add(permission);
+        }
+
+        public static void SetPermissions(this FieldType type, string documentTypeAlias, bool isBuiltInProperty = false)
+        {
+            var propertyAlias = type.Name;
+
+            // If its a built in Umbraco property, add an additional flag to the key so it doesn't clash with any custom properties we set
+            var readPermissionKey = isBuiltInProperty ?
+                $"{documentTypeAlias}:builtInProperty:{propertyAlias}:Read" : $"{documentTypeAlias}:{propertyAlias}:Read";
+
+            type.RequirePermission(readPermissionKey);
+        }
+
+        public static void SetPermissions(this FieldType type, GraphType graphType, bool isBuiltInProperty = false)
+        {
+            // The graph type should have the doc type alias set in the meta data so we're accessing it from that
+            var doctypeAlias = graphType.GetMetadata<string>("documentTypeAlias");
+            type.SetPermissions(doctypeAlias, isBuiltInProperty);
+        }
+
+        public static void SetDoctypeMetadata(this FieldType type, string doctypeAlias)
+        {
+            var currentAlias = type.GetMetadata<List<string>>("documentTypeAlias");
+
+            if (currentAlias == null)
+            {
+                type.Metadata["documentTypeAlias"] = doctypeAlias;
+            }
+        }
+
+        public static FieldBuilder<TSourceType, TReturnType> RequirePermission<TSourceType, TReturnType>(
+            this FieldBuilder<TSourceType, TReturnType> builder, string permission)
+        {
+            builder.FieldType.RequirePermission(permission);
+            return builder;
+        }
+    }
+}

src/Our.Umbraco.GraphQL/GraphQLAuthenticationExtensions.cs

@@ -0,0 +1,102 @@
+using Our.Umbraco.GraphQL.Models;
+using System.Linq;
+using Umbraco.Core;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.Migrations;
+using Umbraco.Core.Persistence.SqlSyntax;
+using System;
+using Umbraco.Core.Persistence;
+
+namespace Our.Umbraco.GraphQL.Migrations
+{
+    [Migration("1.0.0", 1, "GraphQL")]
+    public class CreateInitialTables : MigrationBase
+    {
+        public const string accountsTableName = "Accounts";
+        public const string accountSettingsTableName = "AccountSettings";
+
+        private readonly UmbracoDatabase _database = ApplicationContext.Current.DatabaseContext.Database;
+        private readonly DatabaseSchemaHelper _schemaHelper;
+
+        public CreateInitialTables(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        {
+            _schemaHelper = new DatabaseSchemaHelper(_database, logger, sqlSyntax);
+        }
+
+        public override void Down()
+        {
+            Logger.Info<CreateInitialTables>("1.0.0: Running Migration Down");
+
+            DropTables();
+        }
+
+        public override void Up()
+        {
+            Logger.Info<CreateInitialTables>("1.0.0: Running Migration Up");
+
+            CreateTables();
+            InsertData();
+        }
+
+        private void CreateTables()
+        {
+            if (!_schemaHelper.TableExist(accountsTableName))
+            {
+                Logger.Info<CreateInitialTables>("Creation Accounts Table");
+                _schemaHelper.CreateTable<Account>();
+            }
+
+            if (!_schemaHelper.TableExist(accountSettingsTableName))
+            {
+                Logger.Info<CreateInitialTables>("Creating AccountSettings Table");
+                _schemaHelper.CreateTable<AccountSettings>();
+            }
+        }
+
+        private void DropTables()
+        {
+            if (_schemaHelper.TableExist(accountsTableName))
+            {
+                Logger.Info<CreateInitialTables>("Deleting Accounts Table");
+                _schemaHelper.DropTable(accountsTableName);
+            }
+            if (_schemaHelper.TableExist(accountSettingsTableName))
+            {
+                Logger.Info<CreateInitialTables>("Deleting AccountSettings Table");
+                _schemaHelper.DropTable(accountSettingsTableName);
+            }
+        }
+
+        private void InsertData()
+        {
+            var account = new Account()
+            {
+                //AccessToken = Guid.NewGuid(),
+                AccessToken = new Guid("6bd10bc4-1d31-478a-8abc-78560086286b"),
+                CreatedBy = 0,
+                CreatedOn = DateTime.Now,
+                UpdatedOn = DateTime.Now,
+                IsEnabled = true,
+                Name = "Pete Test",
+                Notes = "Just as test account setup in the create initial tables migration",
+            };
+
+            _database.Insert(account);
+
+            var accountSetting = new AccountSettings()
+            {
+                AccountId = account.Id,
+                DocTypeAlias = "home",
+                PropertyTypeAlias = "sitename",
+                IsBuiltInProperty = false,
+                Permission = Permissions.Read,
+                CreatedOn = DateTime.Now,
+                UpdatedOn = DateTime.Now,
+                Notes = ""
+            };
+
+            _database.Insert(accountSetting);
+        }
+    }
+}