sirtimbly/bewcloud
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Files CRUD.

Browse Source 
Remove Contacts and Calendar + CardDav and CalDav.
This commit is contained in:
Bruno Bernardino
2024-04-03 14:02:04 +01:00
parent c4788761d2
commit 4e5fdd569a
89 changed files with 2302 additions and 8001 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
routes/api/calendar/add-event.tsx
View File

@@ -1,77 +0,0 @@
import { Handlers } from 'fresh/server.ts';
import { CalendarEvent, FreshContextState } from '/lib/types.ts';
import { createCalendarEvent, getCalendar, getCalendarEvents } from '/lib/data/calendar.ts';
interface Data {}
export interface RequestBody {
calendarIds: string[];
calendarView: 'day' | 'week' | 'month';
calendarStartDate: string;
calendarId: string;
title: string;
startDate: string;
endDate: string;
isAllDay?: boolean;
}
export interface ResponseBody {
success: boolean;
newCalendarEvents: CalendarEvent[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (
!requestBody.calendarId || !requestBody.calendarIds || !requestBody.title || !requestBody.startDate ||
!requestBody.endDate || !requestBody.calendarView || !requestBody.calendarStartDate
) {
return new Response('Bad Request', { status: 400 });
}
const calendar = await getCalendar(requestBody.calendarId, context.state.user.id);
if (!calendar) {
return new Response('Not Found', { status: 404 });
}
const newCalendarEvent = await createCalendarEvent(
context.state.user.id,
requestBody.calendarId,
requestBody.title,
new Date(requestBody.startDate),
new Date(requestBody.endDate),
requestBody.isAllDay,
);
if (!newCalendarEvent) {
return new Response('Not Found', { status: 404 });
}
const dateRange = { start: new Date(requestBody.calendarStartDate), end: new Date(requestBody.calendarStartDate) };
if (requestBody.calendarView === 'day') {
dateRange.start.setDate(dateRange.start.getDate() - 1);
dateRange.end.setDate(dateRange.end.getDate() + 1);
} else if (requestBody.calendarView === 'week') {
dateRange.start.setDate(dateRange.start.getDate() - 7);
dateRange.end.setDate(dateRange.end.getDate() + 7);
} else {
dateRange.start.setDate(dateRange.start.getDate() - 7);
dateRange.end.setDate(dateRange.end.getDate() + 31);
}
const newCalendarEvents = await getCalendarEvents(context.state.user.id, requestBody.calendarIds, dateRange);
const responseBody: ResponseBody = { success: true, newCalendarEvents };
return new Response(JSON.stringify(responseBody));
},
};

39
routes/api/calendar/add.tsx
View File

@@ -1,39 +0,0 @@
import { Handlers } from 'fresh/server.ts';
import { Calendar, FreshContextState } from '/lib/types.ts';
import { createCalendar, getCalendars } from '/lib/data/calendar.ts';
interface Data {}
export interface RequestBody {
name: string;
}
export interface ResponseBody {
success: boolean;
newCalendars: Calendar[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (requestBody.name) {
const newCalendar = await createCalendar(context.state.user.id, requestBody.name);
if (!newCalendar) {
return new Response('Not found', { status: 404 });
}
}
const newCalendars = await getCalendars(context.state.user.id);
const responseBody: ResponseBody = { success: true, newCalendars };
return new Response(JSON.stringify(responseBody));
},
};

73
routes/api/calendar/delete-event.tsx
View File

