@benchcubed/today-cli 1.0.0

package/dist/lambda/admin.js

@@ -0,0 +1,818 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const client_cognito_identity_provider_1 = require("@aws-sdk/client-cognito-identity-provider");
+const dynamoClient = new client_dynamodb_1.DynamoDBClient({ region: process.env.AWS_REGION || 'eu-west-2' });
+const docClient = lib_dynamodb_1.DynamoDBDocumentClient.from(dynamoClient);
+const cognitoClient = new client_cognito_identity_provider_1.CognitoIdentityProviderClient({ region: process.env.AWS_REGION || 'eu-west-2' });
+const KNOWLEDGE_TABLE = process.env.KNOWLEDGE_TABLE_NAME;
+const USER_POOL_ID = process.env.USER_POOL_ID;
+const CLIENT_ID = process.env.CLIENT_ID;
+const corsHeaders = {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Headers': 'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token',
+    'Access-Control-Allow-Methods': 'GET,POST,PUT,DELETE,OPTIONS',
+    'Content-Type': 'application/json'
+};
+const handler = async (event) => {
+    console.log('Admin API Event:', JSON.stringify(event, null, 2));
+    // Handle CORS preflight
+    if (event.httpMethod === 'OPTIONS') {
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: ''
+        };
+    }
+    try {
+        const path = event.path;
+        const method = event.httpMethod;
+        const pathParams = event.pathParameters || {};
+        const queryParams = event.queryStringParameters || {};
+        const body = event.body ? JSON.parse(event.body) : {};
+        console.log('Request details:', {
+            path,
+            method,
+            pathParams,
+            resource: event.resource,
+            headers: event.headers
+        });
+        // Handle proxy path - extract the actual route from the proxy parameter
+        // For proxy routes: pathParams.proxy contains the path after /admin/
+        // For non-proxy routes like /api/admin/auth: extract from full path
+        let routePath;
+        if (pathParams.proxy) {
+            const proxyPath = pathParams.proxy;
+            // Handle routes like "admin/auth" -> "/auth" or just "auth" -> "/auth"
+            const pathParts = proxyPath.split('/');
+            const routePart = pathParts[pathParts.length - 1]; // Get last part
+            routePath = `/${routePart}`;
+        }
+        else {
+            // Extract everything after /api/admin
+            const match = path.match(/\/api\/admin(\/.*)?$/);
+            routePath = match ? (match[1] || '') : '';
+        }
+        console.log('Resolved route path:', routePath);
+        // Route handling - simplified routing based on the proxy path
+        if (routePath === '/auth' && method === 'POST') {
+            return await handleAuth(body);
+        }
+        if (routePath === '/stats' && method === 'GET') {
+            return await getAdminStats();
+        }
+        if (routePath === '/knowledge' && method === 'GET') {
+            return await getKnowledgeEntries(queryParams);
+        }
+        if (routePath === '/knowledge' && method === 'POST') {
+            return await createKnowledgeEntry(body);
+        }
+        if (routePath.startsWith('/knowledge/') && method === 'PUT') {
+            const entryId = routePath.split('/')[2];
+            return await updateKnowledgeEntry(entryId, body);
+        }
+        if (routePath.startsWith('/knowledge/') && routePath.endsWith('/approve') && method === 'POST') {
+            const entryId = routePath.split('/')[2];
+            return await approveKnowledgeEntry(entryId);
+        }
+        if (routePath.startsWith('/knowledge/') && routePath.endsWith('/reject') && method === 'POST') {
+            const entryId = routePath.split('/')[2];
+            return await rejectKnowledgeEntry(entryId, body.reason);
+        }
+        if (routePath.startsWith('/knowledge/') && routePath.endsWith('/assign-expert') && method === 'POST') {
+            const entryId = routePath.split('/')[2];
+            return await assignExpertToEntry(entryId, body.expertId);
+        }
+        if (routePath === '/knowledge/bulk-approve' && method === 'POST') {
+            return await bulkApproveEntries(body.entryIds);
+        }
+        if (routePath === '/experts' && method === 'GET') {
+            return await getExperts();
+        }
+        if (routePath === '/experts' && method === 'POST') {
+            return await createExpert(body);
+        }
+        if (routePath.startsWith('/experts/') && routePath.endsWith('/toggle-status') && method === 'POST') {
+            const expertId = routePath.split('/')[2];
+            return await toggleExpertStatus(expertId);
+        }
+        if (routePath.startsWith('/experts/') && routePath.endsWith('/availability') && method === 'POST') {
+            const expertId = routePath.split('/')[2];
+            return await updateExpertAvailability(expertId, body.availability);
+        }
+        if (routePath === '/topics' && method === 'GET') {
+            return await getTopics();
+        }
+        if (routePath === '/search' && method === 'GET') {
+            return await searchKnowledge(queryParams.q || '');
+        }
+        return {
+            statusCode: 404,
+            headers: corsHeaders,
+            body: JSON.stringify({ error: 'Endpoint not found' })
+        };
+    }
+    catch (error) {
+        console.error('Admin API Error:', error);
+        return {
+            statusCode: 500,
+            headers: corsHeaders,
+            body: JSON.stringify({
+                error: 'Internal server error',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            })
+        };
+    }
+};
+exports.handler = handler;
+async function handleAuth(body) {
+    try {
+        const { username, password } = body;
+        if (!username || !password) {
+            return {
+                statusCode: 400,
+                headers: corsHeaders,
+                body: JSON.stringify({ error: 'Username and password are required' })
+            };
+        }
+        // Use AdminInitiateAuth for server-side authentication
+        const command = new client_cognito_identity_provider_1.AdminInitiateAuthCommand({
+            UserPoolId: USER_POOL_ID,
+            ClientId: CLIENT_ID,
+            AuthFlow: 'ADMIN_NO_SRP_AUTH',
+            AuthParameters: {
+                USERNAME: username,
+                PASSWORD: password
+            }
+        });
+        const response = await cognitoClient.send(command);
+        if (!response.AuthenticationResult) {
+            return {
+                statusCode: 401,
+                headers: corsHeaders,
+                body: JSON.stringify({ error: 'Authentication failed' })
+            };
+        }
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: JSON.stringify({
+                token: response.AuthenticationResult.IdToken,
+                accessToken: response.AuthenticationResult.AccessToken,
+                refreshToken: response.AuthenticationResult.RefreshToken,
+                expiresIn: response.AuthenticationResult.ExpiresIn
+            })
+        };
+    }
+    catch (error) {
+        console.error('Auth error:', error);
+        return {
+            statusCode: 401,
+            headers: corsHeaders,
+            body: JSON.stringify({
+                error: 'Authentication failed',
+                message: error.message || 'Invalid credentials'
+            })
+        };
+    }
+}
+async function getAdminStats() {
+    try {
+        // Get all knowledge entries from DynamoDB
+        const entriesResult = await docClient.send(new lib_dynamodb_1.ScanCommand({
+            TableName: KNOWLEDGE_TABLE
+        }));
+        console.log(`Found ${entriesResult.Items?.length || 0} raw items in DynamoDB`);
+        // Parse entries from the stored JSON format
+        const entries = [];
+        (entriesResult.Items || []).forEach(item => {
+            if (item.entry_data) {
+                try {
+                    // Document client automatically unmarshals DynamoDB types, so entry_data is already a string
+                    const entryData = JSON.parse(item.entry_data);
+                    entries.push({
+                        ...entryData,
+                        status: entryData.status || 'approved', // Default to approved for existing entries
+                        assignedExperts: entryData.assignedExperts || []
+                    });
+                }
+                catch (error) {
+                    console.warn('Failed to parse entry data:', error, 'Raw item:', JSON.stringify(item));
+                }
+            }
+        });
+        console.log(`Successfully parsed ${entries.length} knowledge entries`);
+        // Extract experts from the actual knowledge entries
+        const expertMap = new Map();
+        entries.forEach(entry => {
+            if (entry.authorId) {
+                // Handle missing authorName by converting authorId to readable name
+                const authorName = entry.authorName || entry.authorId.replace(/-/g, ' ').replace(/\b\w/g, (l) => l.toUpperCase());
+                if (!expertMap.has(entry.authorId)) {
+                    expertMap.set(entry.authorId, {
+                        id: entry.authorId,
+                        name: authorName,
+                        email: `${entry.authorId}@company.com`,
+                        expertise: [],
+                        entryCount: 0,
+                        helpfulnessScore: 0,
+                        availability: 'medium',
+                        isActive: true,
+                        createdAt: entry.createdAt,
+                        lastActive: entry.createdAt
+                    });
+                }
+                const expert = expertMap.get(entry.authorId);
+                expert.entryCount++;
+                expert.helpfulnessScore += entry.helpfulnessRating || 0;
+                // Add topics to expertise
+                if (entry.aiTopics && Array.isArray(entry.aiTopics)) {
+                    entry.aiTopics.forEach(topic => {
+                        if (!expert.expertise.includes(topic)) {
+                            expert.expertise.push(topic);
+                        }
+                    });
+                }
+                // Update last active if this entry is newer
+                if (entry.createdAt > expert.lastActive) {
+                    expert.lastActive = entry.createdAt;
+                }
+            }
+        });
+        // Calculate average helpfulness scores
+        const experts = Array.from(expertMap.values()).map(expert => ({
+            ...expert,
+            helpfulnessScore: expert.entryCount > 0 ? expert.helpfulnessScore / expert.entryCount : 0
+        }));
+        console.log(`Extracted ${experts.length} experts from entries`);
+        // Calculate statistics
+        const totalEntries = entries.length;
+        const pendingApprovals = entries.filter(e => e.status === 'pending').length;
+        const totalExperts = experts.length;
+        const activeExperts = experts.filter(e => e.isActive).length;
+        // Calculate recent activity (last 7 days)
+        const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+        const recentEntries = entries.filter(e => e.createdAt && e.createdAt > sevenDaysAgo);
+        const recentExperts = experts.filter(e => e.createdAt && e.createdAt > sevenDaysAgo);
+        // Calculate top topics
+        const topicCounts = new Map();
+        entries.forEach(entry => {
+            // Ensure aiTopics exists and is an array
+            const topics = entry.aiTopics || [];
+            if (Array.isArray(topics)) {
+                topics.forEach(topic => {
+                    if (!topicCounts.has(topic)) {
+                        topicCounts.set(topic, { count: 0, totalImpact: 0, experts: new Set() });
+                    }
+                    const topicData = topicCounts.get(topic);
+                    topicData.count++;
+                    topicData.totalImpact += entry.impactScore || 0;
+                    topicData.experts.add(entry.authorId);
+                });
+            }
+        });
+        const topTopics = Array.from(topicCounts.entries())
+            .map(([topic, data]) => ({
+            topic,
+            entryCount: data.count,
+            expertCount: data.experts.size,
+            avgImpactScore: data.count > 0 ? data.totalImpact / data.count : 0,
+            recentActivity: recentEntries.filter(e => (e.aiTopics || []).includes(topic)).length
+        }))
+            .sort((a, b) => b.entryCount - a.entryCount)
+            .slice(0, 10);
+        const stats = {
+            totalEntries,
+            pendingApprovals,
+            totalExperts,
+            activeExperts,
+            topTopics,
+            recentActivity: {
+                newEntries: recentEntries.length,
+                approvedEntries: recentEntries.filter(e => e.status === 'approved').length,
+                newExperts: recentExperts.length
+            }
+        };
+        console.log('Admin stats calculated:', JSON.stringify(stats, null, 2));
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: JSON.stringify(stats)
+        };
+    }
+    catch (error) {
+        console.error('Error getting admin stats:', error);
+        throw error;
+    }
+}
+async function getKnowledgeEntries(queryParams) {
+    try {
+        const { search, status, expertise, limit = '100' } = queryParams;
+        // Get all entries from DynamoDB
+        const result = await docClient.send(new lib_dynamodb_1.ScanCommand({
+            TableName: KNOWLEDGE_TABLE,
+            Limit: parseInt(limit)
+        }));
+        // Parse entries from the stored JSON format
+        let entries = [];
+        (result.Items || []).forEach(item => {
+            if (item.entry_data) {
+                try {
+                    // Document client automatically unmarshals DynamoDB types, so entry_data is already a string
+                    const entryData = JSON.parse(item.entry_data);
+                    entries.push({
+                        ...entryData,
+                        status: entryData.status || 'approved', // Default to approved for existing entries
+                        assignedExperts: entryData.assignedExperts || []
+                    });
+                }
+                catch (error) {
+                    console.warn('Failed to parse entry data:', error, 'Raw item:', JSON.stringify(item));
+                }
+            }
+        });
+        // Apply filters
+        if (search) {
+            entries = entries.filter(entry => entry.content.toLowerCase().includes(search.toLowerCase()) ||
+                (entry.aiTopics && entry.aiTopics.some(topic => topic.toLowerCase().includes(search.toLowerCase()))));
+        }
+        if (status && status !== 'all') {
+            entries = entries.filter(entry => entry.status === status);
+        }
+        if (expertise && expertise !== 'all') {
+            entries = entries.filter(entry => entry.expertiseLevel === expertise);
+        }
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: JSON.stringify({ entries })
+        };
+    }
+    catch (error) {
+        console.error('Error getting knowledge entries:', error);
+        throw error;
+    }
+}
+async function getExperts() {
+    try {
+        // Get all entries from DynamoDB
+        const entriesResult = await docClient.send(new lib_dynamodb_1.ScanCommand({
+            TableName: KNOWLEDGE_TABLE
+        }));
+        // Parse entries from the stored JSON format
+        const entries = [];
+        (entriesResult.Items || []).forEach(item => {
+            if (item.entry_data) {
+                try {
+                    // Document client automatically unmarshals DynamoDB types, so entry_data is already a string
+                    const entryData = JSON.parse(item.entry_data);
+                    entries.push({
+                        ...entryData,
+                        status: entryData.status || 'approved',
+                        assignedExperts: entryData.assignedExperts || []
+                    });
+                }
+                catch (error) {
+                    console.warn('Failed to parse entry data:', error, 'Raw item:', JSON.stringify(item));
+                }
+            }
+        });
+        // Extract experts from the actual knowledge entries
+        const expertMap = new Map();
+        entries.forEach(entry => {
+            if (entry.authorId) {
+                // Handle missing authorName by converting authorId to readable name
+                const authorName = entry.authorName || entry.authorId.replace(/-/g, ' ').replace(/\b\w/g, (l) => l.toUpperCase());
+                if (!expertMap.has(entry.authorId)) {
+                    expertMap.set(entry.authorId, {
+                        id: entry.authorId,
+                        name: authorName,
+                        email: `${entry.authorId}@company.com`,
+                        expertise: [],
+                        entryCount: 0,
+                        helpfulnessScore: 0,
+                        availability: 'medium',
+                        isActive: true,
+                        createdAt: entry.createdAt,
+                        lastActive: entry.createdAt
+                    });
+                }
+                const expert = expertMap.get(entry.authorId);
+                expert.entryCount++;
+                expert.helpfulnessScore += entry.helpfulnessRating || 0;
+                // Add topics to expertise
+                if (entry.aiTopics && Array.isArray(entry.aiTopics)) {
+                    entry.aiTopics.forEach(topic => {
+                        if (!expert.expertise.includes(topic)) {
+                            expert.expertise.push(topic);
+                        }
+                    });
+                }
+                // Update last active if this entry is newer
+                if (entry.createdAt > expert.lastActive) {
+                    expert.lastActive = entry.createdAt;
+                }
+            }
+        });
+        // Calculate average helpfulness scores and return experts
+        const experts = Array.from(expertMap.values()).map(expert => ({
+            ...expert,
+            helpfulnessScore: expert.entryCount > 0 ? expert.helpfulnessScore / expert.entryCount : 0
+        }));
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: JSON.stringify({ experts })
+        };
+    }
+    catch (error) {
+        console.error('Error getting experts:', error);
+        throw error;
+    }
+}
+async function getTopics() {
+    try {
+        const result = await docClient.send(new lib_dynamodb_1.ScanCommand({
+            TableName: KNOWLEDGE_TABLE
+        }));
+        // Parse entries from the stored JSON format
+        const entries = [];
+        (result.Items || []).forEach(item => {
+            if (item.entry_data) {
+                try {
+                    const entryData = JSON.parse(item.entry_data);
+                    entries.push({
+                        ...entryData,
+                        status: entryData.status || 'approved',
+                        assignedExperts: entryData.assignedExperts || []
+                    });
+                }
+                catch (error) {
+                    console.warn('Failed to parse entry data:', error);
+                }
+            }
+        });
+        // Calculate topic statistics
+        const topicStats = new Map();
+        const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+        entries.forEach(entry => {
+            // Ensure aiTopics exists and is an array
+            const topics = entry.aiTopics || [];
+            if (Array.isArray(topics)) {
+                topics.forEach(topic => {
+                    if (!topicStats.has(topic)) {
+                        topicStats.set(topic, {
+                            entryCount: 0,
+                            expertCount: 0,
+                            totalImpact: 0,
+                            recentActivity: 0,
+                            experts: new Set()
+                        });
+                    }
+                    const stats = topicStats.get(topic);
+                    stats.entryCount++;
+                    stats.totalImpact += entry.impactScore || 0;
+                    stats.experts.add(entry.authorId);
+                    if (entry.createdAt > sevenDaysAgo) {
+                        stats.recentActivity++;
+                    }
+                });
+            }
+        });
+        const topics = Array.from(topicStats.entries()).map(([topic, stats]) => ({
+            topic,
+            entryCount: stats.entryCount,
+            expertCount: stats.experts.size,
+            avgImpactScore: stats.totalImpact / stats.entryCount,
+            recentActivity: stats.recentActivity
+        })).sort((a, b) => b.entryCount - a.entryCount);
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: JSON.stringify({ topics })
+        };
+    }
+    catch (error) {
+        console.error('Error getting topics:', error);
+        throw error;
+    }
+}
+async function searchKnowledge(query) {
+    try {
+        if (!query.trim()) {
+            return {
+                statusCode: 400,
+                headers: corsHeaders,
+                body: JSON.stringify({ error: 'Search query is required' })
+            };
+        }
+        // Get all entries and filter in memory since we store data as JSON strings
+        const result = await docClient.send(new lib_dynamodb_1.ScanCommand({
+            TableName: KNOWLEDGE_TABLE,
+            Limit: 200 // Get more entries to search through
+        }));
+        // Parse and filter entries
+        const entries = [];
+        (result.Items || []).forEach(item => {
+            if (item.entry_data) {
+                try {
+                    const entryData = JSON.parse(item.entry_data);
+                    const entry = {
+                        ...entryData,
+                        status: entryData.status || 'approved',
+                        assignedExperts: entryData.assignedExperts || []
+                    };
+                    // Check if entry matches search query
+                    const queryLower = query.toLowerCase();
+                    const contentMatch = entry.content.toLowerCase().includes(queryLower);
+                    const topicsMatch = entry.aiTopics && entry.aiTopics.some((topic) => topic.toLowerCase().includes(queryLower));
+                    const authorName = entry.authorName || entry.authorId.replace(/-/g, ' ').replace(/\b\w/g, (l) => l.toUpperCase());
+                    const authorMatch = authorName.toLowerCase().includes(queryLower);
+                    if (contentMatch || topicsMatch || authorMatch) {
+                        entries.push(entry);
+                    }
+                }
+                catch (error) {
+                    console.warn('Failed to parse entry data during search:', error);
+                }
+            }
+        });
+        // Limit results and sort by relevance (could be improved with proper scoring)
+        const limitedEntries = entries.slice(0, 50);
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: JSON.stringify({ entries: limitedEntries })
+        };
+    }
+    catch (error) {
+        console.error('Error searching knowledge:', error);
+        throw error;
+    }
+}
+// Remaining functions for CRUD operations...
+async function createKnowledgeEntry(entryData) {
+    try {
+        const entry = {
+            id: `entry_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
+            content: entryData.content || '',
+            authorId: entryData.authorId || 'admin',
+            authorName: entryData.authorName || 'Admin',
+            teamId: entryData.teamId || 'default',
+            createdAt: new Date().toISOString(),
+            aiTopics: entryData.aiTopics || [],
+            expertiseLevel: entryData.expertiseLevel || 'intermediate',
+            impactScore: entryData.impactScore || 5,
+            helpfulnessRating: 0,
+            timeSavedMinutes: entryData.timeSavedMinutes || 0,
+            viewCount: 0,
+            shareCount: 0,
+            questionsAnswered: 0,
+            onboardingRelevance: entryData.onboardingRelevance || false,
+            status: 'approved', // Admin-created entries are auto-approved
+            assignedExperts: entryData.assignedExperts || []
+        };
+        await docClient.send(new lib_dynamodb_1.PutCommand({
+            TableName: KNOWLEDGE_TABLE,
+            Item: entry
+        }));
+        return {
+            statusCode: 201,
+            headers: corsHeaders,
+            body: JSON.stringify({ entry })
+        };
+    }
+    catch (error) {
+        console.error('Error creating knowledge entry:', error);
+        throw error;
+    }
+}
+async function updateKnowledgeEntry(entryId, updates) {
+    try {
+        const updateExpressions = [];
+        const expressionAttributeValues = {};
+        const expressionAttributeNames = {};
+        Object.entries(updates).forEach(([key, value]) => {
+            if (key !== 'id' && value !== undefined) {
+                updateExpressions.push(`#${key} = :${key}`);
+                expressionAttributeValues[`:${key}`] = value;
+                expressionAttributeNames[`#${key}`] = key;
+            }
+        });
+        if (updateExpressions.length === 0) {
+            return {
+                statusCode: 400,
+                headers: corsHeaders,
+                body: JSON.stringify({ error: 'No valid updates provided' })
+            };
+        }
+        await docClient.send(new lib_dynamodb_1.UpdateCommand({
+            TableName: KNOWLEDGE_TABLE,
+            Key: { id: entryId },
+            UpdateExpression: `SET ${updateExpressions.join(', ')}`,
+            ExpressionAttributeValues: expressionAttributeValues,
+            ExpressionAttributeNames: expressionAttributeNames
+        }));
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: JSON.stringify({ message: 'Entry updated successfully' })
+        };
+    }
+    catch (error) {
+        console.error('Error updating knowledge entry:', error);
+        throw error;
+    }
+}
+async function approveKnowledgeEntry(entryId) {
+    try {
+        await docClient.send(new lib_dynamodb_1.UpdateCommand({
+            TableName: KNOWLEDGE_TABLE,
+            Key: { id: entryId },
+            UpdateExpression: 'SET #status = :status, approvedAt = :approvedAt',
+            ExpressionAttributeNames: { '#status': 'status' },
+            ExpressionAttributeValues: {
+                ':status': 'approved',
+                ':approvedAt': new Date().toISOString()
+            }
+        }));
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: JSON.stringify({ message: 'Entry approved successfully' })
+        };
+    }
+    catch (error) {
+        console.error('Error approving knowledge entry:', error);
+        throw error;
+    }
+}
+async function rejectKnowledgeEntry(entryId, reason) {
+    try {
+        await docClient.send(new lib_dynamodb_1.UpdateCommand({
+            TableName: KNOWLEDGE_TABLE,
+            Key: { id: entryId },
+            UpdateExpression: 'SET #status = :status, rejectedAt = :rejectedAt, rejectionReason = :reason',
+            ExpressionAttributeNames: { '#status': 'status' },
+            ExpressionAttributeValues: {
+                ':status': 'rejected',
+                ':rejectedAt': new Date().toISOString(),
+                ':reason': reason || 'No reason provided'
+            }
+        }));
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: JSON.stringify({ message: 'Entry rejected successfully' })
+        };
+    }
+    catch (error) {
+        console.error('Error rejecting knowledge entry:', error);
+        throw error;
+    }
+}
+async function assignExpertToEntry(entryId, expertId) {
+    try {
+        await docClient.send(new lib_dynamodb_1.UpdateCommand({
+            TableName: KNOWLEDGE_TABLE,
+            Key: { id: entryId },
+            UpdateExpression: 'ADD assignedExperts :expertId',
+            ExpressionAttributeValues: {
+                ':expertId': new Set([expertId])
+            }
+        }));
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: JSON.stringify({ message: 'Expert assigned successfully' })
+        };
+    }
+    catch (error) {
+        console.error('Error assigning expert to entry:', error);
+        throw error;
+    }
+}
+async function bulkApproveEntries(entryIds) {
+    try {
+        const approvedAt = new Date().toISOString();
+        // Process in batches to avoid DynamoDB limits
+        const batchSize = 25;
+        for (let i = 0; i < entryIds.length; i += batchSize) {
+            const batch = entryIds.slice(i, i + batchSize);
+            await Promise.all(batch.map(entryId => docClient.send(new lib_dynamodb_1.UpdateCommand({
+                TableName: KNOWLEDGE_TABLE,
+                Key: { id: entryId },
+                UpdateExpression: 'SET #status = :status, approvedAt = :approvedAt',
+                ExpressionAttributeNames: { '#status': 'status' },
+                ExpressionAttributeValues: {
+                    ':status': 'approved',
+                    ':approvedAt': approvedAt
+                }
+            }))));
+        }
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: JSON.stringify({
+                message: `${entryIds.length} entries approved successfully`
+            })
+        };
+    }
+    catch (error) {
+        console.error('Error bulk approving entries:', error);
+        throw error;
+    }
+}
+async function createExpert(expertData) {
+    try {
+        const expert = {
+            id: `expert_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
+            name: expertData.name || '',
+            email: expertData.email || '',
+            expertise: expertData.expertise || [],
+            entryCount: 0,
+            helpfulnessScore: 0,
+            availability: expertData.availability || 'medium',
+            isActive: true,
+            createdAt: new Date().toISOString(),
+            lastActive: new Date().toISOString()
+        };
+        await docClient.send(new lib_dynamodb_1.PutCommand({
+            TableName: KNOWLEDGE_TABLE,
+            Item: expert
+        }));
+        return {
+            statusCode: 201,
+            headers: corsHeaders,
+            body: JSON.stringify({ expert })
+        };
+    }
+    catch (error) {
+        console.error('Error creating expert:', error);
+        throw error;
+    }
+}
+async function toggleExpertStatus(expertId) {
+    try {
+        // First get the current status
+        const result = await docClient.send(new lib_dynamodb_1.QueryCommand({
+            TableName: KNOWLEDGE_TABLE,
+            KeyConditionExpression: 'id = :id',
+            ExpressionAttributeValues: { ':id': expertId }
+        }));
+        if (!result.Items || result.Items.length === 0) {
+            return {
+                statusCode: 404,
+                headers: corsHeaders,
+                body: JSON.stringify({ error: 'Expert not found' })
+            };
+        }
+        const expert = result.Items[0];
+        const newStatus = !expert.isActive;
+        await docClient.send(new lib_dynamodb_1.UpdateCommand({
+            TableName: KNOWLEDGE_TABLE,
+            Key: { id: expertId },
+            UpdateExpression: 'SET isActive = :status, lastActive = :lastActive',
+            ExpressionAttributeValues: {
+                ':status': newStatus,
+                ':lastActive': new Date().toISOString()
+            }
+        }));
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: JSON.stringify({
+                message: `Expert ${newStatus ? 'activated' : 'deactivated'} successfully`
+            })
+        };
+    }
+    catch (error) {
+        console.error('Error toggling expert status:', error);
+        throw error;
+    }
+}
+async function updateExpertAvailability(expertId, availability) {
+    try {
+        await docClient.send(new lib_dynamodb_1.UpdateCommand({
+            TableName: KNOWLEDGE_TABLE,
+            Key: { id: expertId },
+            UpdateExpression: 'SET availability = :availability, lastActive = :lastActive',
+            ExpressionAttributeValues: {
+                ':availability': availability,
+                ':lastActive': new Date().toISOString()
+            }
+        }));
+        return {
+            statusCode: 200,
+            headers: corsHeaders,
+            body: JSON.stringify({ message: 'Expert availability updated successfully' })
+        };
+    }
+    catch (error) {
+        console.error('Error updating expert availability:', error);
+        throw error;
+    }
+}
+//# sourceMappingURL=admin.js.map