378 lines
13 KiB
TypeScript
378 lines
13 KiB
TypeScript
import { NextResponse } from 'next/server';
|
|
import { getServerSession } from 'next-auth';
|
|
import { authOptions } from '@/app/api/auth/[...nextauth]/route';
|
|
import { DOMParser } from '@xmldom/xmldom';
|
|
import { Buffer } from 'buffer';
|
|
import { PrismaClient } from '@prisma/client';
|
|
import { prisma } from '@/lib/prisma';
|
|
|
|
// Cache for folder structure and credentials
|
|
const folderCache = new Map<string, { folders: string[]; timestamp: number }>();
|
|
const credentialsCache = new Map<string, { password: string; timestamp: number }>();
|
|
|
|
// Cache for Nextcloud connectivity check
|
|
let lastConnectivityCheck = 0;
|
|
let isNextcloudAccessible = false;
|
|
|
|
async function sleep(ms: number) {
|
|
return new Promise(resolve => setTimeout(resolve, ms));
|
|
}
|
|
|
|
async function checkNextcloudConnectivity(nextcloudUrl: string): Promise<boolean> {
|
|
const now = Date.now();
|
|
if (now - lastConnectivityCheck < 5 * 60 * 1000) { // 5 minutes cache
|
|
return isNextcloudAccessible;
|
|
}
|
|
|
|
try {
|
|
const testResponse = await fetch(`${nextcloudUrl}/status.php`);
|
|
isNextcloudAccessible = testResponse.ok;
|
|
lastConnectivityCheck = now;
|
|
return isNextcloudAccessible;
|
|
} catch (error) {
|
|
console.error('Nextcloud connectivity check failed:', error);
|
|
isNextcloudAccessible = false;
|
|
lastConnectivityCheck = now;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async function parseXMLResponse(response: Response): Promise<any> {
|
|
const text = await response.text();
|
|
const parser = new DOMParser();
|
|
const xmlDoc = parser.parseFromString(text, 'text/xml');
|
|
|
|
// Check for parsing errors
|
|
const parserError = xmlDoc.getElementsByTagName('parsererror');
|
|
if (parserError.length > 0) {
|
|
console.error('XML Parsing Error:', parserError[0].textContent);
|
|
throw new Error('Failed to parse XML response');
|
|
}
|
|
|
|
const result: any = {};
|
|
const root = xmlDoc.documentElement;
|
|
|
|
if (root && root.nodeName === 'ocs') {
|
|
const data = root.getElementsByTagName('data')[0];
|
|
if (data) {
|
|
const children = data.childNodes;
|
|
for (let i = 0; i < children.length; i++) {
|
|
const child = children[i];
|
|
if (child.nodeType === 1) { // Element node
|
|
result[child.nodeName] = child.textContent;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
async function createFolder(nextcloudUrl: string, username: string, password: string, folderPath: string) {
|
|
try {
|
|
// First check if folder exists
|
|
const checkResponse = await fetch(`${nextcloudUrl}/remote.php/dav/files/${encodeURIComponent(username)}/${folderPath}`, {
|
|
method: 'PROPFIND',
|
|
headers: {
|
|
'Authorization': `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`,
|
|
'Depth': '0',
|
|
},
|
|
});
|
|
|
|
if (checkResponse.ok) {
|
|
console.log(`Folder ${folderPath} already exists`);
|
|
return;
|
|
}
|
|
|
|
// If folder doesn't exist, create it
|
|
const response = await fetch(`${nextcloudUrl}/remote.php/dav/files/${encodeURIComponent(username)}/${folderPath}`, {
|
|
method: 'MKCOL',
|
|
headers: {
|
|
'Authorization': `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`,
|
|
},
|
|
});
|
|
|
|
if (!response.ok && response.status !== 405) { // 405 means folder already exists
|
|
const errorText = await response.text();
|
|
console.error(`Failed to create folder ${folderPath}:`, {
|
|
status: response.status,
|
|
statusText: response.statusText,
|
|
error: errorText,
|
|
url: `${nextcloudUrl}/remote.php/dav/files/${encodeURIComponent(username)}/${folderPath}`
|
|
});
|
|
throw new Error(`Failed to create folder ${folderPath}: ${response.status} ${response.statusText}`);
|
|
}
|
|
} catch (error) {
|
|
console.error(`Error creating folder ${folderPath}:`, error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function ensureFolderStructure(nextcloudUrl: string, username: string, password: string) {
|
|
try {
|
|
// First, ensure the Private folder exists
|
|
await createFolder(nextcloudUrl, username, password, 'Private');
|
|
|
|
// Create all required subfolders
|
|
const subfolders = [
|
|
'Private/Diary',
|
|
'Private/Health',
|
|
'Private/Contacts',
|
|
'Private/Notes'
|
|
];
|
|
|
|
for (const folder of subfolders) {
|
|
await createFolder(nextcloudUrl, username, password, folder);
|
|
}
|
|
} catch (error) {
|
|
console.error('Error creating folder structure:', error);
|
|
// Don't throw the error, just log it
|
|
// This way we don't trigger password regeneration
|
|
}
|
|
}
|
|
|
|
async function getWebDAVCredentials(nextcloudUrl: string, username: string, adminUsername: string, adminPassword: string, userId: string) {
|
|
try {
|
|
// First check if user exists in Nextcloud
|
|
const userInfoResponse = await fetch(`${nextcloudUrl}/ocs/v1.php/cloud/users/${encodeURIComponent(username)}`, {
|
|
headers: {
|
|
'Authorization': `Basic ${Buffer.from(`${adminUsername}:${adminPassword}`).toString('base64')}`,
|
|
'OCS-APIRequest': 'true',
|
|
},
|
|
});
|
|
|
|
if (userInfoResponse.status === 404) {
|
|
console.log(`User ${username} does not exist in Nextcloud`);
|
|
throw new Error(`User ${username} does not exist in Nextcloud`);
|
|
}
|
|
|
|
if (!userInfoResponse.ok) {
|
|
throw new Error(`Failed to get user info: ${userInfoResponse.status} ${userInfoResponse.statusText}`);
|
|
}
|
|
|
|
// Check database for existing credentials
|
|
const existingCredentials = await prisma.webDAVCredentials.findUnique({
|
|
where: { userId }
|
|
});
|
|
|
|
if (existingCredentials) {
|
|
// Verify if the existing credentials still work
|
|
const verifyResponse = await fetch(`${nextcloudUrl}/remote.php/dav/files/${encodeURIComponent(username)}/`, {
|
|
method: 'PROPFIND',
|
|
headers: {
|
|
'Authorization': `Basic ${Buffer.from(`${username}:${existingCredentials.password}`).toString('base64')}`,
|
|
'Depth': '1',
|
|
'Content-Type': 'application/xml',
|
|
},
|
|
body: '<?xml version="1.0" encoding="UTF-8"?><d:propfind xmlns:d="DAV:"><d:prop><d:resourcetype/></d:prop></d:propfind>',
|
|
});
|
|
|
|
if (verifyResponse.ok) {
|
|
console.log('Using existing credentials from database');
|
|
// Update cache
|
|
credentialsCache.set(userId, {
|
|
password: existingCredentials.password,
|
|
timestamp: Date.now()
|
|
});
|
|
return existingCredentials.password;
|
|
}
|
|
|
|
// If verification failed, delete the invalid credentials
|
|
console.log('Existing credentials verification failed, removing from database');
|
|
await prisma.webDAVCredentials.delete({
|
|
where: { userId }
|
|
});
|
|
}
|
|
|
|
// If we get here, we need to generate a new password
|
|
const newPassword = Math.random().toString(36).slice(-12);
|
|
console.log('Setting new password for user');
|
|
|
|
// Set the user's password in Nextcloud
|
|
const setPasswordResponse = await fetch(`${nextcloudUrl}/ocs/v1.php/cloud/users/${encodeURIComponent(username)}`, {
|
|
method: 'PUT',
|
|
headers: {
|
|
'Authorization': `Basic ${Buffer.from(`${adminUsername}:${adminPassword}`).toString('base64')}`,
|
|
'OCS-APIRequest': 'true',
|
|
'Content-Type': 'application/x-www-form-urlencoded',
|
|
},
|
|
body: new URLSearchParams({
|
|
key: 'password',
|
|
value: newPassword,
|
|
}).toString(),
|
|
});
|
|
|
|
if (!setPasswordResponse.ok) {
|
|
throw new Error(`Failed to set password: ${setPasswordResponse.status} ${setPasswordResponse.statusText}`);
|
|
}
|
|
|
|
// Store the new credentials in the database
|
|
await prisma.webDAVCredentials.upsert({
|
|
where: { userId },
|
|
update: {
|
|
username: username,
|
|
password: newPassword
|
|
},
|
|
create: {
|
|
userId,
|
|
username: username,
|
|
password: newPassword
|
|
}
|
|
});
|
|
|
|
// Update cache
|
|
credentialsCache.set(userId, {
|
|
password: newPassword,
|
|
timestamp: Date.now()
|
|
});
|
|
|
|
return newPassword;
|
|
} catch (error) {
|
|
console.error('Error in getWebDAVCredentials:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function getFolderStructure(nextcloudUrl: string, username: string, password: string): Promise<string[]> {
|
|
try {
|
|
const webdavUrl = `${nextcloudUrl}/remote.php/dav/files/${encodeURIComponent(username)}/Private/`;
|
|
console.log('Fetching folders from:', webdavUrl);
|
|
|
|
const foldersResponse = await fetch(webdavUrl, {
|
|
method: 'PROPFIND',
|
|
headers: {
|
|
'Authorization': `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`,
|
|
'Depth': '1',
|
|
'Content-Type': 'application/xml',
|
|
},
|
|
body: '<?xml version="1.0" encoding="UTF-8"?><d:propfind xmlns:d="DAV:"><d:prop><d:resourcetype/><d:displayname/></d:prop></d:propfind>',
|
|
});
|
|
|
|
console.log('Folders response status:', foldersResponse.status);
|
|
|
|
if (foldersResponse.status === 429) {
|
|
// Rate limited, wait and retry
|
|
const retryAfter = foldersResponse.headers.get('Retry-After');
|
|
console.log('Rate limited, retrying after:', retryAfter);
|
|
await sleep((retryAfter ? parseInt(retryAfter) : 5) * 1000);
|
|
return getFolderStructure(nextcloudUrl, username, password);
|
|
}
|
|
|
|
if (!foldersResponse.ok) {
|
|
console.error('Failed to fetch folders:', {
|
|
status: foldersResponse.status,
|
|
statusText: foldersResponse.statusText,
|
|
url: webdavUrl
|
|
});
|
|
throw new Error(`Failed to fetch folders: ${foldersResponse.status} ${foldersResponse.statusText}`);
|
|
}
|
|
|
|
const folderData = await foldersResponse.text();
|
|
console.log('Folder data:', folderData);
|
|
|
|
// Parse the XML response to get folder names
|
|
const parser = new DOMParser();
|
|
const xmlDoc = parser.parseFromString(folderData, 'text/xml');
|
|
const responses = Array.from(xmlDoc.getElementsByTagName('d:response'));
|
|
|
|
const folders: string[] = [];
|
|
for (const response of responses) {
|
|
const resourceType = response.getElementsByTagName('d:resourcetype')[0];
|
|
const isCollection = resourceType?.getElementsByTagName('d:collection').length > 0;
|
|
|
|
if (isCollection) {
|
|
const href = response.getElementsByTagName('d:href')[0]?.textContent;
|
|
if (href) {
|
|
// Extract folder name from href
|
|
const parts = href.split('/').filter(Boolean);
|
|
const folderName = decodeURIComponent(parts[parts.length - 1]);
|
|
if (folderName && folderName !== 'Private') {
|
|
folders.push(folderName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
console.log('Parsed folders:', folders);
|
|
return folders;
|
|
} catch (error) {
|
|
console.error('Error getting folder structure:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
export async function GET() {
|
|
try {
|
|
const session = await getServerSession(authOptions);
|
|
if (!session?.user?.email || !session?.user?.id || !session?.accessToken) {
|
|
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
|
|
}
|
|
|
|
const nextcloudUrl = process.env.NEXTCLOUD_URL;
|
|
const adminUsername = process.env.NEXTCLOUD_ADMIN_USERNAME;
|
|
const adminPassword = process.env.NEXTCLOUD_ADMIN_PASSWORD;
|
|
|
|
if (!nextcloudUrl || !adminUsername || !adminPassword) {
|
|
console.error('Missing Nextcloud configuration');
|
|
return NextResponse.json({ error: 'Nextcloud configuration is missing' }, { status: 500 });
|
|
}
|
|
|
|
// Check Nextcloud connectivity with caching
|
|
const isAccessible = await checkNextcloudConnectivity(nextcloudUrl);
|
|
if (!isAccessible) {
|
|
return NextResponse.json({ error: "Nextcloud n'est pas accessible" }, { status: 503 });
|
|
}
|
|
|
|
// Use the Keycloak ID as the Nextcloud username
|
|
const nextcloudUsername = `cube-${session.user.id}`;
|
|
console.log('Using Nextcloud username:', nextcloudUsername);
|
|
|
|
// Check cache first
|
|
const cachedData = folderCache.get(nextcloudUsername);
|
|
if (cachedData) {
|
|
const cacheAge = Date.now() - cachedData.timestamp;
|
|
if (cacheAge < 5 * 60 * 1000) { // 5 minutes cache
|
|
return NextResponse.json({
|
|
isConnected: true,
|
|
folders: cachedData.folders
|
|
});
|
|
}
|
|
}
|
|
|
|
// Get or create WebDAV credentials
|
|
const webdavPassword = await getWebDAVCredentials(
|
|
nextcloudUrl,
|
|
nextcloudUsername,
|
|
adminUsername,
|
|
adminPassword,
|
|
session.user.id
|
|
);
|
|
|
|
if (!webdavPassword) {
|
|
throw new Error('Failed to get WebDAV credentials');
|
|
}
|
|
|
|
// Ensure the folder structure exists
|
|
await ensureFolderStructure(nextcloudUrl, nextcloudUsername, webdavPassword);
|
|
|
|
// Get folder structure
|
|
const folders = await getFolderStructure(nextcloudUrl, nextcloudUsername, webdavPassword);
|
|
|
|
// Update cache
|
|
folderCache.set(nextcloudUsername, {
|
|
folders,
|
|
timestamp: Date.now()
|
|
});
|
|
|
|
return NextResponse.json({
|
|
isConnected: true,
|
|
folders
|
|
});
|
|
} catch (error) {
|
|
console.error('Error in Nextcloud status endpoint:', error);
|
|
return NextResponse.json(
|
|
{ error: error instanceof Error ? error.message : 'An error occurred' },
|
|
{ status: 500 }
|
|
);
|
|
}
|
|
} |