@@ -1,73 +0,0 @@
import { Handlers } from 'fresh/server.ts';
import { CalendarEvent, FreshContextState } from '/lib/types.ts';
import { deleteCalendarEvent, getCalendar, getCalendarEvent, getCalendarEvents } from '/lib/data/calendar.ts';
interface Data {}
export interface RequestBody {
calendarIds: string[];
calendarView: 'day' | 'week' | 'month';
calendarStartDate: string;
calendarId: string;
calendarEventId: string;
}
export interface ResponseBody {
success: boolean;
newCalendarEvents: CalendarEvent[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (
!requestBody.calendarId || !requestBody.calendarIds || !requestBody.calendarEventId ||
!requestBody.calendarEventId ||
!requestBody.calendarView || !requestBody.calendarStartDate
) {
return new Response('Bad Request', { status: 400 });
}
const calendar = await getCalendar(requestBody.calendarId, context.state.user.id);
if (!calendar) {
return new Response('Not Found', { status: 404 });
}
const calendarEvent = await getCalendarEvent(
requestBody.calendarEventId,
context.state.user.id,
);
if (!calendarEvent || requestBody.calendarId !== calendarEvent.calendar_id) {
return new Response('Not Found', { status: 404 });
}
await deleteCalendarEvent(requestBody.calendarEventId, requestBody.calendarId, context.state.user.id);
const dateRange = { start: new Date(requestBody.calendarStartDate), end: new Date(requestBody.calendarStartDate) };
if (requestBody.calendarView === 'day') {
dateRange.start.setDate(dateRange.start.getDate() - 1);
dateRange.end.setDate(dateRange.end.getDate() + 1);
} else if (requestBody.calendarView === 'week') {
dateRange.start.setDate(dateRange.start.getDate() - 7);
dateRange.end.setDate(dateRange.end.getDate() + 7);
} else {
dateRange.start.setDate(dateRange.start.getDate() - 7);
dateRange.end.setDate(dateRange.end.getDate() + 31);
}
const newCalendarEvents = await getCalendarEvents(context.state.user.id, requestBody.calendarIds, dateRange);
const responseBody: ResponseBody = { success: true, newCalendarEvents };
return new Response(JSON.stringify(responseBody));
},
};

41
routes/api/calendar/delete.tsx
View File

@@ -1,41 +0,0 @@
import { Handlers } from 'fresh/server.ts';
import { Calendar, FreshContextState } from '/lib/types.ts';
import { deleteCalendar, getCalendar, getCalendars } from '/lib/data/calendar.ts';
interface Data {}
export interface RequestBody {
calendarId: string;
}
export interface ResponseBody {
success: boolean;
newCalendars: Calendar[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (requestBody.calendarId) {
const calendar = await getCalendar(requestBody.calendarId, context.state.user.id);
if (!calendar) {
return new Response('Not found', { status: 404 });
}
await deleteCalendar(requestBody.calendarId, context.state.user.id);
}
const newCalendars = await getCalendars(context.state.user.id);
const responseBody: ResponseBody = { success: true, newCalendars };
return new Response(JSON.stringify(responseBody));
},
};

38
routes/api/calendar/get-events.tsx
View File

@@ -1,38 +0,0 @@
import { Handlers } from 'fresh/server.ts';
import { CalendarEvent, FreshContextState } from '/lib/types.ts';
import { getCalendarEvents } from '/lib/data/calendar.ts';
interface Data {}
export interface RequestBody {
calendarIds: string[];
}
export interface ResponseBody {
success: boolean;
calendarEvents: CalendarEvent[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (!requestBody.calendarIds) {
return new Response('Bad Request', { status: 400 });
}
const calendarEvents = await getCalendarEvents(
context.state.user.id,
requestBody.calendarIds,
);
const responseBody: ResponseBody = { success: true, calendarEvents };
return new Response(JSON.stringify(responseBody));
},
};

97
routes/api/calendar/import.tsx
View File

@@ -1,97 +0,0 @@
import { Handlers } from 'fresh/server.ts';
import { CalendarEvent, FreshContextState } from '/lib/types.ts';
import { concurrentPromises } from '/lib/utils/misc.ts';
import { createCalendarEvent, getCalendar, getCalendarEvents, updateCalendarEvent } from '/lib/data/calendar.ts';
interface Data {}
export interface RequestBody {
calendarIds: string[];
calendarView: 'day' | 'week' | 'month';
calendarStartDate: string;
partialCalendarEvents: Partial<CalendarEvent>[];
calendarId: string;
}
export interface ResponseBody {
success: boolean;
newCalendarEvents: CalendarEvent[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (
!requestBody.calendarId || !requestBody.calendarIds || !requestBody.partialCalendarEvents ||
!requestBody.calendarView || !requestBody.calendarStartDate
) {
return new Response('Bad Request', { status: 400 });
}
const calendar = await getCalendar(requestBody.calendarId, context.state.user.id);
if (!calendar) {
return new Response('Not Found', { status: 404 });
}
if (requestBody.partialCalendarEvents.length === 0) {
return new Response('Not found', { status: 404 });
}
await concurrentPromises(
requestBody.partialCalendarEvents.map((partialCalendarEvent) => async () => {
if (partialCalendarEvent.title && partialCalendarEvent.start_date && partialCalendarEvent.end_date) {
const calendarEvent = await createCalendarEvent(
context.state.user!.id,
requestBody.calendarId,
partialCalendarEvent.title,
new Date(partialCalendarEvent.start_date),
new Date(partialCalendarEvent.end_date),
partialCalendarEvent.is_all_day,
);
const parsedExtra = JSON.stringify(partialCalendarEvent.extra || {});
if (parsedExtra !== '{}') {
calendarEvent.extra = partialCalendarEvent.extra!;
if (
calendarEvent.extra.is_recurring && calendarEvent.extra.recurring_sequence === 0 &&
!calendarEvent.extra.recurring_id
) {
calendarEvent.extra.recurring_id = calendarEvent.id;
}
await updateCalendarEvent(calendarEvent);
}
}
}),
5,
);
const dateRange = { start: new Date(requestBody.calendarStartDate), end: new Date(requestBody.calendarStartDate) };
if (requestBody.calendarView === 'day') {
dateRange.start.setDate(dateRange.start.getDate() - 1);
dateRange.end.setDate(dateRange.end.getDate() + 1);
} else if (requestBody.calendarView === 'week') {
dateRange.start.setDate(dateRange.start.getDate() - 7);
dateRange.end.setDate(dateRange.end.getDate() + 7);
} else {
dateRange.start.setDate(dateRange.start.getDate() - 7);
dateRange.end.setDate(dateRange.end.getDate() + 31);
}
const newCalendarEvents = await getCalendarEvents(context.state.user.id, requestBody.calendarIds, dateRange);
const responseBody: ResponseBody = { success: true, newCalendarEvents };
return new Response(JSON.stringify(responseBody));
},
};

