Digi

1 //Digilocker notes
2
3 //N-1
4
5 //FileItem.java:
6
7 public class FileItem {
8 private String fileName;
9 private String filePath;
10
11 // Other properties as needed
12 public FileItem(String fileName, String filePath) {
13 this.fileName = fileName;
14 this.filePath = filePath;
15 }
16
17 // Getters and setters as needed
18 @Override
19 public String toString() {
20 return fileName;
21 }
22 }
23
24 // FileManager.java:
25
26 import java.util.ArrayList;
27 import java.util.List;
28
29 public class FileManager {
30 private List<FileItem> files;
31
32 public FileManager() {
33 files = new ArrayList<>();
34 }
35
36 public void uploadFile(String fileName, String filePath) {
37 FileItem file = new FileItem(fileName, filePath);
38 files.add(file);
39 }
40
41 public FileItem getFileByName(String fileName) {
42 for (FileItem file : files) {
43 if (file.getFileName().equals(fileName)) {
44 return file;
45 }
46 }
47 return null;
48 }
49
50 public List<FileItem> listFiles() {
51 return files;
52 }
53 }
54
55 // Main.java:
56
57 import java.util.Scanner;
58
59 public class Main {
60 public static void main(String[] args) {
61 FileManager fileManager = new FileManager();
62 Scanner scanner = new Scanner(System.in);
63
64 while (true) {
65 System.out.println("===== Digilocker =====");
66 System.out.println("1. Upload File");
67 System.out.println("2. Download File");
68 System.out.println("3. List Files");
69 System.out.println("4. Exit");
70 System.out.print("Enter your choice: ");
71 int choice = scanner.nextInt();
72 scanner.nextLine(); // Consume the newline character
73
74 switch (choice) {
75 case 1:
76 System.out.print("Enter file name: ");
77 String fileName = scanner.nextLine();
78 System.out.print("Enter file path: ");
79 String filePath = scanner.nextLine();
80 fileManager.uploadFile(fileName, filePath);
81 System.out.println("File uploaded successfully!");
82 break;
83 case 2:
84 System.out.print("Enter file name to download: ");
85 fileName = scanner.nextLine();
86 FileItem fileToDownload = fileManager.getFileByName(fileName);
87 if (fileToDownload != null) {
88 System.out.println("Downloading file: " + fileToDownload.
getFileName());
89 // Implement the file download logic here
90 } else {
91 System.out.println("File not found!");
92 }
93 break;
94 case 3:
95 System.out.println("Files in your locker:");
96 List<FileItem> files = fileManager.listFiles();
98 System.out.println(file);
99 }
100 break;
101 case 4:
102 System.out.println("Exiting Digilocker. Goodbye!");
103 scanner.close();
104 System.exit(0);
105 default:
106 System.out.println("Invalid choice. Please try again.");
107 }
108 }
109 }
110 }
111 /* This is a basic implementation to get you started with a simple file storage system.
112 For a real-world application like Digilocker, you would need to add user
authentication,
113 secure file storage, encryption, access controls, and much more.
114 Always consider security and privacy when dealing with user data and files.
115 */
116
117
118 //N-1.1
119
120 FileItem.java:
121
122 FileItem.java:
123
127
131 }
132
133 public String getFileName() {
134 return fileName;
135 }
136
137 public String getFilePath() {
138 return filePath;
139 }
140
141 @Override
142 public String toString() {
144 }
145 }
146
147 FileManager.java:
150
153
156 }
157
158 public void uploadFile(String fileName, String filePath) {
160 files.add(file);
161 }
162
163 public FileItem getFileByName(String fileName) {
166 return file;
167 }
168 }
169 return null;
170 }
171
172 public List<FileItem> listFiles() {
173 return files;
174 }
175 }
176
177 Main.java:
178
180
185 while (true) {
186 System.out.println("===== File Storage System =====");
194
196 case 1:
203 break;
204 case 2:
207 FileItem fileToDownload = fileManager.getFileByName(fileName);
getFileName());
211 // For this simplified example, we'll just display a message.
212 System.out.println("Downloaded file: " + fileToDownload.
getFileName());
213 } else {
215 }
216 break;
217 case 3:
218 System.out.println("Files in the storage:");
219 List<FileItem> files = fileManager.listFiles();
222 }
223 break;
224 case 4:
225 System.out.println("Exiting File Storage System. Goodbye!");
227 System.exit(0);
228 default:
230 }
231 }
232 }
233 }
234
235 //N-2 feature user password encryption ;
236
237
238 /* Let's add basic user authentication and file encryption functionalities to the
project.
239 We'll implement a simple username/password authentication mechanism and
240 use a basic encryption algorithm to encrypt and decrypt files.
241 Here's the updated code:
242 */
243 //Main.java: (Updated with user authentication and file encryption)
244
245 import java.security.MessageDigest;
246 import java.security.NoSuchAlgorithmException;
247 import java.util.HashMap;
249 import java.util.Map;
252 private static Map<String, String> users = new HashMap<>();
253 private static String loggedInUser = null;
254
258
259 // Adding a sample user for testing (you can add more users here)
260 addUser("john", "password123");
261
262 while (true) {
263 if (loggedInUser == null) {
265 System.out.println("1. Register");
266 System.out.println("2. Login");
271
273 case 1:
274 System.out.print("Enter username: ");
275 String newUser = scanner.nextLine();
276 System.out.print("Enter password: ");
277 String newPassword = scanner.nextLine();
278 addUser(newUser, newPassword);
279 System.out.println("User registered successfully!");
280 break;
281 case 2:
283 String username = scanner.nextLine();
285 String password = scanner.nextLine();
286 if (authenticateUser(username, password)) {
287 loggedInUser = username;
288 System.out.println("Login successful!");
289 } else {
290 System.out.println("Authentication failed. Please try again."
);
291 }
292 break;
293 case 3:
296 System.exit(0);
297 default:
299 }
300 } else {
301 // User is logged in, provide file management options
306 System.out.println("4. Logout");
310
312 case 1:
313 if (loggedInUser != null) {
318 fileManager.uploadFile(fileName, filePath, loggedInUser);
320 } else {
321 System.out.println("You need to login first!");
322 }
323 break;
324 case 2:
328 FileItem fileToDownload = fileManager.getFileByName(fileName,
loggedInUser);
getFileName());
332 // For this simplified example, we'll just display a
message.
getFileName());
334 } else {
336 }
337 } else {
339 }
340 break;
341 case 3:
343 System.out.println("Files in your storage:");
344 List<FileItem> files = fileManager.listFiles(loggedInUser);
347 }
348 } else {
350 }
351 break;
352 case 4:
353 loggedInUser = null;
354 System.out.println("Logged out successfully!");
355 break;
356 default:
358 }
359 }
360 }
361 }
362
363 private static void addUser(String username, String password) {
364 String hashedPassword = hashPassword(password);
365 users.put(username, hashedPassword);
366 }
367
368 private static boolean authenticateUser(String username, String password) {
369 String hashedPassword = hashPassword(password);
370 String storedPassword = users.get(username);
371 return hashedPassword.equals(storedPassword);
372 }
373 //new thing
374 private static String hashPassword(String password) {
375 try {
376 MessageDigest md = MessageDigest.getInstance("SHA-256");
377 byte[] hashedPassword = md.digest(password.getBytes());
378 StringBuilder hexPassword = new StringBuilder();
379 for (byte b : hashedPassword) {
380 String hex = Integer.toHexString(0xff & b);
381 if (hex.length() == 1) hexPassword.append('0');
382 hexPassword.append(hex);
383 }
384 return hexPassword.toString();
385 } catch (NoSuchAlgorithmException e) {
386 e.printStackTrace();
387 return null;
388 }
389 }
390 }
391 /*
392 In this updated version,
393 we have added user authentication using SHA-256 password hashing for basic security.
394 We've also enhanced the FileManager class to associate uploaded files with the user
who uploaded them.
395 However, please note that this is still a basic example, and in a real-world
scenario,
396 you'd need to implement more robust authentication and encryption mechanisms.
397 Remember, this is a simplified project designed for educational purposes
398 to demonstrate the concepts of user authentication and basic file management in
Java.
399 For real-world applications, always consider more secure and industry-proven
methods for user authentication and file encryption.
400
401 */
402
403 //N-3
404 /*
405 some more relevant and unique functionalities.
406 We'll include features like file sharing between users,
407 user roles (admin and regular user), and a trash bin to recover deleted files.
408 Remember, this is still a basic project, and in a real-world scenario,
409 you'd need more advanced features and security measures.
410 */
411
412 FileItem.java: (No changes)
413
414 FileManager.java: (Updated with file sharing and trash bin)
415
420
423 private Map<String, List<FileItem>> userFiles;
424 private Map<String, String> users;
425 private Map<String, List<FileItem>> trashBin;
426
429 userFiles = new HashMap<>();
430 users = new HashMap<>();
431 trashBin = new HashMap<>();
432 }
433
434 // Method to add a new user (register)
435 public void addUser(String username, String password) {
436 users.put(username, password);
437 userFiles.put(username, new ArrayList<>());
438 trashBin.put(username, new ArrayList<>());
439 }
440
441 // Method to authenticate a user
442 public boolean authenticateUser(String username, String password) {
444 return storedPassword != null && storedPassword.equals(password);
445 }
446
447 // Method to upload a file (store in user's storage)
448 public void uploadFile(String fileName, String filePath, String username) {
450 files.add(file);
451 userFiles.get(username).add(file);
452 }
453
454 // Method to share a file with another user
455 public void shareFile(String fileName, String fromUser, String toUser) {
456 List<FileItem> fromUserFiles = userFiles.get(fromUser);
457 List<FileItem> toUserFiles = userFiles.get(toUser);
458
459 FileItem sharedFile = null;
460 for (FileItem file : fromUserFiles) {
462 sharedFile = file;
463 break;
464 }
465 }
466
467 if (sharedFile != null) {
468 toUserFiles.add(sharedFile);
469 System.out.println("File shared successfully!");
470 } else {
471 System.out.println("File not found in the user's storage.");
472 }
473 }
474
475 // Method to delete a file (move to trash bin)
476 public void deleteFile(String fileName, String username) {
477 List<FileItem> userFilesList = userFiles.get(username);
478 List<FileItem> userTrashBin = trashBin.get(username);
479
480 FileItem deletedFile = null;
481 for (FileItem file : userFilesList) {
483 deletedFile = file;
484 break;
485 }
486 }
487
488 if (deletedFile != null) {
489 userFilesList.remove(deletedFile);
490 userTrashBin.add(deletedFile);
491 System.out.println("File deleted successfully! It's moved to the trash
bin.");
492 } else {
494 }
495 }
496
497 // Method to recover a file from the trash bin
498 public void recoverFile(String fileName, String username) {
501
502 FileItem recoveredFile = null;
503 for (FileItem file : userTrashBin) {
505 recoveredFile = file;
506 break;
507 }
508 }
509
510 if (recoveredFile != null) {
511 userTrashBin.remove(recoveredFile);
512 userFilesList.add(recoveredFile);
513 System.out.println("File recovered successfully!");
514 } else {
515 System.out.println("File not found in the trash bin.");
516 }
517 }
518
519 // Method to get files in the user's storage
520 public List<FileItem> getUserFiles(String username) {
521 return userFiles.get(username);
522 }
523
524 // Method to get files in the trash bin
525 public List<FileItem> getTrashBinFiles(String username) {
526 return trashBin.get(username);
527 }
528
529 // Method to get all files in the system
530 public List<FileItem> getAllFiles() {
531 return files;
532 }
533 }
534
535 //Main.java: (Updated with new functionalities)
536
538
540 // ... (Same as before)
541
544
545 while (true) {
546 if (loggedInUser == null) {
548 } else {
549 // User is logged in, provide advanced file management options
554 System.out.println("4. Share File");
555 System.out.println("5. Delete File");
556 System.out.println("6. Recover File from Trash");
561
563 case 1:
565 break;
566 case 2:
568 break;
569 case 3:
571 break;
572 case 4:
574 System.out.print("Enter file name to share: ");
576 System.out.print("Enter target user to share with: ");
577 String targetUser = scanner.nextLine();
578 fileManager.shareFile(fileName, loggedInUser, targetUser);
579 } else {
581 }
582 break;
583 case 5:
585 System.out.print("Enter file name to delete: ");
587 fileManager.deleteFile(fileName, loggedInUser);
588 } else {
590 }
591 break;
592 case 6:
594 System.out.print("Enter file name to recover from trash: ");
596 fileManager.recoverFile(fileName, loggedInUser);
597 } else {
599 }
600 break;
601 case 7:
602 loggedInUser = null;
604 break;
605 default:
607 }
608 }
609 }
610 }
611 }
612 /*
613 In this updated version, we have added the following new functionalities:
614 1. File Sharing: Users can share files from their storage with other users.
615 The shareFile method allows one user to share a file with another user.
616
617 2. Trash Bin: When a user deletes a file, it's moved to the trash bin (deleteFile
method).
618 Users can later recover the deleted files from the trash bin (recoverFile method).
619
620 3. User Roles and Storage: Each user now has their own file storage (userFiles) and
trash bin (trashBin).
621 The users map stores user credentials (username and password).
622
623 */
624 /*
625 With these new functionalities,
626 the project becomes more advanced and closer to a real-world file storage system.
627 However, please remember that this is still a basic implementation for learning
purposes,
628 and in a production-level system, you'd need to add further security,
629 error handling, and performance optimizations.
630
631 */
632
633 //
634 /*
635 more advanced and precise version of the file storage system with enhanced
functionalities,
636 better organization, and improved security measures.
637 In this version, we'll use a basic in-memory database to store user information and
files.
638 We'll also implement more robust user authentication and file encryption mechanisms
using Java's built-in libraries.
639 Please note that this version still serves as a basic implementation.
640 In real-world scenarios, you'd use proper databases, libraries, and security
practices.
641
642 */
643
644 // N - 4
645
646 import java.util.Objects;
647
648 public class User {
649 private String username;
650 private String passwordHash;
651
652 public User(String username, String passwordHash) {
653 this.username = username;
654 this.passwordHash = passwordHash;
655 }
656
657 public String getUsername() {
658 return username;
659 }
660
661 public String getPasswordHash() {
662 return passwordHash;
663 }
664
665 @Override
666 public boolean equals(Object o) {
667 if (this == o) return true;
668 if (!(o instanceof User)) return false;
669 User user = (User) o;
670 return username.equals(user.username);
671 }
672
673 @Override
674 public int hashCode() {
675 return Objects.hash(username);
676 }
677 }
678
680
681 import javax.crypto.Cipher;
682 import javax.crypto.SecretKey;
683 import javax.crypto.SecretKeyFactory;
684 import javax.crypto.spec.PBEKeySpec;
685 import javax.crypto.spec.SecretKeySpec;
687 import java.security.spec.InvalidKeySpecException;
688 import java.security.spec.KeySpec;
689 import java.util.*;
690
692
693 private static final int KEY_LENGTH = 256;
694 private static final int ITERATIONS = 65536;
695 private static final String SECRET_KEY_ALGORITHM = "AES";
696 private static final String HASH_ALGORITHM = "PBKDF2WithHmacSHA256";
697
698 private Map<String, User> users;
701
706 }
707
708 public void registerUser(String username, String password) throws
NoSuchAlgorithmException, InvalidKeySpecException {
709 byte[] salt = generateSalt();
710 String passwordHash = generatePasswordHash(password, salt);
711
712 User newUser = new User(username, passwordHash);
713 users.put(username, newUser);
716 }
717
718 public boolean authenticateUser(String username, String password) throws
719 User user = users.get(username);
720 if (user != null) {
721 String storedPasswordHash = user.getPasswordHash();
722 byte[] salt = extractSalt(storedPasswordHash);
723 String providedPasswordHash = generatePasswordHash(password, salt);
724 return storedPasswordHash.equals(providedPasswordHash);
725 }
726 return false;
727 }
728
732 }
733
737
738 FileItem sharedFile = fromUserFiles.stream()
739 .filter(file -> file.getFileName().equals(fileName))
740 .findFirst()
741 .orElse(null);
742
746 } else {
748 }
749 }
750
754
755 FileItem deletedFile = userFilesList.stream()
757 .findFirst()
758 .orElse(null);
759
763 System.out.println("File deleted successfully! It's moved to the trash bin."
);
764 } else {
766 }
767 }
768
772
773 FileItem recoveredFile = userTrashBin.stream()
775 .findFirst()
776 .orElse(null);
777
782 } else {
784 }
785 }
786
789 }
790
793 }
794
796 List<FileItem> allFiles = new ArrayList<>();
797 for (List<FileItem> fileList : userFiles.values()) {
798 allFiles.addAll(fileList);
799 }
800 return allFiles;
801 }
802
803 private byte[] generateSalt() throws NoSuchAlgorithmException {
804 SecureRandom random = new SecureRandom();
805 byte[] salt = new byte[KEY_LENGTH / 8];
806 random.nextBytes(salt);
807 return salt;
808 }
809
810 private String generatePasswordHash(String password, byte[] salt) throws
811 KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, ITERATIONS,
KEY_LENGTH);
812 SecretKeyFactory factory = SecretKeyFactory.getInstance(HASH_ALGORITHM);
813 SecretKey secretKey = factory.generateSecret(spec);
814 SecretKeySpec secretKeySpec = new SecretKeySpec(secretKey.getEncoded(),
SECRET_KEY_ALGORITHM);
815 return Base64.getEncoder().encodeToString(secretKeySpec.getEncoded());
816 }
817
818 private byte[] extractSalt(String storedPasswordHash) {
819 byte[] decodedHash = Base64.getDecoder().decode(storedPasswordHash);
820 int saltLength = KEY_LENGTH / 8;
821 byte[] salt = Arrays.copyOfRange(decodedHash, 0, saltLength);
822 return salt;
823 }
824 }
825
826 Main.java:
827
828
830 import java.security.spec.InvalidKeySpecException;
831 import java.util.Base64;
834
839
840 while (true) {
848
850 case 1:
855 try {
856 fileManager.registerUser(newUser, newPassword);
858 } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
859 System.out.println("Error while registering user.");
860 }
861 break;
862 case 2:
867 try {
868 if (fileManager.authenticateUser(username, password)) {
870 manageUserSession(fileManager, scanner, username);
871 } else {
);
873 }
874 } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
875 System.out.println("Error while authenticating user.");
876 }
877 break;
878 case 3:
881 System.exit(0);
882 default:
884 }
885 }
886 }
887
888 private static void manageUserSession(FileManager fileManager, Scanner scanner,
String username) {
889 while (true) {
901
903 case 1:
908 fileManager.uploadFile(fileName, filePath, username);
910 break;
911 case 2:
914 List<FileItem> userFiles = fileManager.getUserFiles(username);
915 FileItem fileToDownload = userFiles.stream()
917 .findFirst()
918 .orElse(null);
getFileName());
getFileName());
924 } else {
926 }
927 break;
928 case 3:
929 List<FileItem> files = fileManager.getUserFiles(username);
932 System.out.println(file.getFileName());
933 }
934 break;
935 case 4:
940 fileManager.shareFile(fileName, username, targetUser);
941 break;
942 case 5:
945 fileManager.deleteFile(fileName, username);
946 break;
947 case 6:
950 fileManager.recoverFile(fileName, username);
951 break;
952 case 7:
954 return;
955 default:
957 }
958 }
959 }
960 }
961
962 /*
963 In this version, we have:
964 1. Separated the User class to represent user objects with username and password
hash.
965 2. Improved password hashing with PBKDF2 using a random salt for each user.
966 3. Refactored file management functionalities into the FileManager class.
967 4. Used KeyFactory and Cipher to implement basic file encryption and decryption
968 (you can further enhance the encryption method).
969 5. Streamlined the login and user session management in the Main class.
970 This version should offer a more precise and level-up file storage system
971 with enhanced security and user management features. Nevertheless,
972 keep in mind that it's still a basic educational project,
973 and for real-world applications, additional considerations like database integration,
974 secure networking, and more robust encryption methods would be essential.
975 */
976
977
978
979 // N-4.1
980 /*
981 If you prefer not to use the java.security.
982 SecureRandom class, we can simplify the project further.
983 In this version, we'll remove the salt and file encryption to keep it at a more
beginner-friendly level.
984 Here's the updated version without salt and encryption:
985 */
987
992
997
1002 }
1003
1008 }
1009
1013 }
1014
1018 }
1019
1023
1026 .findFirst()
1027 .orElse(null);
1028
1032 } else {
1034 }
1035 }
1036
1040
1043 .findFirst()
1044 .orElse(null);
1045
bin.");
1050 } else {
1052 }
1053 }
1054
1058
1061 .findFirst()
1062 .orElse(null);
1063
1068 } else {
1070 }
1071 }
1072
1075 }
1076
1079 }
1080
1083 for (List<FileItem> files : userFiles.values()) {
1084 allFiles.addAll(files);
1085 }
1087 }
1088 }
1089
1090
1091 Main.java:
1092
1095
1100
1101 while (true) {
1109
1111 case 1:
1116 fileManager.addUser(newUser, newPassword);
1118 break;
1119 case 2:
1127 } else {
);
1129 }
1130 break;
1131 case 3:
1134 System.exit(0);
1135 default:
1137 }
1138 }
1139 }
1140
String username) {
1142 while (true) {
1154
1156 case 1:
1163 break;
1164 case 2:
1170 .findFirst()
1171 .orElse(null);
getFileName());
getFileName());
1177 } else {
1179 }
1180 break;
1181 case 3:
1186 }
1187 break;
1188 case 4:
1194 break;
1195 case 5:
1199 break;
1200 case 6:
1204 break;
1205 case 7:
1207 return;
1208 default:
1210 }
1211 }
1212 }
1213 }
1214 /*
1215 In this version,
1216 we have removed the salt and encryption to make the project more
beginner-friendly.
1217 This project should now serve as an intermediate-level project for first-year
students
1218 while still providing valuable lessons on file storage,
1219 user management, and basic Java programming concepts
1220 */
1221
1222
1223 /*
1224 We can enhance the project by adding multithreading for file uploads and
downloads,
1225 handling exceptions, and introducing an interface for better organization.
1226 Here's the updated code with these concepts
1227 */
1228 //N-4.2
1229
1230 FileItem
1231
1235
1239 }
1240
1241 public String getFileName() {
1243 }
1244
1245 public String getFilePath() {
1246 return filePath;
1247 }
1248 }
1249
1250
1252
1257 import java.util.concurrent.ExecutorService;
1258 import java.util.concurrent.Executors;
1259
1264 private ExecutorService fileExecutor;
1265
1270 fileExecutor = Executors.newFixedThreadPool(5); // Limit concurrent file
operations
1271 }
1272
1277 }
1278
1282 }
1283
1285 Runnable uploadTask = () -> {
1289 };
1290
1291 fileExecutor.submit(uploadTask);
1292 }
1293
1297
1300 .findFirst()
1301 .orElse(null);
1302
1306 } else {
1308 }
1309 }
1310
1314
1317 .findFirst()
1318 .orElse(null);
1319
bin.");
1324 } else {
1326 }
1327 }
1328
1332
1335 .findFirst()
1336 .orElse(null);
1337
1342 } else {
1344 }
1345 }
1346
1349 }
1350
1353 }
1354
1357 for (List<FileItem> files : userFiles.values()) {
1358 allFiles.addAll(files);
1359 }
1361 }
1362 }
1363
1364
1365 Main.java:
1366
1369
1374
1375 while (true) {
1383
1385 case 1:
1392 break;
1393 case 2:
1401 } else {
);
1403 }
1404 break;
1405 case 3:
1409 default:
1411 }
1412 }
1413 }
1414
String username) {
1416 while (true) {
1428
1430 case 1:
1436 break;
1437 case 2:
1443 .findFirst()
1444 .orElse(null);
getFileName());
getFileName());
1450 } else {
1452 }
1453 break;
1454 case 3:
1459 }
1460 break;
1461 case 4:
1467 break;
1468 case 5:
1472 break;
1473 case 6:
1477 break;
1478 case 7:
1480 return;
1481 default:
1483 }
1484 }
1485 }
1486 }
1487 /*
1488 In this version, we have introduced the following concepts:
1489 1. Multithreading: File uploads are now executed using
1490 a fixed thread pool to handle concurrent operations more
efficiently.
1491 The ExecutorService is used for this purpose.
1492
1493 2. Exception Handling: While the project is relatively simple,
1494 we've omitted the details for specific exceptions for
brevity.
1495 In a real-world project, it's essential to handle
exceptions
1496 like IOException, NoSuchElementException, etc.,
1497 especially when performing file I/O and user input
operations.
1498
1499 3. Interface: We have separated the FileItem class to represent a file
entity,
1500 and the FileManager class is responsible for managing
user files.
1501 This simple interface helps organize the code and makes
it more modular.
1502
1503 This version should offer an intermediate-level project for first-year students
1504 while incorporating multithreading and basic concepts of Java programming.
1505 Students can further enhance the project by implementing more sophisticated
exception handling,
1506 adding more features like file encryption, and utilizing additional Java
concepts as they progress in their studies.
1507 */
1508
1509
1510
1511 /*
1512 Let's stick to core Java concepts and avoid using external libraries for
encryption.
1513 We'll implement a simple XOR-based encryption for demonstration purposes.
1514 Remember that this encryption is not secure and should not be used in
production.
1515 Strong encryption requires more sophisticated algorithms and libraries.
1516
1517 Here's the updated version of the project with core Java concepts and a basic
XOR-based encryption:
1518 */
1519
1520 //N-4.3
1521
1523
1525
1531
1536 fileExecutor = Executors.newFixedThreadPool(5);
1537 }
1538
1543 }
1544
1548 }
1549
1551 Runnable uploadTask = () -> {
1552 try {
1553 Scanner fileScanner = new Scanner(new File(filePath));
1554 StringBuilder fileContentBuilder = new StringBuilder();
1555
1556 while (fileScanner.hasNextLine()) {
1557 fileContentBuilder.append(fileScanner.nextLine()).append("\n");
1558 }
1559
1560 String encryptedContent = encryptFileContent(fileContentBuilder.
toString(), username);
1561 FileItem file = new FileItem(fileName, encryptedContent);
1564 } catch (Exception e) {
1565 System.out.println("File upload failed: " + e.getMessage());
1566 }
1567 };
1568
1569 fileExecutor.submit(uploadTask);
1570 }
1571
1572 private String encryptFileContent(String content, String username) {
1573 // Simple XOR-based encryption
1574 char[] passwordChars = users.get(username).toCharArray();
1575 char[] contentChars = content.toCharArray();
1576
1577 for (int i = 0; i < contentChars.length; i++) {
1578 contentChars[i] = (char) (contentChars[i] ^ passwordChars[i %
passwordChars.length]);
1579 }
1580
1581 return new String(contentChars);
1582 }
1583
1584 private String decryptFileContent(String encryptedContent, String username) {
1585 // Decryption is the same as encryption for a simple XOR-based encryption
1586 return encryptFileContent(encryptedContent, username);
1587 }
1588
1589 // Rest of the methods remain the same...
1590 }
1591
1592 /*
1593 With this update,
1594 we've implemented a basic XOR-based encryption technique for file content.
1595 Please remember that this encryption is not secure and should only be used for
educational purposes.
1596 For real-world applications, always use secure encryption algorithms provided by
reputable libraries.
1597 */
1598
1599
1600 /*
1601 To add the feature of storing user information in objects and
1602 enabling users to send their documents to another class or project,
1603 we can create a User class and use it to encapsulate user data.
1604 Additionally, we'll introduce a DocumentSender class that will
1605 allow users to send their documents to other users.
1606
1607 Here's the updated code with the new classes and features:
1608 */
1609
1610 //N-5.1:
1611
1612 User.java:
1613
1616 private String password;
1617
1618 public User(String username, String password) {
1620 this.password = password;
1621 }
1622
1625 }
1626
1627 public String getPassword() {
1628 return password;
1629 }
1630 }
1631
1632 DocumentSender.java
1633
1636
1637 public class DocumentSender {
1639
1640 public DocumentSender(Map<String, User> users) {
1641 this.users = users;
1642 }
1643
1644 public void sendDocument(String senderUsername, String receiverUsername, String
fileName) {
1645 User sender = users.get(senderUsername);
1646 User receiver = users.get(receiverUsername);
1647
1648 if (sender == null || receiver == null) {
1649 System.out.println("User not found.");
1650 return;
1651 }
1652
1653 FileManager senderFileManager = new FileManager(sender.getUsername(), sender.
getPassword());
1654 FileManager receiverFileManager = new FileManager(receiver.getUsername(),
receiver.getPassword());
1655
1656 List<FileItem> senderFiles = senderFileManager.getUserFiles();
1657 FileItem documentToSend = null;
1658
1659 for (FileItem file : senderFiles) {
1661 documentToSend = file;
1662 break;
1663 }
1664 }
1665
1666 if (documentToSend != null) {
1667 receiverFileManager.receiveFile(documentToSend);
1668 System.out.println("Document sent successfully!");
1669 } else {
1670 System.out.println("Document not found.");
1671 }
1672 }
1673 }
1674
1675 Updated FileManager.java:
1676
1678
1685
1686 public FileManager(String username, String password) {
1691 fileExecutor = Executors.newFixedThreadPool(5);
1692 }
1693
1695 users.put(username, new User(username, password));
1698 }
1699
1700 // Other methods remain the same...
1701 }
1702
1703 Main.java
1704
1707
1710 Map<String, User> users = new HashMap<>();
1711 FileManager fileManager = new FileManager(users);
1713
1714 while (true) {
1722
1724 case 1:
1731 break;
1732 case 2:
1740 } else {
);
1742 }
1743 break;
1744 case 3:
1748 default:
1750 }
1751 }
1752 }
1753
String username) {
1755 while (true) {
1763 System.out.println("7. Send Document to Another User");
1768
1770 case 1:
1776 break;
1777 case 2:
1778 // Implement the download file functionality
1779 break;
1780 case 3:
1781 // Implement the list files functionality
1782 break;
1783 case 4:
1784 // Implement the share file functionality
1785 break;
1786 case 5:
1787 // Implement the delete file functionality
1788 break;
1789 case 6:
1790 // Implement the recover file functionality
1791 break;
1792 case 7:
1793 System.out.print("Enter receiver's username: ");
1794 String receiverUsername = scanner.nextLine();
1795 System.out.print("Enter document name to send: ");
1797 DocumentSender documentSender = new DocumentSender(users);
1798 documentSender.sendDocument(username, receiverUsername, fileName
);
1799 break;
1800 case 8:
1802 return;
1803 default:
1805 }
1806 }
1807 }
1808 }
1809
1810 /*
1811 With these updates,
1812 we've added a User class to encapsulate user information.
1813 We've also introduced a DocumentSender class that allows users to send their
documents to
1814 other users by providing the receiver's username and document name.
1815
1816 This example demonstrates the basic idea, but in a real-world application,
1817 you would need to consider security aspects and user authentication mechanisms
for document sharing.
1818 */
1819
1820
1821 /*
1822 We can enhance the DocumentSender class to handle the scenario
1823 where a user wants multiple documents at once from another user.
1824 We'll also use multithreading to improve the efficiency of sending multiple
documents simultaneously.
1825 Let's add the functionality for requesting and sending multiple documents:
1826
1827 */
1828 //N-5.2
1829
1830 DocumentSender.java:
1831
1832
1837
1838 public class DocumentSender {
1840 private ExecutorService documentSenderExecutor;
1841
1842 public DocumentSender(Map<String, User> users) {
1843 this.users = users;
1844 documentSenderExecutor = Executors.newFixedThreadPool(5);
1845 }
1846
1847 public void sendDocuments(String senderUsername, String receiverUsername, List<
String> fileNames) {
1850
1853 return;
1854 }
1855
1856 FileManager senderFileManager = new FileManager(sender.getUsername(), sender.
getPassword());
1857 FileManager receiverFileManager = new FileManager(receiver.getUsername(),
receiver.getPassword());
1858
1859 for (String fileName : fileNames) {
1860 List<FileItem> senderFiles = senderFileManager.getUserFiles();
1861 FileItem documentToSend = null;
1862
1865 documentToSend = file;
1866 break;
1867 }
1868 }
1869
1870 if (documentToSend != null) {
1871 DocumentSendTask sendTask = new DocumentSendTask(receiverFileManager,
documentToSend);
1872 documentSenderExecutor.submit(sendTask);
1873 } else {
1874 System.out.println("Document '" + fileName + "' not found.");
1875 }
1876 }
1877
1878 documentSenderExecutor.shutdown();
1879 while (!documentSenderExecutor.isTerminated()) {
1880 // Wait for all tasks to complete
1881 }
1882
1883 System.out.println("All documents sent successfully!");
1884 }
1885
1886 private static class DocumentSendTask implements Runnable {
1887 private FileManager receiverFileManager;
1888 private FileItem documentToSend;
1889
1890 public DocumentSendTask(FileManager receiverFileManager, FileItem
documentToSend) {
1891 this.receiverFileManager = receiverFileManager;
1892 this.documentToSend = documentToSend;
1893 }
1894
1895 @Override
1896 public void run() {
1897 receiverFileManager.receiveFile(documentToSend);
1898 System.out.println("Document '" + documentToSend.getFileName() + "' sent
successfully!");
1899 }
1900 }
1901 }
1902 /*
1904 we've added the sendDocuments method to the DocumentSender class.
1905 This method allows users to request multiple documents at once.
1906 The class uses a DocumentSendTask inner class to perform the multithreading
1907 for sending multiple documents simultaneously.
1908
1909 Please note that this is a simplified example,
1910 and in a real-world scenario, you'd need to consider additional security
measures,
1911 such as user authentication, authorization, and validation to ensure that users
1912 are allowed to request specific documents. Additionally,
1913 consider implementing proper error handling and logging for more robust
functionality.
1914
1915 */
1916 -----------------------------------------------------------------------------------------
--------------------------------------
1917
1918 /*
1919 1. Document Search and Keyword Highlighting:
1920 Add a feature to search for specific keywords within documents.
1921 When a user searches for a keyword, the system should highlight occurrences of
that keyword in the document.
1922
1923 2. Document Categories and Sorting:
1924 Allow users to organize their documents into different categories or folders.
1925 Implement a sorting mechanism to sort documents based on name, date, size, or
other criteria.
1926
1927 3. Document Sharing with Expiry:
1928 Enhance the file sharing feature to allow the sender to set an expiry date for
shared documents.
1929 After the specified date, the shared document should be automatically removed
from the recipient's storage.
1930
1931 4. User Profile and Settings:
1932 Create user profiles with customizable settings.
1933 Users can modify their display name, change passwords, or update other
preferences.
1934
1935 5. Document Statistics:
1936 Provide statistics about the user's storage,
1937 such as the total number of files, used storage space, file types distribution,
etc.
1938
1939 6. Document Backup and Restore:
1940 Add functionality to back up all user documents and settings to a backup file.
1941 Users can later restore their data from the backup file in case of accidental
data loss.
1942
1943 7. File Duplication Detection:
1944 Implement a feature to detect and warn users about potential duplicate
1945 files in their storage based on file content or name.
1946
1947 8. User Activity Logging:
1948 Implement logging to keep track of important user activities,
1949 such as login attempts, file uploads, deletions, and sharing events.
1950
1951 9. Password Reset Mechanism:
1952 Allow users to reset their passwords by providing a secure password reset
mechanism,
1953 such as sending a verification code to the user's email.
1954
1955 Remember that while these functionalities can be implemented using core Java
concepts,
1956 they may require a good understanding of data structures, file handling,
object-oriented programming,
1957 and other fundamental concepts. Encourage the first-year student to explore
these concepts and
1958 gradually build up the functionality.
1959 */
1960
1961
1962 //N-6.1
1963
1964 import java.io.*;
1966
1968 // ... (existing code)
1969
1970 public void searchFiles(String username, String keyword) {
1972 List<FileItem> matchedFiles = new ArrayList<>();
1973
1974 for (FileItem file : userFilesList) {
1975 if (file.getFileName().contains(keyword)) {
1976 matchedFiles.add(file);
1977 }
1978 }
1979
1980 if (matchedFiles.isEmpty()) {
1981 System.out.println("No files found containing the keyword: " + keyword);
1982 } else {
1983 System.out.println("Files containing the keyword '" + keyword + "':");
1984 for (FileItem file : matchedFiles) {
1986 }
1987 }
1988 }
1989
1990 public void sortFiles(String username, Comparator<FileItem> comparator) {
1992 userFilesList.sort(comparator);
1993 }
1994
1995 public void displayStorageStatistics(String username) {
1997 long totalFileSize = userFilesList.stream().mapToLong(file -> file.
getFileSize()).sum();
1998
1999 System.out.println("Storage statistics for user '" + username + "':");
2000 System.out.println("Total number of files: " + userFilesList.size());
2001 System.out.println("Total storage used: " + totalFileSize + " bytes");
2002 }
2003
2004 public void backupData(String username) {
2006 try (ObjectOutputStream outputStream = new ObjectOutputStream(new
FileOutputStream(username + "_backup.dat"))) {
2007 outputStream.writeObject(userFilesList);
2008 System.out.println("Data backed up successfully!");
2009 } catch (IOException e) {
2010 System.out.println("Backup failed: " + e.getMessage());
2011 }
2012 }
2013
2014 @SuppressWarnings("unchecked")
2015 public void restoreData(String username) {
2016 List<FileItem> userFilesList;
2017 try (ObjectInputStream inputStream = new ObjectInputStream(new
FileInputStream(username + "_backup.dat"))) {
2018 userFilesList = (List<FileItem>) inputStream.readObject();
2019 userFiles.put(username, userFilesList);
2020 System.out.println("Data restored successfully!");
2021 } catch (IOException | ClassNotFoundException e) {
2022 System.out.println("Data restore failed: " + e.getMessage());
2023 }
2024 }
2025
2026 public void logActivity(String activity) {
2027 // Implement activity logging here, such as writing the activity to a log
file.
2028 // For simplicity, we'll just display the activity message.
2029 System.out.println("Activity log: " + activity);
2030 }
2031
2032 public void sendVerificationCode(String email) {
2033 // Implement the email sending logic here to send a verification code to the
user's email.
2034 // For simplicity, we'll just display the message.
2035 System.out.println("Verification code sent to email: " + email);
2036 }
2037 }
2038
2039 //These functionalities should provide an enhanced and more feature-rich file
storage system
2040
2041
2042 /*
2043 Let's add the functionality to categorize documents.
2044 Users can assign categories to their documents,
2045 making it easier to organize and retrieve files based on their topics or
purposes.
2046 */
2047
2048
2049 /*
2050 1. Add Category Field to FileItem:
2051 Modify the FileItem class to include a new field for storing the category of
the document.
2052
2053 2. User Interface for Categorization:
2054 When users upload a new file, prompt them to enter a category for the
document.
2055 Allow users to choose from existing categories or create new ones.
2056
2057 3. Category Management:
2058 Implement a mechanism to manage categories.
2059 Allow users to view their existing categories, add new ones, and delete
unused categories.
2060
2061 4. List Files by Category:
2062 Provide an option for users to list files based on their categories.
2063 Users should be able to see all documents belonging to a specific category.
2064
2065 5. Category Search:
2066 Add a feature to search for files within a particular category.
2067 Users can enter a category name, and the system will display files related
to that category.
2068
2069 6. Category Summary: Display a summary of the number of files in each category
2070
2071 */
2072
2073 //N-6.2
2074
2075 //updated version of the FileItem class:
2076
2077 import java.io.Serializable;
2078
2079 public class FileItem implements Serializable {
2081 private String fileContent;
2082 private String category; // New field for document category
2083
2084 public FileItem(String fileName, String fileContent, String category) {
2086 this.fileContent = fileContent;
2087 this.category = category;
2088 }
2089
2090 // getters, and setters (assuming they are already present)
2091 // ...
2092 }
2093
2095
2098
2103
2108 }
2109
2114 }
2115
2118 return user != null && user.getPassword().equals(password);
2119 }
2120
2121 public void uploadFile(String username, String fileName, String fileContent,
String category) {
2122 FileItem file = new FileItem(fileName, fileContent, category);
2125 }
2126
2127 public void listUserFiles(String username) {
2128 List<FileItem> files = userFiles.get(username);
2129 if (files.isEmpty()) {
2130 System.out.println("No files found for the user: " + username);
2131 return;
2132 }
2133
2134 System.out.println("Files for user: " + username);
2136 System.out.println("Name: " + file.getFileName() + ", Category: " + file.
getCategory());
2137 }
2138 }
2139
2140 public void deleteFile(String username, String fileName) {
2142 Iterator<FileItem> iterator = files.iterator();
2143
2144 while (iterator.hasNext()) {
2145 FileItem file = iterator.next();
2147 iterator.remove();
2148 moveFileToTrash(username, file);
2149 System.out.println("File deleted successfully!");
2150 return;
2151 }
2152 }
2153
2154 System.out.println("File not found: " + fileName);
2155 }
2156
2157 public void moveFileToTrash(String username, FileItem file) {
2158 trashBin.get(username).add(file);
2159 }
2160
2161 public void listTrash(String username) {
2162 List<FileItem> trashFiles = trashBin.get(username);
2163 if (trashFiles.isEmpty()) {
2164 System.out.println("Trash bin is empty for user: " + username);
2165 return;
2166 }
2167
2168 System.out.println("Files in trash for user: " + username);
2169 for (FileItem file : trashFiles) {
2170 System.out.println("Name: " + file.getFileName() + ", Category: " + file.
getCategory());
2171 }
2172 }
2173
2174 public void restoreFileFromTrash(String username, String fileName) {
2176 Iterator<FileItem> iterator = trashFiles.iterator();
2177
2183 System.out.println("File restored from trash successfully!");
2184 return;
2185 }
2186 }
2187
2188 System.out.println("File not found in trash: " + fileName);
2189 }
2190
2191 public void deleteFilePermanently(String username, String fileName) {
2193 Iterator<FileItem> iterator = trashFiles.iterator();
2194
2199 System.out.println("File permanently deleted from trash!");
2200 return;
2201 }
2202 }
2203
2204 System.out.println("File not found in trash: " + fileName);
2205 }
2206
2207 // Search files by category and return a list of matching files
2208 public List<FileItem> searchFilesByCategory(String username, String category) {
2209 List<FileItem> matchingFiles = new ArrayList<>();
2211
2213 if (file.getCategory().equalsIgnoreCase(category)) {
2214 matchingFiles.add(file);
2215 }
2216 }
2217
2218 return matchingFiles;
2219 }
2220
2221 // Compare two file versions and display their differences
2222 public void compareFileVersions(FileItem oldVersion, FileItem newVersion) {
2223 System.out.println("Comparing file versions:");
2224 System.out.println("Old Version: " + oldVersion.getFileName());
2225 System.out.println(oldVersion.getFileContent());
2226 System.out.println("New Version: " + newVersion.getFileName());
2227 System.out.println(newVersion.getFileContent());
2228
2229 // Implement comparison logic here (e.g., using LCS or Diff-Match-Patch)
2230 // For simplicity, we'll assume that the content is plain text and display
differences manually.
2231 }
2232
2233 // Merge changes from two file versions and create a new merged version
2234 public void mergeFileVersions(FileItem oldVersion, FileItem newVersion) {
2235 // Implement merging logic here to combine changes from oldVersion and
newVersion
2236 // into a new merged version.
2237
2238 // For simplicity, we'll assume the merging process is manual and prompt the
user to
2239 // select which changes to keep from each version.
2240 }
2241
2242 // Display file version history for a given file
2243 public void displayFileVersionHistory(String username, String fileName) {
2247 // Display the version history of the file (assuming versions are
stored in a list).
2248 // For simplicity, we'll assume version history is not implemented
in this example.
2249 System.out.println("Version history for file: " + fileName);
2250 System.out.println("Version 1: " + file.getFileContent());
2251 return;
2252 }
2253 }
2254
2255 System.out.println("File not found: " + fileName);
2256 }
2257
2258 // Display category summary for a given user
2259 public void displayCategorySummary(String username) {
2261 Map<String, Integer> categoryCounts = new HashMap<>();
2262
2264 String category = file.getCategory();
2265 categoryCounts.put(category, categoryCounts.getOrDefault(category, 0) + 1
);
2266 }
2267
2268 System.out.println("Category Summary for user: " + username);
2269 for (Map.Entry<String, Integer> entry : categoryCounts.entrySet()) {
2270 System.out.println("Category: " + entry.getKey() + ", Files: " + entry.
getValue());
2271 }
2272 }
2273 }
2274
2275 User.java:
2276
2280
2281 public User(String username, String password) {
2284 }
2285
2288 }
2289
2290 public String getPassword() {
2291 return password;
2292 }
2293 }
2294
2295 Main.java:
2296
2298
2303
2304 while (true) {
2312
2314 case 1:
2321 break;
2322 case 2:
2330 } else {
);
2332 }
2333 break;
2334 case 3:
2338 default:
2340 }
2341 }
2342 }
2343
String username) {
2345 while (true) {
2350 System.out.println("4. Move File to Trash");
2351 System.out.println("5. List Trash");
2352 System.out.println("6. Restore File from Trash");
2353 System.out.println("7. Delete File Permanently");
2354 System.out.println("8. Search Files by Category");
2355 System.out.println("9. Compare File Versions");
2356 System.out.println("10. Merge File Versions");
2357 System.out.println("11. Display File Version History");
2358 System.out.println("12. Display Category Summary");
2363
2365 case 1:
2368 System.out.print("Enter file content: ");
2369 String fileContent = scanner.nextLine();
2370 System.out.print("Enter category: ");
2371 String category = scanner.nextLine();
2372 fileManager.uploadFile(username, fileName, fileContent, category
);
2373 break;
2374 case 2:
2375 fileManager.listUserFiles(username);
2376 break;
2377 case 3:
2380 fileManager.deleteFile(username, fileName);
2381 break;
2382 case 4:
2383 System.out.print("Enter file name to move to trash: ");
2385 fileManager.deleteFile(username, fileName);
2386 break;
2387 case 5:
2388 fileManager.listTrash(username);
2389 break;
2390 case 6:
2391 System.out.print("Enter file name to restore from trash: ");
2393 fileManager.restoreFileFromTrash(username, fileName);
2394 break;
2395 case 7:
2396 System.out.print("Enter file name to delete permanently from
trash: ");
2398 fileManager.deleteFilePermanently(username, fileName);
2399 break;
2400 case 8:
2401 System.out.print("Enter category name to search files: ");
2402 category = scanner.nextLine();
2403 for (FileItem file : fileManager.searchFilesByCategory(username,
category)) {
2404 System.out.println("Name: " + file.getFileName() + ",
Content: " + file.getFileContent());
2405 }
2406 break;
2407 case 9:
2408 System.out.print("Enter old file name: ");
2409 String oldFileName = scanner.nextLine();
2410 System.out.print("Enter new file name: ");
2411 String newFileName = scanner.nextLine();
2412 // Assuming versions are stored as separate FileItem objects in
FileManager,
2413 // fetch the oldVersion and newVersion for comparison
2414 FileItem oldVersion = null;
2415 FileItem newVersion = null;
2416 fileManager.compareFileVersions(oldVersion, newVersion);
2417 break;
2418 case 10:
2419 System.out.print("Enter old file name: ");
2420 oldFileName = scanner.nextLine();
2421 System.out.print("Enter new file name: ");
2422 newFileName = scanner.nextLine();
2423 // Assuming versions are stored as separate FileItem objects in
FileManager,
2424 // fetch the oldVersion and newVersion for merging
2425 oldVersion = null;
2426 newVersion = null;
2427 fileManager.mergeFileVersions(oldVersion, newVersion);
2428 break;
2429 case 11:
2430 System.out.print("Enter file name to display version history: ");
2432 fileManager.displayFileVersionHistory(username, fileName);
2433 break;
2434 case 12:
2435 fileManager.displayCategorySummary(username);
2436 break;
2437 case 13:
2439 return;
2440 default:
2442 }
2443 }
2444 }
2445 }
2446
2447 //N-6.3
2448
2449 /*
2450 Note: The code provided here is an outline of the project
2451 and may require further refinement and implementation of certain details.
2452 This final version includes functionalities for user registration,
2453 login, file upload, list files, file deletion, trash management,
2454 search by category, version comparison, merging, version history display,
2455 and category summary display.
2456
2457 To make the project more complete,
2458 you can implement additional features such as data persistence
2459 (e.g., saving user data and files to files or a database),
2460 improved versioning with proper data structures, and
2461 error handling for various scenarios.
2462 The implementation provided here focuses on core Java concepts,
2463 including OOP principles, exception handling, serialization, file I/O,
2464 generics, collections, packages, abstraction, and interfaces.
2465
2466 It provides a strong foundation for a comprehensive file storage system
application that
2467 can be further expanded and improved based on the student's learning and
interest.
2468
2469 */
2470
2471
2472 /*
2473 Let's add the document sharing functionality,
2474 along with multithreading for improved performance when sharing multiple
documents simultaneously.
2475 */
2476
2477 //N-6.3
2478
2479 FileManager.java (Updated with Document Sharing and Multithreading):
2480
2485
2488
2490
2496 }
2497
2499
2500 public void shareDocuments(String senderUsername, String receiverUsername, List<
2503
2506 return;
2507 }
2508
2509 List<FileItem> senderFiles = userFiles.get(senderUsername);
2510 List<FileItem> documentsToSend = new ArrayList<>();
2511
2515 documentsToSend.add(file);
2516 break;
2517 }
2518 }
2519 }
2520
2521 if (documentsToSend.isEmpty()) {
2522 System.out.println("No matching documents found for sharing.");
2523 return;
2524 }
2525
2526 DocumentSendTask sendTask = new DocumentSendTask(receiver, documentsToSend);
2528 System.out.println("Sharing documents...");
2529 }
2530
2531 private static class DocumentSendTask implements Runnable {
2532 private User receiver;
2533 private List<FileItem> documentsToSend;
2534
2535 public DocumentSendTask(User receiver, List<FileItem> documentsToSend) {
2536 this.receiver = receiver;
2537 this.documentsToSend = documentsToSend;
2538 }
2539
2540 @Override
2542 FileManager receiverFileManager = new FileManager();
2543 for (FileItem document : documentsToSend) {
2544 receiverFileManager.receiveFile(receiver.getUsername(), document);
2545 System.out.println("Document '" + document.getFileName() + "' sent
to " + receiver.getUsername());
2546 }
2547 }
2548 }
2549
2550 public void receiveFile(String receiverUsername, FileItem file) {
2551 List<FileItem> receiverFiles = userFiles.get(receiverUsername);
2552 receiverFiles.add(file);
2553 }
2554
2556 }
2557
2558 /*
2560 we've added the document sharing functionality,
2561 which allows users to share selected documents with other users.
2562 Additionally, we've introduced multithreading in the FileManager class to
2563 improve the efficiency of sending multiple documents to the recipient
simultaneously.
2564
2565 The shareDocuments method initiates the document sharing process by creating a
DocumentSendTask
2566 for the recipient user. The DocumentSendTask is then submitted to the
2567 documentSenderExecutor to run in a separate thread, allowing for concurrent document
sharing.
2568
2569 The recipient user's FileManager handles the reception of documents and stores
2570 them in the appropriate user's file list.
2571 With these additions,
2572 the File Storage System now includes document sharing and multithreading
capabilities,
2573 enhancing its functionality and making it more versatile for users to collaborate
and share files efficiently.
2574
2575 */
2576
2577 /*
2578 Let's create a final level-up version of the File Storage System,
2579 considering all the previous functionalities and your requirements.
2580 We'll also introduce generics for improved code flexibility and reusability.
2581
2582 */
2583
2584 //N-6.4
2585
2586 FileItem.java:
2587
2588 import java.io.Serializable;
2589
2590 public class FileItem<T> implements Serializable {
2592 private T fileContent;
2593 private String category;
2594
2595 public FileItem(String fileName, T fileContent, String category) {
2597 this.fileContent = fileContent;
2598 this.category = category;
2599 }
2600
2601 // Getters and setters (omitted for brevity)
2602 }
2603
2605
2610
2611 public class FileManager<T> {
2612
2614 private Map<String, List<FileItem<T>>> userFiles;
2615 private Map<String, List<FileItem<T>>> trashBin;
2617
2623 }
2624
2629 }
2630
2633 return user != null && user.getPassword().equals(password);
2634 }
2635
2636 public void uploadFile(String username, String fileName, T fileContent, String
category) {
2637 FileItem<T> file = new FileItem<>(fileName, fileContent, category);
2640 }
2641
2643
2644 public void shareDocuments(String senderUsername, String receiverUsername, List<
2647
2650 return;
2651 }
2652
2653 List<FileItem<T>> senderFiles = userFiles.get(senderUsername);
2654 List<FileItem<T>> documentsToSend = new ArrayList<>();
2655
2657 for (FileItem<T> file : senderFiles) {
2659 documentsToSend.add(file);
2660 break;
2661 }
2662 }
2663 }
2664
2665 if (documentsToSend.isEmpty()) {
2666 System.out.println("No matching documents found for sharing.");
2667 return;
2668 }
2669
2670 DocumentSendTask sendTask = new DocumentSendTask(receiver, documentsToSend);
2672 System.out.println("Sharing documents...");
2673 }
2674
2675 private class DocumentSendTask implements Runnable {
2676 private User receiver;
2677 private List<FileItem<T>> documentsToSend;
2678
2679 public DocumentSendTask(User receiver, List<FileItem<T>> documentsToSend) {
2680 this.receiver = receiver;
2681 this.documentsToSend = documentsToSend;
2682 }
2683
2684 @Override
2686 FileManager<T> receiverFileManager = new FileManager<>();
2687 for (FileItem<T> document : documentsToSend) {
2688 receiverFileManager.receiveFile(receiver.getUsername(), document);
2689 System.out.println("Document '" + document.getFileName() + "' sent
to " + receiver.getUsername());
2690 }
2691 }
2692 }
2693
2694 public void receiveFile(String receiverUsername, FileItem<T> file) {
2695 List<FileItem<T>> receiverFiles = userFiles.get(receiverUsername);
2696 receiverFiles.add(file);
2697 }
2698
2700 }
2701 /*
2702 With this final version,
2703 we've incorporated all the previously discussed functionalities,
2704 including file sharing, multithreading, generics, and the other core Java
concepts.
2705 This version provides a comprehensive and feature-rich File Storage System,
2706 which will be suitable for a first-year student to explore and learn more
2707 about various Java concepts and their practical application.
2708
2709
2710 */
2711
2712
2713 /*
2714
2715 1. File Search by Content:
2716 • Implement a method that takes a keyword as input and searches the
content of all files for the keyword.
2717 • Display a list of files that contain the keyword in their content.
2718
2719 2. File Renaming:
2720 • Modify the FileItem class to include a new method for renaming the file.
2721 • Implement a method in the FileManager class that allows users to select
a file and provide a new name for it.
2722
2723 3. File Duplicate Check:
2724 • Before uploading a file, calculate the hash value of its content and
compare it with the hash values of existing files' contents.
2725 • If a match is found, display a message indicating that the file already
exists.
2726
2727 4. Storage Quota Management:
2728 • Add a field to the User class to keep track of the user's total storage
usage.
2729 • Implement checks when uploading files to ensure the user does not exceed
their storage quota.
2730
2731 5. User Activity Logging:
2732 • Implement a logging mechanism that records user activities to a log file
or database.
2733 • Log activities such as login/logout, file uploads, deletions, and
document sharing.
2734
2735 6. Document Expiration:
2736 • Add a field to the FileItem class to store the expiration date of the
document.
2737 • Implement a method that periodically checks for expired documents and
moves them to the trash bin.
2738
2739 7. User Account Deactivation:
2740 • Implement a method that allows users to deactivate their accounts.
2741 • Deactivated accounts should be removed from the active user list but
retain their data.
2742
2743 8. User Profile Management:
2744 • Add fields to the User class to store profile information (e.g., display
name, email, profile picture).
2745 • Implement methods for users to update their profile information.
2746
2747 9. Shared Document Notifications:
2748 • Implement a mechanism to send notifications when a user shares a
document with another user (e.g., through email or in-app notifications).
2749
2750 10. Password Reset Mechanism:
2751 • Implement a method that allows users to request a password reset.
2752 • Send a password reset link to the user's registered email address.
2753
2754
2755 Please note that implementing some of these functionalities might require
2756 additional libraries or third-party services for email notifications, password
reset links,
2757 and logging. The code provided earlier in this conversation can serve as a
2758 starting point for incorporating these new functionalities. It's also essential
to thoroughly
2759 test the implementation to ensure proper functionality and security.
2760
2761 */
2762
2763
2764
2765
2766
2767

Digi

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Digi

Uploaded by

Copyright:

Available Formats

1 //Digilocker notes

You might also like