update logout doc

2. get_attendance wip

README.md

@@ -1,9 +1,29 @@
 ## Worflow
+install the dependencies by running `pip install -r requirements.txt`
 start the server by running
 `$python server.py`
 
 ### Login
-`$http --session=./session.json -f POST http://127.0.0.1:5000/api/login username=user@example.com password=password`
+`$ http --session=./session.json -f POST http://127.0.0.1:5000/api/login username=user@example.com password=password`
 
 ### Update Attendance
-`$http --session=./session.json -f POST http://127.0.0.1:5000/api/attendance/student presence=absent identifier=2 time=now`
+The `time` is optional and it may contain values *'now'* or *ISO-8601 time-string*
+#### Student :
+`$ http --session=./session.json -f POST http://127.0.0.1:5000/api/attendance/student presence=absent identifier=2 time=now`
+#### Class :
+`$ http --session=./session.json -f POST http://127.0.0.1:5000/api/attendance/class presence=present identifier=1 time=now`
+
+
+### Get Attendance
+The `start_time` and `end_time` are optional and they may contain values *'now'* or **time string**
+#### Student:
+`$ http --session=./session.json GET "http://127.0.0.1:5000/api/attendance/student?identifier=2&start_time=now&end_time=now"`
+
+or
+
+`$ http --session=./session.json GET "http://127.0.0.1:5000/api/attendance/student?identifier=3&start_time=now&end_time=now"`
+#### Class:
+`$ http --session=./session.json GET "http://127.0.0.1:5000/api/attendance/class?identifier=1"`
+
+### Logout
+`$ http --session=./session.json GET "http://127.0.0.1:5000/api/logout"`

models.py

@@ -1,32 +1,43 @@
 from flask_sqlalchemy import SQLAlchemy
-from flask_security import UserMixin,RoleMixin
+from flask_security import UserMixin, RoleMixin
-from enum import Enum,unique
+from enum import Enum, unique
 from datetime import datetime
 
 db = SQLAlchemy()
 
 roles_users = db.Table('roles_users',
-        db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
+                       db.Column('user_id',
-        db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
+                                 db.Integer(), db.ForeignKey('user.id')),
+                       db.Column('role_id',
+                                 db.Integer(), db.ForeignKey('role.id')))
+
 
 class Role(db.Model, RoleMixin):
     id = db.Column(db.Integer(), primary_key=True)
     name = db.Column(db.String(80), unique=True)
     description = db.Column(db.String(255))
 
+
 class User(db.Model, UserMixin):
     id = db.Column(db.Integer, primary_key=True)
     email = db.Column(db.String(255), unique=True)
     password = db.Column(db.String(255))
     active = db.Column(db.Boolean())
     confirmed_at = db.Column(db.DateTime())
-    roles = db.relationship('Role', secondary=roles_users,
+    roles = db.relationship(
-                            backref=db.backref('users', lazy='dynamic'))
+        'Role',
+        secondary=roles_users,
+        backref=db.backref('users', lazy='dynamic'))
+
 
 @unique
 class Presence(Enum):
     """docstring for ResultType."""
-    PRESENT,ABSENT,SICK,VACATION = range(4)
+    PRESENT, ABSENT, SICK, VACATION = range(4)
+
+
+presense_map = {i: str(i).replace('Presence.', '').upper() for i in Presence}
+
 
 class Gradeclass(db.Model):
     id = db.Column(db.Integer, primary_key=True)
@@ -35,16 +46,19 @@ class Gradeclass(db.Model):
     def __init__(self, class_name):
         self.class_name = class_name
 
+
 class Student(db.Model):
     id = db.Column(db.Integer, primary_key=True)
     student_name = db.Column(db.String(255))
     gradeclass_id = db.Column(db.Integer, db.ForeignKey('gradeclass.id'))
-    gradeclass = db.relationship('Gradeclass',backref=db.backref('gradeclass', lazy='dynamic'))
+    gradeclass = db.relationship(
+        'Gradeclass', backref=db.backref('students', lazy='dynamic'))
 