42
routes/api/calendar/search-events.tsx
View File

@@ -1,42 +0,0 @@
import { Handlers } from 'fresh/server.ts';
import { CalendarEvent, FreshContextState } from '/lib/types.ts';
import { searchCalendarEvents } from '/lib/data/calendar.ts';
interface Data {}
export interface RequestBody {
calendarIds: string[];
searchTerm: string;
}
export interface ResponseBody {
success: boolean;
matchingCalendarEvents: CalendarEvent[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (
!requestBody.calendarIds || !requestBody.searchTerm
) {
return new Response('Bad Request', { status: 400 });
}
const matchingCalendarEvents = await searchCalendarEvents(
requestBody.searchTerm,
context.state.user.id,
requestBody.calendarIds,
);
const responseBody: ResponseBody = { success: true, matchingCalendarEvents };
return new Response(JSON.stringify(responseBody));
},
};

48
routes/api/calendar/update.tsx
View File

@@ -1,48 +0,0 @@
import { Handlers } from 'fresh/server.ts';
import { Calendar, FreshContextState } from '/lib/types.ts';
import { getCalendar, getCalendars, updateCalendar } from '/lib/data/calendar.ts';
interface Data {}
export interface RequestBody {
id: string;
name: string;
color: string;
is_visible: boolean;
}
export interface ResponseBody {
success: boolean;
newCalendars: Calendar[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (requestBody.id) {
const calendar = await getCalendar(requestBody.id, context.state.user.id);
if (!calendar) {
return new Response('Not found', { status: 404 });
}
calendar.name = requestBody.name;
calendar.color = requestBody.color;
calendar.is_visible = requestBody.is_visible;
await updateCalendar(calendar);
}
const newCalendars = await getCalendars(context.state.user.id);
const responseBody: ResponseBody = { success: true, newCalendars };
return new Response(JSON.stringify(responseBody));
},
};

41
routes/api/contacts/add.tsx
View File

@@ -1,41 +0,0 @@
import { Handlers } from 'fresh/server.ts';
import { Contact, FreshContextState } from '/lib/types.ts';
import { createContact, getContacts } from '/lib/data/contacts.ts';
interface Data {}
export interface RequestBody {
firstName: string;
lastName: string;
page: number;
}
export interface ResponseBody {
success: boolean;
contacts: Pick<Contact, 'id' | 'first_name' | 'last_name'>[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (requestBody.firstName) {
const contact = await createContact(context.state.user.id, requestBody.firstName, requestBody.lastName);
if (!contact) {
return new Response('Not found', { status: 404 });
}
}
const contacts = await getContacts(context.state.user.id, requestBody.page - 1);
const responseBody: ResponseBody = { success: true, contacts };
return new Response(JSON.stringify(responseBody));
},
};

42
routes/api/contacts/delete.tsx
View File

