diff --git a/FlaskAPI/.cert b/FlaskAPI/.cert
new file mode 100644
index 0000000..e69de29
diff --git a/FlaskAPI/.gitignore b/FlaskAPI/.gitignore
index b3cac3e..d03277b 100644
--- a/FlaskAPI/.gitignore
+++ b/FlaskAPI/.gitignore
@@ -1,3 +1,4 @@
 .env
 venv/
-.idea/
\ No newline at end of file
+.idea/
+.cert
\ No newline at end of file
diff --git a/FlaskAPI/__pycache__/__init__.cpython-37.pyc b/FlaskAPI/__pycache__/__init__.cpython-37.pyc
new file mode 100644
index 0000000..6ec7abf
Binary files /dev/null and b/FlaskAPI/__pycache__/__init__.cpython-37.pyc differ
diff --git a/FlaskAPI/__pycache__/app.cpython-37.pyc b/FlaskAPI/__pycache__/app.cpython-37.pyc
new file mode 100644
index 0000000..68fd050
Binary files /dev/null and b/FlaskAPI/__pycache__/app.cpython-37.pyc differ
diff --git a/FlaskAPI/__pycache__/models.cpython-36.pyc b/FlaskAPI/__pycache__/models.cpython-36.pyc
new file mode 100644
index 0000000..4e9ab10
Binary files /dev/null and b/FlaskAPI/__pycache__/models.cpython-36.pyc differ
diff --git a/FlaskAPI/__pycache__/settings.cpython-36.pyc b/FlaskAPI/__pycache__/settings.cpython-36.pyc
new file mode 100644
index 0000000..687b55c
Binary files /dev/null and b/FlaskAPI/__pycache__/settings.cpython-36.pyc differ
diff --git a/FlaskAPI/__pycache__/settings.cpython-37.pyc b/FlaskAPI/__pycache__/settings.cpython-37.pyc
new file mode 100644
index 0000000..0dad0ea
Binary files /dev/null and b/FlaskAPI/__pycache__/settings.cpython-37.pyc differ
diff --git a/FlaskAPI/__pycache__/views.cpython-36.pyc b/FlaskAPI/__pycache__/views.cpython-36.pyc
new file mode 100644
index 0000000..ac81534
Binary files /dev/null and b/FlaskAPI/__pycache__/views.cpython-36.pyc differ
diff --git a/FlaskAPI/app.py b/FlaskAPI/app.py
index 4b059ec..5d44e04 100644
--- a/FlaskAPI/app.py
+++ b/FlaskAPI/app.py
@@ -1,12 +1,57 @@
-from flask import Flask
+from flask import Flask, request, render_template, jsonify
+from flask_cors import CORS
+from flask_jwt_extended import JWTManager, jwt_required, get_raw_jwt
+from views import schema_blueprint
+from views import db
+
+from settings import CERT
+
+import jwt as tokenizer
+import os
+import requests
+from dotenv import load_dotenv
 
 app = Flask(__name__)
+app.config.from_object('settings')
+
+cors = CORS(app, resources={r"/*": {"origins": "*"}})
+jwt = JWTManager(app)
+app.config.update(JWT=jwt)
+
+app.register_blueprint(schema_blueprint)
+
+db.init_app(app)
 
 
-@app.route('/')
+@app.before_first_request
+def create_database():
+     db.create_all()
+
+@app.route('/ola')
+@jwt_required
 def hello_world():
+    token = request.headers["Authorization"].split()[1]  # Split Bearer from token
     return 'Hello World!'
 
+@app.route('/node/<nodeID>')
+def node_info(nodeID):
+    if nodeID=='1':
+    	r = requests.get('http://192.168.1.141:5000/testi')
+    	if r.status_code != 200:
+    		msg = {'msg': 'Erro 200'}
+    		return msg
+    	return jsonify(r.json())
+
+    if nodeID=='2':
+        r = requests.get('http://192.168.1.142:5000/testi')
+        if r.status_code != 200:
+            msg = {'msg': 'Erro 200'}
+            return msg
+        return jsonify(r.json())
+
+
 
 if __name__ == '__main__':
