├── .idea
    ├── .gitignore
    ├── kotlinc.xml
    ├── vcs.xml
    ├── modules.xml
    ├── misc.xml
    └── libraries
    │   └── KotlinJavaRuntime.xml
├── out
    └── production
    │   └── untitled
    │       ├── Player.class
    │       ├── demo.class
    │       ├── Playground.class
    │       ├── Registration.class
    │       └── PlaygroundOwner.class
├── untitled.iml
├── LICENSE.md
├── src
    ├── Player.java
    ├── PlaygroundOwner.java
    ├── Playground.java
    ├── Registration.java
    └── demo.java
└── README.md


/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 | 


--------------------------------------------------------------------------------
/out/production/untitled/Player.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KhaledAshrafH/GoFo-System/HEAD/out/production/untitled/Player.class


--------------------------------------------------------------------------------
/out/production/untitled/demo.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KhaledAshrafH/GoFo-System/HEAD/out/production/untitled/demo.class


--------------------------------------------------------------------------------
/out/production/untitled/Playground.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KhaledAshrafH/GoFo-System/HEAD/out/production/untitled/Playground.class


--------------------------------------------------------------------------------
/out/production/untitled/Registration.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KhaledAshrafH/GoFo-System/HEAD/out/production/untitled/Registration.class


--------------------------------------------------------------------------------
/out/production/untitled/PlaygroundOwner.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KhaledAshrafH/GoFo-System/HEAD/out/production/untitled/PlaygroundOwner.class


--------------------------------------------------------------------------------
/.idea/kotlinc.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="Kotlin2JvmCompilerArguments">
4 |     <option name="jvmTarget" value="1.8" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="VcsDirectoryMappings">
4 |     <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="ProjectModuleManager">
4 |     <modules>
5 |       <module fileurl="file://$PROJECT_DIR$/untitled.iml" filepath="$PROJECT_DIR$/untitled.iml" />
6 |     </modules>
7 |   </component>
8 | </project>


--------------------------------------------------------------------------------
/untitled.iml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <module type="JAVA_MODULE" version="4">
 3 |   <component name="NewModuleRootManager" inherit-compiler-output="true">
 4 |     <exclude-output />
 5 |     <content url="file://$MODULE_DIR$">
 6 |       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
 7 |     </content>
 8 |     <orderEntry type="inheritedJdk" />
 9 |     <orderEntry type="sourceFolder" forTests="false" />
10 |     <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
11 |   </component>
12 | </module>


--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project version="4">
 3 |   <component name="JavadocGenerationManager">
 4 |     <option name="OUTPUT_DIRECTORY" value="$PROJECT_DIR$/JavaDoc" />
 5 |     <option name="OPTION_DOCUMENT_TAG_USE" value="true" />
 6 |     <option name="OPTION_DOCUMENT_TAG_AUTHOR" value="true" />
 7 |     <option name="OPTION_DOCUMENT_TAG_VERSION" value="true" />
 8 |   </component>
 9 |   <component name="ProjectRootManager" version="2" languageLevel="JDK_15" default="true" project-jdk-name="15" project-jdk-type="JavaSDK">
10 |     <output url="file://$PROJECT_DIR$/out" />
11 |   </component>
12 | </project>


--------------------------------------------------------------------------------
/.idea/libraries/KotlinJavaRuntime.xml:
--------------------------------------------------------------------------------
 1 | <component name="libraryTable">
 2 |   <library name="KotlinJavaRuntime">
 3 |     <CLASSES>
 4 |       <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib.jar!/" />
 5 |       <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-reflect.jar!/" />
 6 |       <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-test.jar!/" />
 7 |     </CLASSES>
 8 |     <JAVADOC />
 9 |     <SOURCES>