@@ -1,42 +0,0 @@
import { Handlers } from 'fresh/server.ts';
import { Contact, FreshContextState } from '/lib/types.ts';
import { deleteContact, getContact, getContacts } from '/lib/data/contacts.ts';
interface Data {}
export interface RequestBody {
contactId: string;
page: number;
}
export interface ResponseBody {
success: boolean;
contacts: Pick<Contact, 'id' | 'first_name' | 'last_name'>[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (requestBody.contactId) {
const contact = await getContact(requestBody.contactId, context.state.user.id);
if (!contact) {
return new Response('Not found', { status: 404 });
}
await deleteContact(requestBody.contactId, context.state.user.id);
}
const contacts = await getContacts(context.state.user.id, requestBody.page - 1);
const responseBody: ResponseBody = { success: true, contacts };
return new Response(JSON.stringify(responseBody));
},
};

27
routes/api/contacts/get.tsx
View File

@@ -1,27 +0,0 @@
import { Handlers } from 'fresh/server.ts';
import { Contact, FreshContextState } from '/lib/types.ts';
import { getAllContacts } from '/lib/data/contacts.ts';
interface Data {}
export interface RequestBody {}
export interface ResponseBody {
success: boolean;
contacts: Contact[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const contacts = await getAllContacts(context.state.user.id);
const responseBody: ResponseBody = { success: true, contacts };
return new Response(JSON.stringify(responseBody));
},
};

60
routes/api/contacts/import.tsx
View File

@@ -1,60 +0,0 @@
import { Handlers } from 'fresh/server.ts';
import { Contact, FreshContextState } from '/lib/types.ts';
import { concurrentPromises } from '/lib/utils/misc.ts';
import { createContact, getContacts, updateContact } from '/lib/data/contacts.ts';
interface Data {}
export interface RequestBody {
partialContacts: Partial<Contact>[];
page: number;
}
export interface ResponseBody {
success: boolean;
contacts: Pick<Contact, 'id' | 'first_name' | 'last_name'>[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (requestBody.partialContacts) {
if (requestBody.partialContacts.length === 0) {
return new Response('Not found', { status: 404 });
}
await concurrentPromises(
requestBody.partialContacts.map((partialContact) => async () => {
if (partialContact.first_name) {
const contact = await createContact(
context.state.user!.id,
partialContact.first_name,
partialContact.last_name || '',
);
const parsedExtra = JSON.stringify(partialContact.extra || {});
if (parsedExtra !== '{}') {
contact.extra = partialContact.extra!;
await updateContact(contact);
}
}
}),
5,
);
}
const contacts = await getContacts(context.state.user.id, requestBody.page - 1);
const responseBody: ResponseBody = { success: true, contacts };
return new Response(JSON.stringify(responseBody));
},
};

47
routes/api/files/create-directory.tsx Normal file
View File

@@ -0,0 +1,47 @@
import { Handlers } from 'fresh/server.ts';
import { Directory, FreshContextState } from '/lib/types.ts';
import { createDirectory, getDirectories } from '/lib/data/files.ts';
interface Data {}
export interface RequestBody {
parentPath: string;
name: string;
}
export interface ResponseBody {
success: boolean;
newDirectories: Directory[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (
!requestBody.parentPath || !requestBody.name?.trim() || !requestBody.parentPath.startsWith('/') ||
requestBody.parentPath.includes('../')
) {
return new Response('Bad Request', { status: 400 });
}
// TODO: Verify user has write access to path and get the appropriate ownerUserId
const createdDirectory = await createDirectory(
context.state.user.id,
requestBody.parentPath,
requestBody.name.trim(),
);
const newDirectories = await getDirectories(context.state.user.id, requestBody.parentPath);
const responseBody: ResponseBody = { success: createdDirectory, newDirectories };
return new Response(JSON.stringify(responseBody));
},
};

47
routes/api/files/delete-directory.tsx Normal file
View File

@@ -0,0 +1,47 @@
import { Handlers } from 'fresh/server.ts';
import { Directory, FreshContextState } from '/lib/types.ts';
import { deleteDirectoryOrFile, getDirectories } from '/lib/data/files.ts';
interface Data {}
export interface RequestBody {
parentPath: string;
name: string;
}
export interface ResponseBody {
success: boolean;
newDirectories: Directory[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (
!requestBody.parentPath || !requestBody.name?.trim() || !requestBody.parentPath.startsWith('/') ||
requestBody.parentPath.includes('../')
) {
return new Response('Bad Request', { status: 400 });
}
// TODO: Verify user has write access to path and get the appropriate ownerUserId
const deletedDirectory = await deleteDirectoryOrFile(
context.state.user.id,
requestBody.parentPath,
requestBody.name.trim(),
);
const newDirectories = await getDirectories(context.state.user.id, requestBody.parentPath);
const responseBody: ResponseBody = { success: deletedDirectory, newDirectories };
return new Response(JSON.stringify(responseBody));
},
};

