Started implementing the adapters

client/src/adapters/comment.ts

+
+export interface Comment {
+    id: string;
+    task: string;
+    user: string;
+    text: string;
+    created: Date;
+    edited: Date;
+}
+

client/src/adapters/project.ts

+
+export interface Project {
+    id: string;
+    name: string;
+    status: 'open' | 'closed' | 'suspended';
+    teams: Array<string>;
+}
+

client/src/adapters/task.ts

+
+
+export interface TaskRequirement {
+    role: string;
+    time: number;
+}
+
+export interface TaskAssignment {
+    user: string;
+    time: number;
+    finished: boolean;
+}
+
+export interface Task {
+    id: string;
+    project: string;
+    name: string;
+    text: string;
+    icon: string;
+    priority: 'low' | 'medium' | 'high' | 'urgent';
+    status: 'open' | 'closed' | 'suspended';
+    dependentcies: Array<string>;
+    requirements: Array<TaskRequirement>;
+    assigned: Array<TaskAssignment>;
+    created: Date;
+    edited: Date;
+}
+

client/src/adapters/team.ts

+
+export interface Team {
+    id: string;
+    name: string;
+    role?: string;
+}
+

client/src/adapters/user.ts

 
 import { apiRoot } from 'config';
 
+import { getAuthHeader } from './auth';
+import { Task } from './task';
+import { Work } from './work';
+
 export async function exists(username: string) {
     try {
         const response = await fetch(`${apiRoot}/user/name/${username}`);
@@ -11,3 +15,88 @@ export async function exists(username: string) {
     }
 }
 
+export interface User {
+    id: string;
+    username: string;
+    realname?: string;
+    email?: string;
+}
+
+export async function getCurrentUser(): Promise<User> {
+    try {
+        const response = await fetch(`${apiRoot}/user/`, { headers: getAuthHeader() });
+        if (response.ok) {
+            return (await response.json()).user;
+        } else {
+            throw new Error("Failed to get user");
+        }
+    } catch (e) {
+        throw e;
+    }
+}
+
+export async function getTasks(): Promise<Array<Task>> {
+    try {
+        const response = await fetch(`${apiRoot}/user/tasks`, { headers: getAuthHeader() });
+        if (response.ok) {
+            return (await response.json()).tasks.map((task: any) => ({
+                ...task,
+                edited: new Date(task.edited),
+                created: new Date(task.created),
+            }));
+        } else {
+            throw new Error("Failed to get user tasks");
+        }
+    } catch (e) {
+        throw e;
+    }
+}
+
+export async function getWork(): Promise<Work> {
+    try {
+        const response = await fetch(`${apiRoot}/user/work`, { headers: getAuthHeader() });
+        if (response.ok) {
+            return (await response.json()).work;
+        } else {
+            throw new Error("Failed to get user work");
+        }
+    } catch (e) {
+        throw e;
+    }
+}
+
+export async function getUser(uuid: string): Promise<User> {
+    try {
+        const response = await fetch(`${apiRoot}/user/${uuid}`, { headers: getAuthHeader() });
+        if (response.ok) {
+            return (await response.json()).user;
+        } else {
+            throw new Error("Failed to get user");
+        }
+    } catch (e) {
+        throw e;
+    }
+}
+
+export async function updateUser(user: { realname?: string, email?: string }) {
+    try {
+        const response = await fetch(`${apiRoot}/user/`, {
+            method: 'PUT',
+            headers: {
+                ...getAuthHeader(),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(user),
+        });
+        if (!response.ok) {
+            throw new Error("Failed to update user");
+        }
+    } catch (e) {
+        throw e;
+    }
+}
+
+export function getUserImageUri(uuid: string): string {
+    return `${apiRoot}/user/${uuid}/image`;
+}
+

client/src/adapters/work.ts

+
+export interface Work {
+    id: string;
+    task: string;
+    user: string;
+    started: Date;
+    finished: Date;
+}
+