-    def __init__(self, student_name,gradeclass_id):
+    def __init__(self, student_name, gradeclass_id):
         self.student_name = student_name
         self.gradeclass_id = gradeclass_id
 
+
 class AttendanceUpdate(db.Model):
     id = db.Column(db.Integer, primary_key=True)
     time = db.Column(db.DateTime())
@@ -52,7 +66,7 @@ class AttendanceUpdate(db.Model):
     update_type = db.Column(db.String(10))
     value_identifier = db.Column(db.Integer)
 
-    def __init__(self, update_type, value_identifier,time,presence):
+    def __init__(self, update_type, value_identifier, time, presence):
         self.update_type = update_type
         self.value_identifier = value_identifier
         self.presence = presence

requirements.txt

@@ -2,7 +2,9 @@ aniso8601==1.2.1
 Babel==2.5.0
 bcrypt==3.1.3
 blinker==1.4
+certifi==2017.7.27.1
 cffi==1.10.0
+chardet==3.0.4
 click==6.7
 Flask==0.12.2
 Flask-BabelEx==0.9.3
@@ -10,10 +12,11 @@ Flask-Login==0.4.0
 Flask-Mail==0.9.1
 Flask-Principal==0.4.0
 Flask-Restless==0.17.0
-flask-restplus==0.10.1
 Flask-Security==3.0.0
 Flask-SQLAlchemy==2.2
 Flask-WTF==0.14.2
+httpie==0.9.9
+idna==2.6
 itsdangerous==0.24
 Jinja2==2.9.6
 jsonschema==2.6.0
@@ -21,11 +24,14 @@ MarkupSafe==1.0
 mimerender==0.6.0
 passlib==1.7.1
 pycparser==2.18
+Pygments==2.2.0
 python-dateutil==2.6.1
 python-mimeparse==1.6.0
 pytz==2017.2
+requests==2.18.4
 six==1.10.0
 speaklater==1.3
 SQLAlchemy==1.1.13
+urllib3==1.22
 Werkzeug==0.12.2
 WTForms==2.1

server.py

@@ -1,8 +1,11 @@
-from flask import Flask, Blueprint, request, Response
+from flask import Flask, Blueprint, request
-from flask_security import SQLAlchemyUserDatastore, login_required, current_user, Security
+from flask_security import (SQLAlchemyUserDatastore, login_required,
-from flask_security.utils import verify_and_update_password,login_user
+                            current_user, Security)
+from flask_security.utils import (verify_and_update_password, login_user,
+                                  logout_user)
 from flask_restless import APIManager, ProcessingException
-from models import db, User, Role, Gradeclass, Student, AttendanceUpdate, Presence
+from models import (db, User, Role, Gradeclass, Student, AttendanceUpdate,
+                    Presence, presense_map)
 from sqlalchemy import func
 import json
 from datetime import datetime, date
@@ -11,11 +14,11 @@ from dateutil import parser
 app = Flask(__name__)
 app.config['DEBUG'] = True
 app.config['PORT'] = 5001
-app.config['SECRET_KEY'] = 'super-secret'
+app.config['SECRET_KEY'] = '3kljk1232kl1j32kmk13nbciw'
 app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/db.sqlite'
 app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
-app.config['DEFAULT_MAIL_SENDER'] = 'info@example.com'
 app.config['SECURITY_PASSWORD_SALT'] = 'uaisfyasiduyaisiuf'
+app.config['SECURITY_UNAUTHORIZED_VIEW'] = None
 
 db.init_app(app)
 user_datastore = SQLAlchemyUserDatastore(db, User, Role)
@@ -23,18 +26,28 @@ security = Security(app, user_datastore)
 
 
 def auth_func(*args, **kwargs):
-    # if not current_user.is_authenticated:
+    if not current_user.is_authenticated:
-    #     raise ProcessingException(description='Not authenticated', code=401)
+        raise ProcessingException(description='Not authenticated', code=401)
     return True
 
 
 verify_logged_id = dict(GET_SINGLE=[auth_func], GET_MANY=[auth_func])
 
 manager = APIManager(app, flask_sqlalchemy_db=db)