47
routes/api/files/delete.tsx Normal file
View File

@@ -0,0 +1,47 @@
import { Handlers } from 'fresh/server.ts';
import { DirectoryFile, FreshContextState } from '/lib/types.ts';
import { deleteDirectoryOrFile, getFiles } from '/lib/data/files.ts';
interface Data {}
export interface RequestBody {
parentPath: string;
name: string;
}
export interface ResponseBody {
success: boolean;
newFiles: DirectoryFile[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (
!requestBody.parentPath || !requestBody.name?.trim() || !requestBody.parentPath.startsWith('/') ||
requestBody.parentPath.includes('../')
) {
return new Response('Bad Request', { status: 400 });
}
// TODO: Verify user has write access to path/file and get the appropriate ownerUserId
const deletedFile = await deleteDirectoryOrFile(
context.state.user.id,
requestBody.parentPath,
requestBody.name.trim(),
);
const newFiles = await getFiles(context.state.user.id, requestBody.parentPath);
const responseBody: ResponseBody = { success: deletedFile, newFiles };
return new Response(JSON.stringify(responseBody));
},
};

47
routes/api/files/get-directories.tsx Normal file
View File

@@ -0,0 +1,47 @@
import { Handlers } from 'fresh/server.ts';
import { Directory, FreshContextState } from '/lib/types.ts';
import { getDirectories } from '/lib/data/files.ts';
interface Data {}
export interface RequestBody {
parentPath: string;
directoryPathToExclude?: string;
}
export interface ResponseBody {
success: boolean;
directories: Directory[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (
!requestBody.parentPath || !requestBody.parentPath.startsWith('/') || requestBody.parentPath.includes('../')
) {
return new Response('Bad Request', { status: 400 });
}
const directories = await getDirectories(
context.state.user.id,
requestBody.parentPath,
);
const filteredDirectories = requestBody.directoryPathToExclude
? directories.filter((directory) =>
`${directory.parent_path}${directory.directory_name}` !== requestBody.directoryPathToExclude
)
: directories;
const responseBody: ResponseBody = { success: true, directories: filteredDirectories };
return new Response(JSON.stringify(responseBody));
},
};

52
routes/api/files/move-directory.tsx Normal file
View File

@@ -0,0 +1,52 @@
import { Handlers } from 'fresh/server.ts';
import { Directory, FreshContextState } from '/lib/types.ts';
import { getDirectories, renameDirectoryOrFile } from '/lib/data/files.ts';
interface Data {}
export interface RequestBody {
oldParentPath: string;
newParentPath: string;
name: string;
}
export interface ResponseBody {
success: boolean;
newDirectories: Directory[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (
!requestBody.oldParentPath || !requestBody.newParentPath || !requestBody.name?.trim() ||
!requestBody.oldParentPath.startsWith('/') ||
requestBody.oldParentPath.includes('../') || !requestBody.newParentPath.startsWith('/') ||
requestBody.newParentPath.includes('../')
) {
return new Response('Bad Request', { status: 400 });
}
// TODO: Verify user has write access to old and new paths and get the appropriate ownerUserIds
const movedDirectory = await renameDirectoryOrFile(
context.state.user.id,
requestBody.oldParentPath,
requestBody.newParentPath,
requestBody.name.trim(),
requestBody.name.trim(),
);
const newDirectories = await getDirectories(context.state.user.id, requestBody.oldParentPath);
const responseBody: ResponseBody = { success: movedDirectory, newDirectories };
return new Response(JSON.stringify(responseBody));
},
};

52
routes/api/files/move.tsx Normal file
View File

