first attempt to integrate backend and front-end

Author: alesanchezr

.gitignore

@@ -52,6 +52,8 @@ Thumbs.db
 # ignore node/grunt dependency directories
 node_modules/
 
+# webpack output
+dist/*
 public/
 
 # ignore the dist directory were our bundle files are going to be
@@ -60,4 +62,11 @@ public/
 !.htaccess
 !.eslintrc
 !.env.example
-.now
+.now
+
+# backend stuff
+.venv
+database.database
+database.db
+diagram.png
+__pycache__/

.gitpod.yml

@@ -1,8 +1,18 @@
 ports:
     - port: 3000
-      onOpen: open-browser
+      onOpen: open-preview
+    - port: 3306
+      onOpen: ignore
 tasks:
+    - init: >
+        cp .env.example .env;
+        pipenv install;
+        mysql -u root -e "CREATE DATABASE example";
+        pipenv run init;
+        pipenv run migrate;
+        pipenv run upgrade;
     - init: >
         npm i now -g &&
         npm install &&
         cp .env.example .env
+      openMode: split-right

.htaccess

@@ -0,0 +1,29 @@
+[[source]]
+name = "pypi"
+url = "https://pypi.org/simple"
+verify_ssl = true
+
+[dev-packages]
+
+[packages]
+flask = "*"
+sqlalchemy = "*"
+flask-sqlalchemy = "*"
+flask-migrate = "*"
+flask-swagger = "*"
+psycopg2-binary = "*"
+python-dotenv = "*"
+mysql-connector-python = "*"
+flask-cors = "*"
+gunicorn = "*"
+mysqlclient = "*"
+
+[requires]
+python_version = "3.8"
+
+[scripts]
+start="flask run -p 3000 -h 0.0.0.0"
+init="flask db init"
+migrate="flask db migrate"
+upgrade="flask db upgrade"
+deploy="echo 'Please follow this 3 steps to deploy: https://github.com/4GeeksAcademy/flask-rest-hello/blob/master/README.md#deploy-your-website-to-heroku' "

CHANGELOG.md

@@ -0,0 +1,2 @@
+release: pipenv run upgrade
+web: gunicorn wsgi --chdir ./src/

Pipfile

@@ -0,0 +1,16 @@
+# CHANGE LOG
+
+Here we are tracking the previous and upcoming changes (roadmap), pull request this file or open an issue if you have any suggestions for the next version of the boilerplate.
+
+## Roadmap v2.0
+
+- [ ] Update documentation with more examples
+
+### August 9th, 2019
+- [x] Removed eralchemy from the Pipfile because its compatibility with Apply and PC computers its not clear. There is now way to create a database diagra.png anymore.
+- [x] Added this changelog file to keep track of changes on the boilerplate.
+- [x] Added documentation for [data validations](https://github.com/4GeeksAcademy/flask-rest-hello/blob/master/docs/DATA_VALIDATIONS.md)
+- [x] Added documentation for [SQL Alchemy operations](https://github.com/4GeeksAcademy/flask-rest-hello/edit/master/docs/MYSQL.md).
+
+### Sep 16th, 2019
+- [x] Added debuging functionality

Pipfile.lock

@@ -0,0 +1,157 @@
+# Creating and/or Accessing the MySQL Database
+
+1. Log in to mysql terminal:
+```sh
+$ mysql
+```
+2. Once inside, check if you have the database already created:
+```sql
+SHOW databases;
+```
+3. If you don't see the example database create it by typing:
+```sql
+CREATE DATABASE example;
+```
+Note: Make sure to update the `DB_CONNECTION_STRING` on the `.env` file with the correct database name.
+
+3. If your database is already created, get inside of it by typing:
+```sql
+USE example;
+```
+4. Now you can type any SQL command you like, for example:
+```sql
+SHOW TABLES;
+```
+Note: type `exit;` to quit.
+
+
+# Querying data using Python and SQL Alchemy (SELECT)
+
+Assuming you have a Person object in your models.py file.
+
+```py
+# get all the people
+people_query = Person.query.all()
+
+# get only the ones named "Joe"
+people_query = Person.query.filter_by(name='Joe')
+
+# map the results and your list of people  inside of the all_people variable
+all_people = list(map(lambda x: x.serialize(), people_query))
+
+# get just one person
+user1 = Person.query.get(person_id)
+ ```
+
+## Inserting data
+
+Assuming you have a Person object in your models.py file.
+
+```py
+user1 = Person(username="my_super_username", email="[email protected]")
+db.session.add(user1)
+db.session.commit()
+```
+
+### Updating data
+
+```py
+user1 = Person.query.get(person_id)
+if user1 is None:
+    raise APIException('User not found', status_code=404)
+
+if "username" in body:
+    user1.username = body["username"]
+if "email" in body:
+    user1.email = body["email"]
+db.session.commit()
+```
+ 
+ ### Delete data
+ 
+ ```py
+ user1 = Person.query.get(person_id)
+if user1 is None:
+    raise APIException('User not found', status_code=404)
+db.session.delete(user1)
+db.session.commit()
+ ```
+
+## ONE to MANY relationship
+A one to many relationship places a foreign key on the child table referencing the parent. 
+Relationship() is then specified on the parent, as referencing a collection of items represented by the child:
+
+```py
+class Parent(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(80), nullable=False)
+    children = db.relationship('Child', lazy=True)
+
+    def __repr__(self):
+        return f'<Parent {self.name}>'
+
+    def serialize(self):
+        return {
+            "id": self.id,
+            "name": self.name,
+            "children": list(map(lambda x: x.serialize(), self.children))
+        }
+
+class Child(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(80), nullable=False)
+    parent_id = db.Column(db.Integer, db.ForeignKey("Parent.id"))
+    
+    def __repr__(self):
+        return '<Child {self.name}>
+        
+    def serialize(self):
+        return {
+            "id": self.id,
+            "name": self.name
+        }
+```
+
+## MANY to MANY relationship
+Many to Many adds an association table between two classes. The association table is indicated by the secondary argument to relationship(). Usually, the Table uses the MetaData object associated with the declarative base class, so that the ForeignKey directives can locate the remote tables with which to link:
+
+```py
+association_table = Table('association', Base.metadata,
+    Column("sister_id", Integer, ForeignKey("Sister.id")),
+    Column("brother_id", Integer, ForeignKey("Brother.id"))
+)
+
+class Sister(db.Model):
+    id = db.Column(Integer, primary_key=True)
+    name = db.Column(String(80), nullable=False)
+    brothers = relationship("Brother",
+                    secondary=association_table
+                    back_populates="sisters") # this line is so it updates the field when Sister is updated
+                    
+    def __ref__(self):
+        return f'<Sister {self.name}>'
+        
+    def serialize(self):
+        return {
+            "id": self.id,
+            "name": self.name,
+            "brothers": list(map(lambda x: x.serialize(), self.brothers))
+        }
+
+class Brother(db.Model):
+    id = db.Column(Integer, primary_key=True)
+    name = db.Column(String(80), nullable=False)
+    sisters = relationship("Sister",
+                    secondary=association_table
+                    back_populates="brothers")
+                    
+    def __ref__(self):
+        return f'<Brother {self.name}>'
+        
+    def serialize(self):
+        return {
+            "id": self.id,
+            "name": self.name,
+            "sisters": list(map(lambda x: x.serialize(), self.sisters))
+        }
+```

Procfile

@@ -0,0 +1,36 @@
+# Data Validations
+
+Lets say a request is coming from the client and we need to make sure it contains the right information.
+
+We have to use conditionals to make the validations, if we want to validate the request body we have to retrive it first and then add the condition, like this:
+```py
+body = request.get_json()
+if 'username' not in body:
+    raise APIException('You need to specify the username', status_code=400)
+```
+
+- Its a good practice to raise exeptions because it will stop the code execution.
+- Its a good practice to return 400 because that way the client knows it was his mistake and not ours (the server).
+
+### Here is a full example of a POST request to add a new person into a database:
+
+```py
+@app.route('/person', methods=['POST'])
+def handle_person():
+
+    # First we get the payload json
+    body = request.get_json()
+
+    if body is None:
+        raise APIException("You need to specify the request body as a json object", status_code=400)
+    if 'username' not in body:
+        raise APIException('You need to specify the username', status_code=400)
+    if 'email' not in body:
+        raise APIException('You need to specify the email', status_code=400)
+
+    # at this point, all data has been validated, we can proceed to inster into the bd
+    user1 = Person(username=body['username'], email=body['email'])
+    db.session.add(user1)
+    db.session.commit()
+    return "ok", 200
+```

deploy-to-github.js

@@ -0,0 +1,11 @@
+# Debugging your application
+
+Gitpod and visual studio come with the same debugging functionality embeded and it is super easy to use!
+
+1. Look for the debugin panel: ![debugging icon](https://raw.githubusercontent.com/4GeeksAcademy/flask-rest-hello/master/docs/assets/debugging_icon.png)
+2. Pick `Flask server` as debugging configuration.
+3. Add some breakpoints on your code.
+4. Press the play button.
+5. If the line were you put the breakpoint gets executed your application will froze and show the values of the variables during that particular runtime moment.
+
+![Debugging Gitpod Python](https://raw.githubusercontent.com/4GeeksAcademy/flask-rest-hello/master/docs/assets/debugging.gif)