diff --git a/Server/README.md b/Server/README.md
new file mode 100644
index 0000000..98b7a7d
--- /dev/null
+++ b/Server/README.md
@@ -0,0 +1,24 @@
+# zoom-attendance-check API
+
+API doc can be found [here](https://documenter.getpostman.com/view/4335694/TVRg694k)
+
+## Requirements
+1. Install python 3 and pip
+2. `pip install -r requirements.txt`
+3. `python run.py`
+
+API will be running now at: `http://localhost:5000`
+
+## Project structure
+The server code is inside Server package, and can be runned with the external module `run.py`.
+We decided to use `flask-restful` extenstion in order to create the endpoints, and `flaks-sqlalchemy` in order to create the database.
+
+The inside the `Server` package is organzied into the following sub-packages:
+
+- `api` - package which is responsible for the api endpoints
+- `utils` - general utils for the application
+
+also there are:
+
+- `models.py` - ORM models for the database
+- `config.py` - genreal settings for the application
\ No newline at end of file
diff --git a/Server/Server/__init__.py b/Server/Server/__init__.py
index 264137f..4d3eaf6 100644
--- a/Server/Server/__init__.py
+++ b/Server/Server/__init__.py
@@ -1,22 +1,18 @@
 from flask import Flask
 from flask_sqlalchemy import SQLAlchemy
 from flask_bcrypt import Bcrypt
-from flask_login import LoginManager
 from Server.config import FlaskConfig
+from flask_httpauth import HTTPBasicAuth
 
 app = Flask(__name__)
 app.config.from_object(FlaskConfig)
 
 db = SQLAlchemy(app)
 bcrypt = Bcrypt(app)
-login_manager = LoginManager(app)
-login_manager.login_view = 'users.login'
-login_manager.login_message_category = 'info'
+auth = HTTPBasicAuth(app)
 
 
-from Server.users.routes import users
-from Server.classrooms.routes import classrooms
+from Server.api import api_blueprint
 
-app.register_blueprint(users)
-app.register_blueprint(classrooms)
+app.register_blueprint(api_blueprint)
 
diff --git a/Server/Server/api/__init__.py b/Server/Server/api/__init__.py
new file mode 100644
index 0000000..174bf0f
--- /dev/null
+++ b/Server/Server/api/__init__.py
@@ -0,0 +1,7 @@
+from flask_restful import Api
+from flask import Blueprint
+
+api_blueprint = Blueprint('api', __name__, url_prefix='/api')
+api = Api(api_blueprint)
+
+from Server.api import auth, clasrooms, reports, student_status
diff --git a/Server/Server/api/__pycache__/__init__.cpython-38.pyc b/Server/Server/api/__pycache__/__init__.cpython-38.pyc
new file mode 100644
index 0000000..6fc85eb
Binary files /dev/null and b/Server/Server/api/__pycache__/__init__.cpython-38.pyc differ
diff --git a/Server/Server/api/__pycache__/auth.cpython-38.pyc b/Server/Server/api/__pycache__/auth.cpython-38.pyc
new file mode 100644
index 0000000..4f17d14
Binary files /dev/null and b/Server/Server/api/__pycache__/auth.cpython-38.pyc differ
diff --git a/Server/Server/api/__pycache__/clasrooms.cpython-38.pyc b/Server/Server/api/__pycache__/clasrooms.cpython-38.pyc
new file mode 100644
index 0000000..93f38bb
Binary files /dev/null and b/Server/Server/api/__pycache__/clasrooms.cpython-38.pyc differ
diff --git a/Server/Server/api/__pycache__/reports.cpython-38.pyc b/Server/Server/api/__pycache__/reports.cpython-38.pyc
new file mode 100644
index 0000000..f564043
Binary files /dev/null and b/Server/Server/api/__pycache__/reports.cpython-38.pyc differ
diff --git a/Server/Server/api/auth.py b/Server/Server/api/auth.py
new file mode 100644
index 0000000..58ef9da
--- /dev/null
+++ b/Server/Server/api/auth.py
@@ -0,0 +1,31 @@
+from Server import auth, bcrypt, db
+from flask_restful import Resource, reqparse, abort
+from Server.api import api
+from Server.models import get_user, TeacherModel
+
+
+register_argparse = reqparse.RequestParser()
+register_argparse.add_argument("username", type=str, help="Username is required", location='json', required=True)
+register_argparse.add_argument("email", type=str, help="Email is required", location='json', required=True)
+register_argparse.add_argument("password", type=str, help="Password is required", location='json', required=True)
+
+
+class RegisterResource(Resource):
+    def post(self):
+        args = register_argparse.parse_args()
+        if TeacherModel.query.filter_by(username=args['username']).first():
+            return abort(400, message="Username already taken")
+        if TeacherModel.query.filter_by(email=args['email']).first():
+            return abort(400, message="Email already taken")
+        
+        user = TeacherModel(
+            username=args['username'],
+            email=args['email'],
+            password=bcrypt.generate_password_hash(args['password'])
+        )
+        db.session.add(user)
+        db.session.commit()
+        return '', 204
+        
+         
+api.add_resource(RegisterResource, "/register")
\ No newline at end of file
diff --git a/Server/Server/api/clasrooms.py b/Server/Server/api/clasrooms.py
new file mode 100644
index 0000000..f4a8309
--- /dev/null
+++ b/Server/Server/api/clasrooms.py
@@ -0,0 +1,94 @@
+from Server.api import api
+from flask_restful import Resource, reqparse, abort, fields, marshal
+from Server import auth, db
+from Server.models import TeacherModel, ClassroomModel
+from werkzeug.datastructures import FileStorage
+from Server.utils import parser
+from Server.utils.utils import create_students_df
+import pandas as pd
+
+# Fields:
+classrooms_list_fields = { # Fields list of classrooms
+	'name': fields.String,
+	'id': fields.Integer
+}
+class StudentItemField(fields.Raw): # Custom field to parse StudentModel object
+
+	def format(self, value):
+		without_none = {k: v for k, v in value.__dict__ .items() if v is not None} # Getting only attributes which are not None
+		del without_none['_sa_instance_state']
+		del without_none['class_id']
+		return without_none
+
+classroom_resource_fields = { # Fields for a single classroom 
+	'name': fields.String,
+	'students': fields.List(StudentItemField)
+}
+
+
+# arg parsing:
+classrooms_post_argparse = reqparse.RequestParser()
+classrooms_post_argparse.add_argument('name', type=str, help="Name of the class is required", required=True)
+classrooms_post_argparse.add_argument('students_file', type=FileStorage, location='files', help="Student file is required", required=True)
+
+classroom_put_argparse = reqparse.RequestParser()
+classroom_put_argparse.add_argument('new_name', type=str, help="New name is required in order to update", location="json", required=True)
+
+
+class ClassroomsResource(Resource):
+	method_decorators = [auth.login_required]
+
+	def get(self, class_id=None):
+		if class_id is None:
+			return marshal(auth.current_user().classrooms, classrooms_list_fields)
+
+		current_class = ClassroomModel.query.filter_by(id=class_id, teacher=auth.current_user()).first() # Making sure the class belongs to the current user
+		if current_class is None:
+			abort(400, message="Invalid class id")
+		return marshal(current_class, classroom_resource_fields)
+
+	def post(self, class_id=None):
+		if class_id:
+			return abort(404, message="Invalid route")
+		args = classrooms_post_argparse.parse_args()
+		filename, stream = args['students_file'].filename.replace('"', ""), args['students_file'].stream  #TODO: replace here because of postman post request
+		students_df = create_students_df(filename, stream)
+		students = parser.parse_df(students_df)
+		
+		new_class = ClassroomModel(name=args['name'], teacher=auth.current_user())
+		db.session.add(new_class)
+		db.session.commit()
+
+		students['class_id'] = pd.Series([new_class.id] * students.shape[0])
+		students.to_sql('student', con=db.engine, if_exists="append", index=False)
+		return {'class_id': new_class.id}
+
+	def put(self, class_id=None):
+		if class_id is None:
+			return abort(404, message="Invalid route")
+		args = classroom_put_argparse.parse_args()
+		current_class = ClassroomModel.query.filter_by(id=class_id, teacher=auth.current_user()).first() # Making sure the class belongs to the current user
+		if current_class is None:
+			abort(400, message="Invalid class id")
+		current_class.name = args['new_name']
+		db.session.commit()
+		return "", 204
+
+	def delete(self, class_id=None):
+		if class_id is None: # Deleting all classes
+			teacher_classes_id = db.session.query(ClassroomModel.id).filter_by(teacher=auth.current_user()).all()
+			for class_data in teacher_classes_id:
+				current_class = ClassroomModel.query.filter_by(id=class_data.id, teacher=auth.current_user()).first()
+				db.session.delete(current_class)
+			db.session.commit()
+			return "", 204
+		
+		current_class = ClassroomModel.query.filter_by(id=class_id, teacher=auth.current_user()).first() # Making sure the class belongs to the current user
+		if current_class is None:
+			abort(400, message="Invalid class id")
+		
+		db.session.delete(current_class)
+		db.session.commit()
+		return "", 204
+
+api.add_resource(ClassroomsResource, "/classrooms", "/classrooms/<int:class_id>") 
\ No newline at end of file
diff --git a/Server/Server/api/reports.py b/Server/Server/api/reports.py
new file mode 100644
index 0000000..bee2f08
--- /dev/null
+++ b/Server/Server/api/reports.py
@@ -0,0 +1,105 @@
+from Server.api import api
+from flask_restful import Resource, reqparse, abort, marshal, fields
+from Server.utils.attendance_check import Attendance
+from werkzeug.datastructures import FileStorage
+from Server import db, auth
+from datetime import datetime
+import pandas as pd
+from Server.models import StudentModel, ClassroomModel, ReportModel, SessionModel, ZoomNamesModel, StudentStatus
+from Server.utils.utils import create_chat_df
+
+
+# marshals:
+reports_list_fields = { # Fields list of classrooms
+	'description': fields.String,
+	'id': fields.Integer
+}
+
+student_status_field = {
+    'status': fields.Integer,
+    'student_name': fields.String(attribute='student.name'),
+    'status_id': fields.Integer(attribute="id")
+}
+
+# args:
+report_post_args = reqparse.RequestParser()
+report_post_args.add_argument('description', type=str)
+report_post_args.add_argument('chat_file', type=FileStorage, help="Chat file is required", location='files', required=True)
+report_post_args.add_argument('time_delta', default=1, type=int)
+report_post_args.add_argument('date', default=datetime.now().date(), type=lambda x: datetime.strptime(x, '%d/%m/%y'))
+report_post_args.add_argument('first_sentence', type=str, help='First sentence is required in order to understand when does the check starts', required=True)
+report_post_args.add_argument('not_included_zoom_users', default=[], type=str, help='Must be a list of strings with zoom names', action="append")
+
+
+class ReportsResource(Resource):
+    method_decorators = [auth.login_required]
+    
+    def get(self, class_id, report_id=None): # TODO: create decorator that validates class_id
+        if ClassroomModel.query.filter_by(id=class_id, teacher=auth.current_user()).first() is None:
+            abort(400, message="Invalid class id")
+        if report_id is None:
+            return marshal(ReportModel.query.filter_by(class_id=class_id).all(), reports_list_fields)
+        report = ReportModel.query.filter_by(class_id=class_id, id=report_id).first()
+        if report is None:
+            abort(400, message="Invalid report id")
+        return marshal(report.student_statuses, student_status_field)
+        
+    def post(self, class_id, report_id=None):
+        args = report_post_args.parse_args()
+        if ClassroomModel.query.filter_by(id=class_id, teacher=auth.current_user()).first() is None:
+            abort(400, message="Invalid class id")
+        if report_id:
+            abort(404, message="Invalid route")
+
+        students_df = pd.read_sql(StudentModel.query.filter_by(class_id=class_id).statement, con=db.engine)
+
+
+        chat_file = args['chat_file'].stream.read().decode("utf-8").split("\n")
+        chat_df = create_chat_df(chat_file)
+        report_object = Attendance(chat_df, students_df, ['name', "id_number", "phone"], args['time_delta'], args['first_sentence'], args['not_included_zoom_users'])
+
+        message_time = report_object.first_message_time
+        report_time = datetime(args["date"].year, args["date"].month, args["date"].day,
+                               message_time.hour, message_time.minute, message_time.second)
+
+        new_report = ReportModel(description=args['description'], report_time=report_time, class_id=class_id)
+        db.session.add(new_report)
+        db.session.commit()
+
+        student_status_df = report_object.student_status_table(new_report.id)
+        student_status_df.to_sql('student_status', con=db.engine, if_exists="append", index=False)
+
+        for session_object in report_object.report_sessions:
+            session_table = SessionModel(start_time=session_object._first_message_time, report_id=new_report.id)
+            db.session.add(session_table)
+            db.session.commit()
+
+            zoom_names_df = session_object.zoom_names_table(session_table.id)
+            zoom_names_df.to_sql('zoom_names', con=db.engine, if_exists="append", index=False)
+
+            zoom_names_df = pd.read_sql(ZoomNamesModel.query.filter_by(session_id=session_table.id).statement, con=db.engine)
+            session_chat_df = session_object.chat_table(zoom_names_df)
+            session_chat_df.to_sql('chat', con=db.engine, if_exists="append", index=False)
+
+        return {"report_id": new_report.id}
+
+    def delete(self, class_id, report_id=None):
+        if ClassroomModel.query.filter_by(id=class_id, teacher=auth.current_user()).first() is None:
+            abort(400, message="Invalid class id")
+        if report_id is None:  # Deleting all reports of class
+            class_reports_id = db.session.query(ReportModel.id).filter_by(class_id=class_id).all()
+            for report_data in class_reports_id:
+                current_report = ReportModel.query.filter_by(id=report_data.id).first()
+                db.session.delete(current_report)
+            db.session.commit()
+            return "", 204
+
+        current_report = ReportModel.query.filter_by(id=report_id).first()  # Making sure the class belongs to the current user
+        if current_report is None:
+            abort(400, message="Invalid report id")
+
+        db.session.delete(current_report)
+        db.session.commit()
+        return "", 204
+
+api.add_resource(ReportsResource, '/classrooms/<int:class_id>/reports', '/classrooms/<int:class_id>/reports/<int:report_id>')
diff --git a/Server/Server/api/student_status.py b/Server/Server/api/student_status.py
new file mode 100644
index 0000000..13fdcf7
--- /dev/null
+++ b/Server/Server/api/student_status.py
@@ -0,0 +1,29 @@
+from Server.api import api
+from flask_restful import Resource, reqparse, abort
+from Server import db, auth
+from Server.models import StudentStatus
+
+STATUS_CHOICES = (0, 1, 2)
+
+# arg parsing:
+student_status_argparse = reqparse.RequestParser()
+student_status_argparse.add_argument('new_status', type=int,
+                                     help=f"Bad choice, please pick one of this choices {STATUS_CHOICES}",
+                                     required=True, location="json", choices=STATUS_CHOICES)
+
+class StudentStatusResource(Resource):
+    method_decorators = [auth.login_required]
+
+    def put(self, status_id):
+        args = student_status_argparse.parse_args()
+        status = StudentStatus.query.get(status_id)
+        if status is None or status.report.classroom.teacher != auth.current_user():
+            abort(400, message="Invalid status id")
+
+        status.status = args["new_status"]
+        db.session.commit()
+
+        return "", 204
+
+
+api.add_resource(StudentStatusResource, '/status/<int:status_id>')
diff --git a/Server/Server/classrooms/forms.py b/Server/Server/classrooms/forms.py
deleted file mode 100644
index e644b50..0000000
--- a/Server/Server/classrooms/forms.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from flask_wtf import FlaskForm
-from flask_wtf.file import FileField, FileAllowed, FileRequired
-from wtforms.validators import DataRequired
-from wtforms import StringField, SubmitField, IntegerField
-
-
-class CreateClassForm(FlaskForm):
-    name = StringField('Name of the class', validators=[DataRequired()])
-    students_file = FileField('Csv/Excel file of students', validators=[FileAllowed(['xlsx', 'csv', 'xls']), FileRequired()])
-    submit = SubmitField('Create')
-
-
-class CreateReportForm(FlaskForm):
-    start_sentence = StringField('Sentence to start the zoom check', validators=[DataRequired()])
-    chat_file = FileField('Zoom chat file', validators=[FileRequired(), FileAllowed(['txt'])]) 
-    time = IntegerField('Number of minutes', validators=[DataRequired()])
-    submit = SubmitField('Create Report')
diff --git a/Server/Server/classrooms/routes.py b/Server/Server/classrooms/routes.py
deleted file mode 100644
index 4112dfa..0000000
--- a/Server/Server/classrooms/routes.py
+++ /dev/null
@@ -1,74 +0,0 @@
-from flask import render_template, redirect, url_for, flash, Blueprint, request, session
-from Server import db
-from Server.classrooms.forms import CreateClassForm, CreateReportForm
-from Server.models import ClassroomModel, StudentModel, ReportModel, SessionModel, ZoomNamesModel, ChatModel
-from flask_login import current_user, login_required
-import pandas as pd
-from Server.classrooms.attendance_check import Attendance
-from Server.classrooms.utils import create_chat_df, create_students_df
-from Server.classrooms import parser
-from  datetime import datetime
-
-classrooms = Blueprint('classrooms', __name__)
-
-
-@classrooms.route('/', methods=['GET', 'POST'])
-@classrooms.route('/home', methods=['GET', 'POST'])
-@login_required
-def home():
-    form = CreateClassForm()
-    if form.validate_on_submit():
-        students_df = create_students_df(form.students_file.data.filename, form.students_file.data)
-        students = parser.parse_df(students_df)
-        new_class = ClassroomModel(name=form.name.data, teacher_model=current_user)
-        db.session.add(new_class)
-        db.session.commit()
-        students['class_id'] = pd.Series([new_class.id] * students.shape[0])
-        students.to_sql('student_model', con=db.engine, if_exists="append", index=False)
-        return redirect(url_for('classrooms.classroom', class_id=new_class.id))
-    return render_template('home.html', form=form)
-
-
-@classrooms.route('/classroom/<class_id>', methods=['GET', 'POST'])
-@login_required
-def classroom(class_id):
-    current_class = ClassroomModel.query.filter_by(id=class_id, teacher_model=current_user).first() # Making sure the class belongs to the current user
-    if current_class is None:
-        flash('Invalid class!', 'danger')
-        return redirect(url_for('classrooms.home'))
-    
-    form = CreateReportForm() 
-    if form.validate_on_submit(): # If form was submitted, creating report for the class
-        description = "this is the best class"  # TODO : add from the form file
-        report_date = datetime.now().date()    # TODO : add from the form file
-        students_df = pd.read_sql(StudentModel.query.filter_by(class_id=class_id).statement, con=db.engine)
-        chat_file = form.chat_file.data.stream.read().decode("utf-8").split("\n")
-        chat_df = create_chat_df(chat_file)
-
-        report_object = Attendance(chat_df, students_df, ['name', "id_number", "phone"], form.time.data, form.start_sentence.data, ["ITC", "Tech", "Challenge"])
-
-        new_report = ReportModel(description=description, start_time=report_object.first_message_time, report_date=report_date, class_id=class_id)
-        db.session.add(new_report)
-        db.session.commit()
-
-        # insert relevant data for each session to the database
-        for session_object in report_object.report_sessions:
-            session_table = SessionModel(start_time=session_object._first_message_time, report_id=new_report.id)
-            db.session.add(session_table)
-            db.session.commit()
-
-            zoom_names_df = session_object.zoom_names_table(session_table.id)
-            zoom_names_df.to_sql('zoom_names_model', con=db.engine, if_exists="append", index=False)
-
-            zoom_names_df = pd.read_sql(ZoomNamesModel.query.filter_by(session_id=session_table.id).statement, con=db.engine)
-            session_chat_df = session_object.chat_table(zoom_names_df)
-            session_chat_df.to_sql('chat_model', con=db.engine, if_exists="append", index=False)
-
-
-
-        return render_template("report.html")
-        
-
-    return render_template('classroom.html', current_class=current_class, form=form)
-
-
diff --git a/Server/Server/models.py b/Server/Server/models.py
index d47a8d3..fc0282c 100644
--- a/Server/Server/models.py
+++ b/Server/Server/models.py
@@ -1,32 +1,43 @@
-from Server import db, login_manager, app
+from Server import db, bcrypt, auth
 from flask_login import UserMixin
 
 
-@login_manager.user_loader
-def load_user(user_id):
-    return TeacherModel.query.get(int(user_id))
-
+@auth.verify_password
+def get_user(username_or_email, password):
+    user = TeacherModel.query.filter_by(email=username_or_email).first() or \
+         TeacherModel.query.filter_by(username=username_or_email).first() # User can be validated with both username and email
+    if user and bcrypt.check_password_hash(user.password, password):
+        return user
+    
 
 class TeacherModel(db.Model, UserMixin):
+    __tablename__ = 'teacher'
+
     id = db.Column(db.Integer, primary_key=True)
     username = db.Column(db.String(40), unique=True, nullable=False)
     email = db.Column(db.String(120), unique=True, nullable=False)
     password = db.Column(db.String(60), nullable=False) # 60 chars because of the hashing algo
-    classrooms = db.relationship('ClassroomModel', backref='teacher_model', lazy=True)
+   
+    classrooms = db.relationship('ClassroomModel', backref='teacher', lazy=True)
     
     def __repr__(self):
         return f'Teacher({self.username}, {self.email}, {self.password})'
 
 
 class ClassroomModel(db.Model):
+    __tablename__ = 'classroom'
+
     id = db.Column(db.Integer, primary_key=True)
     name = db.Column(db.String(70), unique=False, nullable=False)
-    teacher_id = db.Column(db.Integer, db.ForeignKey('teacher_model.id'), nullable=False)
-    students = db.relationship('StudentModel', backref='classroom_model', lazy=True)
-    reports = db.relationship('ReportModel', backref='classroom_model', lazy=True)
+
+    teacher_id = db.Column(db.Integer, db.ForeignKey('teacher.id'), nullable=False)
+    students = db.relationship('StudentModel', backref='classroom', cascade="all,delete", lazy=True)
+    reports = db.relationship('ReportModel', backref='classroom', cascade="all,delete", lazy=True)
 
 
 class StudentModel(db.Model):
+    __tablename__ = 'student'
+
     id = db.Column(db.Integer, primary_key=True)
     name = db.Column(db.String(70), unique=False, nullable=False)
     id_number = db.Column(db.String(10), unique=False, nullable=True)
@@ -34,43 +45,61 @@ class StudentModel(db.Model):
     gender = db.Column(db.Boolean, unique=False, nullable=True)  # True means male
     phone = db.Column(db.Integer, unique=False, nullable=True)
 
-    class_id = db.Column(db.Integer, db.ForeignKey('classroom_model.id'), nullable=False)
-    zoom_names = db.relationship('ZoomNamesModel', backref='student_model', lazy=True)
+    class_id = db.Column(db.Integer, db.ForeignKey('classroom.id'), nullable=False)
+    zoom_names = db.relationship('ZoomNamesModel', backref='student', lazy=True)
+    statuses = db.relationship('StudentStatus', backref='student', lazy=True)
 
 
 class ReportModel(db.Model):
+    __tablename__ = 'report'
+
     id = db.Column(db.Integer, primary_key=True)
     description = db.Column(db.Text(), unique=False, nullable=True)
-    start_time = db.Column(db.DateTime(), unique=False, nullable=False) # first timestamp of chat file
-    report_date = db.Column(db.Date(), unique=False, nullable=True) # date of the report - given by the user
+    report_time = db.Column(db.DateTime(), unique=False, nullable=False) # first timestamp of chat file, date by user or date of the request
 
-    class_id = db.Column(db.Integer, db.ForeignKey('classroom_model.id'), nullable=False)
-    sessions = db.relationship('SessionModel', backref='report_model', lazy=True)
+    class_id = db.Column(db.Integer, db.ForeignKey('classroom.id'), nullable=False)
+    sessions = db.relationship('SessionModel', backref='report',cascade="all,delete", lazy=True)
+    student_statuses = db.relationship('StudentStatus', backref='report', cascade="all,delete", lazy=True)
 
 
 class SessionModel(db.Model):
+    __tablename__ = 'session'
+
     id = db.Column(db.Integer, primary_key=True)
     start_time = db.Column(db.DateTime(), unique=False, nullable=False) # first timestamp of chat session
 
-    report_id = db.Column(db.Integer, db.ForeignKey('report_model.id'), nullable=False)
-    zoom_names = db.relationship('ZoomNamesModel', backref='session_model', lazy=True)
+    report_id = db.Column(db.Integer, db.ForeignKey('report.id'), nullable=False)
+    zoom_names = db.relationship('ZoomNamesModel', backref='session',cascade="all,delete", lazy=True)
 
 
 class ZoomNamesModel(db.Model):
+    __tablename__ = 'zoom_names'
+
     id = db.Column(db.Integer, primary_key=True)
     name = db.Column(db.String(50), unique=False, nullable=True)
-    session_id = db.Column(db.Integer, db.ForeignKey('session_model.id'), nullable=False)
-    student_id = db.Column(db.Integer, db.ForeignKey('student_model.id'), nullable=True) # if Null - means the student wasn't present in the session
 
-    chat = db.relationship('ChatModel', backref='zoom_names_model', lazy=True)
+    session_id = db.Column(db.Integer, db.ForeignKey('session.id'), nullable=False)
+    student_id = db.Column(db.Integer, db.ForeignKey('student.id'), nullable=True) # if Null - means the student wasn't present in the session
+    chat = db.relationship('ChatModel', backref='zoom_name',cascade="all,delete", lazy=True)
 
 
 class ChatModel(db.Model):
+    __tablename__ = 'chat'
+
     id = db.Column(db.Integer, primary_key=True)
     time = db.Column(db.DateTime, unique=False, nullable=False)  # time the message written
     message = db.Column(db.Text, unique=False, nullable=True)  # message zoom user wrote
     relevant = db.Column(db.Boolean, unique=False, nullable=False)  # True is message is part of the report
-    zoom_names_id = db.Column(db.Integer, db.ForeignKey('zoom_names_model.id'), nullable=False)
 
+    zoom_names_id = db.Column(db.Integer, db.ForeignKey('zoom_names.id'), nullable=False)
+
+
+class StudentStatus(db.Model):
+    __tablename__ = 'student_status'
+
+    id = db.Column(db.Integer, primary_key=True)
+    status = db.Column(db.Integer, unique=False, nullable=False)
 
+    student_id = db.Column(db.Integer, db.ForeignKey('student.id'), nullable=False)
+    report_id = db.Column(db.Integer, db.ForeignKey('report.id'), nullable=False)
 
diff --git a/Server/Server/templates/_render_form_field.html b/Server/Server/templates/_render_form_field.html
deleted file mode 100644
index e4947f8..0000000
--- a/Server/Server/templates/_render_form_field.html
+++ /dev/null
@@ -1,31 +0,0 @@
-{% macro render_field(field) %}
-
-<div class="form-group">
-    {{ field.label }}
-    {% if field.errors %}
-    {{ field(class="form-control is-invalid")}} 
-    <div class="invalid-feedback">
-      {% for error in field.errors %}
-          <span>{{ error }}</span>
-      {% endfor %}
-    </div>
-  {% else %}
-    {{ field(class="form-control")}} 
-  {% endif %}	
-</div>
-
-{% endmacro %}
-
-{% macro render_file_field(field) %}
-
-<div class="form-group">
-    {{ field.label }}
-    {{ field(class="form-control-file") }}
-    {% if field.errors %}
-    {% for error in field.errors %}
-        <span class="text-danger">{{ error }}</span>
-    {% endfor %}
-{% endif %}
-</div>
-
-{% endmacro %}
\ No newline at end of file
diff --git a/Server/Server/templates/classroom.html b/Server/Server/templates/classroom.html
deleted file mode 100644
index b6fa625..0000000
--- a/Server/Server/templates/classroom.html
+++ /dev/null
@@ -1,74 +0,0 @@
-{% extends "layout.html" %}
-{% from "_render_form_field.html" import render_field, render_file_field %}
-
-{% block content %}
-		<div class="row justify-content-between">
-			<div class="col-6">
-				<h3>Class: {{ current_class.name }}</h3>
-			</div>
-			<div class="col">
-                <button type="button" class="btn btn-success btn-block" data-toggle="collapse" data-target="#createReport">Create Report</button>
-            </div> 
-			<div class="col-1">
-				<a role="button" class="btn btn-dark" href="{{ url_for('classrooms.home') }}"><span class="fas fa-long-arrow-alt-left"></span></a>
-			</div>
-		</div>
-		<div class="row collapse" id="createReport">
-			<div class="col">
-				<div class="card card-body">
-					<form method="POST" action="" enctype="multipart/form-data" novalidate>
-						{{ form.hidden_tag() }}
-						{{ render_field(form.start_sentence) }}
-						{{ render_file_field(form.chat_file)}}
-						{{ render_field(form.time) }}
-						<div class="form-group">
-							{{ form.submit(class="btn btn-outline-info") }}
-						</div>
-					</form>
-				</div>
-			</div>
-		</div>
-		<div class="row">
-			<div class="col">
-				<table class="table table-bordered">
-					<thead class="thead-dark">
-						<tr>
-							<th scope="col">Student Name</th>
-							<th scope="col">Class</th>
-							<th scope="col">Id Number</th>
-							<th scope="col">Phone</th>
-							<th scope="col">gender</th>
-						</tr>
-					</thead>
-					<tbody>
-						{% for student in current_class.students %}
-							<tr>
-								<td>{{ student.name }}</td>
-								<td>{{ student.org_class }}</td>
-								{% if student.id_number == None %}
-									<td></td>
-								{% else %}
-									<td>{{ student.id_number }}</td>
-								{% endif %}
-								{% if student.phone == None %}
-								<td></td>
-								{% else %}
-									<td>{{ student.phone }}</td>
-								{% endif %}
-								{% if student.gender == None %}
-								<td></td>
-								{% else %}
-									{% if student.gender %}
-										<td>Male</td>
-									{% else %}
-										<td>Female</td>
-									{% endif %}
-								{% endif %}
-							</tr>
-						{% endfor %}
-					</tbody>
-				</table>
-			</div>
-		</div>
-
-{% endblock content %}
\ No newline at end of file
diff --git a/Server/Server/templates/home.html b/Server/Server/templates/home.html
deleted file mode 100644
index 081567c..0000000
--- a/Server/Server/templates/home.html
+++ /dev/null
@@ -1,46 +0,0 @@
-{% extends "layout.html" %}
-{% from "_render_form_field.html" import render_field, render_file_field %}
-
-{% block content %}
-    <div class="container">
-        <div class="row justify-content-between">
-            <div class="col-6">
-                <h3>My classes</h3>
-            </div>
-            <div class="col-1">
-                <button type="button" class="btn btn-success btn-block" data-toggle="collapse" data-target="#createClass"><span class="fas fa-plus"></span></button>
-            </div>
-        </div>
-        <div class="row collapse justify-content-center" id="createClass">
-            <div class="col">
-                <div class="card card-body">
-                    <form method="POST" action="" enctype="multipart/form-data" novalidate>
-                        {{ form.hidden_tag() }}
-                        <div class="row">
-                            <div class="col-8">
-                                {{ render_field(form.name) }}
-                            </div>
-                            <div class="col-4">
-                                {{ render_file_field(form.students_file) }}
-                            </div>
-                        </div>
-                        <div class="form-group">
-                            {{ form.submit(class="btn btn-outline-info") }}
-                        </div>
-                    </form>
-                </div>         
-            </div>
-        </div>
-        <div class="row">
-            <div class="col">
-                <div class="list-group">
-                    {% for classroom in current_user.classes %}                   
-                        <a href="{{ url_for('classrooms.classroom', class_id=classroom.id) }}" class="list-group-item list-group-item-action">
-                            {{ classroom.name }}
-                        </a>
-                    {% endfor %}
-                </div>
-            </div>
-        </div>
-    </div>
-{% endblock content %}
\ No newline at end of file
diff --git a/Server/Server/templates/layout.html b/Server/Server/templates/layout.html
deleted file mode 100644
index d4dd5d8..0000000
--- a/Server/Server/templates/layout.html
+++ /dev/null
@@ -1,61 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
-
-    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css" integrity="sha384-JcKb8q3iqJ61gNV9KGb8thSsNjpSL0n8PARn9HuZOnIxN0hoP+VmmDGMN5t9UJ0Z" crossorigin="anonymous">
-    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.0/css/all.css" integrity="sha384-lZN37f5QGtY3VHgisS14W3ExzMWZxybE1SJSEsQp9S+oqd12jhcu+A56Ebc1zFSJ" crossorigin="anonymous">
-    <style>
-      .row {
-        margin-top: 15px;
-      }
-    </style>
-
-    <title>Temp Title</title>
-  </head>
-  <body>
-    <nav class="navbar navbar-dark navbar-expand-sm bg-dark">
-      <a href="#" class="navbar-brand">Zoom Attendance</a>
-      <button class="navbar-toggler" data-toggle="collapse" data-target="#menu">
-        <span class="navbar-toggler-icon"></span>
-      </button>
-      <div class="collapse navbar-collapse" id="menu">
-        <ul class="navbar-nav ml-auto">
-          {% if current_user.is_authenticated %}
-            <li class="nav-item">
-              <a href={{ url_for('users.logout') }} class="nav-link">Logout</a>
-            </li>
-          {% else %}
-            <li class="nav-item">
-              <a href={{ url_for('users.register') }} class="nav-link">Register</a>
-            </li>       
-            <li class="nav-item">
-              <a href={{ url_for('users.login') }} class="nav-link">Login</a>
-            </li> 
-          {% endif %}
-        </ul>
-      </div>
-    </nav>
-    <main class="container" role="main">
-      <div class="row">
-        <div class="col">
-            {% with messages = get_flashed_messages(with_categories=true) %}
-                {% if messages %}
-                    {% for category, message in messages %}
-                        <div class="alert alert-{{ category }} alert-dismissable fade show" role="alert">
-                          {{ message }}
-                        </div>
-                    {% endfor %}
-                {% endif %}
-            {% endwith %}
-            {% block content %}{% endblock %}
-        </div>
-      </div>
-    </main>
-
-    <script src="https://code.jquery.com/jquery-3.5.1.slim.min.js" integrity="sha384-DfXdz2htPH0lsSSs5nCTpuj/zy4C+OGpamoFVy38MVBnE+IbbVYUew+OrCXaRkfj" crossorigin="anonymous"></script>
-    <script src="https://cdn.jsdelivr.net/npm/popper.js@1.16.1/dist/umd/popper.min.js" integrity="sha384-9/reFTGAW83EW2RDu2S0VKaIzap3H66lZH81PoYlFhbGU+6BZp6G7niu735Sk7lN" crossorigin="anonymous"></script>
-    <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.min.js" integrity="sha384-B4gt1jrGC7Jh4AgTPSdUtOBvfO8shuf57BaghqFfPlYxofvL8/KUEfYiJOMMV+rV" crossorigin="anonymous"></script>
-  </body>
-</html>
\ No newline at end of file
diff --git a/Server/Server/templates/login.html b/Server/Server/templates/login.html
deleted file mode 100644
index 97196f5..0000000
--- a/Server/Server/templates/login.html
+++ /dev/null
@@ -1,19 +0,0 @@
-{% extends "layout.html" %}
-{% from "_render_form_field.html" import render_field %}
-
-{% block content %}
-
-<form method="POST" action="" style="width: 500px; margin:auto" novalidate>
-    {{ form.hidden_tag() }}
-    {{ render_field(form.auth) }}
-    {{ render_field(form.password)}}
-    <div class="form-check">
-        {{ form.remember(class="form-check-input") }}   
-        {{ form.remember.label() }}
-    </div>
-    <div class="form-group">
-        {{ form.submit(class="btn btn-outline-info")}}
-    </div>
-</form>
-
-{% endblock content %}
\ No newline at end of file
diff --git a/Server/Server/templates/register.html b/Server/Server/templates/register.html
deleted file mode 100644
index 0f4cb2b..0000000
--- a/Server/Server/templates/register.html
+++ /dev/null
@@ -1,15 +0,0 @@
-{% extends "layout.html" %}
-{% from "_render_form_field.html" import render_field %}
-
-{% block content %}
-<form method="POST" action="" style="width: 500px; margin:auto" novalidate>
-    {{ form.hidden_tag() }}
-    {{ render_field(form.username) }}
-    {{ render_field(form.email) }}
-    {{ render_field(form.password) }}
-    {{ render_field(form.confirm_password) }}
-    <div class="form-group">
-        {{ form.submit(class="btn btn-outline-info")}}
-    </div>
-</form>
-{% endblock content %}
\ No newline at end of file
diff --git a/Server/Server/templates/report.html b/Server/Server/templates/report.html
deleted file mode 100644
index 0f25d3b..0000000
--- a/Server/Server/templates/report.html
+++ /dev/null
@@ -1,4 +0,0 @@
-{% extends "layout.html" %}
-{% block content %}
-<h1>Reports file</h1>
-{% endblock content %}
\ No newline at end of file
diff --git a/Server/Server/users/__init__.py b/Server/Server/users/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/Server/Server/users/forms.py b/Server/Server/users/forms.py
deleted file mode 100644
index e2dd8aa..0000000
--- a/Server/Server/users/forms.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from flask_wtf import FlaskForm
-from wtforms import StringField, PasswordField, SubmitField, BooleanField
-from wtforms.validators import DataRequired, EqualTo, Length, Email, ValidationError
-from Server.models import TeacherModel
-
-
-class RegistrationForm(FlaskForm):
-    username = StringField('Username', validators=[DataRequired()]) 
-    email = StringField('Email', validators=[DataRequired(), Email()])
-    password = PasswordField('Password', validators=[DataRequired(), Length(min=8)])
-    confirm_password = PasswordField('Confirm Password', validators=[EqualTo('password')])
-    submit = SubmitField('Sign Up')
-
-    def validate_username(self, username):
-        user = TeacherModel.query.filter_by(username=username.data).first()
-        if user:
-            print(user)
-            raise ValidationError('Username already taken.')
-        # Add special signs validations
-
-    def validate_email(self, email):
-        user = TeacherModel.query.filter_by(email=email.data).first()
-        if user:
-            raise ValidationError('Email already taken.')     
-
-
-class LoginForm(FlaskForm):
-    auth = StringField('Auth', validators=[DataRequired()]) # Auth can be username or email
-    password = PasswordField('Password', validators=[DataRequired()])
-    remember = BooleanField('Remember Me')
-    submit = SubmitField('Login')
diff --git a/Server/Server/users/routes.py b/Server/Server/users/routes.py
deleted file mode 100644
index 7418fdf..0000000
--- a/Server/Server/users/routes.py
+++ /dev/null
@@ -1,51 +0,0 @@
-from flask import render_template, redirect, url_for, flash, Blueprint
-from Server import bcrypt, db
-from Server.users.forms import LoginForm, RegistrationForm
-from Server.models import TeacherModel
-from flask_login import login_user, current_user, logout_user, login_required
-
-users = Blueprint('users', __name__)
-
-@users.route('/login', methods=['GET', 'POST'])
-def login():
-    if current_user.is_authenticated:
-        return redirect(url_for('classrooms.home'))
-
-    form = LoginForm()
-    if form.validate_on_submit():
-        user = TeacherModel.query.filter_by(email=form.auth.data).first() or \
-         TeacherModel.query.filter_by(username=form.auth.data).first() # User can be validated with both username and email
-        if user and bcrypt.check_password_hash(user.password, form.password.data):
-            login_user(user, remember=form.remember.data)
-            return redirect(url_for('classrooms.home'))
-        else: # Unique validation that has to be checked here
-            flash(f'Invalid credentials', 'danger')
-
-    return render_template('login.html', form=form)
-
-
-@users.route('/register', methods=['GET', 'POST'])
-def register():
-    if current_user.is_authenticated:
-        return redirect(url_for('classrooms.home'))
-
-    form = RegistrationForm()
-    if form.validate_on_submit():
-        hashed_password = bcrypt.generate_password_hash((form.password.data)).decode('utf-8') 
-        user = TeacherModel(
-            username=form.username.data,
-            password=hashed_password,
-            email=form.email.data
-        )
-        db.session.add(user)
-        db.session.commit()
-        flash(f'Account created for {form.username.data}!', 'success')
-        return redirect(url_for('users.login'))
-    return render_template('register.html', form=form)
-
-
-@users.route('/logout')
-@login_required
-def logout():
-    logout_user()
-    return redirect(url_for('users.login'))
\ No newline at end of file
diff --git a/Server/Server/classrooms/__init__.py b/Server/Server/utils/__init__.py
similarity index 56%
rename from Server/Server/classrooms/__init__.py
rename to Server/Server/utils/__init__.py
index daaea2c..790df24 100644
--- a/Server/Server/classrooms/__init__.py
+++ b/Server/Server/utils/__init__.py
@@ -1,5 +1,5 @@
 from Server.config import ParseConfig
-from Server.classrooms.loading_classroom_file import ParseClassFile
+from Server.utils.loading_classroom_file import ParseClassFile
 
 
 parser = ParseClassFile.from_object(ParseConfig)
\ No newline at end of file
diff --git a/Server/Server/classrooms/attendance_check.py b/Server/Server/utils/attendance_check.py
similarity index 74%
rename from Server/Server/classrooms/attendance_check.py
rename to Server/Server/utils/attendance_check.py
index a1bc161..117480c 100644
--- a/Server/Server/classrooms/attendance_check.py
+++ b/Server/Server/utils/attendance_check.py
@@ -4,30 +4,31 @@
 
 class Attendance:
     """
-    receives student class df, the zoom chat and other configuration. returns:
-     1. table of attendant students from the student class df
-     2. list of table of relevant data from zoom users that didn't add a student return
+    receives student class df, the zoom chat and other configuration.
+    returns:
+     1. report_sessions - session object
+     2. student_status_table - df of "student" table
     """
     def __init__(self, chat_df, students_df, filter_modes, time_delta, start_sentence, not_included_zoom_users):
         """
-        - convert the chat text file to a data frame and arrange columns.
-        - creates df for each session according the appearance of the start sentence and time delta
         :param chat_df: zoom chat in df (df)
         :param students_df: student class raw data (df)
         :param filter_modes: filters the user picked for parsing the text file (list of str)
         :param time_delta: max time from start sentence to the last message to parse in each session in minutes (int)
         :param start_sentence: start sentence that initiate sessions for parse (str)
+        :param not_included_zoom_users: zoom names that will not be considered (list of str)
         :return: data frame with the data from the chat
         """
 
-        self.first_message_time = chat_df["time"].sort_values().iloc[0]
+        self.first_message_time = chat_df["time"].sort_values().iloc[0] # get time of first message in the chat
         start_indices = chat_df.index[chat_df['message'].apply(lambda string: start_sentence.lower() in string.lower())] #TODO: slice by time or by next message
         df_students_for_report = students_df.set_index("id").astype(str).reset_index()  # set all columns to str except the id
+        self._df_students = df_students_for_report
 
         self._sessions = []
         for start_index in start_indices:
             df_session = Attendance.get_df_of_time_segment(chat_df, start_index, time_delta)
-            self._sessions.append(Session(df_students_for_report, df_session, filter_modes, not_included_zoom_users))
+            self._sessions.append(Session(self._df_students, df_session, filter_modes, not_included_zoom_users))
 
     @staticmethod
     def get_df_of_time_segment(df, start_index, time_delta):
@@ -43,14 +44,24 @@ def get_df_of_time_segment(df, start_index, time_delta):
     def report_sessions(self):
         return self._sessions
 
+    def student_status_table(self, report_id):
+        df_status_report = self._df_students.loc[:, ["id", "name"]]
+        for i, session_object in enumerate(self.report_sessions):
+            df_status_report[f"session_{i}"] = df_status_report["id"].apply(lambda x: 1 if x in session_object._relevant_chat["id"].values else np.nan)
+
+        status = lambda row: 0 if row.isna().all() else (1 if row.isna().any() else 2)  # {0 : "red", 1: "yellow", 2: "green"}
+        df_status_report["status"] = df_status_report.loc[:, df_status_report.columns.str.startswith('session')].apply(status, axis=1)
+        df_status_report['report_id'] = pd.Series([report_id] * df_status_report.shape[0])
+        df_status_report.rename(columns={"id": "student_id"}, inplace=True)
+        return df_status_report.loc[:, ["student_id", "report_id", "status"]]
+
 
 class Session:
 
-    def __init__(self, df_students, df_session_chat, filter_modes, not_included_zoom_users):
+    def __init__(self, students_df, df_session_chat, filter_modes, not_included_zoom_users):
 
         self._first_message_time = df_session_chat["time"].sort_values().iloc[0]
-        self._relevant_chat = self.get_participants_in_session(df_students,filter_modes, df_session_chat, not_included_zoom_users)
-
+        self._relevant_chat = self.get_participants_in_session(students_df, filter_modes, df_session_chat, not_included_zoom_users)
 
     @ staticmethod
     def get_participants_in_session(df_students, filter_modes, df_chat, not_included_zoom_users):
@@ -103,7 +114,8 @@ def chat_table(self, zoom_df):
     df_students = create_students_df(file_name=excel_file_path.split("\\")[-1], file_data=excel_file_path)
 
     my_class = Attendance(chat_df, df_students, ['name', "id_number", "phone"], 5, "Attendance check", ["ITC", "Tech", "Challenge"])
-
-    df_part_session = my_class._sessions[0]
-    df_part_session.zoom_names_table(2)
+    a = my_class.student_status_table(1)
+    print(a)
+    # df_part_session = my_class._sessions[0]
+    # df_part_session.zoom_names_table(2)
 
diff --git a/Server/Server/classrooms/loading_classroom_file.py b/Server/Server/utils/loading_classroom_file.py
similarity index 98%
rename from Server/Server/classrooms/loading_classroom_file.py
rename to Server/Server/utils/loading_classroom_file.py
index a02e126..3c68734 100644
--- a/Server/Server/classrooms/loading_classroom_file.py
+++ b/Server/Server/utils/loading_classroom_file.py
@@ -29,7 +29,6 @@ def parse_df(self, df_students):
                     current_excel_dict[key] = df_students[col]
 
         if len(current_excel_dict) == 0 and len(relevant_cols) <= 1:
-            print("Mashov file")
             header_index = df_students.notnull().sum(axis=1).argmax()
             df_students = pd.DataFrame(df_students.values[header_index + 1:-2], columns=df_students.iloc[header_index])
             df_students.dropna(axis=0, how='all', inplace=True)
diff --git a/Server/Server/classrooms/utils.py b/Server/Server/utils/utils.py
similarity index 99%
rename from Server/Server/classrooms/utils.py
rename to Server/Server/utils/utils.py
index b5b82db..d2929af 100644
--- a/Server/Server/classrooms/utils.py
+++ b/Server/Server/utils/utils.py
@@ -15,12 +15,10 @@ def create_chat_df(chat_file):
 
 
 def create_students_df(file_name, file_data):
-
     if file_name.endswith(".csv"):
         df_students = pd.read_csv(file_data)
     elif file_name.endswith(".xlsx"):
         df_students = pd.read_excel(file_data)
     else:
         df_students = pd.read_html(file_data, header=1)[0]
-
     return df_students
\ No newline at end of file