Initial Commit

backend/api/controllers/tasks.ts

@@ -0,0 +1,83 @@
+import { Request, Response, Router } from 'express';
+import { DeleteResult, getManager, UpdateResult } from 'typeorm';
+import { Task } from '../entities/Task';
+
+const router = Router();
+
+router.get('/tasks', async (_req: Request, res: Response) => {
+    try {
+        const taskRepository = getManager().getRepository(Task);
+        await taskRepository.find({
+            order: { id: 'DESC' },
+        }).then((tasks: Task[]) => {
+            res.status(200).send(tasks);
+        }).catch((error) => {
+            res.status(400).send(error);
+        });
+    } catch (error) {
+        res.status(400).send(error);
+    }
+});
+
+router.post('/tasks', async (req: Request, res: Response) => {
+    try {
+        const taskRepository = getManager().getRepository(Task);
+        const task: Task = new Task();
+        task.title = req.body.title;
+        task.done = req.body.done;
+        task.dueDate = req.body.dueDate;
+
+        await taskRepository.save(task).then((result: Task) => {
+            return res.status(200).send({
+                message: `Task successfully created`,
+                response: result,
+            });
+        }).catch((error) => {
+            res.status(400).send(error);
+        });
+    } catch (error) {
+        res.status(400).send(error);
+    }
+});
+
+router.put('/tasks/:id', (req: Request, res: Response) => {
+    try {
+        const taskRepository = getManager().getRepository(Task);
+        const task: Task = new Task();
+        task.title = req.body.title;
+        task.done = req.body.done;
+        task.dueDate = req.body.dueDate;
+        taskRepository.update(
+            req.params.id,
+            task,
+        ).then((updatedTask: UpdateResult) => {
+            res.status(200).send({
+                message: `Task successfully updated`,
+                response: updatedTask,
+            });
+        }).catch((error) => {
+            res.status(400).send(error);
+        });
+    } catch (error) {
+        res.status(400).send(error);
+    }
+});
+
+router.delete('/tasks/:id', async (req: Request, res: Response) => {
+    try {
+        const taskRepository = getManager().getRepository(Task);
+        const taskEntity = await taskRepository.findOne(req.params.id);
+        if (taskEntity) {
+            taskRepository.delete(req.params.id).then((result: DeleteResult) => {
+                res.status(200).send({
+                    message: `Task successfully deleted`,
+                    response: result,
+                });
+            });
+        }
+    } catch (error) {
+        res.status(400).send(error);
+    }
+});
+
+export default router;

backend/api/entities/Task.ts

@@ -0,0 +1,36 @@
+import {
+    Column,
+    CreateDateColumn,
+    Entity, PrimaryGeneratedColumn,
+    UpdateDateColumn,
+} from 'typeorm';
+
+@Entity()
+export class Task {
+
+    @PrimaryGeneratedColumn()
+    id: number;
+
+    @Column()
+    title: string;
+
+    @Column({
+        default: false,
+    })
+    done: boolean;
+
+    @Column()
+    dueDate: Date;
+
+    @CreateDateColumn()
+    createdAt: Date;
+
+    @UpdateDateColumn()
+    updatedAt: Date;
+
+    columns: {
+        updatedAt: {
+            updateDate: true,
+        },
+    };
+}

backend/api/migrations/1548630212872-MigrationTask.ts

@@ -0,0 +1,37 @@
+import { MigrationInterface, QueryRunner, Table } from 'typeorm';
+
+export class MigrationTask1548630212872 implements MigrationInterface {
+
+    public async up(queryRunner: QueryRunner): Promise<any> {
+        await queryRunner.createTable(new Table({
+            name: 'task',
+            columns: [
+                {
+                    name: 'id',
+                    type: 'int',
+                    isPrimary: true,
+                }, {
+                    name: 'title',
+                    type: 'varchar',
+                }, {
+                    name: 'done',
+                    type: 'boolean',
+                }, {
+                    name: 'dueDate',
+                    type: 'datetime',
+                }, {
+                    name: 'createdAt',
+                    type: 'datetime',
+                }, {
+                    name: 'updatedAt',
+                    type: 'datetime',
+                },
+            ],
+        }), true);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<any> {
+        console.log(queryRunner);
+    }
+
+}

backend/api/router.ts

@@ -0,0 +1,8 @@
+import { Router } from 'express';
+import taskRouter from './controllers/tasks';
+
+const router = Router();
+
+router.use(taskRouter);
+
+export default router;

backend/api/server.ts

@@ -0,0 +1,29 @@
+import * as bodyParser from 'body-parser';
+import * as express from 'express';
+import * as cors from 'cors';
+import 'reflect-metadata';
+import { Connection, createConnection } from 'typeorm';
+import router from './router';
+
+const app = express();
+
+app.use(cors());
+app.use(bodyParser.json());
+app.use((_req: express.Request, res: express.Response, next: express.NextFunction) => {
+    res.header('Access-Control-Allow-Origin', '*');
+    res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+    res.header('Access-Control-Allow-Headers', 'X-Requested-With, Content-Type');
+    next();
+});
+app.use('/api', router);
+app.set('port', 2000);
+
+createConnection().then(async (connection: Connection) => {
+    app.listen(app.get('port'), () => {
+        console.log(`Node API is running at http://localhost:${app.get('port')} in ${app.get('env')} mode`);
+        console.log(`Connected to your ${connection.options.type} database`);
+        console.log('Press CTRL-C to stop\n');
+    });
+}).catch((error) => console.error(`TypeORM connection ${error}`));
+
+export default app;