10 |       <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-sources.jar!/" />
11 |       <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-reflect-sources.jar!/" />
12 |       <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-test-sources.jar!/" />
13 |     </SOURCES>
14 |   </library>
15 | </component>


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Khaled Ashraf Hanafy
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/Player.java:
--------------------------------------------------------------------------------
 1 | import java.util.Scanner;
 2 | /**
 3 |  * @since 12/6/2021
 4 |  * @version 1.0
 5 |  * @author Shimaa Reda Saeed
 6 |  * @author Khaled Ashraf Hanafy
 7 |  * @author Ahmed Sayed Hassan
 8 |  * */
 9 | public class Player {
10 |     /**
11 |      * String namePlayground
12 |      * */
13 |     protected String namePlayground;
14 | 
15 |     Scanner input = new Scanner(System.in);
16 |     int start , end , index = -1;
17 |     /**
18 |      * @param playground
19 |      * Booking playground
20 |      * */
21 |     public void Book( Playground playground)
22 |     {
23 |         if(playground.playgrounds.isEmpty())//if ArrayList to store playgrounds is Empty
24 |         {
25 |             System.out.println("Not Available Playgrounds");
26 |         }
27 |         else
28 |         {
29 |             playground.displayPlaygrounds();//Display information playgrounds in System
30 |             System.out.print("Choose NamePlayground : ");
31 |             namePlayground = input.next();
32 |             index = playground.SearchName(namePlayground);//Return index of position playground
33 |             if(index != -1)//if Name found
34 |             {
35 |                 System.out.println(playground.playgrounds.get(index));//get Index
36 |                 //Book Range
37 |                 System.out.print("Enter Start Time : ");
38 |                 start = input.nextInt();
39 |                 System.out.print("Enter End Time : ");
40 |                 end = input.nextInt();
41 |                 playground.Range(start,end,playground.playgrounds.get(index));
42 |             }
43 |             else
44 |             {
45 |                 System.out.println("This playground Not found");
46 |             }
47 |         }
48 |     }
49 | }


--------------------------------------------------------------------------------
/src/PlaygroundOwner.java:
--------------------------------------------------------------------------------
 1 | import java.util.ArrayList;
 2 | import java.util.Scanner;
 3 | /**
 4 |  * @since 12/6/2021
 5 |  * @version 1.0
 6 |  * @author Shimaa Reda Saeed
 7 |  * @author Khaled Ashraf Hanafy
 8 |  * @author Ahmed Sayed Hassan
 9 |  * */
