Merge branch 'rebaseServerTestingForMerge' into 'main'

Server receiving for reviews and users completed. Events receiving is blank....

See merge request !25

App/ServerF/.idea/.gitignore

+# Default ignored files
+/shelf/
+/workspace.xml

App/ServerF/.idea/misc.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
\ No newline at end of file

App/ServerF/.idea/modules.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/ServerF.iml" filepath="$PROJECT_DIR$/ServerF.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file

App/ServerF/.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+  </component>
+</project>
\ No newline at end of file

App/ServerF/src/AndroidConnectionPrototypes/Review.java

+package AndroidConnectionPrototypes;
+
+public class Review {
+}

App/ServerF/src/AndroidConnectionPrototypes/SendReviewToServer.java

+package AndroidConnectionPrototypes;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+public class SendReviewToServer implements Runnable {
+    int portNum;
+    String nameOfServer;
+    Review review;
+    public SendReviewToServer(String serverName, int portNumber, Review newReview){
+        portNum = portNumber;
+        nameOfServer = serverName;
+        review = newReview;
+    }
+
+
+    public void run() {
+        //let's connect to the server and create stream to the server
+        //if we cannot find the server we exit(1)
+        //if we cannot connect to the server we exit(2)
+        try (Socket kkSocket = new Socket(nameOfServer, portNum);
+             ObjectOutputStream sendToServer = new ObjectOutputStream(kkSocket.getOutputStream());) {
+            //all we want to do is send the user to the review
+            sendToServer.writeObject(review);
+
+        } catch (UnknownHostException e) {
+            System.out.println("Server is not known to us");
+            System.exit(1);
+        } catch (IOException e) {
+            System.out.println("Failure of connect to host server");
+            System.exit(2);
+        }
+
+
+    }
+}
+

App/ServerF/src/AndroidConnectionPrototypes/SendUserToServer.java

+package AndroidConnectionPrototypes;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+public class SendUserToServer implements Runnable {
+    ServerUser user;
+    int portNum;
+    String nameOfServer;
+
+    public void SentToServer(String serverName, int accessPort, ServerUser newUser){
+        portNum = accessPort;
+        nameOfServer = serverName;
+        user = newUser;
+    }
+
+    @Override
+    public void run() {
+        //let's connect to the server and create stream to the server
+        //if we cannot find the server we exit(1)
+        //if we cannot connect to the server we exit(2)
+        try (Socket kkSocket = new Socket(nameOfServer, portNum);
+             ObjectOutputStream sendToServer = new ObjectOutputStream(kkSocket.getOutputStream());) {
+            //all we want to do is send the user to the server
+            sendToServer.writeObject(user);
+
+        } catch (UnknownHostException e) {
+            System.out.println("Server is not known to us");
+            System.exit(1);
+        } catch (IOException e) {
+            System.out.println("Failure of connect to host server");
+            System.exit(2);
+        }
+
+
+    }
+}
+

App/ServerF/src/AndroidConnectionPrototypes/ServerUser.java

+package AndroidConnectionPrototypes;
+
+public class ServerUser {
+}

App/ServerF/src/AndroidConnectionPrototypes/sendEventToServer.java

+package AndroidConnectionPrototypes;
+
+public class sendEventToServer {
+}

App/ServerF/src/Event.java