-manager.create_api(Student, methods=[
+manager.create_api(
-                   'GET', 'PUT'], results_per_page=5, preprocessors=verify_logged_id)
+    Student,
-manager.create_api(Gradeclass, methods=[
+    methods=['GET', 'PUT'],
-                   'GET', 'PUT'], results_per_page=5, preprocessors=verify_logged_id)
+    results_per_page=5,
+    preprocessors=verify_logged_id)
+manager.create_api(
+    Gradeclass,
+    methods=['GET', 'PUT'],
+    results_per_page=5,
+    preprocessors=verify_logged_id)
+
+json_cont = {'Content-Type': 'application/json'}
+resp = lambda val, code: (json.dumps({'status': val}), code, json_cont)
+resp_res = lambda val, code: (json.dumps({'results': val}), code, json_cont)
 
 
 @app.before_first_request
@@ -42,11 +55,13 @@ def create_test_data():
     try:
         db.drop_all()
         db.create_all()
-        for i in range(12):
+        for i in range(3):
             g_cls = Gradeclass("Class {}".format(i))
             db.session.add(g_cls)
-            for s in range(10):
+            db.session.commit()
-                stu = Student("TestStudent#{}-Class{}".format(s,i), g_cls.id)
+            for s in range(5):
+                stu = Student("TestStudent#{}-Class{}".format(s + 1, g_cls.id),
+                              g_cls.id)
                 db.session.add(stu)
         user_datastore.create_user(
             email='user@example.com', password='password')
@@ -55,81 +70,143 @@ def create_test_data():
         pass
 
 
-def api_resp(data, code=200):
-    return Response(response=data,
-                    status=code,
-                    mimetype="application/json")
-
 def parse_time(time_str):
     utc_now = (time_str and time_str == 'now') or not time_str
     time = datetime.utcnow() if utc_now else None
     try:
-        time = parser.parse(attend_date)
+        time = parser.parse(time_str)
     except:
         pass
     return time
 
+
+def compute_attendance(request_type, object_id, start_time, end_time):
+    def get_records(req_type, obj_id):
+        return AttendanceUpdate.query.filter(
+            AttendanceUpdate.update_type == req_type).filter(
+                AttendanceUpdate.value_identifier == obj_id).filter(
+                    func.date(AttendanceUpdate.time) >=
+                    start_time.date()).filter(
+                        func.date(AttendanceUpdate.time) <=
+                        end_time.date()).all()
+
+    def student_records(stud_id):
+        stud_recs = get_records('student', stud_id)
+        stud = Student.query.get(stud_id)
+        gcls_recs = get_records('class', stud.gradeclass_id)
+        pres_rec = stud_recs
+        for gr in gcls_recs:
+            # if any grade record overlaps with student record -> ignore
+            if not any(
+                    map(lambda x: gr.time.date() == x.time.date(), stud_recs)):
+                pres_rec.append(gr)
+        recs = []
+        # sort student records by time
+        for r in sorted(pres_rec, key=lambda x: x.time):
+            recs.append({
+                "presence": presense_map[r.presence].lower(),
+                "student": stud.student_name,
+                "time": r.time.isoformat()
+            })
+        return recs
+
+    result = []
+    if request_type == 'student':
+        result.extend(student_records(object_id))
+    if request_type == 'class':
+        gcls = Gradeclass.query.get(object_id)
+        # get result for each student
+        for stud in gcls.students:
+            result.extend(student_records(stud.id))
+    return result
+
+
 def upsert_attendance(update_type, object_id, attend_time, pres_enum):
     existing = AttendanceUpdate.query.filter(
-            AttendanceUpdate.update_type == update_type
+        AttendanceUpdate.update_type == update_type).filter(
-        ).filter(
+            AttendanceUpdate.value_identifier == object_id).filter(
-            AttendanceUpdate.value_identifier == object_id
+                func.date(
-        ).filter(
+                    AttendanceUpdate.time) == attend_time.date()).first()
-            func.date(AttendanceUpdate.time) == attend_time.date()
-        ).first()
     if existing:
         existing.presence = pres_enum
     else:
