Entrega do TP

Main.java

@@ -1,13 +1,18 @@
 import filesys.IFileSystem;
+import filesys.Usuario;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Scanner;
 import java.io.FileNotFoundException;
 
 import exception.PermissaoException;
 import exception.CaminhoJaExistenteException;
 import exception.CaminhoNaoEncontradoException;
 
+
 import filesys.FileSystem;
+import filesys.Dir;
 
 // MENU INTERATIVO PARA O SISTEMA DE ARQUIVOS
 // SINTA-SE LIVRE PARA ALTERAR A CLASSE MAIN
@@ -29,6 +34,9 @@ public class Main {
     // Usuário que está executando o programa
     private static String user;
 
+    // Lista de usuários
+    private static List<Usuario> usuarios = new ArrayList<>();
+
     // O sistema de arquivos é inteiramente virtual, ou seja, será reiniciado a cada execução do programa.
     // Logo, não é necessário salvar os arquivos em disco. O sistema será uma simulação em memória.
     public static void main(String[] args) {
@@ -68,7 +76,8 @@ public static void main(String[] args) {
                         */
                         System.out.println(userListed + " " + dir + " " + dirPermission); // Somente imprime o usuário, diretório e permissão
 
-
+                        // Adicionar usuário à lista
+                        usuarios.add(new Usuario(userListed, dir, dirPermission));
                     } else {
                         System.out.println("Formato ruim no arquivo de usuários. Linha: " + line);
                     }
@@ -80,19 +89,28 @@ public static void main(String[] args) {
 
             return;
         }
-
+
+        /* REMOVER ISSO PQ NÃO PRECISA
+        System.out.println("Usuários carregados:");
+        for (Usuario user : usuarios) {
+            System.out.println(user);
+        }
+        */
+
         // Finalmente cria o Sistema de Arquivos
         // Lista de usuários é imutável durante a execução do programa
         // Obs: Como passar a lista de usuários para o FileSystem?
-        fileSystem = new FileSystem(/*usuários?*/);
+        fileSystem = new FileSystem(usuarios);
 
         // // DESCOMENTE O BLOCO ABAIXO PARA CRIAR O DIRETÓRIO RAIZ ANTES DE RODAR O MENU
-        // // Cria o diretório raiz do sistema. Root sempre tem permissão total "rwx"
-        // try {
-        //     fileSystem.mkdir(ROOT_DIR, ROOT_USER);
-        // } catch (CaminhoJaExistenteException | PermissaoException e) {
-        //     System.out.println(e.getMessage());
-        // }
+        // Cria o diretório raiz do sistema. Root sempre tem permissão total "rwx"
+        /*
+        try {
+            fileSystem.mkdir(ROOT_DIR, ROOT_USER);
+        } catch (CaminhoJaExistenteException | PermissaoException e) {
+            System.out.println(e.getMessage());
+        }
+        */
 
         // Menu interativo.
         menu();
@@ -153,7 +171,7 @@ public static void menu() {
                     default:
                         System.out.println("Comando inválido!");
                 } 
-            } catch (CaminhoNaoEncontradoException | CaminhoJaExistenteException | PermissaoException e) {
+            } catch (CaminhoNaoEncontradoException | CaminhoJaExistenteException | PermissaoException | IllegalArgumentException e) {
                 System.out.println("Erro: " + e.getMessage());
             }
 
@@ -185,13 +203,15 @@ public static void mkdir() throws CaminhoJaExistenteException, PermissaoExceptio
     public static void rm() throws CaminhoNaoEncontradoException, PermissaoException {
         System.out.println("Insira o caminho do diretório a ser removido:");
         String caminho = scanner.nextLine();
+
         System.out.println("Remover recursivamente? (true/false):");
         boolean recursivo = Boolean.parseBoolean(scanner.nextLine());
 
         fileSystem.rm(caminho, user, recursivo);
     }
 
-    public static void touch() throws CaminhoJaExistenteException, PermissaoException {
+
+    public static void touch() throws CaminhoJaExistenteException, PermissaoException, CaminhoNaoEncontradoException {
         System.out.println("Insira o caminho do arquivo a ser criado:");
         String caminho = scanner.nextLine();
 
@@ -210,12 +230,32 @@ public static void write() throws CaminhoNaoEncontradoException, PermissaoExcept
         fileSystem.write(caminho, user, anexar, buffer);
     }
 
+    // Read foi modificado
     public static void read() throws CaminhoNaoEncontradoException, PermissaoException {
         System.out.println("Insira o caminho do arquivo a ser lido:");
         String caminho = scanner.nextLine();
         byte[] buffer = new byte[READ_BUFFER_SIZE]; // Exemplo de tamanho de buffer por load/leitura . O que acontece se o Buffer for menor que o conteúdo a ser lido?     
-
-        fileSystem.read(caminho, user, buffer); // Lógica para ler arquivos maiores que o buffer deve ser implementada. 
+
+        int offset = 0; // Offset para leitura
+        int offsetAntes;
+        int leitura;
+
+        System.out.println("Lendo arquivo: " + caminho + "\n");
+
+        do {
+            offsetAntes = offset; // Salva o offset antes da leitura
+            offset += fileSystem.read(caminho, user, buffer, offset); // Lê o arquivo no caminho especificado
+            leitura = offset - offsetAntes; // Calcula a quantidade de bytes lidos nesta iteração
+
+            if (leitura > 0) {
+                System.out.write(buffer, 0, leitura); // Escreve os bytes lidos no console
+            } else {
+                break; // Se não houver mais bytes para ler, sai do loop
+            }
+        } while (leitura > 0); // Garante que o offset seja não negativo
+
+        System.out.flush(); // Garante que todos os bytes sejam escritos no console
+        System.out.println("\n\nLeitura concluída.");
     }
 
     public static void mv() throws CaminhoNaoEncontradoException, PermissaoException {
@@ -228,9 +268,9 @@ public static void mv() throws CaminhoNaoEncontradoException, PermissaoException
     }
 
     public static void ls() throws CaminhoNaoEncontradoException, PermissaoException {
-        System.out.println("Insira o caminho do diretório a ser listado:");
+        System.out.print("Insira o caminho do diretório a ser listado: ");
         String caminho = scanner.nextLine();
-        System.out.println("Listar recursivamente? (true/false):");
+        System.out.print("Listar recursivamente? (true/false): ");
         boolean recursivo = Boolean.parseBoolean(scanner.nextLine());
 
         fileSystem.ls(caminho, user, recursivo);

filesys/BlocoDeDados.java

@@ -0,0 +1,29 @@
+package filesys;
+
+public class BlocoDeDados {
+    private byte[] dados; // Dados do bloco
+
+    // Construtores
+    public BlocoDeDados() {
+        this.dados = new byte[File.TAMANHO_BYTES_BLOCO]; // Inicializa o bloco com o tamanho especificado
+    }
+
+    public BlocoDeDados(byte[] dados) {
+        setDados(dados);
+    }
+
+
+    // Dados
+    public byte[] getDados() {
+        return dados;
+    }
+
+    public void setDados(byte[] dados) {
+        if (dados.length <= File.TAMANHO_BYTES_BLOCO) {
+            this.dados = new byte[dados.length];
+            System.arraycopy(dados, 0, this.dados, 0, dados.length); // Copia os novos dados para o bloco
+        } else {
+            throw new IllegalArgumentException("Dados excedem o tamanho do bloco.");
+        }
+    }
+}

filesys/Dir.java

@@ -0,0 +1,214 @@
+package filesys;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Dir {
+    // Atributos
+    private String nome;
+    private String dono;
+    private String permissoes;
+
+    // Relacionamentos
+    protected Dir pai;
+    protected Map<String, Dir> filhos;
+    private Map<String, String> permissoesUsuarios;
+
+    // Construtor
+    public Dir(String nome, String dono, String permissoes) {
+        this.nome = nome;
+        this.dono = dono;
+        this.permissoes = permissoes;
+
+        this.pai = null; // Inicialmente, o diretório não tem pai
+        this.filhos = new HashMap<>();
+        this.permissoesUsuarios = new HashMap<>();
+
+        // Define as permissões iniciais para o dono do diretório
+        this.permissoesUsuarios.put(dono, "rwx"); // O dono tem permissão total
+    }
+
+    // Nome
+    public String getNome() {
+        return nome;
+    }
+
+    public void setNome(String nome) {
+        this.nome = nome;
+    }
+
+
+    // Dono
+    public String getDono() {
+        return dono;
+    }
+
+    public void setDono(String dono) {
+        this.dono = dono;
+    }
+
+
+    // Permissões
+    public String getPermissoes() {
+        return permissoes;
+    }
+
+    public void setPermissoes(String permissoes) {
+        this.permissoes = permissoes;
+    }
+
+
+    // Pai
+    public Dir getPai() {
+        return pai;
+    }
+
+    public void setPai(Dir pai) {
+        this.pai = pai;
+    }
+
+
+    // Filhos
+    public Map<String, Dir> getFilhos() {
+        return filhos;
+    }
+
+    public Dir getFilho(String nome) {
+        return filhos.get(nome);
+    }
+
+    public void setFilhos(Map<String, Dir> filhos) {
+        this.filhos = filhos;
+        for (Dir filho : filhos.values()) {
+            filho.setPai(this); // Define o pai de cada filho
+        }
+    }
+
+    public void addFilho(Dir filho) {
+        filhos.put(filho.getNome(), filho);
+        filho.setPai(this); // Define o pai do filho
+    }
+
+    public void removeFilho(String nome) {
+        filhos.remove(nome);
+    }
+
+
+    // Permissões dos usuários
+    public Map<String, String> getPermissoesUsuarios() {
+        return permissoesUsuarios;
+    }
+
+    public String getPermissoesUsuario(String usuario) {
+        if ("root".equals(usuario)) return "rwx"; // O usuário root sempre tem permissão total
+
+        // Verifica se o usuário é nulo ou vazio
+        if (usuario == null || usuario.isEmpty()) {
+            throw new IllegalArgumentException("Usuário não pode ser nulo ou vazio");
+        }
+
+        // Verifica se o usuário tem permissões definidas
+        if (!permissoesUsuarios.containsKey(usuario)) {
+            throw new IllegalArgumentException("Usuário não encontrado: " + usuario);
+        }
+
+        if (dono.equals(usuario)) return permissoes; // O dono do diretório tem as permissões do diretório
+
+        return permissoesUsuarios.getOrDefault(usuario, "---"); // Retorna as permissões do usuário ou um padrão se não tiver
+    }
+
+    public void setPermissoesUsuario(String usuario, String permissoes) {
+        if (permissoes == null || permissoes.length() != 3) {
+            throw new IllegalArgumentException("As permissões precisam ter 3 caracteres");
+        }
+
+        this.permissoesUsuarios.put(usuario, permissoes);
+    }
+
+
+    // Verifica se o usuário tem permissão para acessar o diretório
+    public boolean temPerm(String usuario, String permissao) {
+        // Verifica se o usuário é nulo ou vazio
+        if (usuario == null || usuario.isEmpty()) {
+            throw new IllegalArgumentException("Usuário não pode ser nulo ou vazio");
+        }
+
+        if ("root".equals(usuario)) {
+            return true; // O dono do diretório sempre tem permissão total
+        }
+
+        if (usuario.equals(dono)) {
+            return true; // O dono do diretório sempre tem permissão total
+        }
+
+        // Verifica se a permissão é nula ou vazia
+        if (permissao == null || permissao.isEmpty()) {
+            throw new IllegalArgumentException("Permissão não pode ser nula ou vazia");
+        }
+
+        // Verifica se o usuário tem permissões definidas
+        if (!permissoesUsuarios.containsKey(usuario)) {
+            throw new IllegalArgumentException("Usuário não encontrado nas permissões: " + usuario);
+        }
+
+        String permissoesUsuario = getPermissoesUsuario(usuario);
+
+        // Verifica se o usuário tem a permissão solicitada
+        if (permissoesUsuario.contains(permissao)) {
+            return true; // O usuário tem a permissão solicitada
+        }
+
+        // Se não tiver a permissão solicitada, verifica permissões do diretório pai
+        if (pai != null) {
+            return pai.temPerm(usuario, permissao); // Verifica no diretório pai
+        }
+
+        // Se não, o usuário não tem permissão
+        return false;
+    }
+
+
+    // É um arquivo?
+    public boolean isArquivo() {
+        return false; // Esta classe representa um diretório, não um arquivo
+    }
+
+    public String getCaminhoCompleto(){
+        if(this.getPai() == null){
+            return "/" + this.getNome();
+        }
+        else{
+            String caminhoPai = this.getPai().getCaminhoCompleto();
+            if(caminhoPai.endsWith("/")){
+                return caminhoPai + this.getNome();
+            } else {
+                return caminhoPai + "/" + this.getNome();
+            }
+        }
+    }
+
+
+    public boolean temSubdiretorios() {
+    for (Dir filho : getFilhos().values()) {
+        if (!filho.isArquivo()) {
+            return true;
+        }
+    }
+    return false;
+}
+
+
+    // Transformando em string
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+
+        sb.append("  Diretório: ").append(nome).append("\n")
+        .append("    - Dono: ").append(dono).append("\n")
+        .append("    - Permissões: ").append(permissoes).append("\n")
+        .append("    - Pai: ").append(pai != null ? pai.getNome() : "Nenhum").append("\n")
+        .append("    - Filhos: ").append(getFilhos().isEmpty() ? "Nenhum" : getFilhos().keySet()).append("\n")
+        .append("    - Permissões dos usuários: ").append(permissoesUsuarios).append("\n");
+        return sb.toString();
+    }
+}