+
+
+import javafx.scene.image.Image;
+
+import java.text.DateFormat;
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+public class Event implements java.io.Serializable{
+
+    private String name;
+    private GregorianCalendar startDate;
+    private GregorianCalendar  endDate;
+    private String location;
+    public String description;
+    private String[] links;
+    private String[] tags;
+    private Image pictures;
+    private String id;
+    private Double rating;
+    private String host;
+    private ServerUser creator;
+
+
+    public Event(){
+
+    }
+
+
+
+    /***
+     * Constructor with all the info
+     * @param sDate start date
+     * @param eDate end date
+     * @param loc location
+     * @param eventDes event description
+     * @param lks links
+     * @param t tags
+     * @param pics pictures
+     */
+    public Event(String n, GregorianCalendar  sDate, GregorianCalendar  eDate, String loc, String eventDes, String[] lks, String[] t, Image pics, String s){
+        name = n;
+        startDate = sDate;
+        endDate = eDate;
+        location = loc;
+        description = eventDes;
+        links = lks;
+        pictures = pics;
+        tags = t;
+        id = someHashGenerator();
+        host = s;
+
+        //TODO Refactor
+        double temp = Math.random()*5;
+        this.rating = Math.round(temp*10.0)/10.0;
+    }
+
+
+
+    /***
+     * Update all the info at once
+     * @param sDate start date
+     * @param eDate end date
+     * @param loc location
+     * @param eventDes event description
+     * @param lks links
+     * @param t tags
+     * @param pics pictures
+     */
+    public void changeSetting(GregorianCalendar  sDate, GregorianCalendar  eDate, String loc, String eventDes, String[] lks, String[] t, Image pics, String s){
+        startDate = sDate;
+        endDate = eDate;
+        location = loc;
+        description = eventDes;
+        links = lks;
+        pictures = pics;
+        tags = t;
+        id = someHashGenerator();
+        host = s;
+
+    }
+
+    public void editEvent(){
+        //TODO
+    }
+
+    public void addPictures(){
+        //TODO
+    }
+
+    public void deletePicture(){
+        //TODO
+    }
+
+    public String[] getTags(){
+        return tags;
+    }
+
+    public String getLocation(){
+        return location;
+    }
+
+    public Image getImages() {
+        return pictures;
+    }
+
+    /***
+     * Function to fill the description in the cards
+     * @return String with hosts, date and address
+     */
+    public String getSummary() {
+        String summary = "By " + host+ "\n";
+        DateFormat df = DateFormat.getDateInstance();
+        String start = df.format(startDate);
+        if (endDate!=null){
+            String end = df.format(endDate);
+            summary += start + " to " + end + "\n";
+        } else {
+            summary += start + "\n";
+        }
+        summary += location;
+        return summary;
+    }
+
+    public String getName(){ return name; }
+
+    /**
+     * This is generates an id number but needs to be reworked
+     * @return int representation of a timestamp
+     */
+    public String someHashGenerator(){
+        return String.valueOf(new Date().getTime());
+    }
+
+    public String getId(){ return id; }
+
+    public Double getRating() { return this.rating; }
+
+    public String[] getLinks(){ return this.links; }
+
+    public String getHost(){ return this.host; }
+
+    public String getStartDate(){
+        DateFormat df = DateFormat.getDateInstance();
+        return df.format(startDate);
+    }
+
+    public String getEndDate(){
+        DateFormat df = DateFormat.getDateInstance();
+        return df.format(endDate);
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+}

App/ServerF/src/EventRecieveThread.java

+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+public class EventRecieveThread implements Runnable{
+    Model usingModel;
+    EventRecieveThread(Model newModel){
+        usingModel = newModel;
+    }
+    @Override
+    public void run() {
+        int portNumber = 8002;
+        while (true) {
+            try(ServerSocket userServer = new ServerSocket(portNumber);
+                Socket clientSocket = userServer.accept();
+                BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))
+            ) {
+                System.out.println("got connection to add Event");
+
+            } catch (IOException e) {
+                continue;
+            }
+        }
+    }
+}

App/ServerF/src/Main.java

+import java.net.Inet4Address;
+import java.net.UnknownHostException;
+
+public class Main {
+    static String address;
+    static Inet4Address localAd;
+
+    public static void main(String[] args) throws UnknownHostException {
+        System.out.println("Hello world!");
+        //ip address changes as you most around
+        //this will tell you what update your address to
+        address = Inet4Address.getLocalHost().getHostAddress();
+        System.out.println(address);
+
+        //tell everyone about eachother
+        Model model = new Model();
+        UserReThread userReceiving = new UserReThread(model);
+        EventRecieveThread eventReceiving = new EventRecieveThread(model);
+        ReviewRecieveThread reviewReceiving = new ReviewRecieveThread(model);
+
+        //turn them into threads
+        Thread userReceivingThread = new Thread(userReceiving);
+        Thread eventReceivingThread = new Thread(eventReceiving);
+        Thread reviewReceivingThread = new Thread(reviewReceiving);
+
+        //start these threads
+        userReceivingThread.start();
+        eventReceivingThread.start();
+        reviewReceivingThread.start();
+    }
+}
\ No newline at end of file

App/ServerF/src/Model.java

+import java.util.ArrayList;
+import java.util.List;
+
+public class Model {
+    private static List<ServerUser> users;
+    private static List<Review> reviews;
+    private static List<Event> events;
+
+    public Model(){
+        users = new ArrayList<>();
+        reviews = new ArrayList<>();
+        events = new ArrayList<>();
+    }
+    public void addUser(ServerUser newUser) {
+        users.add(newUser);
+        System.out.println("added user");
+    }
+
+    public void addReview(Review newReview){
+        reviews.add(newReview);
+        System.out.println("added review");
+    }
+    public void addEvent(Event newEvent){
+        events.add(newEvent);
+        System.out.println("added event");
+    }
+    public boolean usersContains(String user,String password){
+        for (ServerUser u : users){
+            if (u.isMatch(user,password)){
+                return true;
+            }
+        }
+        return false;
+    }
+}

App/ServerF/src/Review.java

+public class Review implements java.io.Serializable{
+    private String comment, name, restEventDesignation,eventType;
+    private Integer rating;
+
+    /**
+     * Review object structure
+     *
+     * @param comment A review comment
+     * @param rating A rating
+     */
+
+    public Review( String comment, String name, String restEventDesignation, Integer rating, String restOrEvent){
+        this.name = name;
+        this.restEventDesignation = restEventDesignation;
+        this.comment = comment;
+        this.rating = rating;
+        this.eventType = restOrEvent;
+    }
+
+    public double getRating() {
+        return rating;
+    }
+
+    public String getComment() {
+        return comment;
+    }
+
+    public void setComment(String setComment) {
+        this.comment = setComment;
+    }
+
+    public void changeComment(String newComment){
+        this.comment = newComment;
+    }
+}