@@ -0,0 +1,52 @@
import { Handlers } from 'fresh/server.ts';
import { DirectoryFile, FreshContextState } from '/lib/types.ts';
import { getFiles, renameDirectoryOrFile } from '/lib/data/files.ts';
interface Data {}
export interface RequestBody {
oldParentPath: string;
newParentPath: string;
name: string;
}
export interface ResponseBody {
success: boolean;
newFiles: DirectoryFile[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (
!requestBody.oldParentPath || !requestBody.newParentPath || !requestBody.name?.trim() ||
!requestBody.oldParentPath.startsWith('/') ||
requestBody.oldParentPath.includes('../') || !requestBody.newParentPath.startsWith('/') ||
requestBody.newParentPath.includes('../')
) {
return new Response('Bad Request', { status: 400 });
}
// TODO: Verify user has write access to old and new paths/files and get the appropriate ownerUserIds
const movedFile = await renameDirectoryOrFile(
context.state.user.id,
requestBody.oldParentPath,
requestBody.newParentPath,
requestBody.name.trim(),
requestBody.name.trim(),
);
const newFiles = await getFiles(context.state.user.id, requestBody.oldParentPath);
const responseBody: ResponseBody = { success: movedFile, newFiles };
return new Response(JSON.stringify(responseBody));
},
};

51
routes/api/files/rename-directory.tsx Normal file
View File

@@ -0,0 +1,51 @@
import { Handlers } from 'fresh/server.ts';
import { Directory, FreshContextState } from '/lib/types.ts';
import { getDirectories, renameDirectoryOrFile } from '/lib/data/files.ts';
interface Data {}
export interface RequestBody {
parentPath: string;
oldName: string;
newName: string;
}
export interface ResponseBody {
success: boolean;
newDirectories: Directory[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (
!requestBody.parentPath || !requestBody.oldName?.trim() || !requestBody.newName?.trim() ||
!requestBody.parentPath.startsWith('/') ||
requestBody.parentPath.includes('../')
) {
return new Response('Bad Request', { status: 400 });
}
// TODO: Verify user has write access to path and get the appropriate ownerUserId
const movedDirectory = await renameDirectoryOrFile(
context.state.user.id,
requestBody.parentPath,
requestBody.parentPath,
requestBody.oldName.trim(),
requestBody.newName.trim(),
);
const newDirectories = await getDirectories(context.state.user.id, requestBody.parentPath);
const responseBody: ResponseBody = { success: movedDirectory, newDirectories };
return new Response(JSON.stringify(responseBody));
},
};

51
routes/api/files/rename.tsx Normal file
View File

@@ -0,0 +1,51 @@
import { Handlers } from 'fresh/server.ts';
import { DirectoryFile, FreshContextState } from '/lib/types.ts';
import { getFiles, renameDirectoryOrFile } from '/lib/data/files.ts';
interface Data {}
export interface RequestBody {
parentPath: string;
oldName: string;
newName: string;
}
export interface ResponseBody {
success: boolean;
newFiles: DirectoryFile[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().json() as RequestBody;
if (
!requestBody.parentPath || !requestBody.oldName?.trim() || !requestBody.newName?.trim() ||
!requestBody.parentPath.startsWith('/') ||
requestBody.parentPath.includes('../')
) {
return new Response('Bad Request', { status: 400 });
}
// TODO: Verify user has write access to path/file and get the appropriate ownerUserId
const movedFile = await renameDirectoryOrFile(
context.state.user.id,
requestBody.parentPath,
requestBody.parentPath,
requestBody.oldName.trim(),
requestBody.newName.trim(),
);
const newFiles = await getFiles(context.state.user.id, requestBody.parentPath);
const responseBody: ResponseBody = { success: movedFile, newFiles };
return new Response(JSON.stringify(responseBody));
},
};

42
routes/api/files/upload.tsx Normal file
View File

@@ -0,0 +1,42 @@
import { Handlers } from 'fresh/server.ts';
import { DirectoryFile, FreshContextState } from '/lib/types.ts';
import { createFile, getFiles } from '/lib/data/files.ts';
interface Data {}
export interface ResponseBody {
success: boolean;
newFiles: DirectoryFile[];
}
export const handler: Handlers<Data, FreshContextState> = {
async POST(request, context) {
if (!context.state.user) {
return new Response('Unauthorized', { status: 401 });
}
const requestBody = await request.clone().formData();
const parentPath = requestBody.get('parent_path') as string;
const name = requestBody.get('name') as string;
const contents = requestBody.get('contents') as File;
if (
!parentPath || !name.trim() || !contents || !parentPath.startsWith('/') ||
parentPath.includes('../')
) {
return new Response('Bad Request', { status: 400 });
}
// TODO: Verify user has write access to path and get the appropriate ownerUserId
const createdFile = await createFile(context.state.user.id, parentPath, name.trim(), await contents.arrayBuffer());
const newFiles = await getFiles(context.state.user.id, parentPath);
const responseBody: ResponseBody = { success: createdFile, newFiles };
return new Response(JSON.stringify(responseBody));
},
};