initial commit

Author: AlexKlimenkov

.gitignore

@@ -0,0 +1,9 @@
+bin
+obj
+*.suo
+**/packages/*
+!**/packages/repositories.config
+.vs
+*.ldf
+*.mdf
+*.user

README.md

@@ -0,0 +1,12 @@
+# dhtmlxScheduler with ASP.NET Core 
+
+Implementing backend for dhtmlxGantt using ASP.NET Core and Entity Framework Core
+
+## Requirements
+
+- Visual Studio 2017
+
+
+## Tutorial
+
+A complete tutorial can be found here https://docs.dhtmlx.com/scheduler/desktop__how_to_start.html

SchedulerApp.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.28307.106
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SchedulerApp", "SchedulerApp\SchedulerApp.csproj", "{13C3D3AE-4665-49E4-80CD-BC009D1ED68D}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{13C3D3AE-4665-49E4-80CD-BC009D1ED68D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{13C3D3AE-4665-49E4-80CD-BC009D1ED68D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{13C3D3AE-4665-49E4-80CD-BC009D1ED68D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{13C3D3AE-4665-49E4-80CD-BC009D1ED68D}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {CFA6CFCC-50E3-4A8E-A8AF-577FB7AB4977}
+	EndGlobalSection
+EndGlobal

SchedulerApp/Controllers/EventsController.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.AspNetCore.Mvc;
+using SchedulerApp.Models;
+
+namespace SchedulerApp.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class EventsController : ControllerBase
+    {
+        private readonly SchedulerContext _context;
+        public EventsController(SchedulerContext context)
+        {
+            _context = context;
+        }
+
+        // GET api/events
+        [HttpGet]
+        public IEnumerable<WebAPIEvent> Get([FromQuery] DateTime from, [FromQuery] DateTime to)
+        {
+            return _context.Events
+                .Where(e => e.StartDate < to && e.EndDate >= from)
+                .ToList()
+                .Select(e => (WebAPIEvent)e);
+        }
+
+        // GET api/events/5
+        [HttpGet("{id}")]
+        public WebAPIEvent Get(int id)
+        {
+            return (WebAPIEvent)_context
+                .Events
+                .Find(id);
+        }
+
+        // POST api/events
+        [HttpPost]
+        public ObjectResult Post([FromForm] WebAPIEvent apiEvent)
+        {
+            var newEvent = (SchedulerEvent)apiEvent;
+
+            _context.Events.Add(newEvent);
+            _context.SaveChanges();
+
+            return Ok(new
+            {
+                tid = newEvent.Id,
+                action = "inserted"
+            });
+        }
+
+        // PUT api/events/5
+        [HttpPut("{id}")]
+        public ObjectResult Put(int id, [FromForm] WebAPIEvent apiEvent)
+        {
+            var updatedEvent = (SchedulerEvent)apiEvent;
+            var dbEveht = _context.Events.Find(id);
+            dbEveht.Name = updatedEvent.Name;
+            dbEveht.StartDate = updatedEvent.StartDate;
+            dbEveht.EndDate = updatedEvent.EndDate;
+            _context.SaveChanges();
+
+            return Ok(new
+            {
+                action = "updated"
+            });
+        }
+
+        // DELETE api/events/5
+        [HttpDelete("{id}")]
+        public ObjectResult DeleteEvent(int id)
+        {
+            var e = _context.Events.Find(id);
+            if (e != null)
+            {
+            _context.Events.Remove(e);
+            _context.SaveChanges();
+            }
+ 
+            return Ok(new
+            {
+                action = "deleted"
+            });
+        }
+    
+    }
+}

SchedulerApp/Controllers/RecurringEventsController.cs

@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.AspNetCore.Mvc;
+using SchedulerApp.Models;
+
+namespace SchedulerApp.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class RecurringEventsController : ControllerBase
+    {
+        private readonly SchedulerContext _context;
+        public RecurringEventsController(SchedulerContext context)
+        {
+            _context = context;
+        }
+
+        // GET api/recurringevents
+        [HttpGet]
+        public IEnumerable<WebAPIRecurring> Get([FromQuery] DateTime from, [FromQuery] DateTime to)
+        {
+            return _context.RecurringEvents
+                .Where(e => e.StartDate < to && e.EndDate >= from)
+                .ToList()
+                .Select(e => (WebAPIRecurring)e);
+        }
+
+        // GET api/recurringevents/5
+        [HttpGet("{id}")]
+        public WebAPIRecurring Get(int id)
+        {
+            return (WebAPIRecurring)_context
+                .RecurringEvents
+                .Find(id);
+        }
+
+        // POST api/recurringevents
+        [HttpPost]
+        public ObjectResult Post([FromForm] WebAPIRecurring apiEvent)
+        {
+            var newEvent = (SchedulerRecurringEvent)apiEvent;
+
+            _context.RecurringEvents.Add(newEvent);
+            _context.SaveChanges();
+
+            // delete a single occurrence from  recurring series
+            var resultAction = "inserted";
+            if(newEvent.RecType == "none")
+            {
+                resultAction = "deleted";
+            }
+
+            return Ok(new
+            {
+                tid = newEvent.Id,
+                action = resultAction
+            });
+        }
+
+        // PUT api/recurringevents/5
+        [HttpPut("{id}")]
+        public ObjectResult Put(int id, [FromForm] WebAPIRecurring apiEvent)
+        {
+            var updatedEvent = (SchedulerRecurringEvent)apiEvent;
+            var dbEveht = _context.RecurringEvents.Find(id);
+            dbEveht.Name = updatedEvent.Name;
+            dbEveht.StartDate = updatedEvent.StartDate;
+            dbEveht.EndDate = updatedEvent.EndDate;
+            dbEveht.EventPID = updatedEvent.EventPID;
+            dbEveht.RecType = updatedEvent.RecType;
+            dbEveht.EventLength = updatedEvent.EventLength;
+
+            if (!string.IsNullOrEmpty(updatedEvent.RecType) && updatedEvent.RecType != "none")
+            {
+                // all modified occurrences must be deleted when we update recurring series
+                // https://docs.dhtmlx.com/scheduler/server_integration.html#savingrecurringevents
+
+                _context.RecurringEvents.RemoveRange(
+                    _context.RecurringEvents.Where(e => e.EventPID == id)
+                );
+            }
+
+            _context.SaveChanges();
+
+            return Ok(new
+            {
+                action = "updated"
+            });
+        }
+
+        // DELETE api/recurringevents/5
+        [HttpDelete("{id}")]
+        public ObjectResult DeleteEvent(int id)
+        {
+            var e = _context.RecurringEvents.Find(id);
+            if (e != null)
+            {
+                // some logic specific to recurring events support
+                // https://docs.dhtmlx.com/scheduler/server_integration.html#savingrecurringevents
+
+                if (e.EventPID != default(int))
+                {
+                    // deleting modified occurrence from recurring series
+                    // If an event with the event_pid value was deleted - it needs updating 
+                    // with rec_type==none instead of deleting.
+
+                    e.RecType = "none";
+                }
+                else
+                {
+                    // if a recurring series was deleted - delete all modified occurrences of the series
+                    if (!string.IsNullOrEmpty(e.RecType) && e.RecType != "none")
+                    {
+                        // all modified occurrences must be deleted when we update recurring series
+                        // https://docs.dhtmlx.com/scheduler/server_integration.html#savingrecurringevents
+
+                        _context.RecurringEvents.RemoveRange(
+                            _context.RecurringEvents.Where(ev => ev.EventPID == id)
+                        );
+                    }
+
+                    _context.RecurringEvents.Remove(e);
+                }
+
+                
+                _context.SaveChanges();
+            }
+ 
+            return Ok(new
+            {
+                action = "deleted"
+            });
+        }
+    
+    }
+}

SchedulerApp/Models/SchedulerContext.cs

@@ -0,0 +1,14 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace SchedulerApp.Models
+{
+    public class SchedulerContext : DbContext
+    {
+        public SchedulerContext(DbContextOptions<SchedulerContext> options)
+           : base(options)
+        {
+        }
+        public DbSet<SchedulerEvent> Events { get; set; }
+        public DbSet<SchedulerRecurringEvent> RecurringEvents { get; set; }
+    }
+}

SchedulerApp/Models/SchedulerEvent.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace SchedulerApp.Models
+{
+    public class SchedulerEvent
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public DateTime StartDate { get; set; }
+        public DateTime EndDate { get; set; }
+    }
+}