App/ServerF/src/ReviewRecieveThread.java

+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+public class ReviewRecieveThread implements Runnable{
+    Model usingModel;
+
+    public ReviewRecieveThread(Model newModel){
+        usingModel = newModel;
+    }
+
+    @Override
+    public void run() {
+        //ServerUser addUser;
+        //Review newReview;
+        String user, pass, eventType, eventName, rating, review;
+        int portNumber = 8001;
+
+        while(true) {
+            try (ServerSocket userServer = new ServerSocket(portNumber);
+                 Socket clientSocket = userServer.accept();
+                 BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))
+            ) {
+                System.out.println("got connection to add review");
+                user = in.readLine();
+                pass = in.readLine();
+                eventType = in.readLine();
+                eventName = in.readLine();
+                rating = in.readLine();
+                review = in.readLine();
+                //Someone may have creating a user profile and not connected
+                //to the server, so let's check. If this was the case we will
+                //add them as a user
+                if (!usingModel.usersContains(user,pass)){
+                    usingModel.addUser(new ServerUser(user,pass));
+                }
+                usingModel.addReview(new Review(review,user,eventName,Integer.getInteger(rating),eventType));
+
+            } catch (IOException e) {
+                continue;
+            }
+        }
+    }
+}
+

App/ServerF/src/ServerUser.java

+public class ServerUser implements java.io.Serializable {
+    private String name,address,password;
+
+    public ServerUser(String newName, String uPass) {
+        name = newName;
+        password = uPass;
+        //was unable to pull address from android device
+        address = null;
+    }
+
+    @Override
+    public String toString() {
+        return super.toString();
+    }
+
+    public boolean isMatch(String user,String pass){
+        return (user.equalsIgnoreCase(this.name)) && (pass.equals(password));
+    }
+}

App/ServerF/src/UserReThread.java

+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+public class UserReThread implements Runnable{
+    Model usingModel;
+
+    UserReThread(Model newModel){
+        usingModel = newModel;
+    }
+
+    @Override
+    public void run() {
+        ServerUser newUser;
+        String user, pass;
+
+        int portNumber = 8000;
+        System.out.println("Thread user is running and listening at port: "+portNumber);
+        while (true) {
+            try(ServerSocket userServer = new ServerSocket(portNumber);
+                Socket clientSocket = userServer.accept();
+                BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))
+            ) {
+                System.out.println("got connection to add user");
+                user = in.readLine();
+                pass = in.readLine();
+                usingModel.addUser(new ServerUser(user,pass));
+
+            } catch (IOException e) {
+                continue;
+            }
+        }
+    }
+}

App/event36/app/src/main/java/com/example/event36/AndroidIp.java

+package com.example.event36;
+
+
+import android.net.wifi.WifiManager;
+
+import androidx.appcompat.app.AppCompatActivity;
+
+import java.net.UnknownHostException;
+
+
+public class AndroidIp extends AppCompatActivity {
+//    private Integer ipAd;
+//    private WifiManager thing = (WifiManager) this.getApplicationContext().getSystemService(WIFI_SERVICE);
+//
+//    public AndroidIp() throws UnknownHostException {
+//        ipAd = thing.getConnectionInfo().getIpAddress();
+//    }
+//    public String getIpAd() {return ipAd.toString();}
+}
\ No newline at end of file

App/event36/app/src/main/java/com/example/event36/BackgroudTask.java

+package com.example.event36;
+
+import android.net.wifi.WifiEnterpriseConfig;
+import android.net.wifi.WifiManager;
+import android.os.AsyncTask;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.io.PrintWriter;
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+class BackgroudTask extends AsyncTask<String,Void,Void> {
+    String serverName ="172.16.1.79";
+    int portNumber = 8000;
+    @Override
+    protected Void doInBackground(String... voids) {
+        try {
+            String userName = voids[0];
+            String deviceName = Inet4Address.getLocalHost().getHostAddress();
+            String hostNawm = Inet4Address.getLocalHost().getHostName();
+            Socket kkSocket = new Socket(serverName, portNumber);
+
+            PrintWriter writer = new PrintWriter(kkSocket.getOutputStream());
+
+            assert deviceName != null;
+            writer.println(userName);
+            writer.println(deviceName);
+            writer.println(hostNawm);
+
+            writer.flush();
+            writer.close();
+            kkSocket.close();
+
+        } catch (UnknownHostException e) {
+            System.out.println("Failed locate local device");
+        } catch (IOException e) {
+            System.out.println("failed to send to server");
+        }
+        return null;
+    }
+
+
+
+
+
+}

App/event36/app/src/main/java/com/example/event36/MainActivity.java

@@ -8,6 +8,7 @@ import androidx.activity.result.contract.ActivityResultContracts;
 import androidx.appcompat.app.AppCompatActivity;
 
 import android.content.Intent;
+import android.net.wifi.WifiManager;
 import android.graphics.drawable.Drawable;
 import android.icu.util.GregorianCalendar;
 import android.os.Bundle;