10 | public class PlaygroundOwner {
11 |     Scanner input=new Scanner(System.in);
12 | 
13 |     ArrayList<Playground> playgrounds = new ArrayList<>();//ArrayList to store playgrounds
14 | 
15 |     /**
16 |      *Display Playgrounds In the System
17 |      * */
18 |     public void displayPlaygrounds()//Display Playgrounds In the System
19 |     {
20 |         if(playgrounds.isEmpty())//if ArrayList to store playgrounds is Empty
21 |         {
22 |          System.out.println("Not Found Playground");
23 |         }
24 |         else
25 |         {
26 |             for (int i=0;i<playgrounds.size();i++)//print Playground name, PlaygroundOwner name and Price
27 |             {
28 |                 System.out.println("Playground Name : "+playgrounds.get(i).namePlayground);
29 |                 System.out.println("PlaygroundOwner Name : "+playgrounds.get(i).namePlaygroundOwner);
30 |                 System.out.println("Price : "+playgrounds.get(i).price+"\n");
31 |             }
32 |         }
33 |     }
34 |     /**
35 |     * @param playground
36 |      * Add new Playground
37 |     * */
38 |     public void AddPlayground(Playground playground)
39 |     {
40 |         playgrounds.add(playground);
41 |     }
42 | 
43 |     int arr[] = new int[13];//To store Book Time
44 |     int Available = 0;
45 | 
46 |     /**
47 |      * @param start
48 |      * Start Time
49 |      * @param end
50 |      * end Time
51 |      * */
52 |     public void Range(int start,int end)//Range of time
53 |     {
54 |         if(Available == 0)
55 |         {
56 |             insert();
57 |             Available++;
58 |         }
59 |         for(int i=start;i<=end;i++)
60 |         {
61 |             if(arr[i] == 0 )//Already Book
62 |             {
63 |                 System.out.println("Time Not Available\n");
64 |                 break;
65 |             }
66 |             else
67 |             {
68 |                 System.out.println("Time Is Available and you Booked\n");
69 |                 for(int j=start;j<end;j++)
70 |                 {
71 |                     arr[j] = 0;
72 |                 }
73 |                 break;
74 |             }
75 |         }
76 |     }
77 | 
78 |     /**
79 |      * Insert 12 hours For Time
80 |      * */
81 |     public void insert()//Insert 12 hours For Time
82 |     {
83 |         for (int i=1;i<=12;i++)
84 |         {
85 |             arr[i]=i;
86 |         }
87 |     }
88 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Football Playground Booking System
 2 | 
 3 | This project is a booking system for football playgrounds. It serves the players and playground owners as well as an administrator who oversees the overall operations of the system. The project is developed as part of a software engineering course.
 4 | 
 5 | ## Features
 6 | 
 7 | - Users can register themselves on the system and create a profile with their name, ID, password, email, phone and default location.
 8 | - Users can see the playgrounds near to them or in a specific area or all of them.
 9 | - Playground owners can register their playgrounds and add their name, location, size, available hours, price per hour and cancellation period. They can also set and change the hours available for booking for their playgrounds, view their bookings and check the money in their eWallet.
10 | - Players can display the playgrounds near to them or in a specific location on specific dates. They can filter them by the hours and date they select. They can book a time slot of 1 or more hours if available and not booked. They can also cancel a booking if within the cancellation period. They can pay for the bookings from their eWallet to the eWallet of the owner. They can also send invitations to their team members via email. To make this step easy, they can create their favorite team and store their names and emails.
11 | - An administrator can approve or reject the registration requests of playground owners. He can also delete or suspend a playground or activate it again. He can monitor the overall operations of the system and ensure that no fraud takes place.
12 | - The system uses an external eWallet service to allow users to add money to their eWallets and transfer money to other eWallets.
13 | 
14 | ## Installation
15 | 
16 | To install this project, you need to have Java 11 or higher installed on your machine.
17 | 
18 | 1. Clone this repository to your local machine using `git clone https://github.com/KhaledAshrafH/GoFo-System.git`
19 | 2. Open the project folder in your preferred IDE (such as Eclipse or IntelliJ IDEA).
20 | 3. Compile the `Demo.java` file as a Java application.
21 | 
22 | ## Usage
23 | 
24 | To use this project, you need to interact with the console interface that provides menus and prompts for different actions.
25 | 
26 | 1. Run the `Demo.java` file as a Java application.
27 | 2. You will see the main menu of the system where you can choose to sign up or log in as a user, a playground owner or an administrator.
28 | 3. Follow the instructions on each menu to perform different actions such as creating a profile, registering a playground, displaying playgrounds, booking a time slot, sending invitations, etc.
29 | 
30 | ## License
31 | 
32 | This project is licensed under the MIT License - see the LICENSE file for details.
33 | 
34 | ## Contributors
35 | 
36 | This project is developed by:
37 | 
38 | - [Khaled Ashraf](https://github.com/KhaledAshrafH)
39 | - [Ahmed Sayed](https://github.com/AhmedSayed117)
40 | - [Shaimaa Reda](https://github.com/Shimaa-reda)
41 | 
42 | If you have any questions or suggestions, please feel free to contact us.
43 | 


--------------------------------------------------------------------------------
/src/Playground.java:
--------------------------------------------------------------------------------
  1 | import java.util.ArrayList;
  2 | /**
  3 |  * @since 12/6/2021
  4 |  * @version 1.0
  5 |  * @author Shimaa Reda Saeed
  6 |  * @author Khaled Ashraf Hanafy
  7 |  * @author Ahmed Sayed Hassan
  8 |  * */
  9 | class Playground {
 10 |     protected String namePlayground;
 11 |     protected String namePlaygroundOwner;
 12 |     protected String location;
 13 |     protected String Payment;
 14 |     protected int Start=0,end=0;
 15 |     protected double price;
 16 | 
 17 |     int indexPlayground = 0;
 18 |     ArrayList <Playground> playgrounds = new ArrayList<>();//ArrayList to store playgrounds
 19 | 
 20 |     /**
 21 |      * @param playground
 22 |      * */
 23 |     public void AddPlayground(Playground playground)//Add playground in System
 24 |     {
 25 |         playgrounds.add(indexPlayground++,playground);
 26 |     }
 27 | 
 28 |     /**
 29 |      * Display Playgrounds In the System
 30 |      * */
 31 |     public void displayPlaygrounds()//Display Playgrounds In the System
 32 |     {
 33 |         if(playgrounds.isEmpty())//if ArrayList to store playgrounds is Empty
 34 |         {
 35 |             System.out.println("Not Found Playground");
 36 |         }
 37 |         else
 38 |         {
 39 |             for (int i=0;i<playgrounds.size();i++)//print Playground name, PlaygroundOwner name and Price
 40 |             {
 41 |                 System.out.println("namePlayground: "+playgrounds.get(i).namePlayground);
 42 |                 System.out.println("namePlaygroundOwner: "+playgrounds.get(i).namePlaygroundOwner);
 43 |                 System.out.println("Price: "+playgrounds.get(i).price+"\n");
 44 |             }
 45 |         }
 46 |     }
 47 |     /**
 48 |      * @param namePlayground
 49 |      * @param namePlaygroundOwner
 50 |      * @param location
 51 |      * @param Payment
 52 |      * @param price
 53 |      * */
 54 |     Playground(String namePlayground,String namePlaygroundOwner,String location,String Payment,double price)//parametrize constructor
 55 |     {
 56 |         this.namePlayground=namePlayground;
 57 |         this.namePlaygroundOwner=namePlaygroundOwner;
 58 |         this.location=location;
 59 |         this.Payment=Payment;
 60 |         this.price=price;
 61 |     }
 62 |     /**
 63 |      * default constructor
 64 |      * */
 65 |     Playground(){}//default constructor
 66 | 
 67 |     public int arr[] = new int[13];//To store Book Time
 68 |     public int Available = 0;
 69 | 
 70 |     /**
 71 |      * @param start
 72 |      * @param end
 73 |      * @param obj
 74 |      * */
 75 |     public void Range(int start,int end,Playground obj)//Range of time
 76 |     {
 77 |         if(obj.Available ==0 )
 78 |         {
 79 |             insert(obj);
 80 |             obj.Available++;
 81 |         }
 82 |             for(int i=start;i<=end;i++)
 83 |             {
 84 |                 if(obj.arr[i] ==0 )//Already Book
 85 |                 {
 86 |                     System.out.println("Time Not Available");
 87 |                     break;
 88 |                 }
 89 |                 else
 90 |                 {
 91 |                     System.out.println("Time Is Available and you Booked\n");
 92 |                     for(int j=start;j<end;j++)
 93 |                     {
 94 |                         obj.arr[j]=0;
 95 |                     }
 96 |                     break;
 97 |                 }
 98 |             }
 99 |     }
100 |     /**
101 |      * @param obj
102 |      * */
103 | 
104 |     public void insert(Playground obj)//Insert 12 hours For Time
105 |     {
106 |         for (int i=1;i<=12;i++)
107 |         {
108 |             obj.arr[i] = i;
109 |         }
110 |     }
111 | 
112 |     int j,tmp;
113 |     /**
114 |      * @param Name
115 |      * */
116 |     public int SearchName(String Name)//Search Name Of playground
117 |     {
118 |         for (j = 0;j<playgrounds.size();j++)
119 |         {
120 |             if(playgrounds.get(j).namePlayground.equals(Name))
121 |             {
122 |                 tmp = j;//return index
123 |                 break;
124 |             }
125 |             else
126 |             {
127 |                 tmp = -1;//not found
128 |             }
129 |         }
130 |         return tmp;
131 |     }
132 | 
133 |     /**
134 |      * @return information About Playgrounds
135 |      * */
136 |     @Override
137 |     public String toString() {//Print information About Playgrounds
138 |         return "\nnamePlayground : " + namePlayground +"\n"+"namePlaygroundOwner : " + namePlaygroundOwner +"\n" +
139 |                 "location : " + location + "\n" + "Payment : " + Payment + "\n" + "Price : " + price+"\n";
140 |     }
141 | }


--------------------------------------------------------------------------------
/src/Registration.java:
--------------------------------------------------------------------------------
  1 | import java.util.ArrayList;
  2 | import java.util.Scanner;
  3 | /**
  4 |  * @since 12/6/2021
  5 |  * @version 1.0
  6 |  * @author Shimaa Reda Saeed
  7 |  * @author Khaled Ashraf Hanafy
  8 |  * @author Ahmed Sayed Hassan
  9 |  *for login, Register , check User
 10 |  * */
 11 | public class Registration {//for login, Register , check User
 12 |     Scanner input = new Scanner(System.in);
 13 |     /**
 14 |      * String userName of player or playgroundOwner
 15 |      * */
 16 |     protected String userName;
 17 |     /**
 18 |      * String password of player or playgroundOwner
 19 |      * */
 20 |     protected String password;
 21 |     /**
 22 |      * String email of player or playgroundOwner
 23 |      * */
 24 |     protected String email;
 25 |     /**
 26 |      * String phone of player or playgroundOwner
 27 |      * */
 28 |     protected String phone;
 29 |     /**
 30 |      * String userType of player or playgroundOwner
 31 |      * */
 32 |     protected String userType="";
 33 | 
 34 |     /**
 35 |      * @return password
 36 |      * Getters
 37 |      * */
 38 |     public String getPassword() {
 39 |         return password;
 40 |     }
 41 |     /**
 42 |      * @return userName
 43 |      * Getters
 44 |      * */
 45 |     public String getUserName() {
 46 |         return userName;
 47 |     }
 48 | 
 49 |     String str;//To check if user player or playground Owner
 50 |     boolean Bool = false;//check if Account valid or not
 51 |     /**
 52 |      * @param userName
 53 |      * userName of player or playgroundOwner
 54 |      * @param password
 55 |      * password of player or playgroundOwner
 56 |      * @param s
 57 |      * Type
 58 |      * @return Bool
 59 |      * Login
 60 |      * */
 61 |     public boolean Login(String userName, String password,String s)
 62 |     {
 63 |         str=s;//Type of User
 64 |         if(CheckUser(userName,password))
 65 |         {
 66 |             this.userName=userName;this.password=password;
 67 |             Bool = true;
 68 |         }
 69 |         else
 70 |         {
 71 |             System.out.println("Not Found Account");
 72 |             Bool = false;
 73 |         }
 74 |         return Bool;//Return State of User
 75 |     }
 76 | 
 77 |     int indexOfPlayers=0,indexOfPlaygroundOwner=0;
 78 |     ArrayList<Registration> Players = new ArrayList<>();//ArrayList to store players Accounts
 79 |     ArrayList<Registration> PlaygroundOwners = new ArrayList<>();//ArrayList to store playground owner Accounts
 80 | 
 81 |     /**
 82 |      * @param Kind
 83 |      * Player or PlaygroundOwner
 84 |      * */
 85 |     public void Register(String Kind)
 86 |     {
 87 |         Registration R = new Registration();//new object from Registration
 88 | 
 89 |         //enter username information
 90 |         System.out.println("Enter Your information");
 91 |         System.out.print("Enter Your Name : ");
 92 |         R.userName = input.next();
 93 |         System.out.print("Enter Your Password : ");
 94 |         R.password = input.next();
 95 |         System.out.print("Enter Your phone : ");
 96 |         R.phone = input.next();
 97 |         System.out.print("Enter Your Email : ");
 98 |         R.email = input.next();
 99 | 
100 |         if(Kind.equals("1"))//Account is player
101 |         {
102 |             R.userType="Player";
103 |             Players.add(indexOfPlayers++,R);//
104 |         }
105 |         else if (Kind.equals("2"))//Account is playground owner
106 |         {
107 |             R.userType="PlaygroundOwner";
108 |             PlaygroundOwners.add(indexOfPlaygroundOwner++,R);
109 |         }
110 |         else
111 |         {
112 |             System.out.println("NOt Recognize Type! ");
113 |         }
114 |     }
115 |     boolean check = false;//State of Check User
116 | 
117 |     /**
118 |      * @param Username
119 |      * userName of player or playgroundOwner
120 |      * @param Password
121 |      * password of player or playgroundOwner
122 |      * @return check
123 |      * */
124 |     public boolean CheckUser(String Username,String Password)
125 |     {
126 |         if(str.equals("Player"))//Option 1 is player
127 |         {
128 |             if(Players.isEmpty())//if ArrayList to store players Accounts is Empty
129 |             {
130 |                 check = false;
131 |             }
132 |             else
133 |             {
134 |                 for(int i=0;i<Players.size();i++)
135 |                 {
136 |                     if(Players.get(i).getUserName().equals(Username))//check if user name already stored in System or not
137 |                     {
138 |                         if(Players.get(i).getPassword().equals(Password))//check its Password
139 |                         {
140 |                             System.out.println("Login Successfully\n");
141 |                             check = true;
142 |                             break;
143 |                         }
144 |                         else
145 |                         {
146 |                             check = false;
147 |                             break;
148 |                         }
149 |                     }
150 |                     else
151 |                     {
152 |                         check = false;
153 |                     }
154 |                 }
155 |             }
156 | 
157 |         }//end player
158 |         else if(str.equals("PlaygroundOwner")) //Option 2 is PlaygroundOwner
159 |         {
160 |             if(PlaygroundOwners.isEmpty())//if ArrayList to store playground owner is Empty
161 |             {
162 |                 check=false;
163 |             }
164 |             else
165 |             {
166 |                 for(int i=0;i<PlaygroundOwners.size();i++)
167 |                 {
168 |                     if(PlaygroundOwners.get(i).getUserName().equals(Username))//check if user name already stored in System or not
169 |                     {
170 |                         if(PlaygroundOwners.get(i).getPassword().equals(Password))//check its Password
171 |                         {
172 |                             System.out.println("Login Successfully\n");
173 |                             check = true;
174 |                             break;
175 |                         }
176 |                         else
177 |                         {
178 |                             check = false;
179 |                             break;
180 |                         }
181 |                     }
182 |                     else
183 |                     {
184 |                         check = false;
185 |                     }
186 |                 }
187 |             }
188 |         }
189 |             return check;
190 |     }
191 | 
192 |     /**
193 |      * @return Information Accounts
194 |      * */
195 |     @Override
196 |     public String toString() {//To print Information Accounts
197 |         return  "\nUsername : " + userName + "\n" +"Password : " + password + "\n" +"Email : " + email + "\n" +"Phone : " + phone + "\n" +
198 |                 "UserType : " + userType + "\n";
199 |     }
200 | }


--------------------------------------------------------------------------------
/src/demo.java:
--------------------------------------------------------------------------------
  1 | import java.util.Scanner;
  2 | /**
  3 |  * @since 12/6/2021
  4 |  * @version 1.0
  5 |  * @author Shimaa Reda Saeed
  6 |  * @author Khaled Ashraf Hanafy
  7 |  * @author Ahmed Sayed Hassan
  8 |  * */
  9 | public class demo {
 10 |     /**
 11 |      * @param args
 12 |      * Main menu (demo)
 13 |      * */
 14 |     static public void main(String args []){
 15 |         Scanner input=new Scanner(System.in);
 16 |         System.out.println("System Football");
 17 |         String check="";//option in menu choose
 18 |         String checkType="";//Check if User is Player Or playground owner
 19 |         //objects from classes
 20 |         Registration Register=new Registration();
 21 |         Playground playground ;
 22 |         PlaygroundOwner playgroundowner = new PlaygroundOwner();
 23 |         Player player = new Player();
 24 |         Playground obj = new Playground();
 25 | 
 26 |         System.out.print("1-Player\n2-PlaygroundOwner\n");
 27 |         checkType = input.next();
 28 |        while (true)
 29 |        {
 30 |            if(checkType.equals("1"))//menu is player
 31 |            {
 32 |                System.out.println("\nPlayer System");
 33 | 
 34 |                System.out.print("1-Login\n2-Register\n3-Transform to playgroundOwner\n4-Close\n");
 35 |                check=input.next();
 36 | 
 37 |                 boolean StaySignIn = true;
 38 |                if(check.equals("1"))//if User Enter Number 1 (Login)
 39 |                {
 40 |                    //Enter information Account
 41 |                    String Name,Password;
 42 |                    System.out.println("Enter Your information");
 43 |                    System.out.print("Enter Your Name : ");
 44 |                    Name=input.next();
 45 |                    System.out.print("Enter Your Password : ");
 46 |                    Password=input.next();
 47 | 
 48 |                    if(Register.Login(Name,Password,"Player"))//login
 49 |                    {
 50 |                        while (StaySignIn)
 51 |                        {
 52 |                            player.Book(obj);//Booking
 53 |                            System.out.println("Book another? : 1-yes 2-No");
 54 |                            String str =input.next();
 55 |                            if(str.equals("1"))//Book another
 56 |                            {
 57 |                                StaySignIn = true;//stay login
 58 |                            }
 59 |                            else if(str.equals("2"))//log-out
 60 |                            {
 61 |                                System.out.println("Successful log-out");
 62 |                                StaySignIn = false;
 63 |                            }
 64 |                            else
 65 |                            {
 66 |                                System.out.println("Invalid Number! ");
 67 |                            }
 68 |                        }
 69 |                    }
 70 | 
 71 |                }
 72 |                else if (check.equals("2"))//register
 73 |                {
 74 |                    Register.Register(checkType);
 75 |                }
 76 |                else if(check.equals("3"))//transform to menu of playground owner
 77 |                {
 78 |                    checkType="2";
 79 |                }
 80 |                else if(check.equals("4"))//exit program
 81 |                {
 82 |                    System.exit(0);
 83 |                }
 84 |                else
 85 |                {
 86 |                    System.out.println("Invalid Choose Number!");
 87 |                }
 88 | 
 89 |            }//end menu player
 90 |            else if(checkType.equals("2"))//menu playgroundOwner
 91 |            {
 92 |                System.out.println("\nPlaygroundOwner System");
 93 |                System.out.print("1-Login\n2-Register\n3-Transform to player\n4-Close\n");
 94 |                check=input.next();
 95 |                if(check.equals("1"))//if User Enter Number 1 (Login)
 96 |                {    //Enter Account
 97 |                    String Name,Password;
 98 |                    System.out.println("Enter Your information");
 99 |                    System.out.print("Enter Your Name : ");
100 |                    Name=input.next();
101 |                    System.out.print("Enter Your Password : ");
102 |                    Password=input.next();
103 | 
104 |                    if(Register.Login(Name,Password,"PlaygroundOwner"))//if Account already Existing
105 |                    {
106 |                         boolean StaySignIn=true;
107 |                         while (StaySignIn)
108 |                         {
109 |                             playground = new Playground();//Add new playground
110 |                             String namePlayground;String location;String Payment;double price;
111 |                             System.out.print("Enter namePlayground : ");
112 |                             namePlayground=input.next();
113 | 
114 |                             System.out.print("Enter location : ");
115 |                             location=input.next();
116 |                             System.out.print("Enter Payment : ");
117 |                             Payment=input.next();
118 |                             System.out.print("Enter price : ");
119 |                             price=input.nextInt();
120 | 
121 |                             playground.namePlayground = namePlayground;
122 |                             playground.namePlaygroundOwner = Register.userName;
123 |                             playground.location=location;
124 |                             playground.Payment=Payment;
125 |                             playground.price=price;
126 | 
127 |                             playgroundowner.AddPlayground(playground);
128 |                             obj.AddPlayground(playground);
129 | 
130 |                             System.out.println("Add another? : 1-yes 2-No");//Add another playground?
131 |                             String str =input.next();
132 |                             if(str.equals("1"))//yes and stay login
133 |                             {
134 |                                 StaySignIn = true;
135 |                             }
136 |                             else if(str.equals("2"))//log-out
137 |                             {
138 |                                 System.out.println("Successful log-out");
139 |                                 StaySignIn = false;
140 |                             }
141 |                             else
142 |                             {
143 |                                 System.out.println("Invalid Number! ");
144 |                             }
145 | 
146 |                         }
147 |                     }
148 | 
149 |                }
150 |                else if (check.equals("2"))//Register playgroundOwner account
151 |                {
152 |                    Register.Register(checkType);
153 |                }
154 |                else if(check.equals("3"))//Transform To play menu Player
155 |                {
156 |                    checkType="1";
157 |                }
158 |                else if(check.equals("4"))//exit program
159 |                {
160 |                    System.exit(0);
161 |                }
162 |                else
163 |                {
164 |                    System.out.println("Invalid Choose Number!");
165 |                }
166 |            }
167 |            else
168 |            {
169 |                System.out.println("Invalid Choose Number!");
170 |                break;
171 |            }
172 |        }
173 |     }
174 | }


--------------------------------------------------------------------------------