Zikai's Codes

.gitignore

@@ -0,0 +1,4 @@
+out/
+bin/
+obj/
+

.vscode/launch.json

@@ -0,0 +1,46 @@
+{
+   // Use IntelliSense to find out which attributes exist for C# debugging
+   // Use hover for the description of the existing attributes
+   // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+   "version": "0.2.0",
+   "configurations": [
+        {
+            "name": ".NET Core Launch (web)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/bin/Debug/netcoreapp2.0/diary.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}",
+            "stopAtEntry": false,
+            "internalConsoleOptions": "openOnSessionStart",
+            "launchBrowser": {
+                "enabled": true,
+                "args": "${auto-detect-url}",
+                "windows": {
+                    "command": "cmd.exe",
+                    "args": "/C start ${auto-detect-url}"
+                },
+                "osx": {
+                    "command": "open"
+                },
+                "linux": {
+                    "command": "xdg-open"
+                }
+            },
+            "env": {
+                "ASPNETCORE_ENVIRONMENT": "Development"
+            },
+            "sourceFileMap": {
+                "/Views": "${workspaceFolder}/Views"
+            }
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach",
+            "processId": "${command:pickProcess}"
+        }
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,15 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/diary.csproj"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

ApiControllers/DiaryController.cs

@@ -0,0 +1,175 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using diary.ApiModels;
+using diary.ApiModels.DiaryController;
+using diary.Data;
+using diary.Models;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace diary.Controllers
+{
+    [Route("api/[controller]")]
+    public class DiaryController : Controller
+    {
+        private readonly ApplicationDbContext _dbContext;
+
+        public DiaryController(ApplicationDbContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        // GET /api/diary OR :8080/diary
+        [HttpGet]
+        public RetrieveDiaryResponse Get()
+        {
+            return new RetrieveDiaryResponse()
+            {
+                Status = true,
+                Result = _dbContext.Diaries.Where(p => p.IsPublic == true).ToList()
+            };
+        }
+
+        // POST /api/diary OR :8080/diary
+        [HttpPost]
+        public RetrieveDiaryResponse Post([FromBody]RetrieveDiaryRequest retrieveRequest)
+        {
+            if (ModelState.IsValid)
+            {
+                ApplicationUser user = _dbContext.GetUserWithToken(retrieveRequest.Token);
+                if (user != null)
+                {
+                    return new RetrieveDiaryResponse()
+                    {
+                        Status = true,
+                        Result = _dbContext.Diaries.Where(p => p.Author == user.UserName).ToList()
+                    };
+                }
+            }
+
+            return new RetrieveDiaryResponse()
+            {
+                Status = false,
+                Error = "Invalid authentication token."
+            };
+        }
+
+        // POST /api/diary/create OR :8080/diary/create
+        [HttpPost]
+        [Route("create")]
+        public ApiResponseModel Create([FromBody]CreateDiaryRequest createRequest)
+        {
+            if (ModelState.IsValid)
+            {
+                ApplicationUser user = _dbContext.GetUserWithToken(createRequest.Token);
+                if (user != null)
+                {
+
+                    Diary newDiary = new Diary()
+                    {
+                        Title = createRequest.Title,
+                        Author = user.UserName,
+                        PublishDate = DateTime.Now,
+                        IsPublic = createRequest.IsPublic,
+                        Text = createRequest.Text
+                    };
+                    _dbContext.Add(newDiary);
+                    if (_dbContext.SaveChanges() > 0)
+                    {
+                        Response.StatusCode = 201;
+                        return new ApiResponseModel()
+                        {
+                            Status = true,
+                            Result = new CreateDiaryResultModel()
+                            {
+                                Id = newDiary.Id.ToString()
+                            } 
+                        };
+                    }
+                }
+            }
+
+            return new ApiResponseModel()
+            {
+                Status = false,
+                Error = "Invalid authentication token."
+            };
+        }
+
+        // POST /api/diary/delete OR :8080/diary/delete
+        [HttpPost]
+        [Route("delete")]
+        public DeleteDiaryResponse Delete([FromBody]DeleteDiaryRequest deleteRequest)
+        {
+            int deleteId = 0;
+            if (ModelState.IsValid && int.TryParse(deleteRequest.Id, out deleteId))
+            {
+                ApplicationUser user = _dbContext.GetUserWithToken(deleteRequest.Token);
+                if (user != null)
+                {
+                    IQueryable<Diary> result = _dbContext.Diaries.Where(
+                                                        p => p.Author == user.UserName &&
+                                                             p.Id == deleteId);
+                    if (result.Count() == 1)
+                    {
+                        Diary toDelete = result.First();
+                        _dbContext.Diaries.Remove(toDelete);
+                        if (_dbContext.SaveChanges() > 0)
+                        {
+                            return new DeleteDiaryResponse()
+                            {
+                                Status = true
+                            };
+                        }
+                    }
+                }
+            }
+
+            return new DeleteDiaryResponse()
+            {
+                Status = false,
+                Error = "Invalid authentication token."
+            };
+        }
+
+        // POST /api/diary/permission OR :8080/diary/permission
+        [HttpPost]
+        [Route("permission")]
+        public AdjustDiaryPermissionResponse Permission([FromBody]AdjustDiaryPermissionRequest adjustRequest)
+        {
+            int adjustId = 0;
+            if (ModelState.IsValid && int.TryParse(adjustRequest.Id, out adjustId))
+            {
+                ApplicationUser user = _dbContext.GetUserWithToken(adjustRequest.Token);
+                if (user != null)
+                {
+                    IQueryable<Diary> result = _dbContext.Diaries.Where(
+                                                    p => p.Author == user.UserName &&
+                                                         p.Id == adjustId);
+
+                    if (result.Count() == 1)
+                    {
+                        Diary toAdjust = result.First();
+                        toAdjust.IsPublic = adjustRequest.IsPublic;
+                        _dbContext.Diaries.Update(toAdjust);
+                        if (_dbContext.SaveChanges() > 0)
+                        {
+                            return new AdjustDiaryPermissionResponse()
+                            {
+                                Status = true
+                            };
+                        }
+                    }
+                }
+            }
+
+            return new AdjustDiaryPermissionResponse()
+            {
+                Status = false,
+                Error = "Invalid authentication token."
+            };
+        }
+    }
+}

ApiControllers/MetaController.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using diary.ApiModels;
+using diary.ApiModels.MetaController;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace diary.Controllers
+{
+    [Route("api/[controller]")]
+    public class MetaController : Controller
+    {
+        private static readonly string[] MEMBERS = 
+        {
+            "Muhammad Mustaqiim Bin Muhar",
+            "Ng Qing Hua",
+            "Ng Zi Kai",
+            "Yee Jian Feng, Eric"
+        };
+
+
+        // GET /api/meta/heartbeat OR :8080/meta/heartbeat
+        [HttpGet]
+        [Route("heartbeat")]
+        public ApiResponseModel Heartbeat()
+        {
+            return new ApiResponseModel()
+            {
+                Status = true
+            };
+        }
+
+        // GET /api/meta/members OR :8080/meta/members
+        [HttpGet]
+        [Route("members")]
+        public MembersResponse Members()
+        {
+            return new MembersResponse()
+            {
+                Status = true,
+                Result = MEMBERS.ToList()
+            };
+        }
+    }
+}

ApiControllers/RootController.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using diary.ApiModels.RootController;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace diary.Controllers
+{
+    [Route("api/[controller]")]
+    public class RootController : Controller
+    {
+        private static readonly string[] IMPLEMENTED_ENDPOINTS = 
+        {
+            "/",
+            "/meta/heartbeat",
+            "/meta/members",
+            "/users/register",
+            "/users/authenticate",
+            "/users/expire",
+            "/users",
+            "/diary",
+            "/diary/create",
+            "/diary/delete",
+            "/diary/permission"
+        };
+
+        // GET /api/root OR GET :8080/
+        [HttpGet]
+        public ImplementedEndpointsResponse Get()
+        {
+            return new ImplementedEndpointsResponse()
+            {
+                Status = true,
+                Result = IMPLEMENTED_ENDPOINTS.ToList()
+            };
+        }
+    }
+}