API tools faq
paste
Advertisement
Guest User

AAAAAAAAAAAAAAAAAAAAAAAAAAAHHHAAA

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