Adding ticket edit

Deliverables/D7.md

@@ -0,0 +1,241 @@
+# Requirements
+
+_Group 10 - "Super Simple Ticketing System"\
+Date and location: April 7, 2024\
+Group Members: Olivia Vester, Dallon Jarman, Charles Descamps, Hannah Penado, Sam Cain, Jared Kaige_
+
+## 1. Description
+In the Super Simple Ticketing System, our goal is to provide a simple and responsive user experience. Our system aims to solve the issue of overly complicated and bulky ticketing systems by implementing one that is both simple and navigable. We achieved this goal by relying on Flask as our framework and an extremely responsive database MongoDB. As we developed SSTS, we worked to make the system very sleek as well as the code “under the hood” for both a pleasant user experience and easy maintenance. Overall the Super Simple Ticketing System aims to be a platform that makes creating, editing, and closing tickets a smooth and organized experience.
+
+## 2. Verification (tests)
+*Unit test*
+
+1. For our unit testing we chose to use pytest with mongomock to test the coupling between collection classes such as Users and Workers or Users and Clients.
+
+2. Here is the link to the folder containing the Unit Tests: \
+https://github.com/oliveoil222/CS386-Project/tree/main/ssts/Testing
+
+
+3. Below is an example of some mock objects being tested along with the classes the pytest case, that tested the functionality of the coupling of the worker class using the user class. The link to the GitHub file containing the example: \
+https://github.com/oliveoil222/CS386-Project/blob/main/ssts/Testing/mockTests.py
+
+```
+# create database class
+class Database:
+   # create init function
+   def __init__(self):
+       # get mongomock database
+       self.client = mongomock.MongoClient()
+       # create mock database to test
+              self.db = self.client['ssts']
+
+
+# create class for user
+class UserCollection:
+   # create init function
+   def __init__(self):
+       # connect to user database
+       database = Database()
+       self.collection = database.db['users']
+   # function to add user to database collection
+   # the user variable to input is a Worker/Client object
+   def add_user(self, user):
+       print("USER", user)
+       collection = self.collection
+       new_user = {
+           'name' : user.name,
+           'email': user.email,
+           'password': user.password,
+           'type' : user.user_type
+       }
+       return collection.insert_one(new_user)
+# create subclass of users for clients
+class ClientCollection:
+   # create init function
+   def __init__(self):
+       database = Database()
+       # connect to client collection
+       self.collection = database.db['clients']
+
+   def add_client_to_users(self, client):
+       users = UserCollection()
+       user = User(client.name,
+                   client.email,
+                   client.user_type,
+                   client.password)
+       user_added = users.add_user(user)
+       print("USER ADDED", user_added)
+       return user_added
+   # add client method
+   def add_client(self, client):
+       # add client to users
+       self.add_client_to_users(client)
+       # set up client collection connection
+       clients = self.collection
+       # create a new document for the new client
+       new_client = {
+           'email' : client.email,
+           'name': client.name,
+           'phone number' : client.phone_num,
+           'contact method' : client.contact_method,
+           'password': client.password
+       }
+       # return the new added client pymongo id
+       return clients.insert_one(new_client)
+
+   def get_client(self, email):
+       # add client to the user collection
+       collection = self.collection
+       client = collection.find_one({'email':email})
+       client = Client(client['email'],
+                       client['name'],
+                       client['phone number'],
+                       client['contact method'],
+                       client['password'])
+       return client
+
+
+# test if new client is able to be added to both user collection
+# and client collection
+def test_add_client():
+   client = Client('mock.client@test.com', 'Mongo Mock', '5558888', 'phone', 'password')
+   print(CLIENTS.add_client(client))
+   # test to see if client was added to both client and user collections
+   in_users = USERS.find_user('mock.client@test.com')
+   print("USERS", in_users)
+   in_clients = CLIENTS.get_client('mock.client@test.com')
+   print("CLIENTS", in_clients)
+   assert in_users != None and in_clients != None
+```
+
+4. Below is a screenshot of the mock unit testing results, where two tests were passed successfully, indicating that the WorkerCollection and ClientCollection classes continue to have functionality with coupling to the UserCollection.
+
+![Mock Tests](/Deliverables/img/D7/mockTests.png)
+
+*Acceptance test*
+1. For out acceptance testing we decided to use Selenium Webdriver with a Chromedriver
+
+2. The link to the GitHub folder containing the acceptance test: \
+https://github.com/oliveoil222/CS386-Project/tree/main/ssts/Testing
+
+3. The link to the GitHub with the example below: \
+https://github.com/oliveoil222/CS386-Project/blob/main/ssts/Testing/acceptanceTests.py
+
+```
+def check_login():
+   driver.get("https://ssts.app/login")
+   username_element = driver.find_element(By.ID, "email")
+   username_element.send_keys("hannahpenado@gmail.com")
+   password_element = driver.find_element(By.ID, "password")
+   password_element.send_keys("1234")
+   sign_in_button = driver.find_element(By.XPATH, ".//form/button[@type='submit']")
+   sign_in_button.click()
+   expected_url = "https://ssts.app/"
+   current_url = driver.current_url
+   assert expected_url == current_url, "sign in url not matching"
+```
+
+4. Screenshots of the acceptance test below, where the top of the screen shows that the chrome window is being run by an automated test software. 
+
+![Login Paeg](/Deliverables/img/D7/login.png)
+![Create Incident Page](/Deliverables/img/D7/create_inicident.png)
+
+## 3. Valication (user evaluation)
+
+**Script:**
+
+Screenshots of the acceptance test below, where the top of the screen shows that the chrome window is being run by an automated test software. 
+
+Start the user on the home page and tell them to create a ticket for this issue. Observe how they do this (i.e. where they first look, if they have trouble finding the create ticket menu).
+
+Observe as the user creates the ticket, noting any interesting behavior.
+Have the user look at the ticket in the My Tickets page.
+
+Ask the user some ending questions, such as:
+
+- What did you think of the overall design?
+- How difficult was it to create tickets?
+- How would you describe your experience with this app?
+- Is there anything you would change? 
+
+### Evaluation #1:
+
+**User**: Roger M. (roommate) - Jared
+
+**Prompt**: User was in the perspective of an IT worker whose company just switched to our system. He received an issue from a customer about a broken computer and needs to create a ticket associated with this issue. After creating the ticket, they view the ticket from the Ticket menu.
+
+**Results**: After being prompted to create the ticket. The user easily found the create ticket menu. Given the information about the broken PC, the ticket was successfully created with little issue. After creating the ticket, because the tickets menu is brought up immediately, it was simple to see the created ticket. After all this, the user was asked multiple questions. The responses included that the overall website design was simple and well made, that creating tickets was very easy, the experience using the app was great, and that there wasn’t anything that they thought needed to be changed.
+
+**Reflections**: The most important thing from this evaluation was the fact that the user was able to perform their tasks easily and without issue. That was the main thing that we went for, so accomplishing that was a great thing to hear. Every feature worked as intended, and I feel that our value proposition was definitely met.
+
+### Evaluation #2:
+
+**User**: Brody E. (Coworker) - Charles
+
+**Prompt**: A customer has come to you with a device that has started to blare “Computer has a VIRUS, call 1-800-888-3333 to get customer support” and would like you to stop it. Create a ticket, and enter in the information. 
+
+**Results**: The user was able to create an account, sign into the website, and navigate to the create issue page. The navigation bar was very intuitive for the user, and was able to create the issue without opening the bar fully. They were able to input the information, and then submit the ticket.
+
+**Reflections**: The dashboard needs more work. Main navigation bar is good, intuitive. The create issue needs some polishing. GUI looks good overall. Overall experience would be a “4 out of 5,” it was just confusing at first. The dashboard would need to be changed before they would fully use the application.
+
+### Evaluation #3:
+
+**User**: Bella R. (roommate) - Hannah
+
+**Prompt**: You are experiencing some issues with your laptop and are seeking help from your local IT department. Sign up for the application and submit a ticket describing your problem
+
+**Results**: The user was able to quickly create an account and sign into the website application. The navigation on the side bar was easy to navigate and a helpful tool in knowing where to go. Knowing what to do when submitting an issue was a bit of a problem, as not having any IT knowledge submitting a ticket wasn’t as easily known that the ticket was an issue submission. The process of creating a ticket was simple and easy to follow for the user, but the device's OS selection type led to some confusion for someone with minimal knowledge of computers and what the operating system was. 
+
+**Reflections**: \
+What did you think of the overall design?
+
+- The design was very simple and straightforward, I would like some more design to make the dashboard page more pleasing to the eye.
+
+How difficult was it to create tickets?
+
+- It was fairly simple, I wasn’t too sure what a 
+
+How would you describe your experience with this app?
+
+- It seemed pretty quick and simple, I don’t know too much about computers so some directions on what to do would be helpful, but it seems like a very easy to use application that is simple and quick to learn. I could see how IT people would like this app.
+
+Is there anything you would change?
+
+- I would like some direction help, like a FAQ for how someone like me would be able to understand quicker on what to do and where to get information like “Device OS” for creating a ticket. Also just some general information on what the site can do for clients submitting tickets for their devices on the main page when they log in on how to get started would be helpful.
+
+
+### Evaluation #4:
+
+**User**: Noelia C. (CS Major) - Olivia
+
+**Prompt**: A customer calls in to report a broken iPad that appears to be cracked and has some water damage and would like to file a repair request. Create a ticket, and enter in the information. 
+
+**Results**: The user was able to quickly navigate through the system and find where to create a ticket. The user took the given prompt and was able to create a ticket that fits the described issues and submit it. Following this task, the user answered a series of questions about the software which is included in the reflections.
+
+**Reflections**: \
+What did you think of the overall design?
+
+- Overall design was clean and easy to navigate through. 
+
+How difficult was it to create tickets?
+
+- It was pretty simple and straightforward. No issues arose. 
+
+How would you describe your experience with this app?
+
+- I would describe my experience as quick and easy which is what you expect with a ticketing service. 
+
+Is there anything you would change?
+
+- I wouldn’t change much, I think it would be cool to add a little question box that you can ask questions too but outside of that it is great!
+
+### Evaluation #5:
+
+**User**: Skyler P. (Co-worker) - Dallon
+
+**Prompt**: A customer calls in to report that their device has been maliciously infected with malware and they are constantly getting pop-ups and are scared that they could lose some serious data. Draft up a ticket and enter the user information.
+
+**Results**: The user was able to navigate through the site with little trouble. They were able to create the ticket and view it. With the given information, they were able to use the create_inicident site to quickly and efficiently write up a ticket that expressed the customer's troubles. 
+
+**Reflections**: \
+It would be better to have a pop up when a invalid username or password was entered rather than nothing at all. It would also be nice to change the settings for the site allowing for more user customization. I do enjoy the sidebar and how easy it is to make simple changes to tickets and how quickly everything loads.

Deliverables/img/D7/test.txt

@@ -0,0 +1 @@
+