API tools faq
paste
Guest User

Untitled

a guest
Jan 8th, 2017
58
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 18.09 KB | None | 0 0
raw download clone embed print report
  1. package pl.magazyn.controllers;
  2.  
  3. import pl.magazyn.views.*;
  4. import java.beans.PropertyChangeListener;
  5. import java.util.ArrayList;
  6. import java.io.*;
  7. import java.net.*;
  8.  
  9. /**
  10.  * Main Controller representing logic of the application
  11.  *
  12.  * @author Mateusz Mazurek
  13.  * @version 4.0
  14.  */
  15. public class MainController implements javax.swing.Action  {
  16.    
  17.     /**
  18.      * login servver response enum
  19.      */
  20.     public enum LoginServerRespone {
  21.         NoUser, NotActive, WrongPassword, Done
  22.     }
  23.  
  24.     /**
  25.      * login server response enum
  26.      */
  27.     public enum ReserveServerRespone{
  28.         Done, Unaviable, AccessDenied, HaveTool
  29.     }
  30.    
  31.     /**
  32.      * return tool server response
  33.      */
  34.     public enum ReturnServerResponse{
  35.         Done, NothingToReturn
  36.     }
  37.    
  38.     /**
  39.      * add user server response
  40.      */
  41.     public enum AddUserServerResponse{
  42.         Done, AccessDenied, UserExists
  43.     }
  44.    
  45.     /**
  46.      * name of the currently logged user
  47.      */
  48.     private String currentUser;
  49.  
  50.     /**
  51.      * Main HUI object
  52.      */
  53.     private MainGUI mainGui;
  54.  
  55.     /**
  56.      * Guest flag
  57.      */
  58.     private boolean guestFlag;
  59.  
  60.     /**
  61.      * Login flag
  62.      */
  63.     private boolean loginFlag;
  64.    
  65.     /**
  66.      * register flag
  67.      */
  68.     private boolean registerFlag;
  69.  
  70.     /**
  71.      * User data form
  72.      */
  73.     private UserCreationForm userGui;
  74.    
  75.     /**
  76.      * command/data send to the server
  77.      */
  78.     private String toServer;
  79.    
  80.     /**
  81.      * data received from the server
  82.      */
  83.     private String fromServer;
  84.    
  85.     /**
  86.      * buffer reader
  87.      */
  88.     private BufferedReader inFromUser;
  89.    
  90.     /**
  91.      * socket
  92.      */
  93.     private Socket clientSocket;
  94.    
  95.     /**
  96.      * output stream
  97.      */
  98.     private DataOutputStream outToServer;
  99.    
  100.     /**
  101.      * input from server
  102.      */
  103.     private BufferedReader inFromServer;
  104.    
  105.     /**
  106.      * server IP address
  107.      */
  108.     private String serverIP;
  109.    
  110.     /**
  111.      * server port
  112.      */
  113.     private int port;
  114.    
  115.     private String name;
  116.     private String pass;
  117.  
  118.     /**
  119.      * @param args the command line arguments
  120.      */
  121.     public void startApp(String[] args)  /*throws Exception*/ {
  122.         mainGui = new MainGUI();
  123.         mainGui.setVisible(true);
  124.         userGui = new UserCreationForm();
  125.        
  126.  
  127.         try {
  128.             name= args[0];
  129.             pass=args[1];
  130.         } catch (ArrayIndexOutOfBoundsException exc) {
  131.             userGui.setVisible(true);
  132.             loginFlag = true;
  133.         } catch(Exception exc){
  134.             mainGui.showError("Błąd połączenia:\n " + exc.getMessage());
  135.         }
  136.  
  137.         mainGui.addController(this);
  138.         userGui.addController(this);
  139.  
  140.     }
  141.    
  142.     /**
  143.      * connecting to server
  144.      */
  145.     public void connect() {
  146.         serverIP = "192.168.21.4";
  147.         port = 6789;
  148.         inFromUser = new BufferedReader(new InputStreamReader(System.in));
  149.         try {
  150.             clientSocket = new Socket(serverIP, port);
  151.             outToServer = new DataOutputStream(clientSocket.getOutputStream());
  152.             inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
  153.         } catch (Exception e) {
  154.             mainGui.showError("Błąd połączenia:\n " + e.getMessage());
  155.         }
  156.     }
  157.  
  158.     /**
  159.      * Method allows user to log in
  160.      *
  161.      * @param name user name
  162.      * @param pass user password
  163.      */
  164.     public void logIn(String name, String pass) throws Exception {
  165.         LoginServerRespone response;
  166.         toServer = "login";
  167.         outToServer.writeBytes(toServer+"\n");
  168.         String message = inFromServer.readLine();
  169.                 if(!message.equals(toServer+"OK")){
  170.                     throw new Exception("Nie przyjęto komendy: "+message);
  171.                 }
  172.         outToServer.writeBytes(name+"\n");
  173.         outToServer.writeBytes(pass+"\n");
  174.         response = LoginServerRespone.valueOf(inFromServer.readLine());
  175.         switch(response){
  176.             case NoUser:
  177.                 mainGui.showError("Nie znaleziono użytkownika. Logowanie jako gość.");
  178.             currentUser = "Guest";
  179.             mainGui.showError("Zalogowano jako: " + currentUser);
  180.             guestFlag = true;
  181.                 break;
  182.             case NotActive:
  183.                 mainGui.showError("Użytkownik nieaktywny! Logowanie jako gość.");
  184.             currentUser = "Guest";
  185.             guestFlag = true;
  186.                 break;
  187.             case WrongPassword:
  188.                 mainGui.showError("Nieprawidłowe hasło! Logowanie jako gość.");
  189.             currentUser = "Guest";
  190.             guestFlag = true;
  191.                 break;
  192.             case Done:
  193.                 currentUser = name;
  194.                 guestFlag = false;
  195.                 break;
  196.         }
  197.        
  198.  
  199.         mainGui.setRegisterEnable(guestFlag);
  200.  
  201.         mainGui.setCurrentUser(currentUser);
  202.         mainGui.showError("Zalogowany jako: " + currentUser);
  203.     }
  204.  
  205.     /**
  206.      * manages returning tool
  207.      */
  208.     public void returnTool() throws Exception{
  209.         ReturnServerResponse response;
  210.         response = ReturnServerResponse.valueOf(inFromServer.readLine());
  211.         switch (response) {
  212.             case Done:
  213.                 mainGui.showError("Przedmiot oddany");
  214.                 break;
  215.             case NothingToReturn:
  216.                 mainGui.showError("Nie ma przedmiotów do oddania");
  217.                 break;
  218.  
  219.         }
  220.        
  221.     }
  222.  
  223.     /**
  224.      * Registering new User
  225.      *
  226.      * @param data ArrayList
  227.      */
  228.     public void registerUser(ArrayList<String> data) throws Exception{
  229.         if (data.size() != 2) {
  230.             mainGui.showError("Nieprawidłowa ilość danych użytkownika");
  231.             return;
  232.         }
  233.         if (data.get(0) == null || data.get(1) == null || data.get(0).isEmpty() || data.get(1).isEmpty()) {
  234.             mainGui.showError("Niepoprawne parametry");
  235.             return;
  236.         }
  237.         toServer ="Zarejestruj";
  238.         outToServer.writeBytes(toServer+"\n");
  239.         String message = inFromServer.readLine();
  240.         if(!message.equals(toServer+"OK")){
  241.                     throw new Exception("Nie przyjęto komendy: "+message);
  242.                 }
  243.         outToServer.writeBytes(data.get(0)+"\n");
  244.         outToServer.writeBytes(data.get(1)+"\n");
  245.        
  246.         AddUserServerResponse response = AddUserServerResponse.valueOf("Done");
  247.        
  248.         switch(response){
  249.             case Done:
  250.                 mainGui.showError("Użytkownik zarejestrowany. Oczekiwanie na akceptacje administratora.");
  251.                 break;
  252.             case AccessDenied:
  253.                 mainGui.showError("Odmowa dostępu");
  254.                 break;
  255.             case UserExists:
  256.                 mainGui.showError("Podany użytkownik już istnieje");
  257.                 break;
  258.         }
  259.        
  260.     }
  261.  
  262.     /**
  263.      * Method for interface compatibilities only (not provide to occur)
  264.      *
  265.      * @param string
  266.      * @return Object
  267.      */
  268.     @Override
  269.     public Object getValue(String string) {
  270.         throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
  271.     }
  272.  
  273.     /**
  274.      * Method for interface compatibilities only (not provide to occur)
  275.      *
  276.      * @param string String
  277.      * @param o Object
  278.      */
  279.     @Override
  280.     public void putValue(String string, Object o) {
  281.         throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
  282.     }
  283.  
  284.     /**
  285.      * Method for interface compatibilities only (not provide to occur)
  286.      *
  287.      * @param bln boolean
  288.      */
  289.     @Override
  290.     public void setEnabled(boolean bln) {
  291.         throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
  292.     }
  293.  
  294.     /**
  295.      * Method for interface compatibilities only (not provide to occur)
  296.      *
  297.      * @return boolean
  298.      */
  299.     @Override
  300.     public boolean isEnabled() {
  301.         throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
  302.     }
  303.  
  304.     /**
  305.      * Method for interface compatibilities only (not provide to occur)
  306.      *
  307.      * @param pl PropertyChangeListener
  308.      */
  309.     @Override
  310.     public void addPropertyChangeListener(PropertyChangeListener pl) {
  311.         throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
  312.     }
  313.  
  314.     /**
  315.      * Method for interface compatibilities only (not provide to occur)
  316.      *
  317.      * @param pl PropertyChangeListener
  318.      */
  319.     @Override
  320.     public void removePropertyChangeListener(PropertyChangeListener pl) {
  321.         throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
  322.     }
  323.  
  324.     /**
  325.      * Main event listener
  326.      *
  327.      * @param e java.awt.event.ActionEvent
  328.      */
  329.     @Override
  330.     public void actionPerformed(java.awt.event.ActionEvent e) {
  331.         String message;
  332.         String action = e.getActionCommand();
  333.         toServer = action;
  334.         switch (action) {
  335.             case "Odśwież":
  336.                 try {
  337.                 outToServer.writeBytes(toServer+"\n");
  338.                 message = inFromServer.readLine();
  339.                 if(!message.equals(toServer+"OK")){
  340.                     throw new Exception("Nie przyjęto komendy: "+message);
  341.                 }
  342.                 }
  343.                 catch (Exception exc){
  344.                     mainGui.showError("Błąd połączenia:\n " + exc.getMessage());
  345.                 }
  346.                 mainGui.setModelTools(getToolsDataForGUI());
  347.                 mainGui.setModelUsers(getUserDataForGUI());
  348.                 break;
  349.             case "Wypożycz":
  350.                 try {
  351.                 outToServer.writeBytes(toServer+"\n");
  352.                 message = inFromServer.readLine();
  353.                 if(!message.equals(toServer+"OK")){
  354.                     throw new Exception("Nie przyjęto komendy: "+message);
  355.                 }
  356.                 reserveEvent();
  357.                 }
  358.                 catch (Exception exc){
  359.                     mainGui.showError("Błąd połączenia:\n " + exc.getMessage());
  360.                 }
  361.                 break;
  362.             case "Zwróć":
  363.                 try {
  364.                 outToServer.writeBytes(toServer+"\n");
  365.                 message = inFromServer.readLine();
  366.                 if(!message.equals(toServer+"OK")){
  367.                     throw new Exception("Nie przyjęto komendy: "+message);
  368.                 }
  369.                 returnTool();
  370.                 }
  371.                 catch (Exception exc){
  372.                     mainGui.showError("Błąd połączenia:\n " + exc.getMessage());
  373.                 }
  374.                
  375.                
  376.                 break;
  377.             case "Wyloguj i wyjdź":
  378.                 try {
  379.                 outToServer.writeBytes(toServer+"\n");
  380.                 message = inFromServer.readLine();
  381.                 if(!message.equals(toServer+"OK")){
  382.                     throw new Exception("Nie przyjęto komendy: "+message);
  383.                 }
  384.                 clientSocket.close();
  385.                 }
  386.                 catch (Exception exc){
  387.                     mainGui.showError("Błąd połączenia:\n " + exc.getMessage());
  388.                 }
  389.                
  390.                 System.exit(0);
  391.                 break;
  392.             case "Dodaj":
  393.                 userGui.setVisible(true);
  394.                 break;
  395.             case "Potwierdz":
  396.                 try {
  397.                 addUserEvent();
  398.                 }
  399.                 catch (Exception exc){
  400.                     mainGui.showError("Błąd połączenia:\n " + exc.getMessage());
  401.                 }
  402.                
  403.                 break;
  404.             case "Zarejestruj":
  405.                 registerFlag = true;
  406.                 userGui.setVisible(true);
  407.                 break;
  408.             case "Aktywuj":
  409.                 try {
  410.                 outToServer.writeBytes(toServer+"\n");
  411.                 message = inFromServer.readLine();
  412.                 if(!message.equals(toServer+"OK")){
  413.                     throw new Exception("Nie przyjęto komendy: "+message);
  414.                 }
  415.                
  416.                 activateEvent();
  417.                 }
  418.                 catch (Exception exc){
  419.                     mainGui.showError("Błąd połączenia:\n " + exc.getMessage());
  420.                 }
  421.                
  422.                 break;
  423.             case "Usuń":
  424.                 try {
  425.                 outToServer.writeBytes(toServer+"\n");
  426.                 message = inFromServer.readLine();
  427.                 if(!message.equals(toServer+"OK")){
  428.                     throw new Exception("Nie przyjęto komendy: "+message);
  429.                 }
  430.                 deleteEvent();
  431.                 }
  432.                 catch (Exception exc){
  433.                     mainGui.showError("Błąd połączenia:\n " + exc.getMessage());
  434.                 }
  435.                
  436.                 break;
  437.                 case "Połącz":
  438.                     connect();
  439.  
  440.         }
  441.  
  442.     } //actionPerformed()
  443.  
  444.     /**
  445.      * reserve tool request
  446.      * @throws Exception
  447.      */
  448.     public void reserveEvent() throws Exception{
  449.         Integer selected;
  450.  
  451.         selected = mainGui.getSelectedTool();
  452.         if (selected != -1) {
  453.             outToServer.writeChar(selected);
  454.         }
  455.         ReserveServerRespone response = ReserveServerRespone.valueOf(inFromServer.readLine());
  456.         switch(response){
  457.             case Done:
  458.                 mainGui.showError("Wypożyczono.");
  459.                 break;
  460.             case HaveTool:
  461.                 mainGui.showError("Masz już narzędzie");
  462.                 break;
  463.             case Unaviable:
  464.                 mainGui.showError("Narzędzie niedostępne");
  465.                 break;
  466.             case AccessDenied:
  467.                 mainGui.showError("Odmowa dostępu!");
  468.                 break;
  469.         }
  470.     }
  471.  
  472.     /**
  473.      * add user event logic
  474.      */
  475.     public void addUserEvent() throws Exception{
  476.         if (loginFlag) {
  477.             loginFlag = false;
  478.             logIn(userGui.getUserData().get(0), userGui.getUserData().get(1));
  479.         }
  480.         if (registerFlag) {
  481.             registerFlag =false;
  482.         registerUser(userGui.getUserData());
  483.         }
  484.         userGui.setVisible(false);
  485.         if (guestFlag) {
  486.            
  487.             mainGui.setRegisterEnable(guestFlag);
  488.             guestFlag = false;
  489.         }
  490.     }
  491.  
  492.     /**
  493.      * Activate event logic
  494.      */
  495.     public void activateEvent() throws Exception{
  496.         Integer selected;
  497.         selected = mainGui.getSelectedUser();
  498.         if (selected != -1) {
  499.             outToServer.writeChar(selected);
  500.             String message=inFromServer.readLine();
  501.             switch(message){
  502.                 case "Done":
  503.                     mainGui.showError("Aktywowano");
  504.                     break;
  505.                 case "AccessDenied":
  506.                     mainGui.showError("Odmowa dostępu!");
  507.                     break;
  508.             }
  509.         }
  510.     }
  511.  
  512.     /**
  513.      * Delete event logic
  514.      */
  515.     public void deleteEvent()throws Exception{
  516.         Integer selected;
  517.  
  518.         selected = mainGui.getSelectedUser();
  519.         if (selected != -1) {
  520.             outToServer.writeChar(selected);
  521.             String message=inFromServer.readLine();
  522.             switch(message){
  523.                 case "Done":
  524.                     mainGui.showError("Usunięto");
  525.                     break;
  526.                 case "AccessDenied":
  527.                     mainGui.showError("Odmowa dostępu!");
  528.                     break;
  529.             }
  530.            
  531.         }
  532.     }
  533.  
  534.     /**
  535.      * returns tools data prepared for GUI
  536.      *
  537.      * @return ArrayList
  538.      */
  539.     public ArrayList<ArrayList<String>> getToolsDataForGUI() {
  540.         ArrayList<ArrayList<String>> data = new ArrayList<>();
  541.         for (Integer i = 0;; i++) {
  542.             try{
  543.             fromServer = inFromServer.readLine();
  544.             }
  545.             catch(Exception e){
  546.                 mainGui.showError("Błąd połączenia:\n " + e.getMessage());
  547.             }
  548.             if(fromServer.equals("END")){
  549.                 break;
  550.             }
  551.            
  552.             ArrayList<String> rowData = new ArrayList<>();
  553.             rowData.add(i.toString());
  554.             rowData.add(fromServer);
  555.             try{
  556.             fromServer = inFromServer.readLine();
  557.             rowData.add(fromServer);
  558.             fromServer = inFromServer.readLine();
  559.             rowData.add(fromServer);
  560.             }
  561.             catch(Exception e){
  562.                 mainGui.showError("Błąd połączenia:\n " + e.getMessage());
  563.             }
  564.            
  565.             data.add(rowData);
  566.  
  567.         }
  568.         return data;
  569.     }
  570.  
  571.     /**
  572.      * returns tools data prepared for GUI
  573.      *
  574.      * @return ArrayList
  575.      */
  576.     public ArrayList<ArrayList<String>> getUserDataForGUI() {
  577.         ArrayList<ArrayList<String>> data = new ArrayList<>();
  578.         for (Integer i = 0;; i++) {
  579.             try{
  580.             fromServer = inFromServer.readLine();
  581.             }
  582.             catch(Exception e){
  583.                 mainGui.showError("Błąd połączenia:\n " + e.getMessage());
  584.             }
  585.             if(fromServer.equals("END")){
  586.                 break;
  587.             }
  588.            
  589.             ArrayList<String> rowData = new ArrayList<>();
  590.             rowData.add(i.toString());
  591.             rowData.add(fromServer);
  592.             try{
  593.             fromServer = inFromServer.readLine();
  594.             rowData.add(fromServer);
  595.             fromServer = inFromServer.readLine();
  596.             rowData.add(fromServer);
  597.             fromServer = inFromServer.readLine();
  598.             rowData.add(fromServer);
  599.             }
  600.             catch(Exception e){
  601.                 mainGui.showError("Błąd połączenia:\n " + e.getMessage());
  602.             }
  603.            
  604.             data.add(rowData);
  605.  
  606.         }
  607.         return data;
  608.     }
  609. }
Add Comment
Please, Sign In to add comment
Public Pastes
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!