-        new_entry = AttendanceUpdate(
+        new_entry = AttendanceUpdate(update_type, object_id, attend_time,
-            update_type, object_id, attend_time, pres_enum)
+                                     pres_enum)
         db.session.add(new_entry)
     db.session.commit()
 
+
 def validate_attend(update_type, object_id):
-    return True
     if update_type in ['class', 'student'] and object_id:
-        g_cls_found =  update_type == 'class' and Gradeclass.query.get(object_id)
+        g_cls_found = update_type == 'class' and Gradeclass.query.get(
-        stud_found =  update_type == 'student' and Student.query.get(object_id)
+            object_id)
+        stud_found = update_type == 'student' and Student.query.get(object_id)
         return g_cls_found or stud_found
     else:
         return False
 
 
-presense_keys = [str(i).replace('Presence.', '').upper() for i in Presence]
+def get_attendance(update_type, request):
+    object_id = request.args.get('identifier', None)
+    start_timestr = request.args.get('start_time', None)
+    end_timestr = request.args.get('end_time', None)
+    start_time, end_time = parse_time(start_timestr), parse_time(end_timestr)
+    ret_data = resp('invalid', 400)
+    if validate_attend(update_type, object_id) and start_time and end_time:
+        pres = compute_attendance(update_type, object_id, start_time, end_time)
+        ret_data = resp_res(pres, 200)
+    return ret_data
 
 
-@app.route('/api/attendance/<update_type>', methods=['POST'])
+def update_attendance(update_type, request):
-# @login_required
-def update_attendance(update_type):
     object_id = request.form.get('identifier', None)
     presence = request.form.get('presence', None)
     attend_str = request.form.get('time', None)
     attend_time = parse_time(attend_str)
-    ret_data = (json.dumps({'status': 'invalid'}),400)
+    ret_data = resp('invalid', 400)
-    if validate_attend(update_type, object_id) and presence and attend_time and presence.upper() in presense_keys:
+    if validate_attend(
+            update_type,
+            object_id) and presence and attend_time and presence.upper(
+            ) in presense_map.values():
         pres_enum = Presence[presence.upper()]
         upsert_attendance(update_type, object_id, attend_time, pres_enum)
-        ret_data = (json.dumps({'status': 'updated'}),200)
+        ret_data = resp('updated', 200)
-    return api_resp(*ret_data)
+    return ret_data
 
-@app.route('/api/login',methods=['POST'])
+
+@app.route('/api/attendance/<update_type>', methods=['GET', 'POST'])
+@login_required
+def attendance(update_type):
+    if request.method == 'GET':
+        return get_attendance(update_type, request)
+    elif request.method == 'POST':
+        return update_attendance(update_type, request)
+
+
+@app.route('/api/login', methods=['POST'])
 def login():
     username = request.form.get('username', None)
     password = request.form.get('password', None)
-    print(username,password)
+    ret_data = (json.dumps({'status': 'failed'}), 401, json_cont)
-    ret_data = (json.dumps({'status': 'failed'}),401)
     if username and password:
         user = User.query.filter(User.email == username).first()
         if not user:
-            ret_data = (json.dumps({'status': 'notfound'}),401)
+            ret_data = resp('notfound', 401)
-        elif verify_and_update_password(password,user):
+        elif verify_and_update_password(password, user):
             login_user(user)
-            ret_data = (json.dumps({'status': 'success'}),200)
+            ret_data = resp('success', 200)
     return ret_data
 
+
+@app.route('/api/logout', methods=['GET'])
+def logout():
+    logout_user()
+    return resp('success', 200)
+
+
 @app.route('/')
 def home():
-    return 'hello'
+    return 'welcome'
 
 
 if __name__ == '__main__':