generated from corrad-software/corrad-af-2024
1204 lines
36 KiB
JavaScript
1204 lines
36 KiB
JavaScript
import { defineStore } from 'pinia';
|
|
|
|
export const useDmsStore = defineStore('dms', {
|
|
state: () => ({
|
|
// Navigation state
|
|
currentPath: '/',
|
|
pathHistory: ['/'],
|
|
historyIndex: 0,
|
|
|
|
// User information
|
|
currentUser: {
|
|
id: 'user1',
|
|
name: 'Aiman Fakhrullah',
|
|
email: 'aiman@example.com',
|
|
role: 'engineer', // engineer, admin, manager, etc.
|
|
department: 'JKR Bahagian Kejuruteraan Awam Cawangan Kota Bharu'
|
|
},
|
|
|
|
// Cabinet access types
|
|
cabinetAccessTypes: [
|
|
{ id: 'public', name: 'Public Access', icon: 'check-circle', color: 'green' },
|
|
{ id: 'personal', name: 'Personal Access', icon: 'circle-check', color: 'orange' },
|
|
{ id: 'private', name: 'Private Access', icon: 'lock', color: 'red' }
|
|
],
|
|
|
|
// Access request statuses
|
|
accessRequestStatuses: [
|
|
{ id: 'pending', name: 'Pending', color: 'orange' },
|
|
{ id: 'approved', name: 'Approved', color: 'green' },
|
|
{ id: 'rejected', name: 'Rejected', color: 'red' }
|
|
],
|
|
|
|
// Items state - in production this would be loaded from API
|
|
cabinets: [
|
|
{
|
|
id: 'public-cabinet',
|
|
name: 'Public Cabinet',
|
|
type: 'cabinet',
|
|
accessType: 'public',
|
|
children: [
|
|
{
|
|
id: 'public-cabinet-1',
|
|
name: 'Public Cabinet',
|
|
type: 'cabinet',
|
|
accessType: 'public',
|
|
parentId: 'public-cabinet'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
id: 'my-cabinets',
|
|
name: 'My Cabinets',
|
|
type: 'cabinet-group',
|
|
accessType: 'personal',
|
|
children: [
|
|
{
|
|
id: 'jkr-tebedu',
|
|
name: 'JKR Cawangan Tebedu, Sarawak',
|
|
type: 'cabinet',
|
|
accessType: 'personal',
|
|
parentId: 'my-cabinets',
|
|
hasAccess: true
|
|
},
|
|
{
|
|
id: 'jkr-kota-bharu',
|
|
name: 'JKR Cawangan Kota Bharu, Kelantan',
|
|
type: 'cabinet',
|
|
accessType: 'personal',
|
|
parentId: 'my-cabinets',
|
|
hasAccess: true,
|
|
children: [
|
|
{
|
|
id: 'jkr-kewangan-kb',
|
|
name: 'JKR Bahagian Kewangan Cawangan Kota Bharu',
|
|
type: 'cabinet',
|
|
accessType: 'personal',
|
|
parentId: 'jkr-kota-bharu',
|
|
hasAccess: true
|
|
},
|
|
{
|
|
id: 'jkr-kejuruteraan-kb',
|
|
name: 'JKR Bahagian Kejuruteraan Awam Cawangan Kota Bharu',
|
|
type: 'cabinet',
|
|
accessType: 'personal',
|
|
parentId: 'jkr-kota-bharu',
|
|
hasAccess: true,
|
|
children: [
|
|
{
|
|
id: 'pembinaan-jambatan-kb',
|
|
name: 'Pembinaan Jambatan Kota Bharu',
|
|
type: 'cabinet',
|
|
accessType: 'personal',
|
|
parentId: 'jkr-kejuruteraan-kb',
|
|
hasAccess: true,
|
|
children: [
|
|
{
|
|
id: 'kewangan-tag',
|
|
name: 'Kewangan',
|
|
type: 'tag',
|
|
color: 'purple',
|
|
parentId: 'pembinaan-jambatan-kb'
|
|
},
|
|
{
|
|
id: 'kejuruteraan-awam-tag',
|
|
name: 'Kejuruteraan Awam',
|
|
type: 'tag',
|
|
color: 'purple',
|
|
parentId: 'pembinaan-jambatan-kb'
|
|
},
|
|
{
|
|
id: 'teknologi-maklumat-tag',
|
|
name: 'Teknologi Maklumat',
|
|
type: 'tag',
|
|
color: 'purple',
|
|
parentId: 'pembinaan-jambatan-kb'
|
|
}
|
|
]
|
|
},
|
|
{
|
|
id: 'projek-jalan-raya-kb',
|
|
name: 'Projek Jalan Raya Kota Bharu',
|
|
type: 'cabinet',
|
|
accessType: 'personal',
|
|
parentId: 'jkr-kejuruteraan-kb',
|
|
hasAccess: true
|
|
}
|
|
]
|
|
},
|
|
{
|
|
id: 'jkr-teknologi-kb',
|
|
name: 'JKR Bahagian Teknologi Maklumat Cawangan Kota Bharu',
|
|
type: 'cabinet',
|
|
accessType: 'personal',
|
|
parentId: 'jkr-kota-bharu',
|
|
hasAccess: true
|
|
}
|
|
]
|
|
},
|
|
{
|
|
id: 'jkr-ipoh',
|
|
name: 'JKR Cawangan Ipoh, Perak',
|
|
type: 'cabinet',
|
|
accessType: 'personal',
|
|
parentId: 'my-cabinets',
|
|
hasAccess: true
|
|
}
|
|
]
|
|
},
|
|
{
|
|
id: 'private-cabinets',
|
|
name: 'Private Cabinets',
|
|
type: 'cabinet-group',
|
|
accessType: 'private',
|
|
children: [
|
|
{
|
|
id: 'jkr-batu-kawan',
|
|
name: 'JKR Cawangan Batu Kawan, Penang',
|
|
type: 'cabinet',
|
|
accessType: 'private',
|
|
parentId: 'private-cabinets',
|
|
hasAccess: false,
|
|
accessRequestStatus: 'pending'
|
|
},
|
|
{
|
|
id: 'jkr-kuala-terengganu',
|
|
name: 'JKR Cawangan Kuala Terengganu, Terengganu',
|
|
type: 'cabinet',
|
|
accessType: 'private',
|
|
parentId: 'private-cabinets',
|
|
hasAccess: false,
|
|
accessRequestStatus: 'pending'
|
|
},
|
|
{
|
|
id: 'jkr-arkitek',
|
|
name: 'JKR Cawangan Arkitek',
|
|
type: 'cabinet',
|
|
accessType: 'private',
|
|
parentId: 'private-cabinets',
|
|
hasAccess: false,
|
|
accessRequestStatus: 'pending'
|
|
},
|
|
{
|
|
id: 'jkr-putrajaya',
|
|
name: 'JKR Cawangan Putrajaya',
|
|
type: 'cabinet',
|
|
accessType: 'private',
|
|
parentId: 'private-cabinets',
|
|
hasAccess: false,
|
|
accessRequestStatus: 'rejected',
|
|
isLocked: true
|
|
}
|
|
]
|
|
}
|
|
],
|
|
|
|
// Files within cabinets
|
|
items: [
|
|
{
|
|
id: 'file1',
|
|
name: 'Pembangunan_Sistem_IT_2021.pdf',
|
|
type: 'file',
|
|
extension: 'pdf',
|
|
size: '4MB',
|
|
modified: '2021-05-20',
|
|
cabinetId: 'jkr-kota-bharu',
|
|
accessType: 'personal',
|
|
status: 'locked',
|
|
info: {
|
|
title: 'Projek Pembangunan Sistem IT',
|
|
subject: 'Dokumen spesifikasi sistem',
|
|
state: 'Kelantan',
|
|
date: '2021-05-20',
|
|
user: 'Mohd Faizal bin Abdullah',
|
|
storeDate: '2021-05-25'
|
|
}
|
|
},
|
|
{
|
|
id: 'file2',
|
|
name: 'Projek_Jalan_Raya_Kota_Bharu.pdf',
|
|
type: 'file',
|
|
extension: 'pdf',
|
|
size: '5MB',
|
|
modified: '2021-06-15',
|
|
cabinetId: 'jkr-kejuruteraan-kb',
|
|
accessType: 'personal',
|
|
status: 'unlocked'
|
|
},
|
|
{
|
|
id: 'file3',
|
|
name: 'Anggaran_Kos_Projek_MRT3.xlsx',
|
|
type: 'file',
|
|
extension: 'xlsx',
|
|
size: '3MB',
|
|
modified: '2021-07-10',
|
|
cabinetId: 'pembinaan-jambatan-kb',
|
|
accessType: 'personal',
|
|
status: 'locked'
|
|
},
|
|
{
|
|
id: 'file4',
|
|
name: 'EIA_Empangan_Nenggiri.pdf',
|
|
type: 'file',
|
|
extension: 'pdf',
|
|
size: '15MB',
|
|
modified: '2021-04-18',
|
|
cabinetId: 'jkr-ipoh',
|
|
accessType: 'personal',
|
|
status: 'locked'
|
|
},
|
|
{
|
|
id: 'file5',
|
|
name: 'Borang_Maklumabalas.xlsx',
|
|
type: 'file',
|
|
extension: 'xlsx',
|
|
size: '34.1 KB',
|
|
modified: '2025-01-27',
|
|
cabinetId: 'public-cabinet-1',
|
|
accessType: 'public',
|
|
createdBy: 'aimantasan',
|
|
status: 'unlocked',
|
|
info: {
|
|
authors: 'aimantasan',
|
|
lastSavedBy: 'aimantasan',
|
|
dateAccessed: '2025-05-28',
|
|
dateModified: '2025-01-27',
|
|
contentCreated: '2025-01-27'
|
|
}
|
|
}
|
|
],
|
|
|
|
// Access requests
|
|
accessRequests: [
|
|
{
|
|
id: 'req1',
|
|
userId: 'user1',
|
|
userName: 'Aiman Fakhrullah',
|
|
cabinetId: 'jkr-batu-kawan',
|
|
cabinetName: 'JKR Cawangan Batu Kawan, Penang',
|
|
requestDate: '2023-06-15',
|
|
status: 'pending',
|
|
reason: 'Need access for project collaboration'
|
|
},
|
|
{
|
|
id: 'req2',
|
|
userId: 'user1',
|
|
userName: 'Aiman Fakhrullah',
|
|
cabinetId: 'jkr-kuala-terengganu',
|
|
cabinetName: 'JKR Cawangan Kuala Terengganu, Terengganu',
|
|
requestDate: '2023-06-16',
|
|
status: 'pending',
|
|
reason: 'Required for cross-department coordination'
|
|
},
|
|
{
|
|
id: 'req3',
|
|
userId: 'user1',
|
|
userName: 'Aiman Fakhrullah',
|
|
cabinetId: 'jkr-arkitek',
|
|
cabinetName: 'JKR Cawangan Arkitek',
|
|
requestDate: '2023-06-17',
|
|
status: 'pending',
|
|
reason: 'Need architectural plans for current project'
|
|
},
|
|
{
|
|
id: 'req4',
|
|
userId: 'user1',
|
|
userName: 'Aiman Fakhrullah',
|
|
cabinetId: 'jkr-putrajaya',
|
|
cabinetName: 'JKR Cawangan Putrajaya',
|
|
requestDate: '2023-06-01',
|
|
status: 'rejected',
|
|
reason: 'Need access to headquarters documents',
|
|
rejectionReason: 'Access restricted to headquarters staff only'
|
|
}
|
|
],
|
|
|
|
// Selected item
|
|
selectedItem: null,
|
|
|
|
// View settings
|
|
viewMode: 'list', // list, grid, details
|
|
sortBy: 'name',
|
|
sortDirection: 'asc',
|
|
|
|
// User permissions - would be loaded from auth service
|
|
userPermissions: {
|
|
canCreate: true,
|
|
canEdit: true,
|
|
canDelete: true,
|
|
canManageAccess: true
|
|
},
|
|
|
|
// Flags
|
|
isLoading: false,
|
|
showFileViewer: false,
|
|
viewerDocument: null,
|
|
searchQuery: '',
|
|
searchResults: [],
|
|
|
|
// Settings integration
|
|
systemSettings: {
|
|
upload: {
|
|
allowedFileTypes: ['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'txt', 'jpg', 'png'],
|
|
blockedFileTypes: ['exe', 'bat', 'cmd'],
|
|
maxFileSize: 100 * 1024 * 1024, // 100MB in bytes
|
|
quotas: {
|
|
perUser: 5000 * 1024 * 1024, // 5GB
|
|
perGroup: 50000 * 1024 * 1024, // 50GB
|
|
perProject: 100000 * 1024 * 1024 // 100GB
|
|
}
|
|
},
|
|
metadata: {
|
|
customFields: [
|
|
{ name: 'Department', type: 'dropdown', required: true, options: ['HR', 'Finance', 'IT', 'Legal'] },
|
|
{ name: 'Priority', type: 'select', required: false, options: ['Low', 'Medium', 'High', 'Critical'] },
|
|
{ name: 'Project Code', type: 'text', required: true },
|
|
{ name: 'Review Date', type: 'date', required: false }
|
|
],
|
|
predefinedTags: ['urgent', 'confidential', 'public', 'draft', 'final'],
|
|
userGeneratedTags: true,
|
|
tagSuggestions: true
|
|
},
|
|
documents: {
|
|
versionControl: {
|
|
enabled: true,
|
|
maxVersions: 10,
|
|
autoVersioning: true
|
|
},
|
|
namingConventions: {
|
|
autoGenerate: true,
|
|
pattern: '{department}_{title}_{date}'
|
|
}
|
|
},
|
|
access: {
|
|
rbacEnabled: true,
|
|
permissions: {
|
|
view: true,
|
|
edit: true,
|
|
delete: false,
|
|
download: true,
|
|
share: true
|
|
}
|
|
}
|
|
},
|
|
|
|
// Enhanced user permissions with detailed tracking
|
|
userQuotas: {
|
|
used: 1500 * 1024 * 1024, // 1.5GB used
|
|
limit: 5000 * 1024 * 1024, // 5GB limit
|
|
documents: 450,
|
|
maxDocuments: 1000
|
|
},
|
|
|
|
// Document metadata templates
|
|
metadataTemplates: {
|
|
standard: {
|
|
title: '',
|
|
description: '',
|
|
department: '',
|
|
author: '',
|
|
tags: [],
|
|
priority: 'Medium',
|
|
reviewDate: null,
|
|
projectCode: ''
|
|
},
|
|
contract: {
|
|
title: '',
|
|
description: '',
|
|
department: 'Legal',
|
|
contractType: '',
|
|
vendor: '',
|
|
startDate: null,
|
|
endDate: null,
|
|
value: '',
|
|
tags: ['contract'],
|
|
priority: 'High'
|
|
},
|
|
report: {
|
|
title: '',
|
|
description: '',
|
|
department: '',
|
|
reportType: '',
|
|
period: '',
|
|
author: '',
|
|
tags: ['report'],
|
|
priority: 'Medium'
|
|
}
|
|
},
|
|
|
|
// Version tracking
|
|
documentVersions: {},
|
|
|
|
// Enhanced search with metadata
|
|
advancedSearchFilters: {
|
|
fileType: [],
|
|
department: [],
|
|
tags: [],
|
|
dateRange: { start: null, end: null },
|
|
author: [],
|
|
priority: [],
|
|
hasVersions: false
|
|
}
|
|
}),
|
|
|
|
getters: {
|
|
// Get items at the current cabinet
|
|
currentCabinetItems: (state) => {
|
|
const currentCabinetId = state.currentPath.split('/').filter(Boolean).pop();
|
|
return state.items.filter(item => item.cabinetId === currentCabinetId);
|
|
},
|
|
|
|
// Get breadcrumbs for current path
|
|
breadcrumbs: (state) => {
|
|
if (state.currentPath === '/') return [{ name: 'Home', path: '/' }];
|
|
|
|
const paths = state.currentPath.split('/').filter(Boolean);
|
|
let breadcrumbPath = '';
|
|
|
|
return [
|
|
{ name: 'Home', path: '/' },
|
|
...paths.map(segment => {
|
|
breadcrumbPath += `/${segment}`;
|
|
|
|
// Find the actual cabinet name
|
|
const findCabinetName = (cabinets, id) => {
|
|
for (const cabinet of cabinets) {
|
|
if (cabinet.id === id) return cabinet.name;
|
|
if (cabinet.children) {
|
|
const name = findCabinetName(cabinet.children, id);
|
|
if (name) return name;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const name = findCabinetName(state.cabinets, segment) || segment;
|
|
|
|
return {
|
|
name: name,
|
|
path: breadcrumbPath
|
|
};
|
|
})
|
|
];
|
|
},
|
|
|
|
// Get public cabinets
|
|
publicCabinets: (state) => {
|
|
return state.cabinets.filter(cabinet => cabinet.accessType === 'public');
|
|
},
|
|
|
|
// Get personal cabinets (ones the user has access to)
|
|
personalCabinets: (state) => {
|
|
return state.cabinets.find(cabinet => cabinet.id === 'my-cabinets') || null;
|
|
},
|
|
|
|
// Get private cabinets
|
|
privateCabinets: (state) => {
|
|
return state.cabinets.find(cabinet => cabinet.id === 'private-cabinets') || null;
|
|
},
|
|
|
|
// Check if we can navigate back
|
|
canGoBack: (state) => {
|
|
return state.historyIndex > 0;
|
|
},
|
|
|
|
// Check if we can navigate forward
|
|
canGoForward: (state) => {
|
|
return state.historyIndex < state.pathHistory.length - 1;
|
|
},
|
|
|
|
// Filter items by access level
|
|
publicDocuments: (state) => {
|
|
return state.items.filter(item => item.accessType === 'public');
|
|
},
|
|
|
|
personalDocuments: (state) => {
|
|
return state.items.filter(item => item.accessType === 'personal');
|
|
},
|
|
|
|
privateDocuments: (state) => {
|
|
return state.items.filter(item => item.accessType === 'private');
|
|
},
|
|
|
|
// Get pending access requests
|
|
pendingAccessRequests: (state) => {
|
|
return state.accessRequests.filter(req => req.status === 'pending');
|
|
}
|
|
},
|
|
|
|
actions: {
|
|
// Navigation actions
|
|
navigateTo(path) {
|
|
// Add to history if it's a new path
|
|
if (path !== this.currentPath) {
|
|
// If we navigated back and then to a new path, truncate the forward history
|
|
if (this.historyIndex < this.pathHistory.length - 1) {
|
|
this.pathHistory = this.pathHistory.slice(0, this.historyIndex + 1);
|
|
}
|
|
|
|
this.pathHistory.push(path);
|
|
this.historyIndex = this.pathHistory.length - 1;
|
|
}
|
|
|
|
this.currentPath = path;
|
|
this.selectedItem = null;
|
|
},
|
|
|
|
navigateBack() {
|
|
if (this.canGoBack) {
|
|
this.historyIndex--;
|
|
this.currentPath = this.pathHistory[this.historyIndex];
|
|
this.selectedItem = null;
|
|
}
|
|
},
|
|
|
|
navigateForward() {
|
|
if (this.canGoForward) {
|
|
this.historyIndex++;
|
|
this.currentPath = this.pathHistory[this.historyIndex];
|
|
this.selectedItem = null;
|
|
}
|
|
},
|
|
|
|
selectItem(item) {
|
|
this.selectedItem = item;
|
|
},
|
|
|
|
// View actions
|
|
setViewMode(mode) {
|
|
this.viewMode = mode;
|
|
},
|
|
|
|
setSortBy(field) {
|
|
if (this.sortBy === field) {
|
|
// Toggle direction if clicking the same field
|
|
this.sortDirection = this.sortDirection === 'asc' ? 'desc' : 'asc';
|
|
} else {
|
|
this.sortBy = field;
|
|
this.sortDirection = 'asc';
|
|
}
|
|
},
|
|
|
|
// File viewer actions
|
|
openFileViewer(document) {
|
|
this.viewerDocument = document;
|
|
this.showFileViewer = true;
|
|
},
|
|
|
|
closeFileViewer() {
|
|
this.showFileViewer = false;
|
|
this.viewerDocument = null;
|
|
},
|
|
|
|
// Enhanced file validation based on settings
|
|
validateFile(file) {
|
|
const errors = [];
|
|
const settings = this.systemSettings.upload;
|
|
|
|
// Check file type
|
|
const fileExtension = file.name.split('.').pop().toLowerCase();
|
|
if (!settings.allowedFileTypes.includes(fileExtension)) {
|
|
errors.push(`File type .${fileExtension} is not allowed`);
|
|
}
|
|
|
|
if (settings.blockedFileTypes.includes(fileExtension)) {
|
|
errors.push(`File type .${fileExtension} is blocked`);
|
|
}
|
|
|
|
// Check file size
|
|
if (file.size > settings.maxFileSize) {
|
|
const maxSizeMB = settings.maxFileSize / (1024 * 1024);
|
|
errors.push(`File size exceeds limit of ${maxSizeMB}MB`);
|
|
}
|
|
|
|
// Check user quota
|
|
if (this.userQuotas.used + file.size > this.userQuotas.limit) {
|
|
errors.push('Upload would exceed your storage quota');
|
|
}
|
|
|
|
return {
|
|
isValid: errors.length === 0,
|
|
errors
|
|
};
|
|
},
|
|
|
|
// Enhanced metadata validation
|
|
validateMetadata(metadata, template = 'standard') {
|
|
const errors = [];
|
|
const templateConfig = this.metadataTemplates[template];
|
|
const customFields = this.systemSettings.metadata.customFields;
|
|
|
|
// Validate required custom fields
|
|
customFields.forEach(field => {
|
|
if (field.required && (!metadata[field.name] || metadata[field.name].toString().trim() === '')) {
|
|
errors.push(`${field.name} is required`);
|
|
}
|
|
|
|
// Validate field options for dropdown/select types
|
|
if (field.options && metadata[field.name] && !field.options.includes(metadata[field.name])) {
|
|
errors.push(`Invalid value for ${field.name}`);
|
|
}
|
|
});
|
|
|
|
// Validate document naming convention
|
|
if (this.systemSettings.documents.namingConventions.autoGenerate) {
|
|
const pattern = this.systemSettings.documents.namingConventions.pattern;
|
|
const requiredFields = pattern.match(/{(\w+)}/g)?.map(match => match.slice(1, -1)) || [];
|
|
|
|
requiredFields.forEach(field => {
|
|
if (!metadata[field]) {
|
|
errors.push(`${field} is required for auto-generated naming`);
|
|
}
|
|
});
|
|
}
|
|
|
|
return {
|
|
isValid: errors.length === 0,
|
|
errors
|
|
};
|
|
},
|
|
|
|
// Generate document name based on naming convention
|
|
generateDocumentName(metadata, originalFileName) {
|
|
if (!this.systemSettings.documents.namingConventions.autoGenerate) {
|
|
return originalFileName;
|
|
}
|
|
|
|
let pattern = this.systemSettings.documents.namingConventions.pattern;
|
|
const date = new Date().toISOString().split('T')[0];
|
|
|
|
// Replace placeholders
|
|
pattern = pattern.replace(/{department}/g, metadata.department || 'unknown');
|
|
pattern = pattern.replace(/{title}/g, metadata.title || 'document');
|
|
pattern = pattern.replace(/{date}/g, date);
|
|
pattern = pattern.replace(/{author}/g, metadata.author || 'unknown');
|
|
pattern = pattern.replace(/{projectCode}/g, metadata.projectCode || '');
|
|
|
|
// Get file extension
|
|
const extension = originalFileName.split('.').pop();
|
|
|
|
return `${pattern}.${extension}`;
|
|
},
|
|
|
|
// Enhanced upload with metadata and validation
|
|
async uploadFileWithMetadata(file, metadata, currentPath) {
|
|
// Validate file
|
|
const fileValidation = this.validateFile(file);
|
|
if (!fileValidation.isValid) {
|
|
throw new Error(`File validation failed: ${fileValidation.errors.join(', ')}`);
|
|
}
|
|
|
|
// Validate metadata
|
|
const metadataValidation = this.validateMetadata(metadata);
|
|
if (!metadataValidation.isValid) {
|
|
throw new Error(`Metadata validation failed: ${metadataValidation.errors.join(', ')}`);
|
|
}
|
|
|
|
this.isLoading = true;
|
|
|
|
try {
|
|
// Generate document name
|
|
const documentName = this.generateDocumentName(metadata, file.name);
|
|
|
|
// Create document object
|
|
const newDocument = {
|
|
id: `doc_${Date.now()}`,
|
|
name: documentName,
|
|
originalName: file.name,
|
|
type: 'file',
|
|
extension: file.name.split('.').pop().toLowerCase(),
|
|
size: this.formatFileSize(file.size),
|
|
modified: new Date().toLocaleDateString(),
|
|
author: metadata.author || 'Current User',
|
|
department: metadata.department,
|
|
description: metadata.description,
|
|
tags: metadata.tags || [],
|
|
priority: metadata.priority,
|
|
projectCode: metadata.projectCode,
|
|
reviewDate: metadata.reviewDate,
|
|
version: 1,
|
|
hasAccess: true,
|
|
accessType: metadata.accessType || 'private',
|
|
metadata: { ...metadata }
|
|
};
|
|
|
|
// Add to items (simulate upload)
|
|
this.items.push(newDocument);
|
|
|
|
// Update user quota
|
|
this.userQuotas.used += file.size;
|
|
this.userQuotas.documents += 1;
|
|
|
|
// Initialize version tracking if enabled
|
|
if (this.systemSettings.documents.versionControl.enabled) {
|
|
this.documentVersions[newDocument.id] = [{
|
|
version: 1,
|
|
uploadDate: new Date().toISOString(),
|
|
author: metadata.author,
|
|
changes: 'Initial upload',
|
|
fileSize: file.size
|
|
}];
|
|
}
|
|
|
|
return newDocument;
|
|
} catch (error) {
|
|
console.error('Upload failed:', error);
|
|
throw error;
|
|
} finally {
|
|
this.isLoading = false;
|
|
}
|
|
},
|
|
|
|
// Version control actions
|
|
async createNewVersion(documentId, file, metadata) {
|
|
if (!this.systemSettings.documents.versionControl.enabled) {
|
|
throw new Error('Version control is not enabled');
|
|
}
|
|
|
|
const document = this.items.find(item => item.id === documentId);
|
|
if (!document) {
|
|
throw new Error('Document not found');
|
|
}
|
|
|
|
// Check version limit
|
|
const versions = this.documentVersions[documentId] || [];
|
|
if (versions.length >= this.systemSettings.documents.versionControl.maxVersions) {
|
|
// Remove oldest version
|
|
versions.shift();
|
|
}
|
|
|
|
// Create new version
|
|
const newVersion = {
|
|
version: document.version + 1,
|
|
uploadDate: new Date().toISOString(),
|
|
author: metadata.author,
|
|
changes: metadata.changes || 'Updated document',
|
|
fileSize: file.size
|
|
};
|
|
|
|
// Update document
|
|
document.version = newVersion.version;
|
|
document.modified = new Date().toLocaleDateString();
|
|
document.size = this.formatFileSize(file.size);
|
|
|
|
// Add version to tracking
|
|
versions.push(newVersion);
|
|
this.documentVersions[documentId] = versions;
|
|
|
|
return newVersion;
|
|
},
|
|
|
|
// Get document versions
|
|
getDocumentVersions(documentId) {
|
|
return this.documentVersions[documentId] || [];
|
|
},
|
|
|
|
// Enhanced search with metadata
|
|
async advancedSearch(query, filters = {}) {
|
|
this.isLoading = true;
|
|
this.searchQuery = query;
|
|
Object.assign(this.advancedSearchFilters, filters);
|
|
|
|
try {
|
|
// Mock API delay
|
|
await new Promise(resolve => setTimeout(resolve, 300));
|
|
|
|
let results = this.items.filter(item => item.type === 'file');
|
|
|
|
// Text search
|
|
if (query) {
|
|
const searchLower = query.toLowerCase();
|
|
results = results.filter(item =>
|
|
item.name.toLowerCase().includes(searchLower) ||
|
|
item.description?.toLowerCase().includes(searchLower) ||
|
|
item.department?.toLowerCase().includes(searchLower) ||
|
|
item.author?.toLowerCase().includes(searchLower) ||
|
|
item.projectCode?.toLowerCase().includes(searchLower) ||
|
|
item.tags?.some(tag => tag.toLowerCase().includes(searchLower))
|
|
);
|
|
}
|
|
|
|
// Filter by file type
|
|
if (filters.fileType && filters.fileType.length > 0) {
|
|
results = results.filter(item => filters.fileType.includes(item.extension));
|
|
}
|
|
|
|
// Filter by department
|
|
if (filters.department && filters.department.length > 0) {
|
|
results = results.filter(item => filters.department.includes(item.department));
|
|
}
|
|
|
|
// Filter by tags
|
|
if (filters.tags && filters.tags.length > 0) {
|
|
results = results.filter(item =>
|
|
item.tags?.some(tag => filters.tags.includes(tag))
|
|
);
|
|
}
|
|
|
|
// Filter by priority
|
|
if (filters.priority && filters.priority.length > 0) {
|
|
results = results.filter(item => filters.priority.includes(item.priority));
|
|
}
|
|
|
|
// Filter by date range
|
|
if (filters.dateRange?.start || filters.dateRange?.end) {
|
|
results = results.filter(item => {
|
|
const itemDate = new Date(item.modified);
|
|
const startDate = filters.dateRange.start ? new Date(filters.dateRange.start) : null;
|
|
const endDate = filters.dateRange.end ? new Date(filters.dateRange.end) : null;
|
|
|
|
if (startDate && itemDate < startDate) return false;
|
|
if (endDate && itemDate > endDate) return false;
|
|
|
|
return true;
|
|
});
|
|
}
|
|
|
|
// Filter by version existence
|
|
if (filters.hasVersions) {
|
|
results = results.filter(item => this.documentVersions[item.id]?.length > 1);
|
|
}
|
|
|
|
this.searchResults = results;
|
|
return results;
|
|
} catch (error) {
|
|
console.error('Advanced search failed:', error);
|
|
throw error;
|
|
} finally {
|
|
this.isLoading = false;
|
|
}
|
|
},
|
|
|
|
// Tag suggestions
|
|
getTagSuggestions(input) {
|
|
if (!this.systemSettings.metadata.tagSuggestions) return [];
|
|
|
|
const allTags = [
|
|
...this.systemSettings.metadata.predefinedTags,
|
|
...new Set(this.items.flatMap(item => item.tags || []))
|
|
];
|
|
|
|
return allTags.filter(tag =>
|
|
tag.toLowerCase().includes(input.toLowerCase())
|
|
).slice(0, 10);
|
|
},
|
|
|
|
// Update system settings
|
|
updateSystemSettings(category, settings) {
|
|
if (this.systemSettings[category]) {
|
|
Object.assign(this.systemSettings[category], settings);
|
|
}
|
|
},
|
|
|
|
// Format file size helper
|
|
formatFileSize(bytes) {
|
|
if (bytes === 0) return '0 B';
|
|
const k = 1024;
|
|
const sizes = ['B', 'KB', 'MB', 'GB'];
|
|
const i = Math.floor(Math.log(bytes) / Math.log(k));
|
|
return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
|
|
},
|
|
|
|
// Cabinet access actions
|
|
async requestCabinetAccess(cabinetId, reason) {
|
|
this.isLoading = true;
|
|
|
|
try {
|
|
// Find the cabinet
|
|
let cabinetName = '';
|
|
const findCabinet = (cabinets, id) => {
|
|
for (const cabinet of cabinets) {
|
|
if (cabinet.id === id) {
|
|
cabinetName = cabinet.name;
|
|
return cabinet;
|
|
}
|
|
if (cabinet.children) {
|
|
const result = findCabinet(cabinet.children, id);
|
|
if (result) return result;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const cabinet = findCabinet(this.cabinets, cabinetId);
|
|
if (!cabinet) throw new Error('Cabinet not found');
|
|
|
|
// Mock API delay
|
|
await new Promise(resolve => setTimeout(resolve, 500));
|
|
|
|
// Create new access request
|
|
const newRequest = {
|
|
id: `req${Date.now()}`,
|
|
userId: this.currentUser.id,
|
|
userName: this.currentUser.name,
|
|
cabinetId: cabinetId,
|
|
cabinetName: cabinetName,
|
|
requestDate: new Date().toISOString().split('T')[0],
|
|
status: 'pending',
|
|
reason: reason
|
|
};
|
|
|
|
// Add to access requests
|
|
this.accessRequests.push(newRequest);
|
|
|
|
// Update cabinet request status
|
|
cabinet.accessRequestStatus = 'pending';
|
|
|
|
return newRequest;
|
|
} catch (error) {
|
|
console.error('Failed to request access:', error);
|
|
throw error;
|
|
} finally {
|
|
this.isLoading = false;
|
|
}
|
|
},
|
|
|
|
async approveAccessRequest(requestId) {
|
|
this.isLoading = true;
|
|
|
|
try {
|
|
// Mock API delay
|
|
await new Promise(resolve => setTimeout(resolve, 500));
|
|
|
|
// Find the request
|
|
const request = this.accessRequests.find(req => req.id === requestId);
|
|
if (!request) throw new Error('Request not found');
|
|
|
|
// Update request status
|
|
request.status = 'approved';
|
|
|
|
// Find the cabinet and update access
|
|
const updateCabinetAccess = (cabinets, id) => {
|
|
for (const cabinet of cabinets) {
|
|
if (cabinet.id === id) {
|
|
cabinet.hasAccess = true;
|
|
cabinet.accessRequestStatus = 'approved';
|
|
return true;
|
|
}
|
|
if (cabinet.children) {
|
|
if (updateCabinetAccess(cabinet.children, id)) return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
updateCabinetAccess(this.cabinets, request.cabinetId);
|
|
|
|
return request;
|
|
} catch (error) {
|
|
console.error('Failed to approve access request:', error);
|
|
throw error;
|
|
} finally {
|
|
this.isLoading = false;
|
|
}
|
|
},
|
|
|
|
async rejectAccessRequest(requestId, reason) {
|
|
this.isLoading = true;
|
|
|
|
try {
|
|
// Mock API delay
|
|
await new Promise(resolve => setTimeout(resolve, 500));
|
|
|
|
// Find the request
|
|
const request = this.accessRequests.find(req => req.id === requestId);
|
|
if (!request) throw new Error('Request not found');
|
|
|
|
// Update request status
|
|
request.status = 'rejected';
|
|
request.rejectionReason = reason;
|
|
|
|
// Find the cabinet and update access
|
|
const updateCabinetAccess = (cabinets, id) => {
|
|
for (const cabinet of cabinets) {
|
|
if (cabinet.id === id) {
|
|
cabinet.hasAccess = false;
|
|
cabinet.accessRequestStatus = 'rejected';
|
|
return true;
|
|
}
|
|
if (cabinet.children) {
|
|
if (updateCabinetAccess(cabinet.children, id)) return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
updateCabinetAccess(this.cabinets, request.cabinetId);
|
|
|
|
return request;
|
|
} catch (error) {
|
|
console.error('Failed to reject access request:', error);
|
|
throw error;
|
|
} finally {
|
|
this.isLoading = false;
|
|
}
|
|
},
|
|
|
|
// CRUD operations
|
|
async createItem(item) {
|
|
this.isLoading = true;
|
|
|
|
try {
|
|
// Mock API delay
|
|
await new Promise(resolve => setTimeout(resolve, 500));
|
|
|
|
// Get current cabinet id
|
|
const currentCabinetId = this.currentPath.split('/').filter(Boolean).pop();
|
|
|
|
// Generate a unique ID
|
|
const newItem = {
|
|
...item,
|
|
id: `${item.type}${Date.now()}`,
|
|
cabinetId: currentCabinetId,
|
|
modified: new Date().toISOString().split('T')[0],
|
|
createdBy: this.currentUser.name
|
|
};
|
|
|
|
// Add to items
|
|
this.items.push(newItem);
|
|
|
|
return newItem;
|
|
} catch (error) {
|
|
console.error('Failed to create item:', error);
|
|
throw error;
|
|
} finally {
|
|
this.isLoading = false;
|
|
}
|
|
},
|
|
|
|
async updateItem(id, updates) {
|
|
this.isLoading = true;
|
|
|
|
try {
|
|
// Mock API delay
|
|
await new Promise(resolve => setTimeout(resolve, 500));
|
|
|
|
// Find the item
|
|
const itemIndex = this.items.findIndex(item => item.id === id);
|
|
if (itemIndex === -1) throw new Error('Item not found');
|
|
|
|
// Update the item
|
|
const updatedItem = {
|
|
...this.items[itemIndex],
|
|
...updates,
|
|
modified: new Date().toISOString().split('T')[0]
|
|
};
|
|
|
|
this.items.splice(itemIndex, 1, updatedItem);
|
|
|
|
return updatedItem;
|
|
} catch (error) {
|
|
console.error('Failed to update item:', error);
|
|
throw error;
|
|
} finally {
|
|
this.isLoading = false;
|
|
}
|
|
},
|
|
|
|
async deleteItem(id) {
|
|
this.isLoading = true;
|
|
|
|
try {
|
|
// Mock API delay
|
|
await new Promise(resolve => setTimeout(resolve, 500));
|
|
|
|
// Find the item
|
|
const itemIndex = this.items.findIndex(item => item.id === id);
|
|
if (itemIndex === -1) throw new Error('Item not found');
|
|
|
|
// Remove the item
|
|
const deletedItem = this.items.splice(itemIndex, 1)[0];
|
|
|
|
return deletedItem;
|
|
} catch (error) {
|
|
console.error('Failed to delete item:', error);
|
|
throw error;
|
|
} finally {
|
|
this.isLoading = false;
|
|
}
|
|
},
|
|
|
|
// Search functionality
|
|
async searchDocuments(query) {
|
|
this.isLoading = true;
|
|
this.searchQuery = query;
|
|
|
|
try {
|
|
// Mock API delay
|
|
await new Promise(resolve => setTimeout(resolve, 500));
|
|
|
|
// Simple search implementation - in production would be more sophisticated
|
|
const results = this.items.filter(item =>
|
|
item.type === 'file' &&
|
|
(item.name.toLowerCase().includes(query.toLowerCase()) ||
|
|
(item.info?.title && item.info.title.toLowerCase().includes(query.toLowerCase())) ||
|
|
(item.info?.subject && item.info.subject.toLowerCase().includes(query.toLowerCase())))
|
|
);
|
|
|
|
this.searchResults = results;
|
|
return results;
|
|
} catch (error) {
|
|
console.error('Failed to search documents:', error);
|
|
throw error;
|
|
} finally {
|
|
this.isLoading = false;
|
|
}
|
|
},
|
|
|
|
clearSearch() {
|
|
this.searchQuery = '';
|
|
this.searchResults = [];
|
|
},
|
|
|
|
// Access request functionality
|
|
async requestAccess(itemId, accessLevel, justification, duration = '7 days') {
|
|
this.isLoading = true;
|
|
|
|
try {
|
|
// Mock API delay
|
|
await new Promise(resolve => setTimeout(resolve, 500));
|
|
|
|
// Generate a unique request ID
|
|
const requestId = `req${Date.now()}`;
|
|
|
|
// Create new access request
|
|
const newRequest = {
|
|
id: requestId,
|
|
userId: 'current-user-id', // Would come from auth store
|
|
userName: 'Current User', // Would come from auth store
|
|
itemId: itemId,
|
|
accessLevel: accessLevel,
|
|
justification: justification,
|
|
duration: duration,
|
|
requestDate: new Date().toISOString().split('T')[0],
|
|
status: 'pending'
|
|
};
|
|
|
|
// Add to access requests
|
|
this.accessRequests.push(newRequest);
|
|
|
|
// Update the item's access request status (for mock data)
|
|
// In production, this would be handled server-side
|
|
const updateItemStatus = (items, id) => {
|
|
for (const item of items) {
|
|
if (item.id === id) {
|
|
item.accessRequestStatus = 'pending';
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
// Try to find and update the item in the mock data arrays
|
|
// This is a simplified approach for demo purposes
|
|
|
|
return newRequest;
|
|
} catch (error) {
|
|
console.error('Failed to submit access request:', error);
|
|
throw error;
|
|
} finally {
|
|
this.isLoading = false;
|
|
}
|
|
}
|
|
}
|
|
});
|