SchedulerApp/Models/SchedulerInitializer.cs

@@ -0,0 +1,25 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.AspNetCore.Hosting;
+
+namespace SchedulerApp.Models
+{
+    public static class SchedulerInitializerExtension
+    {
+        public static IWebHost InitializeDatabase(this IWebHost webHost)
+        {
+            var serviceScopeFactory =
+             (IServiceScopeFactory)webHost.Services.GetService(typeof(IServiceScopeFactory));
+
+            using (var scope = serviceScopeFactory.CreateScope())
+            {
+                var services = scope.ServiceProvider;
+                var dbContext = services.GetRequiredService<SchedulerContext>();
+                dbContext.Database.EnsureDeleted();
+                dbContext.Database.EnsureCreated();
+                SchedulerSeeder.Seed(dbContext);
+            }
+
+            return webHost;
+        }
+    }
+}

SchedulerApp/Models/SchedulerRecurringEvent.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace SchedulerApp.Models
+{
+    public class SchedulerRecurringEvent
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public DateTime StartDate { get; set; }
+        public DateTime EndDate { get; set; }
+
+        public int EventPID { get; set; }
+        public string RecType { get; set; }
+        public long EventLength { get; set; }
+
+    }
+}

SchedulerApp/Models/SchedulerSeeder.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SchedulerApp.Models
+{
+    public static class SchedulerSeeder
+    {
+        public static void Seed(SchedulerContext context)
+        {
+            if (context.Events.Any())
+            {
+                return;   // DB has been seeded
+            }
+
+            var events = new List<SchedulerEvent>()
+            {
+                new SchedulerEvent
+                {
+                    Name = "Event 1",
+                    StartDate = new DateTime(2019, 1, 15, 2, 0, 0),
+                    EndDate = new DateTime(2019, 1, 15, 4, 0, 0)
+                },
+                new SchedulerEvent()
+                {
+                    Name = "Event 2",
+                    StartDate = new DateTime(2019, 1, 17, 3, 0, 0),
+                    EndDate = new DateTime(2019, 1, 17, 6, 0, 0)
+                },
+                new SchedulerEvent()
+                {
+                    Name = "Multiday event",
+                    StartDate = new DateTime(2019, 1, 15, 0, 0, 0),
+                    EndDate = new DateTime(2019, 1, 20, 0, 0, 0)
+                }
+            };
+
+            events.ForEach(s => context.Events.Add(s));
+            context.SaveChanges();
+        }
+    }
+}