-    app.run()
+    app.run(host=app.config['HOST'],
+            port=app.config['PORT'],
+            debug=app.config['DEBUG'])
diff --git a/FlaskAPI/models.py b/FlaskAPI/models.py
new file mode 100644
index 0000000..45a651a
--- /dev/null
+++ b/FlaskAPI/models.py
@@ -0,0 +1,190 @@
+from flask_sqlalchemy import SQLAlchemy
+from marshmallow import Schema
+
+db = SQLAlchemy()
+session = None
+class CRUD:
+    def add(self, resource):
+        db.session.add(resource)
+        return db.session.commit()
+
+    def update(self):
+        return db.session.commit()
+
+    def delete(self, resource):
+        db.session.delete(resource)
+        return db.session.commit()
+
+
+class Role (db.Model, CRUD):
+
+    __tablename__ = 'role'
+    id = db.Column(db.Integer, primary_key=True)
+    role_name = db.Column(db.String(20))
+
+    def __init__(self, role_name):
+        self.role_name = role_name
+
+    @property
+    def serializable(self):
+        return {
+            'id': self.id,
+            'role_name': self.role_name,
+        }
+
+
+class Profile(db.Model, CRUD):
+
+    __tablename__ = 'profile'
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(80), nullable=False)
+    email = db.Column(db.String(200), nullable=False, unique=True)
+    num_test = db.Column(db.INTEGER, nullable=True)
+    register_date = db.Column(db.TIMESTAMP, nullable=False)
+    picture = db.Column(db.String(10485760), nullable=True)
+    last_login = db.Column(db.TIMESTAMP, nullable=True)
+    role = db.Column(db.Integer, db.ForeignKey('role.id'))
+
+    def __init__(self,  name, email, register_date, role, num_test=None, picture=None, last_login=None):
+        self.name = name
+        self.email = email
+        self.num_test = num_test
+        self.register_date = register_date
+        self.picture = picture
+        self.last_login = last_login
+        self.role = role
+
+    def __repr__(self):
+        return '<user: {}, Email: {}, Role: {}'.format(self.name, self.email, self.role)
+
+    @property
+    def serializable(self):
+        return {
+            "id": self.id,
+            "name": self.name,
+            "email": self.email,
+            "num_test": self.num_test,
+            "register_date": self.register_date.strftime("%Y-%m-%d %H:%M:%S"),
+            "picture": self.picture,
+            "last_login": self.last_login,
+            "role": self.role
+        }
+
+
+class Template(db.Model, CRUD):
+
+    __tablename__ = 'template'
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(80))
+    duration = db.Column(db.BIGINT)
+    profile = db.Column(db.Integer, db.ForeignKey('profile.id'))
+
+    def __init__(self, id, name, duration, profile):
+        self.id = id
+        self.name = name
+        self.duration = duration
+        self.profile = profile
+
+    @property
+    def serializable(self):
+        return {
+            "id": self.id,
+            "name": self.name,
+            "duration": self.duration,
+            "profile": self.profile
+        }
+
+
+class Experience(db.Model, CRUD):
+
+    __tablename__ = 'experience'
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(100), nullable=False)
+    begin_date = db.Column(db.TIMESTAMP, nullable=False)
+    end_date = db.Column(db.TIMESTAMP, nullable=False)
+    num_test = db.Column(db.Integer, nullable=False)
+    register_date = db.Column(db.TIMESTAMP, nullable=False)
+    status = db.Column(db.String(20), nullable=False)
+    profile = db.Column(db.Integer, db.ForeignKey('profile.id'))
+    template = db.Column(db.Integer, db.ForeignKey('template.id'))
+
+    def __init__(self, name, begin_date, end_date, num_test, register_date, status, profile, template):
+        self.name = name
+        self.begin_date = begin_date
+        self.end_date = end_date
+        self.num_test = num_test
+        self.register_date = register_date
+        self.status = status
+        self.profile = profile
+        self.template = template
+
+    @property
+    def serializable(self):
+        return {
+            "id": self.id,
+            "name": self.name,
+            "begin_date": self.begin_date.strftime("%Y-%m-%d %H:%M:%S"),
+            "end_date": self.end_date.strftime("%Y-%m-%d %H:%M:%S"),
+            "num_test": self.num_test,
+            "register_date": self.register_date.strftime("%Y-%m-%d %H:%M:%S"),
+            "status": self.status,
+            "profile": self.profile,
+            "template": self.template
+        }
+
+class APU(db.Model, CRUD):
+
+    __tablename__ = 'apu'
+    id = db.Column(db.Integer, primary_key=True)
+
+    def __init__(self, id):
+        self.id = id
+
+    @property
+    def serializable(self):
+        return {
+            "id":self.id
+        }
+
+
+class APUConfig(db.Model, CRUD):
+
+    __tablename__ = 'apuconfig'
+    id = db.Column(db.Integer, primary_key=True)
+    apu = db.Column(db.Integer, db.ForeignKey('apuconfig.id'))
+    ip = db.Column(db.String(40))
+    protocol = db.Column(db.String(50))
+    base_template = db.Column(db.Integer)
+
+    def __init__(self, apu, ip, protocol, base_template):
+        self.apu = apu
+        self.ip = ip
+        self.protocol = protocol
+        self.base_template = base_template
+
+    def serializable(self):
+        return {
+            "id": self.id,
+            "apu": self.apu,
+            "ip": self.ip,
+            "protocol": self.protocol,
+            "base_template": self.base_template
+        }
+
+class APUConfig_Template(db.Model, CRUD):
+
+    __tablename__ = 'apuconfig_template'
+    id_nonexistent = db.Column(db.Integer, primary_key=True)
+    apu_config = db.Column(db.Integer, db.ForeignKey('apuconfig.id'))
+    template = db.Column(db.Integer, db.ForeignKey('template.id'))
+
+    def __init__(self, apu_config, template):
+        self.apu_config = apu_config
+        self.template = template
+
+    @property
+    def serializable(self):
+        return {
+            "apu_config": self.apu_config,
+            "template": self.template
+        }
diff --git a/FlaskAPI/requirements.txt b/FlaskAPI/requirements.txt
new file mode 100644
index 0000000..612e60f
--- /dev/null
+++ b/FlaskAPI/requirements.txt
@@ -0,0 +1,13 @@
+Flask==1.1.2
+Flask-RESTful==0.3.8
+flask-jwt-extended== 3.24.1
+flask_api==2.0
+marshmallow==3.5.1
+SQLAlchemy==1.3.16
+Flask-Cors==3.0.8
+python-dotenv==0.13.0
+pyjwt[crypto]==1.7.1
+requests==2.23.0
+Flask-SQLAlchemy==2.4.1
+psycopg2==2.8.5
+PyJWT==1.7.1
\ No newline at end of file
diff --git a/FlaskAPI/settings.py b/FlaskAPI/settings.py
new file mode 100644
index 0000000..5e37411
--- /dev/null
+++ b/FlaskAPI/settings.py
@@ -0,0 +1,44 @@
+import os
+
+pg_db_hostname = os.getenv('DB_HOST')
+pg_db_name = os.getenv('DB_NAME')
+pg_db_password = os.getenv('DB_PASS')
+pg_db_username = os.getenv('DB_USER')
+
+DEBUG = True
+PORT = 5000
+HOST = "127.0.0.1"
+SQLALCHEMY_ECHO = True
+SQLALCHEMY_TRACK_MODIFICATIONS = True
+SECRET_KEY = "SOME SECRET"
+# PostgreSQL
+SQLALCHEMY_DATABASE_URI = "postgresql://{DB_USER}:{DB_PASS}@{DB_ADDR}/{DB_NAME}".format(DB_USER=pg_db_username,
+                                                                                        DB_PASS=pg_db_password,
+                                                                                        DB_ADDR=pg_db_hostname,
+                                                                                        DB_NAME=pg_db_name)
+
+
+SQLALCHEMY_TRACK_MODIFICATONS = False
+
+
+
+CERT = b'-----BEGIN PUBLIC KEY-----\n' \
+       b'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAlc6LMgsz5b2m2Q3M/ps2\n' \
+       b'XRKIuBRdwOUrY532F9OmkYrrdPsVpDpWTjRsc3Srrc9hUCIWNMQa++Cjq4yMFTHl\n' \
+       b'D3Yn8x1kHJnO+DWw7sIJvg1+8PxZWZnslXUHjFRuuxUNUH5wxy5z/C1T6aMqIO93\n' \
+       b'tXJty1q2nzVdW9GON0AI0oPHhSdPJalbxC7mo1ExZRa5SoYiBv8xe7ER4e1Neb3K\n' \
+       b'sUF+Rfny1t79PQJC6uk0FwnloEQVj5yYvmwAv8HTda0mhFY0GdYqNk5+ks0D3hGg\n' \
+       b'3D7FspI98MOX1lUatEJDq6/xE0JlK111uh24i7aZaZD5Bn3dqZl83zK4PdexXE/z\n' \
+       b'JwIDAQAB\n' \
+       b'-----END PUBLIC KEY-----'
+
+# JWT Decode Algorithm
+JWT_SECRET_KEY = CERT
+
+JWT_DECODE_ALGORITHMS = ['RS256']
+# JWT Decode CERT
+
+# JWT Identifier
+JWT_IDENTITY_CLAIM = 'email'
+
+
diff --git a/FlaskAPI/views.py b/FlaskAPI/views.py
new file mode 100644
index 0000000..f0ef71e
--- /dev/null
+++ b/FlaskAPI/views.py
@@ -0,0 +1,305 @@
+from flask_jwt_extended import jwt_required, get_raw_jwt, get_jti
+from _datetime import datetime, timedelta
+
+from models import *
+from flask import Blueprint, request, jsonify, make_response
+from flask_restful import Api, Resource, reqparse
+from flask_api import status
+
+from sqlalchemy.exc import SQLAlchemyError
+from marshmallow import ValidationError
+
+# Config Files
+schema_blueprint = Blueprint('amazing', __name__)
+api = Api(schema_blueprint)
+
+
+#       Parse definition
+parser = reqparse.RequestParser()
+# users
+parser.add_argument('typeID')
+parser.add_argument('email')
+
+# Users and Experience
+parser.add_argument('content')
+
+# Experience
+parser.add_argument('userID')
+parser.add_argument('date')
+parser.add_argument('begin_date')
+parser.add_argument('end_date')
+parser.add_argument('status')
+
+
+#       BASE Functions
+def get_user_by_email(email):
+    users_query = db.session().query(Profile).filter(Profile.email == email).one()
+    return users_query.serializable
+
+
+class RoleView(Resource):
+    def get(self):
+        role_query = db.session.query(Role).all()
+        results = jsonify([role.serializable for role in role_query])
+        return results
+
+
+class UserView(Resource):
+    @jwt_required
+    def get(self):
+        parse_data = parser.parse_args()
+        jwt_data = get_raw_jwt()
+        if not jwt_data['isAdmin']:
+            results = jsonify()
+            results.status_code = status.HTTP_401_UNAUTHORIZED
+            return results
+
+        users_query = db.session().query(Profile)
+
+        if parse_data['typeID']:
+            users_query = users_query.filter(Profile.role == parse_data['typeID'])
+        if parse_data['email']:
+            users_query = users_query.filter(Profile.email.contains(parse_data['email']))
+        if parse_data['content']:
+            users_query = users_query.filter(Profile.name.contains(parse_data['content']))
+        q = users_query.all()
+        return jsonify([result.serializable for result in q])
+
+    @jwt_required
+    def post(self):
+        if not get_raw_jwt()['isAdmin']:
+            results = jsonify()
+            results.status_code = status.HTTP_401_UNAUTHORIZED
+            return results
+        raw_data = request.get_json(force=True)
+        try:
+            message = raw_data
+            profile = Profile(name=message['name'], email=message['email'], role=message['role'], num_test=0,
+                              register_date=datetime.now())
+            profile.add(profile)
+            return profile.serializable, status.HTTP_201_CREATED
+
+        except ValidationError as err:
+            resp = jsonify({"error": err.messages})
+            resp.status_code = status.HTTP_403_FORBIDDEN
+            return resp
+
+        except SQLAlchemyError as e:
+            db.session.rollback()
+            resp = jsonify({"error": str(e)})
+            resp.status_code = status.HTTP_400_BAD_REQUEST
+            return resp
+
+
+class UserInfoView(Resource):
+    @jwt_required
+    def get(self, id):
+        if not get_raw_jwt()['isAdmin']:
+            results = jsonify()
+            results.status_code = status.HTTP_401_UNAUTHORIZED
+            return results
+        user_query = db.session.query(Profile).get(id)
+        user = jsonify(user_query.serializable)
+        return user
+
+    @jwt_required
+    def put(self, id):
+        jwt_data = get_raw_jwt()
+        if not jwt_data['isAdmin']:
+            results = jsonify()
+            results.status_code = status.HTTP_401_UNAUTHORIZED
+            return results
+
+        raw_data = request.get_json(force=True)
+        message = raw_data['role']
+        profile = db.session.query(Profile).get(id)
+
+        profile.role = message
+        db.session.commit()
+        return profile.serializable
+
+"""
+    @jwt_required
+    def delete(self, id):
+        email = get_raw_jwt()['jti']
+        user_id = get_email_by_id(email)['id']
+
+        if not user_id:
+            resp = jsonify({"error": 'Non-existent user'})
+            resp.status_code = 403
+            return resp
+
+        user = Profile.query.get_or_404(user_id)
+        try:
+            delete = user.delete(user)
+            response = make_response()
+            response.status_code = 204
+            return response
+
+        except SQLAlchemyError as e:
+            db.session.rollback()
+            resp = jsonify({"error": str(e)})
+            resp.status_code = status.HTTP_401_UNAUTHORIZED
+            return resp
+
+"""
+
+
+class ProfileView(Resource):
+    @jwt_required
+    def get(self):
+        email = get_raw_jwt()['email']
+        users_query = db.session.query(Profile).filter(Profile.email==email).one()
+        results = users_query.serializable
+        return jsonify(results)
+
+    @jwt_required
+    def put(self):
+        email = get_raw_jwt()['email']
+        user = users_query = db.session().query(Profile).filter(Profile.email == email).one()
+        raw_data = request.get_json(force=True)
+
+        if raw_data['pic']:
+            user.picture = raw_data['pic']
+        user.name = raw_data['name']
+        db.session.commit()
+        return user.serializable
+
+
+class ExperienceView(Resource):
+    @jwt_required
+    def get(self):
+        parse_data = parser.parse_args()
+        jwt_data = get_raw_jwt()
+        experiences_query = db.session.query(Experience, Profile).filter(Experience.profile == Profile.id)
+        # Apply filters
+        if jwt_data['isAdmin']:
+            if parse_data['userID']:
+                experiences_query = experiences_query.filter(Experience.profile == parse_data['userID'])
+        else:
+            email = jwt_data['email']
+            user_id = get_user_by_email(email)['id']
+            experiences_query = experiences_query.filter(Experience.profile == user_id)
+
+        if parse_data['date']:
+            date_start = datetime.strptime(parse_data['date'], "%Y-%m-%d").date()
+            date_finish = date_start + timedelta(days=1)
+            experiences_query = experiences_query.filter(Experience.begin_date >= date_start).filter( date_finish >= Experience.end_date)
+
+        else:
+            if parse_data['begin_date']:
+                date = datetime.strptime(parse_data['begin_date'], "%Y-%m-%d").date()
+                experiences_query = experiences_query.filter(Experience.begin_date >= date)
+            if parse_data['end_date']:
+                date = datetime.strptime(parse_data['end_date'], "%Y-%m-%d").date()
+                experiences_query = experiences_query.filter(Experience.end_date <= date)
+        if parse_data['status']:
+            experiences_query = experiences_query.filter(Experience.status == parse_data['status'])
+        if parse_data['content']:
+            experiences_query = experiences_query.filter(Experience.name.contains(parse_data['content']))
+        q = experiences_query.all()
+        response = []
+        for experience, profile in q:
+            experience = experience.serializable
+            profile = profile.serializable
+            experience['author'] = profile['name']
+            response.append(experience)
+        return jsonify(response)
+
+    @jwt_required
+    def post(self):
+        jwt_data = get_raw_jwt()
+        email = jwt_data['email']
+        user_id = get_user_by_email(email)['id']
+        raw_data = request.get_json(force=True)
+        try:
+            message = raw_data
+            begin_date = datetime.strptime(message['begin_date'], "%Y-%m-%d %H:%M:%S")
+            template = db.session.query(Template).get(message['template'])
+            total_duration = message['num_test'] * (template.duration + 60)  # 1 min for test setup
+
+            experience = Experience(name=message['name'],
+                                    begin_date=begin_date,
+                                    num_test=message['num_test'],
+                                    end_date=begin_date + timedelta(0, total_duration),
+                                    status='SCHEDULED',
+                                    profile=user_id,
+                                    template=message['template'],
+                                    register_date=datetime.now())
+
+            experience.add(experience)
+            return experience.serializable, status.HTTP_201_CREATED
+
+        except ValidationError as err:
+            resp = jsonify({"error": err.messages})
+            resp.status_code = status.HTTP_403_FORBIDDEN
+            return resp
+
+        except SQLAlchemyError as e:
+            db.session.rollback()
+            resp = jsonify({"error": str(e)})
+            resp.status_code = status.HTTP_400_BAD_REQUEST
+            return resp
+
+
+class ExperienceInfoView(Resource):
+
+    @jwt_required
+    def get(self, id):
+        jwt_data = get_raw_jwt()
+        user_id = get_user_by_email(jwt_data['email'])['id']
+        query = db.session.query(Experience, Template).filter(Experience.id==id).filter(Experience.template == Template.id).one()
+        experience = query[0].serializable
+        template = query[1].serializable
+        if not jwt_data['isAdmin'] and experience.profile != user_id:
+            results = jsonify()
+            results.status_code = status.HTTP_401_UNAUTHORIZED
+        results = make_response({"experience": experience, "template": template})
+        results.status_code = status.HTTP_200_OK
+        return results
+
+
+class ExperienceScheduleView(Resource):
+    def get(self):
+
+        date_now = datetime.now()
+        experience_schedule_query = db.session.query(Experience, Profile)\
+            .filter(Experience.end_date >= date_now)\
+            .filter(Experience.profile == Profile.id)\
+            .order_by(Experience.begin_date.asc())\
+            .limit(2)\
+            .all()
+        calendar = {'current_experience': None, 'next_experience': None}
+
+        if len(experience_schedule_query) == 2:
+            if datetime.strptime(experience_schedule_query[0][0].serializable['begin_date'],
+                                 "%Y-%m-%d %H:%M:%S") < date_now:
+                calendar['current_experience'] = self.format_experience_calendar(experience_schedule_query[0])
+                calendar['next_experience'] = self.format_experience_calendar(experience_schedule_query[1])
+            else:
+                calendar['next_experience'] = self.format_experience_calendar(experience_schedule_query[0])
+
+        elif len(experience_schedule_query) == 1:
+            if datetime.strptime(experience_schedule_query[0][0].serializable['begin_date'],
+                                 "%Y-%m-%d %H:%M:%S") < date_now:
+                calendar['current_experience'] = self.format_experience_calendar(experience_schedule_query[0])
+            else:
+                calendar['next_experience'] = self.format_experience_calendar(experience_schedule_query[0])
+        return calendar
+
+    @staticmethod
+    def format_experience_calendar(experince_calendar_fragment):
+        experience = experince_calendar_fragment[0].serializable
+        profile = experince_calendar_fragment[1].serializable
+        experience['author'] = profile['name']
+        experience['email'] = profile['email']
+        return experience
+
+
+api.add_resource(UserView, '/user', '/user/')
+api.add_resource(UserInfoView, '/user/<int:id>', '/user/<int:id>/')
+api.add_resource(RoleView, '/role', '/role/')
+api.add_resource(ProfileView, '/profile', '/profile/')
+api.add_resource(ExperienceView, '/experience', '/experience/')
+api.add_resource(ExperienceInfoView, '/experience/<int:id>', '/experience/<int:id>/')
+api.add_resource(ExperienceScheduleView, '/experience/now', '/experience/now/')