API tools faq
paste
Advertisement
Guest User

VRUUUUUUM

a guest
Oct 24th, 2018
104
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 63.99 KB | None | 0 0
raw download clone embed print report
  1. import javax.xml.crypto.Data;
  2.         import java.awt.*;
  3.         import java.io.Serializable;
  4.         import java.net.*;
  5.         import java.io.IOException;
  6. import java.sql.Array;
  7. import java.sql.SQLOutput;
  8.         import java.util.ArrayList;
  9.         import java.util.Scanner;
  10.         import java.io.*;
  11.         import static java.lang.Thread.sleep;
  12.  
  13. class User implements Serializable {
  14.     private String username, password, user_type;
  15.  
  16.     public User(String username, String password, String user_type) {
  17.         this.username = username;
  18.         this.password = password;
  19.         this.user_type = user_type;
  20.     }
  21.  
  22.     public String getUsername() {
  23.         return username;
  24.     }
  25.  
  26.     public String getPassword() {
  27.         return password;
  28.     }
  29.  
  30.     public String getUser_type() { return user_type; }
  31.  
  32.     public void setUser_type(String user_type) {
  33.         this.user_type = user_type;
  34.     }
  35. }
  36.  
  37. class Music implements Serializable {
  38.     private String artist, genre, album, name; //Nao sei se fica String album ou se mudo para Album album
  39.     private int duration;
  40.  
  41.     //ArrayList <User> user;
  42.  
  43.     public Music(String artist, String genre, String album, String name, int duration) {
  44.         this.artist = artist;
  45.         this.genre = genre;
  46.         this.album = album;
  47.         this.name = name;
  48.         this.duration = duration;
  49.     }
  50.  
  51.     public String getArtist() {
  52.         return artist;
  53.     }
  54.  
  55.     public String getGenre() {
  56.         return genre;
  57.     }
  58.  
  59.     public String getAlbum_title() {
  60.         return album;
  61.     }
  62.  
  63.     public String getName() {
  64.         return name;
  65.     }
  66.  
  67.     public int getDuration() {
  68.         return duration;
  69.     }
  70.  
  71.     public void setArtist(String artist) {
  72.         this.artist = artist;
  73.     }
  74.  
  75.     public void setGenre(String genre) {
  76.         this.genre = genre;
  77.     }
  78.  
  79.     public void setAlbum(String album) {
  80.         this.album = album;
  81.     }
  82.  
  83.     public void setName(String name) {
  84.         this.name = name;
  85.     }
  86.  
  87.     public void setDuration(int duration) {
  88.         this.duration = duration;
  89.     }
  90. }
  91.  
  92. class Album implements Serializable {
  93.     private String album_name, description;
  94.     private double rating; //rating médio //Nao sei se fica cá ou se o retiro
  95.     private String artist;
  96.     ArrayList <Music> music_list = new ArrayList<>(); //TALVEZ PÔR PRIVATE
  97.     ArrayList <Review> review_list = new ArrayList<>(); //TALVEZ PÔR PRIVATE
  98.  
  99.     public Album(String album_name, String artist, String description, int rating, ArrayList<Music> music_list, ArrayList<Review> review_list) {
  100.         this.album_name = album_name;
  101.         this.description = description;
  102.         this.rating = rating;
  103.         this.artist = artist;
  104.         this.music_list = music_list;
  105.         this.review_list = review_list;
  106.     }
  107.  
  108.     public String getAlbum_name() {
  109.         return album_name;
  110.     }
  111.  
  112.     public String getDescription() {
  113.         return description;
  114.     }
  115.  
  116.     public double getRating() {
  117.         rating = average_rating();
  118.         return rating;
  119.     }
  120.  
  121.     public ArrayList<Music> getMusic_list() {
  122.         return music_list;
  123.     }
  124.  
  125.     public ArrayList<Review> getReview_list() {
  126.         return review_list;
  127.     }
  128.  
  129.     public void setDescription(String description) {
  130.         this.description = description;
  131.     }
  132.  
  133.     public String getArtist() {
  134.         return artist;
  135.     }
  136.  
  137.     public double average_rating (){
  138.         int soma = 0;
  139.         int size = review_list.size();
  140.         double average_rating;
  141.  
  142.         for (Review r: review_list){
  143.             soma += r.getRating();
  144.         }
  145.  
  146.         average_rating = (double) soma / size;
  147.  
  148.         return average_rating;
  149.     }
  150.  
  151.     public void setAlbum_name(String album_name) {
  152.         this.album_name = album_name;
  153.     }
  154.  
  155.     public void setArtist(String artist) {
  156.         this.artist = artist;
  157.     }
  158. }
  159.  
  160. class Review implements Serializable { //AINDA TENHO QUE VER PRECISA DE SERIALIZABLE OU NÃO
  161.     private String text;
  162.     private int rating;
  163.     private String user;
  164.  
  165.     public Review(String text, int rating, String user) {
  166.         this.text = text;
  167.         this.rating = rating;
  168.         this.user = user;
  169.     }
  170.  
  171.     public String getText() {
  172.         return text;
  173.     }
  174.  
  175.     public int getRating() {
  176.         return rating;
  177.     }
  178.  
  179.     public String getUser() {
  180.         return user;
  181.     }
  182. }
  183.  
  184. class Artist implements  Serializable{
  185.  
  186.     private String nome, grupo, genre, biography;
  187.     private String data_nasc; //TALVIZ CRIAR UMA CLASSE DATA
  188.     ArrayList <Music> music_list;
  189.  
  190.     public Artist(String nome, String grupo, String data_nasc, String genre, String biography, ArrayList <Music> music_list) {
  191.         this.nome = nome;
  192.         this.grupo = grupo;
  193.         this.data_nasc = data_nasc;
  194.         this.genre = genre;
  195.         this.biography = biography;
  196.         this.music_list = music_list;
  197.     }
  198.  
  199.     public String getNome() {
  200.         return nome;
  201.     }
  202.  
  203.     public String getGrupo() {
  204.         return grupo;
  205.     }
  206.  
  207.     public String getData_nasc() {
  208.         return data_nasc;
  209.     }
  210.  
  211.     public String getGenre() {
  212.         return genre;
  213.     }
  214.  
  215.     public String getBiography() {
  216.         return biography;
  217.     }
  218.  
  219.     public ArrayList<Music> getMusic_list() {
  220.         return music_list;
  221.     }
  222.  
  223.     public void setNome(String nome) {
  224.         this.nome = nome;
  225.     }
  226.  
  227.     public void setGrupo(String grupo) {
  228.         this.grupo = grupo;
  229.     }
  230.  
  231.     public void setGenre(String genre) {
  232.         this.genre = genre;
  233.     }
  234.  
  235.     public void setBiography(String biography) {
  236.         this.biography = biography;
  237.     }
  238.  
  239.     public void setData_nasc(String data_nasc) {
  240.         this.data_nasc = data_nasc;
  241.     }
  242.  
  243.     public void setMusic_list(ArrayList<Music> music_list) {
  244.         this.music_list = music_list;
  245.     }
  246. }
  247.  
  248.  
  249. class DatabaseConnection {
  250.     //Ver como ir buscar a música a uma diretoria e colocar música nessa diretoria
  251.  
  252.     public DatabaseConnection() {
  253.     }
  254.  
  255.     boolean username_match (String username){
  256.  
  257.         ArrayList <User> users = new ArrayList<>();
  258.  
  259.         //Abrir para a leitura do ficheiro de objetos
  260.         try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("Users_obj.txt"))) {
  261.             users = (ArrayList) oin.readObject();
  262.         } catch (IOException e){
  263.             System.out.println(e.getMessage());
  264.         } catch (ClassNotFoundException e) {
  265.             e.printStackTrace();
  266.         }
  267.  
  268.         for (User u: users){
  269.             if (u.getUsername().equals(username)) {
  270.                 return true;
  271.             }
  272.         }
  273.  
  274.         return false;
  275.     }
  276.  
  277.     boolean password_match (String username, String password){
  278.         //Tenho que procurar por username e depois por password
  279.         //Porque se procuro apenas pela password, pode encontrar a password certa, mas ser de outro utilizador
  280.  
  281.         ArrayList <User> users = new ArrayList<>();
  282.  
  283.         try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("Users_obj.txt"))) {
  284.             users = (ArrayList) oin.readObject();
  285.         } catch (IOException e){
  286.             System.out.println(e.getMessage());
  287.         } catch (ClassNotFoundException e) {
  288.             e.printStackTrace();
  289.         }
  290.  
  291.         for (User u: users) {
  292.             if (u.getUsername().equals(username)) {
  293.                 if (u.getPassword().equals(password)) {
  294.                     return true;
  295.                 }
  296.             }
  297.  
  298.         }
  299.         return false;
  300.     }
  301.  
  302.     void write_user_file(String text, ArrayList <User> users) { //Para escrever no ficheiro de utilizadores
  303.         try {
  304.             ObjectOutputStream oS = new ObjectOutputStream(new FileOutputStream(text));
  305.             oS.writeObject(users);
  306.             oS.close();
  307.  
  308.         } catch (IOException e) {
  309.             System.out.print("ERRO");
  310.             System.out.printf("Ocorreu a exceçao %s ao escrever no ficheiro\n", e);
  311.         }
  312.     }
  313.  
  314.     ArrayList <Album> get_AlbumList (){
  315.         ArrayList <Album> album_list = new ArrayList<>();
  316.  
  317.         try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("AlbumList_obj.txt"))) {
  318.             album_list = (ArrayList) oin.readObject();
  319.         } catch (IOException e){
  320.             System.out.println(e.getMessage());
  321.         } catch (ClassNotFoundException e) {
  322.             e.printStackTrace();
  323.         }
  324.  
  325.         return album_list;
  326.     }
  327.  
  328.     void write_albumlist_file (String text, ArrayList <Album> album_list) { //Para escrever no ficheiro de álbuns
  329.         try {
  330.             ObjectOutputStream oS = new ObjectOutputStream(new FileOutputStream(text));
  331.             oS.writeObject(album_list);
  332.             oS.close();
  333.  
  334.         } catch (IOException e) {
  335.             System.out.print("ERRO");
  336.             System.out.printf("Ocorreu a exceçao %s ao escrever no ficheiro\n", e);
  337.         }
  338.     }
  339.  
  340.     void write_artislist_file (String text, ArrayList <Artist> artist_list) {
  341.  
  342.         try {
  343.             ObjectOutputStream oS = new ObjectOutputStream(new FileOutputStream(text));
  344.             oS.writeObject(artist_list);
  345.             oS.close();
  346.  
  347.         } catch (IOException e) {
  348.             System.out.print("ERRO");
  349.             System.out.printf("Ocorreu a exceçao %s ao escrever no ficheiro\n", e);
  350.         }
  351.     }
  352.  
  353.     void write_musiclist_file (String text, ArrayList <Music> music_list){
  354.         try {
  355.             ObjectOutputStream oS = new ObjectOutputStream(new FileOutputStream(text));
  356.             oS.writeObject(music_list);
  357.             oS.close();
  358.  
  359.         } catch (IOException e) {
  360.             System.out.print("ERRO");
  361.             System.out.printf("Ocorreu a exceçao %s ao escrever no ficheiro\n", e);
  362.         }
  363.  
  364.     }
  365.  
  366.  
  367.     ArrayList <Music> get_MusicList (){
  368.         ArrayList <Music> music_list = new ArrayList<>();
  369.  
  370.         try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("MusicList_obj.txt"))) {
  371.             music_list = (ArrayList) oin.readObject();
  372.         } catch (IOException e){
  373.             System.out.println(e.getMessage());
  374.         } catch (ClassNotFoundException e) {
  375.             e.printStackTrace();
  376.         }
  377.  
  378.         return music_list;
  379.     }
  380.  
  381.     ArrayList <Artist> get_ArtistList (){
  382.         ArrayList <Artist> artist_list = new ArrayList<>();
  383.  
  384.         try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("ArtistList_obj.txt"))) {
  385.             artist_list = (ArrayList) oin.readObject();
  386.         } catch (IOException e){
  387.             System.out.println(e.getMessage());
  388.         } catch (ClassNotFoundException e) {
  389.             e.printStackTrace();
  390.         }
  391.  
  392.         return artist_list;
  393.     }
  394.  
  395.     ArrayList <User> get_UserList (){
  396.         ArrayList <User> user_list = new ArrayList<>();
  397.  
  398.         try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("Users_obj.txt"))) {
  399.             user_list = (ArrayList) oin.readObject();
  400.         } catch (IOException e){
  401.             System.out.println(e.getMessage());
  402.         } catch (ClassNotFoundException e) {
  403.             e.printStackTrace();
  404.         }
  405.  
  406.         return user_list;
  407.     }
  408.  
  409. }
  410.  
  411.  
  412. class MessageParsing {
  413.  
  414.     public String [] MessageParsing (String message){
  415.  
  416.         //Separar por ";" e saber o número de pares
  417.         String [] pares  = message.split(";");
  418.         String  [] campos = new String[pares.length] ;
  419.  
  420.         if (pares.length >= 3){ //NAO SEI SE PRECISO DESTA CONDICAO OU NAO, TENHO QUE TER ATENCAO POR CAUSA DA EXCEPTION
  421.             for (int i = 0; i < pares.length; i++){
  422.                 String [] aux = pares[i].split("\\|");
  423.                 campos[i] = aux[1];
  424.             }
  425.         }
  426.  
  427.         //É melhor imprimir num ciclo que vai ate ao total de elementos do array, caso contrario opde criar exception
  428.         //System.out.println ("Tipo da mensagem: " + campos[0] + " campo2: " + campos[1] + " campo3: " + campos[2]);
  429.  
  430.         return campos;
  431.     }
  432.  
  433. }
  434.  
  435.  
  436. class UDPMulticastProtocol implements Serializable {
  437.  
  438.     private String MULTICAST_ADDRESS = "224.3.2.1";
  439.     private int PORT = 4444; //Porto de envio
  440.     DatabaseConnection data = new DatabaseConnection();
  441.  
  442.     public UDPMulticastProtocol() {
  443.     }
  444.  
  445.     void login (String pack_id, String username, String password, MulticastSocket socket, int server_id){
  446.         System.out.println("O cliente deseja fazer login");
  447.         System.out.println("Username inserido: " + username);
  448.         System.out.println("Password inserida: " + password);
  449.         //Temos que ir à base de dados checkar se o username existe e qual a password associada e se é igual à inserida ou não
  450.  
  451.  
  452.         if (data.username_match(username)){
  453.             if (data.password_match(username, password)){ //SUCESSO
  454.                 String rsp = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|login" + "; status|on; " + "msg|Welcome to DropMusic";
  455.  
  456.                 try{
  457.                     byte[] buffer = rsp.getBytes();
  458.                     DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  459.                     socket.send(packet);
  460.  
  461.                 } catch (IOException e) {
  462.                     e.printStackTrace();
  463.                 }
  464.  
  465.             }
  466.             else { //PASSWORD ERRADA
  467.                 String rsp = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|login" + "; status|failed; " + "msg|Password incorreta";
  468.  
  469.                 try{
  470.                     byte[] buffer = rsp.getBytes();
  471.                     DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  472.                     socket.send(packet);
  473.  
  474.                 } catch (IOException e) {
  475.                     e.printStackTrace();
  476.                 }
  477.             }
  478.         }
  479.  
  480.         else{ //UTILIZADOR NAO EXISTE
  481.             String rsp = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|login" + "; status|failed; " + "msg|Utilizador nao existe";
  482.  
  483.             try{
  484.                 byte[] buffer = rsp.getBytes();
  485.                 InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
  486.                 DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  487.                 socket.send(packet);
  488.  
  489.             } catch (IOException e) {
  490.                 e.printStackTrace();
  491.             }
  492.         }
  493.  
  494.  
  495.     }
  496.  
  497.     void register (String pack_id, String username, String password, MulticastSocket socket, int server_id) throws IOException {
  498.  
  499.         ArrayList <User> users = new ArrayList<>(); //ArrayList que contém todos os utilizadores
  500.         //Abrir para a leitura do ficheiro de objetos
  501.         try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("Users_obj.txt"))) {
  502.             users = (ArrayList) oin.readObject();
  503.         } catch (IOException e){
  504.             System.out.println(e.getMessage());
  505.         } catch (ClassNotFoundException e) {
  506.             e.printStackTrace();
  507.         }
  508.  
  509.         System.out.println("O cliente deseja registar-se");
  510.         System.out.println("Username inserido: " + username);
  511.         System.out.println("Password inserida: " + password);
  512.  
  513.         //Temos que ver se existe o username ou não
  514.         if (!data.username_match(username)) {
  515.  
  516.             //Abrir para escrita no ficheiro de objetos
  517.             if (users.isEmpty()){ //Se der mal, vou ver se o tamanho e zero
  518.                 User u = new User(username, password, "admin");
  519.                 users.add(u);
  520.             }
  521.             else{
  522.                 User u = new User(username, password, "normal");
  523.                 users.add(u);
  524.             }
  525.  
  526.             try {
  527.                 ObjectOutputStream oS = new ObjectOutputStream(new FileOutputStream("Users_obj.txt"));
  528.                 oS.writeObject(users);
  529.                 oS.close();
  530.  
  531.             } catch (IOException e) {
  532.                 System.out.print("ERRO");
  533.                 System.out.printf("Ocorreu a exceçao %s ao escrever no ficheiro\n", e);
  534.             }
  535.  
  536.             String rsp = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|register;" + "; status|successful; " + "msg|Welcome to DropMusic";
  537.             try{
  538.  
  539.                 byte[] buffer = rsp.getBytes();
  540.  
  541.                 InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
  542.                 DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  543.                 socket.send(packet);
  544.  
  545.             } catch (IOException e) {
  546.                 e.printStackTrace();
  547.             }
  548.         }
  549.  
  550.         else {
  551.             String rsp = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|register;" + "; status|unsuccessful; " + "msg|Esse username ja existe";
  552.  
  553.             try{
  554.                 byte[] buffer = rsp.getBytes();
  555.                 //InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
  556.                 DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  557.                 socket.send(packet);
  558.  
  559.             } catch (IOException e) {
  560.                 e.printStackTrace();
  561.             }
  562.         }
  563.  
  564.         //SÓ PARA VER QUEM TENHO REGISTADO
  565.         for (User uss: users){
  566.             System.out.println(uss.getUsername() + " " + uss.getPassword() + " -> " + uss.getUser_type());
  567.         }
  568.  
  569.  
  570.     }
  571.  
  572.     void search_music (String pack_id, String choice, String name, MulticastSocket socket, int server_id){ //FALTA o ALL, COMPLETAR E TESTAR
  573.         System.out.println("O cliente deseja procurar musica");
  574.  
  575.         switch (choice){
  576.             case "all": //Vai procurar por tudo o que os outros "cases" vao procurar //ACHO QUE VOU RETIRAR ISTO
  577.  
  578.                 break;
  579.  
  580.             case "album": //Vai ao ficheiro de albuns e apresenta a lista de musicas desse album
  581.                 ArrayList <Album> album_list = data.get_AlbumList(); //Vai buscar o ficheiro de albuns e põe nesta arraylist
  582.                 //ArrayList <Music> aux = new ArrayList<>(); //ArrayList auxiliar para pôr todos os albuns com o nome "name"
  583.                 String x = "";
  584.                 int item_count = 0;
  585.  
  586.                 for (Album a: album_list){
  587.                     if (a.getAlbum_name().equals(name)){
  588.                         item_count = a.music_list.size();
  589.                         for (int k = 0; k < item_count; k++)
  590.  
  591.                         x += "item_"+k+"_name| " + a.music_list.get(k).getName();
  592.  
  593.                     }
  594.                 }
  595.  
  596.                 //1. ENVIAR RESPOSTA PARA O CLIENTE COM A LISTA DE MÚSICAS
  597.                 String rsp = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|status;" + "; music_search|successful; " + "msg|This is the music list from the searched album" +
  598.                         "item_count| " + item_count + x; //Ver se o item_count é bem apresentado
  599.  
  600.                 try{
  601.                     byte[] buffer = rsp.getBytes();
  602.                     DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  603.                     socket.send(packet);
  604.                 } catch (IOException e) {
  605.                     e.printStackTrace();
  606.                 }
  607.  
  608.  
  609.                 break;
  610.  
  611.             case "music":  //Vai ao ficheiro de musicas e apresenta uma lista de musicas que contenham esse nome
  612.                 ArrayList <Music> music_list = data.get_MusicList();
  613.                 //ArrayList <Music> auxappend = new ArrayList<>();
  614.  
  615.                 String s = "";
  616.                 int item_size = 0;
  617.  
  618.                 for (Music m: music_list){
  619.                     if (m.getName().equals(name)){
  620.                         s += "item_"+item_size+"_name| " + m.getName();
  621.                         item_size++;
  622.  
  623.                     }
  624.                 }
  625.                 //2. ENVIAR RESPOSTA PARA O CLIENTE COM A LISTA DE MÚSICAS
  626.                 String ans = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|status;" + "; music_search|successful; " + "msg|This is the music list you requested" +
  627.                         "item_count| " + item_size + s; //Ver se o item_size é bem apresentado
  628.                 //ENVIAR RESPOSTA PARA O CLIENTE
  629.                 try {
  630.                     byte[] buffer = ans.getBytes();
  631.                     DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT);
  632.                     socket.send(packet);
  633.                 } catch (IOException e) {
  634.                     e.printStackTrace();
  635.                 }
  636.  
  637.                 break;
  638.  
  639.             case "artist": //Vai ao ficheiro de artistas e apresenta as musicas desse artista
  640.  
  641.                 //NOTAAAA: DECIDIR SE CRIO UM FICHEIRO DE ARTISTAS OU SE NÃO É NECESSÁRIO
  642.                 ArrayList <Artist> artist_list = data.get_ArtistList();
  643.  
  644.                 String z = "";
  645.                 int tam = 0;
  646.  
  647.                 for (Artist a: artist_list){
  648.                     if (a.getNome().equals(name)){
  649.                         for (int j = 0; j < a.getMusic_list().size(); j++){
  650.                             tam = a.getMusic_list().size();
  651.                             z += "item_"+ j +"_name| " + a.getMusic_list().get(j).getName();
  652.                         }
  653.                     }
  654.                 }
  655.  
  656.                 //2. ENVIAR RESPOSTA PARA O CLIENTE COM A LISTA DE MÚSICAS
  657.                 String resp = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|status;" + "; music_search|successful; " + "msg|This is the music list you requested" +
  658.                         "item_count| " + tam + z; //Ver se o item_size é bem apresentado
  659.                 //ENVIAR RESPOSTA PARA O CLIENTE
  660.                 try {
  661.                     byte[] buffer = resp.getBytes();
  662.                     DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT);
  663.                     socket.send(packet);
  664.                 } catch (IOException e) {
  665.                     e.printStackTrace();
  666.                 }
  667.  
  668.                 break;
  669.  
  670.             case "genre": //Vai ao ficheiro de musicas e procura no arraylist de musicas pelo parâmetro "genre"
  671.                 ArrayList <Music> music_list1 = data.get_MusicList(); //Vai buscar o ficheiro de albuns e põe nesta arraylist
  672.  
  673.                 String aux = "";
  674.                 int conta = 0;
  675.  
  676.                 for (Music m: music_list1){
  677.                     if (m.getGenre().equals(name)){
  678.                         aux += "item_"+conta +"_name| " + m.getName();
  679.                         conta++;
  680.                     }
  681.                 }
  682.                 //2. ENVIAR RESPOSTA PARA O CLIENTE COM A LISTA DE MÚSICAS
  683.                 String envia = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|status;" + "; music_search|successful; " + "msg|This is the music list you requested" +
  684.                         "item_count| " + conta + aux; //Ver se o conta é bem apresentado
  685.  
  686.                 //ENVIAR RESPOSTA PARA O CLIENTE
  687.                 try {
  688.                     byte[] buffer = envia.getBytes();
  689.                     DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT);
  690.                     socket.send(packet);
  691.                 } catch (IOException e) {
  692.                     e.printStackTrace();
  693.                 }
  694.  
  695.                 break;
  696.  
  697.         }
  698.  
  699.     }
  700.  
  701.     void make_editor (String pack_id, String username, String novo_editor, MulticastSocket socket, int server_id){ //VERIFICAR E TESTAR
  702.         System.out.println("O cliente deseja tornar o utilizador " + novo_editor + " editor");
  703.  
  704.         ArrayList <User> users = new ArrayList<>();
  705.  
  706.         try (ObjectInputStream oin = new ObjectInputStream (new FileInputStream("Users_obj.txt"))) {
  707.             users = (ArrayList) oin.readObject();
  708.         } catch (IOException e){
  709.             System.out.println(e.getMessage());
  710.         } catch (ClassNotFoundException e) {
  711.             e.printStackTrace();
  712.         }
  713.  
  714.         //Verificar se o utilizador que está a querer tornar o outro num editor é também um editor
  715.         if (data.username_match(username)) { //SUCESSO
  716.             for (User u : users) {
  717.                 if (u.getUsername().equals(username)) {
  718.                     if ((u.getUser_type().equals("editor")) || (u.getUser_type().equals("admin"))) {
  719.                         System.out.println("Tem permissao para tornar o utilizador " + novo_editor + " editor");
  720.                         for (User us : users) {
  721.                             if (us.getUsername().equals(novo_editor)) {
  722.                                 us.setUser_type("editor");
  723.                                 data.write_user_file("Users_obj.txt", users);
  724.                                 //ENVIAR RESPOSTA PARA O RMI SERVER
  725.                                 //String rsp = "server_id|" + server_id + "; type|status;" + "; logged|on; " + "msg|Welcome to DropMusic";
  726.                                 String rsp = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|status" + "; make editor|successful; " + "msg|You can edit now";
  727.                                 try {
  728.                                     byte[] buffer = rsp.getBytes();
  729.                                     //InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
  730.                                     DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  731.                                     socket.send(packet);
  732.  
  733.                                 } catch (IOException e) {
  734.                                     e.printStackTrace();
  735.                                 }
  736.                             /*} else { //FALTA PÔR ESTE CHECK A FUNCIONAR
  737.                                 System.out.println("Utilizador nao existe");
  738.                                 //ENVIAR RESPOSTA PARA O RMI SERVER
  739.                             }*/
  740.                             }
  741.                         }
  742.                     }
  743.                 }
  744.             }
  745.  
  746.         } else { //ESSE MANO NAO CONSTA DA BASE DE DADOS
  747.             String rsp = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|status" + "; make editor|unsuccessful; " + "msg|The user you entered is not in our database";
  748.             try {
  749.                 byte[] buffer = rsp.getBytes();
  750.                 //InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
  751.                 DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  752.                 socket.send(packet);
  753.  
  754.             } catch (IOException e) {
  755.                 e.printStackTrace();
  756.             }
  757.         }
  758.  
  759.  
  760.     }
  761.  
  762.     void manage_data (String pack_id, String username, String choice, String search_name, String op_type, String field_type, String name, MulticastSocket socket, int server_id) { //EM FALTA
  763.         System.out.println("O cliente pretende gerir artistas, álbuns e músicas");
  764.  
  765.         //1. Primeiro tenho que ver se o utilizador que quer editar a info é editor
  766.         ArrayList<User> users = data.get_UserList();
  767.  
  768.         ArrayList<Artist> artist_list = data.get_ArtistList();
  769.         ArrayList<Album> album_list = data.get_AlbumList();
  770.         ArrayList<Music> music_list = data.get_MusicList();
  771.  
  772.         if (data.username_match(username)) { //SUCESSO
  773.             for (User u : users) {
  774.                 if (u.getUsername().equals(username)) {
  775.                     if (u.getUser_type().equals("editor")) {
  776.                         System.out.println("Tem permissao para editar");
  777.  
  778.                         switch (choice) {
  779.                             case "artist": /*-------------------------ARTIST--------------------------*/
  780.                                 String artist_name = search_name;
  781.                                 switch (op_type){
  782.                                     case "insert": /*-*************INSERT*****************/
  783.  
  784.                                         String [] artist_details = name.split("-");
  785.                                         String grupo = artist_details[0];
  786.                                         String data_nasc = artist_details[1];
  787.                                         String genre = artist_details[2];
  788.                                         String biography = artist_details[3];
  789.                                         String music_counter = artist_details[4];
  790.  
  791.                                         ArrayList <Music> aux_musiclist = new ArrayList<>();
  792.                                         Artist new_artist;
  793.  
  794.                                         if (Integer.parseInt(music_counter) != 0) {
  795.                                             for (int j = 5; j < artist_details.length; j++) {
  796.                                                 Music m = new Music(null, null, null, artist_details[j], 0);
  797.                                                 aux_musiclist.add(m);
  798.                                             }
  799.                                             new_artist = new Artist(artist_name, grupo, data_nasc, genre, biography, aux_musiclist);
  800.                                         }
  801.                                         else{
  802.                                             new_artist = new Artist(artist_name, grupo, data_nasc, genre, biography, null);
  803.                                         }
  804.                                         artist_list.add(new_artist);
  805.                                         data.write_artislist_file("ArtistList_obj.txt", artist_list);
  806.  
  807.                                         String rsp_client = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|edit info" + "; status|successful; " + "msg|Artist added";
  808.  
  809.                                         try{
  810.                                             byte[] buffer = rsp_client.getBytes();
  811.                                             DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  812.                                             socket.send(packet);
  813.  
  814.                                         } catch (IOException e) {
  815.                                             e.printStackTrace();
  816.                                         }
  817.  
  818.                                         break;
  819.  
  820.                                     case "change": /*-*************CHANGE*****************/
  821.                                         switch (field_type) {
  822.                                             case "name":
  823.                                                 for (Artist a: artist_list){
  824.                                                     if (a.getNome().equals(artist_name)){
  825.                                                         a.setNome(name);
  826.                                                     }
  827.                                                 }
  828.                                                 break;
  829.                                             case "grupo":
  830.                                                 for (Artist a: artist_list){
  831.                                                     if (a.getNome().equals(artist_name)){
  832.                                                         a.setGrupo(name);
  833.                                                     }
  834.                                                 }
  835.                                                 break;
  836.                                             case "genre":
  837.                                                 for (Artist a: artist_list){
  838.                                                     if (a.getNome().equals(artist_name)){
  839.                                                         a.setGenre(name);
  840.                                                     }
  841.                                                 }
  842.                                                 break;
  843.                                             case "biography":
  844.                                                 for (Artist a: artist_list){
  845.                                                     if (a.getNome().equals(artist_name)){
  846.                                                         a.setBiography(name);
  847.                                                     }
  848.                                                 }
  849.                                                 break;
  850.                                             case "data_nasc":
  851.                                                 for (Artist a: artist_list){
  852.                                                     if (a.getNome().equals(artist_name)){
  853.                                                         a.setData_nasc(name);
  854.                                                     }
  855.                                                 }
  856.                                                 break;
  857.                                             case "music list": //-----------------------------NAO FACO PUTO DE IDEIA, TENHO DÚVIDAS
  858.  
  859.                                                 break;
  860.                                         }
  861.  
  862.                                         String r = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|edit info" + "; status|successful; " + "msg|Artist info changed";
  863.  
  864.                                         try{
  865.                                             byte[] buffer = r.getBytes();
  866.                                             DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  867.                                             socket.send(packet);
  868.  
  869.                                         } catch (IOException e) {
  870.                                             e.printStackTrace();
  871.                                         }
  872.                                         break;
  873.  
  874.                                     case "remove": /*-*************REMOVE*****************/
  875.                                         for (Artist a: artist_list){
  876.                                             if(a.getNome().equals(artist_name)){
  877.                                                 artist_list.remove(a);
  878.                                                 data.write_artislist_file("ArtistList_obj.txt", artist_list);
  879.                                             }
  880.                                         }
  881.  
  882.                                         String rr = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|edit info" + "; status|successful; " + "msg|Artist removed";
  883.  
  884.                                         try{
  885.                                             byte[] buffer = rr.getBytes();
  886.                                             DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  887.                                             socket.send(packet);
  888.                                         } catch (IOException e) {
  889.                                             e.printStackTrace();
  890.                                         }
  891.  
  892.                                         break;
  893.                                 }
  894.                                 break;
  895.  
  896.                             case "album": /*-------------------------ALBUM--------------------------*/
  897.                                 String album_title = search_name;
  898.                                 switch (op_type) {
  899.                                     case "insert":
  900.                                         String [] album_details = name.split("-");
  901.                                         String artist = album_details[0];
  902.                                         String description = album_details[1];
  903.                                         String music_counter = album_details[2];
  904.  
  905.                                         ArrayList <Music> aux_music = new ArrayList<>();
  906.                                         Album new_album;
  907.  
  908.                                         if (Integer.parseInt(music_counter) != 0) {
  909.                                             for (int j = 3; j < album_details.length; j++) {
  910.                                                 Music m = new Music(null, null, null, album_details[j], 0);
  911.                                                 aux_music.add(m);
  912.                                             }
  913.                                             new_album = new Album(album_title, artist, description, 0, aux_music, null);
  914.                                         }
  915.                                         else{
  916.                                             new_album = new Album(album_title, artist, description, 0, null, null);
  917.                                         }
  918.                                         album_list.add(new_album);
  919.                                         data.write_albumlist_file("AlbumList_obj.txt", album_list);
  920.  
  921.                                         String rsp_client = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|edit info" + "; status|successful; " + "msg|Album added";
  922.  
  923.                                         try{
  924.                                             byte[] buffer = rsp_client.getBytes();
  925.                                             DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  926.                                             socket.send(packet);
  927.  
  928.                                         } catch (IOException e) {
  929.                                             e.printStackTrace();
  930.                                         }
  931.  
  932.                                         break;
  933.  
  934.                                     case "change":
  935.                                         switch (field_type) {
  936.                                             case "album name":
  937.                                                 for (Album a : album_list) {
  938.                                                     if (a.getAlbum_name().equals(album_title)) {
  939.                                                         a.setAlbum_name(name);
  940.                                                     }
  941.                                                 }
  942.                                                 break;
  943.                                             case "description":
  944.                                                 for (Album a : album_list) {
  945.                                                     if (a.getAlbum_name().equals(album_title)) {
  946.                                                         a.setDescription(name);
  947.                                                     }
  948.                                                 }
  949.                                                 break;
  950.                                             case "artist":
  951.                                                 for (Album a : album_list) {
  952.                                                     if (a.getAlbum_name().equals(album_title)) {
  953.                                                         a.setArtist(name);
  954.                                                     }
  955.                                                 }
  956.                                                 break;
  957.                                             case "review list": //NAO FAZ SENTIDO PORQUE NAO SE VAI MEXER EM ALGO QUE JA ALGUEM ESCREVEU
  958.                                                 //CAGUEI
  959.                                                 break;
  960.                                             case "music list": //DUVIDA //MUDO O QUÊ???????????????????????????
  961.                                                 for (Album a : album_list) {
  962.                                                     if (a.getAlbum_name().equals(album_title)) {
  963.                                                         Music m = new Music(null, null, null, name, 0); //POSSO MUDAR PARA UM CONSTRUTOR APENAS COM O CAMPO NOME
  964.                                                         a.getMusic_list().add(m);
  965.                                                     }
  966.                                                 }
  967.                                                 break;
  968.                                         }
  969.  
  970.                                         break;
  971.                                     case "remove":
  972.                                         for (Album a: album_list){
  973.                                             if (a.getAlbum_name().equals(album_title)){
  974.                                                 album_list.remove(a);
  975.                                                 data.write_albumlist_file("AlbumList_obj.txt", album_list);
  976.                                             }
  977.                                         }
  978.                                         String r = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|edit info" + "; status|successful; " + "msg|Album removed";
  979.  
  980.                                         try{
  981.                                             byte[] buffer = r.getBytes();
  982.                                             DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  983.                                             socket.send(packet);
  984.  
  985.                                         } catch (IOException e) {
  986.                                             e.printStackTrace();
  987.                                         }
  988.  
  989.                                         break;
  990.                                 }
  991.                                 break;
  992.  
  993.                             case "music": /*-------------------------MUSIC--------------------------*/
  994.                                 String music_name = search_name;
  995.                                 switch (op_type) {
  996.                                     case "insert":
  997.                                         String [] music_details = name.split("-");
  998.                                         String artist = music_details[0];
  999.                                         String genre = music_details[1];
  1000.                                         String album = music_details[2];
  1001.                                         String duration = music_details[3];
  1002.  
  1003.                                         Music m = new Music(artist, genre, album, music_name, Integer.parseInt(duration));
  1004.                                         music_list.add(m);
  1005.                                         data.write_musiclist_file("MusicList_obj.txt", music_list);
  1006.  
  1007.                                         String rsp_client = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|edit info" + "; status|successful; " + "msg|Music added";
  1008.  
  1009.                                         try{
  1010.                                             byte[] buffer = rsp_client.getBytes();
  1011.                                             DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  1012.                                             socket.send(packet);
  1013.  
  1014.                                         } catch (IOException e) {
  1015.                                             e.printStackTrace();
  1016.                                         }
  1017.  
  1018.                                         break;
  1019.  
  1020.                                     case "change":
  1021.                                         switch (field_type) {
  1022.                                             case "name":
  1023.                                                 for (Music m : music_list) {
  1024.                                                     if(m.getName().equals(music_name)){
  1025.                                                         m.setName(name);
  1026.                                                     }
  1027.                                                 }
  1028.                                                 break;
  1029.                                             case "genre":
  1030.                                                 for (Music m : music_list) {
  1031.                                                     if(m.getName().equals(music_name)){
  1032.                                                         m.setGenre(name);
  1033.                                                     }
  1034.                                                 }
  1035.                                                 break;
  1036.                                             case "artist":
  1037.                                                 for (Music m : music_list) {
  1038.                                                     if(m.getName().equals(music_name)){
  1039.                                                         m.setArtist(name);
  1040.                                                     }
  1041.                                                 }
  1042.                                                 break;
  1043.                                             case "duration":
  1044.                                                 for (Music m : music_list) {
  1045.                                                     if(m.getName().equals(music_name)){
  1046.                                                         m.setDuration(Integer.parseInt(name));
  1047.                                                     }
  1048.                                                 }
  1049.                                                 break;
  1050.                                             case "album":
  1051.                                                 for (Music m : music_list) {
  1052.                                                     if(m.getName().equals(music_name)){
  1053.                                                         m.setAlbum(name); //VER SE POSSO FAZER ASSIM OU SE TEM QUE SER UM ARRAYLIST ONDE TENHO QUE ADICIONAR O OBJETO
  1054.                                                     }
  1055.                                                 }
  1056.                                                 break;
  1057.                                         }
  1058.  
  1059.                                         String r1 = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|edit info" + "; status|successful; " + "msg|Music info changed";
  1060.  
  1061.                                         try{
  1062.                                             byte[] buffer = r1.getBytes();
  1063.                                             DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  1064.                                             socket.send(packet);
  1065.  
  1066.                                         } catch (IOException e) {
  1067.                                             e.printStackTrace();
  1068.                                         }
  1069.  
  1070.                                         break;
  1071.                                     case "remove":
  1072.                                         for (Music m: music_list){
  1073.                                             if (m.getName().equals(music_name)){
  1074.                                                 music_list.remove(m);
  1075.                                                 data.write_musiclist_file("MusicList_obj.txt", music_list);
  1076.                                             }
  1077.                                         }
  1078.                                         String r = "pack_id|" + pack_id +  "; server_id|" + server_id + "; type|edit info" + "; status|successful; " + "msg|Music removed";
  1079.  
  1080.                                         try{
  1081.                                             byte[] buffer = r.getBytes();
  1082.                                             DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  1083.                                             socket.send(packet);
  1084.  
  1085.                                         } catch (IOException e) {
  1086.                                             e.printStackTrace();
  1087.                                         }
  1088.                                         break;
  1089.                                 }
  1090.                                 break;
  1091.  
  1092.                         }
  1093.                     }
  1094.                 }
  1095.             }
  1096.         }
  1097.     }
  1098.  
  1099.     void search_info (String pack_id, String choice, String msg, MulticastSocket socket, int server_id){ //TESTAR E VER SE AS RESPOSTAS ESTÃO DE ACORDO COM O PROTOCOLO
  1100.         System.out.println("O cliente pretende consultar detalhes sobre álbum e sobre artista");
  1101.  
  1102.         //1. Ver se a choice é album ou artista //E TALVEZ TAMBÉM MÚSICA
  1103.         switch (choice){
  1104.             case "album": //Ir ao ficheiro de albuns e mostrar toda a informacao sobre o album e mandar ao cliente
  1105.                     ArrayList <Album> show_albuns = data.get_AlbumList();
  1106.                     String info = ""; //VER SE ISTO ESTÁ BEM FEITO OU NAO
  1107.                     String lista_music = "Music_list: "; //VER SE ISTO ESTÁ BEM FEITO OU NAO
  1108.                     String lista_review = "Review_list: "; //VER SE ISTO ESTÁ BEM FEITO OU NAO
  1109.  
  1110.                     for (Album a: show_albuns){
  1111.                         if (a.getAlbum_name().equals(msg)){
  1112.                             info += a.getAlbum_name() + a.getArtist() + a.getDescription() + a.getRating();
  1113.                         }
  1114.                     }
  1115.  
  1116.                     for (Album a: show_albuns) {
  1117.                         if (a.getAlbum_name().equals(msg)) {
  1118.                             for (int j = 0; j < a.getMusic_list().size(); j++) {
  1119.                                 lista_music += "item_" + j + "_name" + a.getMusic_list().get(j).getName();
  1120.                             }
  1121.                         }
  1122.                     }
  1123.  
  1124.                     for (Album a: show_albuns) {
  1125.                         if (a.getAlbum_name().equals(msg)) {
  1126.                             for (int k = 0; k < a.getReview_list().size(); k++) {
  1127.                                 lista_review += "item_" + k + "_name" + " user: " + a.getReview_list().get(k).getText() +
  1128.                                         " review: " + a.getReview_list().get(k).getText() + " rating: " + a.getReview_list().get(k).getRating();
  1129.                             }
  1130.                         }
  1131.                     }
  1132.  
  1133.                     String answer = "pack_id|" + pack_id +  "; " + "server_id|" + server_id + "; " + info + lista_music + lista_review; //VER SE OBEDECE AO PROTOCOLO
  1134.                     //ENVIAR RESPOSTA PARA O CLIENTE
  1135.                     try {
  1136.                         byte[] buffer = answer.getBytes();
  1137.                         DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT);
  1138.                         socket.send(packet);
  1139.                     } catch (IOException e) {
  1140.                         e.printStackTrace();
  1141.                     }
  1142.  
  1143.                 break;
  1144.  
  1145.             case "artist": //Ir ao ficheiro de artistas e mostrar toda a informacao sobre o artista e mandar ao cliente
  1146.                     ArrayList <Artist> artist_list = data.get_ArtistList();
  1147.                     String msg_send = "";
  1148.                     String musicas = "";
  1149.  
  1150.                     for (Artist a : artist_list){
  1151.                         if (a.getNome().equals(msg)){
  1152.                             msg_send = a.getGrupo() + a.getData_nasc() + a.getGenre() + a.getBiography();
  1153.                         }
  1154.                     }
  1155.  
  1156.                     for (Artist a: artist_list) {
  1157.                         if (a.getNome().equals(msg)) {
  1158.                             for (int j = 0; j < a.getMusic_list().size(); j++) {
  1159.                                 musicas += "item_" + j + "_name" + a.getMusic_list().get(j).getName();
  1160.                             }
  1161.                         }
  1162.                     }
  1163.  
  1164.                     String env_answer = "pack_id|" + pack_id + "; server_id|" + server_id + "; " + msg_send + musicas;
  1165.                     //ENVIAR RESPOSTA PARA O CLIENTE
  1166.                     try {
  1167.                         byte[] buffer = env_answer.getBytes();
  1168.                         DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT);
  1169.                         socket.send(packet);
  1170.                     } catch (IOException e) {
  1171.                         e.printStackTrace();
  1172.                     }
  1173.  
  1174.                 break;
  1175.  
  1176.             case "music":
  1177.                 ArrayList <Music> music_list = data.get_MusicList();
  1178.                 String resp_aux = "";
  1179.  
  1180.                 for (Music m: music_list){
  1181.                     if (m.getName().equals(msg)){
  1182.                         resp_aux += m.getName() + m.getAlbum_title() + m.getGenre() + m.getArtist() + m.getDuration();
  1183.                     }
  1184.                 }
  1185.  
  1186.                 String resp = "pack_id|" + pack_id + "; server_id|" + server_id + "; " + resp_aux;
  1187.                 //ENVIAR RESPOSTA PARA O CLIENTE
  1188.                 try {
  1189.                     byte[] buffer = resp.getBytes();
  1190.                     DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT);
  1191.                     socket.send(packet);
  1192.                 } catch (IOException e) {
  1193.                     e.printStackTrace();
  1194.                 }
  1195.  
  1196.                 break;
  1197.         }
  1198.     }
  1199.  
  1200.     void album_review (String pack_id, String user, String album_title, String rating, String text, MulticastSocket socket, int server_id){ //TESTAR
  1201.         System.out.println("O cliente " + user + " pretende escrever uma crítica a um álbum");
  1202.  
  1203.         //1. TENHO QUE ABRIR O FICHEIRO E PÔR LÁ A INFORMACAO
  1204.         ArrayList <Album> album_list = data.get_AlbumList();
  1205.         Review r = new Review(text, Integer.parseInt(rating), user);
  1206.  
  1207.         for (Album a: album_list){
  1208.             if (a.getAlbum_name().equals(album_title)){
  1209.                 a.review_list.add(r); //Adicionar a review à lista de reviews
  1210.                 data.write_albumlist_file("AlbumList_obj.txt", album_list);
  1211.  
  1212.                 String rsp = "pack_id|" + pack_id + "; server_id|" + server_id + "; type|review" + "; status|successful; " + "msg|Your review was submitted";
  1213.                 try {
  1214.                     byte[] buffer = rsp.getBytes();
  1215.                     DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT);
  1216.                     socket.send(packet);
  1217.                 } catch (IOException e) {
  1218.                     e.printStackTrace();
  1219.                 }
  1220.             }
  1221.             else { //ÁLBUM NÃO CONSTA DA BASE DE DADOS
  1222.                 String rsp = "pack_id|" + pack_id  + "; server_id|" + server_id + "; type|review" + "; status|unsuccessful; " + "msg|The selected album is not in our database";
  1223.                 try {
  1224.                     byte[] buffer = rsp.getBytes();
  1225.                     DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  1226.                     socket.send(packet);
  1227.                 } catch (IOException e) {
  1228.                     e.printStackTrace();
  1229.                 }
  1230.             }
  1231.         }
  1232.  
  1233.     }
  1234.  
  1235.     void download (String pack_id, String user, String music_name, MulticastSocket socket, int server_id){ //EM FALTA
  1236.         System.out.println("O cliente quer fazer download de uma música");
  1237.  
  1238.         //1. VER SE A MÚSICA EXISTE NA BASE DE DADOS
  1239.  
  1240.         //2. VER SE O UTILIZADOR TEM ACESSO A ESSA MÚSICA OU NÃO
  1241.  
  1242.         //3. SE AMBOS OS REQUISITOS SE CUMPRIREM
  1243.         //3.A. -> IR BUSCAR O PORTO E O ENDEREÇO IP DO SERVIDOR MULTICAST
  1244.  
  1245.         //3.B. -> CRIAR A SOCKET TCP E DEIXAR ABERTO À ESPERA DE UM ACCEPT PARA QUE O DOWNLOAD SEJA INICIADO
  1246.  
  1247.  
  1248.     }
  1249.  
  1250.     void upload (String pack_id, String user, String music_name, MulticastSocket socket, int server_id){ //EM FALTA
  1251.         System.out.println("O cliente quer fazer upload de uma música");
  1252.  
  1253.         //1. VER SE A MÚSICA EXISTE NA BASE DE DADOS (SE JÁ ESTIVER, NÃO DEIXA ADICIONAR DE NOVO)
  1254.  
  1255.         //2. ASSOCIAR O FICHEIRO QUE FOI UPLOADED (Isto é, pôr uma String com a diretoria desse ficheiro associada a um parâmetro da classe Music)
  1256.  
  1257.         //3. SE O REQUISITO 1 SE CUMPRIR
  1258.         //3.A. -> IR BUSCAR O PORTO E O ENDEREÇO IP DO SERVIDOR MULTICAST
  1259.  
  1260.         //3.B. -> CRIAR A SOCKET TCP E DEIXAR ABERTO À ESPERA DE UM ACCEPT PARA QUE O DOWNLOAD SEJA INICIADO
  1261.  
  1262.  
  1263.  
  1264.     }
  1265.  
  1266.     void share_music (String pack_id, String user, String music_name, ArrayList<String>user_list, MulticastSocket socket, int server_id){ //EM FALTA
  1267.         System.out.println("O cliente pretende partilhar música com outros utilizadores");
  1268.  
  1269.         //1. PRIMEIRO QUE TUDO TENHO QUE IR AO ARRAYLIST DE USERS ASSOCIADO A ESTA MUSICA E VER SE O USER TEM ACESSO A ESTA MÚSICA
  1270.         //DÚVIDA: /*UM USER TEM UM ARRAYLIST DE MÚSICAS OU*/ EM PRÍNCIPIO, TER NA CLASSE MUSIC -> UM ARRAYLIST DE USERS
  1271.  
  1272.         //2. SE ESTE REQUISITO SE CUMPRIR, VOU AO ARRAYLIST DE USERS DESSA MÚSICA E ADICIONO OS UTILIZADORES QUE SE ENCONTRAM NA ARRAYLIST
  1273.  
  1274.         //3. POR FIM, ENVIO A MENSAGEM AO CLIENTE A DIZER SE TUDO CORREU BEM OU NÃO
  1275.  
  1276.  
  1277.     }
  1278.  
  1279. }
  1280.  
  1281.  
  1282. class AnswerRequests extends Thread {
  1283.  
  1284.     //private String MULTICAST_ADDRESS = "224.3.2.1";
  1285.     //private int PORT = 4444; //Porto de envio
  1286.     private String message;
  1287.     private String ip;
  1288.     private int porto;
  1289.     private MulticastSocket socket;
  1290.     private int server_id;
  1291.  
  1292.     MessageParsing parsing = new MessageParsing();
  1293.  
  1294.     public AnswerRequests(String message, String ip, int porto, MulticastSocket socket, int server_id) {
  1295.         this.message = message;
  1296.         this.ip = ip;
  1297.         this.porto = porto;
  1298.         this.socket = socket;
  1299.         this.server_id = server_id;
  1300.     }
  1301.  
  1302.     public void run(){
  1303.  
  1304.         UDPMulticastProtocol prot = new UDPMulticastProtocol(); //Ver se é aqui que devo chamar o construtor ou não
  1305.         System.out.println("Mensagem do cliente (IP: " + ip + ";Porto: " + porto + ")" + ": " + message);
  1306.  
  1307.         //Enviar resposta para o cliente
  1308.         //MulticastSocket socket = null;
  1309.  
  1310.         //Parsing da mensagem
  1311.         String [] pares = parsing.MessageParsing(message);
  1312.         String type = pares[2];
  1313.         String pack_id = pares[0];
  1314.  
  1315.         // De acordo com o tipo de argumento no campo "type" vamos definir a operacao pretendida e vai ser invocado o respetivo método
  1316.         //Trata do pedido para depois enviar a resposta para o cliente
  1317.         switch (type) {
  1318.             case "login":
  1319.                 prot.login(pack_id, pares[3], pares[4], socket, server_id);
  1320.                 break;
  1321.  
  1322.             case "search music":
  1323.                 prot.search_music(pack_id, pares[3], pares[4], socket, server_id);
  1324.                 break;
  1325.  
  1326.             case "make editor":
  1327.                 String username = pares[3];
  1328.                 String new_editor = pares[4];
  1329.                 prot.make_editor(pack_id, username, new_editor, socket, server_id); //EDITOR
  1330.                 break;
  1331.  
  1332.             case "register":
  1333.                 try {
  1334.                     prot.register(pack_id, pares[3], pares[4], socket, server_id);
  1335.                 } catch (IOException e) {
  1336.                     e.printStackTrace();
  1337.                 }
  1338.                 break;
  1339.  
  1340.             case "edit info":
  1341.                 String user = pares[3];
  1342.                 String search = pares[4];
  1343.                 String search_name = pares[5];
  1344.                 String op_type = pares[6];
  1345.                 String field_type = pares[7];
  1346.                 String msg = pares[8];
  1347.                 prot.manage_data(pack_id, user, search, search_name, op_type, field_type, msg, socket, server_id); //EDITOR
  1348.                 break;
  1349.  
  1350.             case "search info":
  1351.                 String search_type = pares[3];
  1352.                 String choice_name = pares[4];
  1353.                 prot.search_info(pack_id, search_type,choice_name, socket, server_id);
  1354.                 break;
  1355.  
  1356.             case "review":
  1357.                 String userr = pares[3];
  1358.                 String album_name = pares[4];
  1359.                 String rating = pares[5];
  1360.                 String review_text = pares[6];
  1361.                 prot.album_review(pack_id, userr, album_name, rating, review_text, socket, server_id); //ANY USER
  1362.                 break;
  1363.  
  1364.             case "share music": //DEPOIS
  1365.                 String Uuser = pares[3];
  1366.                 String musicc = pares[4];
  1367.                 //String counter = pares[5]; //ACHO QUE NAO VOU PRECISAR DISTO PARA NADA
  1368.                 ArrayList <String> lista = new ArrayList<>();
  1369.                 for (int j = 6; j < pares.length; j++){
  1370.                     lista.add(pares[j]);
  1371.                 }
  1372.                 prot.share_music(pack_id, Uuser, musicc, lista, socket, server_id);
  1373.                 break;
  1374.  
  1375.             case "download": //DEPOIS
  1376.                 String userrrr = pares[3];
  1377.                 String music = pares[4];
  1378.                 prot.download(pack_id, userrrr, music, socket, server_id);
  1379.                 break;
  1380.  
  1381.             case "upload":  //DEPOIS
  1382.                 String userrr = pares[3];
  1383.                 String music_name = pares[4];
  1384.                 prot.upload(pack_id,userrr, music_name, socket, server_id);
  1385.                 break;
  1386.         }
  1387.  
  1388.     }
  1389.  
  1390. }
  1391.  
  1392. public class MulticastServer extends Thread {
  1393.  
  1394.     private String MULTICAST_ADDRESS = "224.3.2.1";
  1395.     private int PORT = 4321; //Porto de recepção
  1396.     private int BUFFER_SIZE = 4096;
  1397.     private static int SERVER_ID;
  1398.  
  1399.     MessageParsing parsemsg = new MessageParsing();
  1400.  
  1401.     public static void main(String[] args) {
  1402.         SERVER_ID = Integer.parseInt(args[0]); //ID DO SERVIDOR
  1403.         MulticastServer server = new MulticastServer();
  1404.         server.start(); //Ao invocar o start da thread, estamos a chamar o metodo run()
  1405.     }
  1406.  
  1407.     public MulticastServer() {
  1408.         //super ("Server Multicast #" + (long) (Math.random() * 100));
  1409.         super ("Server Multicast #" + SERVER_ID);
  1410.     }
  1411.  
  1412.     public void run(){
  1413.         MulticastSocket socket = null;
  1414.         System.out.println(this.getName() + " running..."); //Vai buscar o que está dentro do método do construtor
  1415.  
  1416.         try {
  1417.             socket = new MulticastSocket(PORT); //cria socket e dá bind
  1418.             InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
  1419.             socket.joinGroup(group); //dá join ao grupo multicast
  1420.  
  1421.  
  1422.             while (true) {
  1423.                 //Recepcao
  1424.                 byte[] inBuffer = new byte[BUFFER_SIZE];
  1425.                 DatagramPacket msgIn = new DatagramPacket(inBuffer, inBuffer.length);
  1426.                 socket.receive(msgIn); //Recebe o datagrama UDP
  1427.  
  1428.                 String clientIP = msgIn.getAddress().getHostAddress(); //Endereço IP do cliente que enviou a mensagem
  1429.                 int clientport = msgIn.getPort(); //Porto do cliente
  1430.  
  1431.                 String message = new String(msgIn.getData(), 0, msgIn.getLength());
  1432.                 String [] fields = parsemsg.MessageParsing(message);
  1433.  
  1434.                 if (Integer.parseInt(fields[1]) == SERVER_ID){
  1435.                     System.out.println("SO VOU RESPONDER EU -> SERVER " + SERVER_ID);
  1436.  
  1437.                     //Vai buscar a informação da mensagem e lança a thread para tratar do pedido
  1438.                     AnswerRequests work = new AnswerRequests(message, clientIP , clientport, socket, SERVER_ID); //Também vou passar a socket por parâmetro
  1439.                     work.start();
  1440.                 }
  1441.                 else{
  1442.                     //Se for um registo, mudança de informação de álbuns ou cenas que têm que ser replicadas
  1443.                     //Ou seja, tem que ir para as 3 bases de dados e vai ser este "else" que vai tratar disso
  1444.                     System.out.println("VOU ESTAR QUIETO -> SERVER " + SERVER_ID);
  1445.  
  1446.                 }
  1447.  
  1448.             }
  1449.  
  1450.         } catch (IOException e) {
  1451.             e.printStackTrace();
  1452.         } finally {
  1453.             socket.close(); //Fechar a socket
  1454.         }
  1455.     }
  1456.  
  1457. }
  1458.  
  1459. /*
  1460. try{
  1461.             socket = new MulticastSocket(); //Não é necessário dar bind porque está apenas a enviar
  1462.             socket.setTimeToLive(1);
  1463.  
  1464.             Scanner keyboardScaner = new Scanner(System.in);
  1465.             while (true){
  1466.                 String keyboard = keyboardScaner.nextLine();
  1467.                 byte[] buffer = keyboard.getBytes();
  1468.  
  1469.                 InetAddress group = InetAddress.getByName(MULTICAST_ADDRESS);
  1470.                 DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName(MULTICAST_ADDRESS), PORT); //mudei aqui
  1471.                 socket.send(packet);
  1472.             }
  1473.         } catch (IOException e) {
  1474.             e.printStackTrace();
  1475.         } finally {
  1476.             socket.close();
  1477.         }
  1478.  */
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!