This is Python Server
5 | Project Screenshots 6 |
7 | 
8 |
9 |
8 |
10 | 
11 |
12 |
--------------------------------------------------------------------------------
/BusTrack/repository/__init__.py:
--------------------------------------------------------------------------------
1 | from sqlalchemy import create_engine
2 | from sqlalchemy.orm import sessionmaker
3 | from sqlalchemy.ext.declarative import declarative_base
4 | from sqlalchemy.pool import StaticPool
5 |
6 | ENGINE_CONNECTION_STRING = 'sqlite:///data.db'
7 |
8 | # create sqlite database engine.
9 | # these setting's are applicable for sqlite3 only.
10 | engine = create_engine(ENGINE_CONNECTION_STRING, echo=True, connect_args={'check_same_thread': False},
11 | poolclass=StaticPool)
12 | session_maker = sessionmaker(bind=engine)
13 | session = session_maker()
14 |
15 | Base = declarative_base()
16 |
--------------------------------------------------------------------------------
/BusTrack/controllers/HelloWorldController.py:
--------------------------------------------------------------------------------
1 | from flask_restful import Resource
2 | from flask import session
3 | from BusTrack.services.UserService import UserService
4 | from BusTrack.repository.schema import users_schema
5 |
6 |
7 | class HelloWorldController(Resource):
8 |
9 | def get(self):
10 | # data = {'hello': 'world'}
11 | u = UserService()
12 | c = u.get_all_user()
13 | if 'user' not in session:
14 | session['user'] = {}
15 | session['user'] = {'a':'a'}# users_schema.jsonify(c)
16 | print('session',session['user'])
17 | return users_schema.jsonify(c)
18 |
--------------------------------------------------------------------------------
/BusTrack/static/js/app.js:
--------------------------------------------------------------------------------
1 |
2 | 'use strict';
3 |
4 | var myApp=angular.module('myApp',['ngRoute',]);
5 |
6 | // routing configuration
7 | myApp.config(['$routeProvider',
8 | function($routeProvider){
9 | $routeProvider.when('/',{
10 | templateUrl:'/static/partials/index.html'
11 | }).when('/about',{
12 | templateUrl:'/static/partials/about.html'
13 | }).when('/register',{
14 | templateUrl:'/static/partials/register.html'
15 | }).when('/login',{
16 | templateUrl:'/static/partials/login.html'
17 | }).when('/task',{
18 | templateUrl:'static/partials/task.html'
19 | }).otherwise(
20 | {
21 | redirectTo:'/'
22 | });
23 |
24 | }]);
25 |
26 |
--------------------------------------------------------------------------------
/BusTrack/helpers/validators.py:
--------------------------------------------------------------------------------
1 | # some validation code related to form
2 | from wtforms.validators import ValidationError
3 |
4 | class Unique(object):
5 | def __init__(self,model,field=None,message='Element already exist.'):
6 | self.model=model
7 | self.field=field
8 | self.message=message
9 |
10 | def __call__(self,form,field):
11 | # check if this field already exist in Model
12 | # in case model require no field
13 | check=False
14 | if field is None:
15 | check=self.model.is_unique()
16 | else:
17 | check=self.model.is_unique(field.raw_data[0])
18 | if check==False:
19 | raise ValidationError(self.message)
--------------------------------------------------------------------------------
/BusTrack/repository/models/Feedback.py:
--------------------------------------------------------------------------------
1 | from sqlalchemy import Column, String, Integer, ForeignKey, DateTime
2 | from datetime import datetime
3 | from BusTrack.repository import Base
4 | from BusTrack.repository.models import STRING_LEN_SMALL, STRING_LEN_MEDIUM, STRING_LEN_LARGE, LEN_MOBILE
5 |
6 |
7 | class Feedback(Base):
8 | __tablename__ = 'feedback'
9 |
10 | id = Column(Integer, primary_key=True)
11 | name = Column(String(STRING_LEN_SMALL))
12 | email = Column(String(STRING_LEN_SMALL))
13 | title = Column(String(STRING_LEN_MEDIUM))
14 | message = Column(String(STRING_LEN_LARGE))
15 | date = Column(DateTime, default=datetime.utcnow())
16 | user_id = Column(ForeignKey('user.id'), default=None)
17 |
--------------------------------------------------------------------------------
/BusTrack/services/UserService.py:
--------------------------------------------------------------------------------
1 | from BusTrack.repository import session
2 | from BusTrack.repository.models.User import User
3 |
4 | """
5 | Service to handle user related queries.
6 | """
7 |
8 |
9 | class UserService:
10 | """
11 | Constructor with db injection for unit test.
12 | """
13 |
14 | def __init__(self, db=session):
15 | self.db = db
16 |
17 | """
18 | Get all user with given role.
19 | """
20 |
21 | def get_users_with_role(self, user_role):
22 | # use join instead
23 | return self.db.query(User).filter(User.user_role.role_name == user_role).all()
24 |
25 | # just for testing
26 | def get_all_user(self):
27 | return self.db.query(User).all()
28 |
--------------------------------------------------------------------------------
/BusTrack/repository/models/Attendance.py:
--------------------------------------------------------------------------------
1 | from sqlalchemy import Column, String, Integer, ForeignKey, DateTime, Boolean
2 | from BusTrack.repository import Base
3 | from BusTrack.repository.models import STRING_LEN_SMALL
4 |
5 |
6 | class Attendance(Base):
7 | __tablename__ = 'attendance'
8 |
9 | id = Column(Integer, primary_key=True)
10 | is_pick_present = Column(Boolean, default=0)
11 | is_drop_present = Column(Boolean, default=0)
12 | pick_gps = Column(String(STRING_LEN_SMALL))
13 | drop_gps = Column(String(STRING_LEN_SMALL))
14 | pick_time = Column(DateTime, nullable=True)
15 | drop_time = Column(DateTime, nullable=True)
16 |
17 | kid_id = Column(ForeignKey('kid.id'))
18 | journey_id = Column(ForeignKey('journey.id'))
19 |
--------------------------------------------------------------------------------
/BusTrack/views/rest_api.py:
--------------------------------------------------------------------------------
1 | from flask_restful import Api
2 | from flask import Blueprint
3 | from BusTrack.controllers.HelloWorldController import HelloWorldController
4 | from BusTrack.controllers.UserLoginController import UserLoginController
5 | from BusTrack.controllers.parent import register_controllers as register_controllers_parent
6 |
7 |
8 | def register_rest_api(app):
9 | rest_api = Blueprint('api', __name__)
10 | api = Api(rest_api) # rest api using flask_restful extension
11 | app.register_blueprint(rest_api, url_prefix='/api/v1')
12 | register_controllers(api)
13 |
14 |
15 | def register_controllers(api):
16 | api.add_resource(HelloWorldController, '/hello')
17 | api.add_resource(UserLoginController, '/login')
18 | register_controllers_parent(api, '/parent')
19 |
--------------------------------------------------------------------------------
/BusTrack/repository/models/UserLogin.py:
--------------------------------------------------------------------------------
1 | from sqlalchemy import Boolean, Column, String, Integer, ForeignKey
2 | from sqlalchemy.orm import relationship, backref
3 | from BusTrack.repository import Base
4 | from BusTrack.repository.models import STRING_LEN_SMALL, STRING_LEN_LARGE, LEN_MOBILE
5 |
6 |
7 | class UserLogin(Base):
8 | __tablename__ = 'user_login'
9 |
10 | id = Column(Integer, primary_key=True)
11 | email = Column(String(STRING_LEN_SMALL))
12 | password = Column(String(STRING_LEN_SMALL))
13 | phone = Column(String(LEN_MOBILE))
14 | is_verified = Column(Boolean, default=False)
15 | api_token = Column(String(STRING_LEN_LARGE))
16 | user_id = Column(Integer, ForeignKey('user.id'),nullable=True)
17 | user = relationship("User", backref=backref("user_login", uselist=False))
18 |
--------------------------------------------------------------------------------
/BusTrack/repository/models/Kid.py:
--------------------------------------------------------------------------------
1 | from sqlalchemy import Column, String, Integer, ForeignKey, DateTime
2 | from sqlalchemy.orm import relationship, backref
3 | from BusTrack.repository import Base
4 | from BusTrack.repository.models import STRING_LEN_SMALL, STRING_LEN_MEDIUM, STRING_LEN_LARGE
5 |
6 |
7 | class Kid(Base):
8 | __tablename__ = 'kid'
9 |
10 | id = Column(Integer, primary_key=True)
11 | name = Column(String(STRING_LEN_MEDIUM))
12 | section = Column(String(STRING_LEN_SMALL))
13 | date_joined = Column(DateTime())
14 | photo = Column(String(STRING_LEN_LARGE))
15 | parent_id = Column(ForeignKey('user.id'), nullable=False)
16 | bus_id = Column(ForeignKey('bus.id'))
17 |
18 | parent = relationship("User", backref=backref("kid", uselist=False))
19 | bus = relationship("Bus", backref=backref("kid", uselist=False))
20 |
--------------------------------------------------------------------------------
/BusTrack/templates/admin/track.html:
--------------------------------------------------------------------------------
1 |
2 | {% extends "layout.html" %}
3 | {% block content %}
4 |
22 |
11 |
23 |
24 |
25 |
28 | {% endblock %}
29 |
--------------------------------------------------------------------------------
/BusTrack/repository/models/UserType.py:
--------------------------------------------------------------------------------
1 | from sqlalchemy import Column, String, Integer
2 | from BusTrack.repository import Base, session
3 | from BusTrack.repository.models import STRING_LEN_SMALL
4 |
5 |
6 | class UserType(Base):
7 | __tablename__ = 'user_type'
8 |
9 | id = Column(Integer, primary_key=True)
10 | role_name = Column(String(STRING_LEN_SMALL))
11 |
12 | @staticmethod
13 | def __create_default_role__():
14 | if session.query(UserType).count() != 0:
15 | return
16 | driver = UserType()
17 | driver.role_name = 'Driver'
18 | parent = UserType()
19 | parent.role_name = 'Parent'
20 | admin = UserType()
21 | admin.role_name = 'Admin'
22 |
23 | session.add(driver)
24 | session.add(parent)
25 | session.add(admin)
26 |
27 | session.commit()
28 | session.close()
29 |
--------------------------------------------------------------------------------
/BusTrack/repository/models/Bus.py:
--------------------------------------------------------------------------------
1 | from sqlalchemy import Boolean, Column, String, Integer
2 | from BusTrack.repository import Base, session
3 | from BusTrack.repository.models import STRING_LEN_SMALL, STRING_LEN_MEDIUM, STRING_LEN_LARGE
4 |
5 |
6 | class Bus(Base):
7 | __tablename__ = 'bus'
8 |
9 | id = Column(Integer, primary_key=True)
10 | name = Column(String(STRING_LEN_MEDIUM))
11 | detail = Column(String(STRING_LEN_LARGE))
12 | vehicle_number = Column(String(STRING_LEN_SMALL))
13 | capacity = Column(Integer, default=40)
14 | is_active = Column(Boolean, default=True)
15 |
16 | @staticmethod
17 | def __create_default_bus__():
18 | if session.query(Bus).count() == 0:
19 | default_bus = Bus()
20 | default_bus.name = 'test bus'
21 | default_bus.detail = 'default bus'
22 | default_bus.vehicle_number = 'MP-22-2525'
23 |
24 | session.add(default_bus)
25 | session.commit()
26 | session.close()
27 |
--------------------------------------------------------------------------------
/BusTrack/repository/models/Journey.py:
--------------------------------------------------------------------------------
1 | from enum import Enum
2 |
3 | from sqlalchemy import Column, Integer, ForeignKey, DateTime, String
4 | from sqlalchemy.orm import relationship, backref
5 |
6 | from BusTrack.repository import Base
7 | from BusTrack.repository.models import STRING_LEN_SMALL
8 |
9 |
10 | class JourneyType(Enum):
11 | TypeHomeToSchool = 1
12 | TypeSchoolToHome = 2
13 |
14 |
15 | class Journey(Base):
16 | __tablename__ = 'journey'
17 |
18 | id = Column(Integer, primary_key=True)
19 | type = Column(Integer, default=1)
20 | date = Column(DateTime())
21 | start_timestamp = Column(DateTime(), nullable=True)
22 | end_timestamp = Column(DateTime(), nullable=True)
23 | latest_gps = Column(String(STRING_LEN_SMALL))
24 | last_update_timestamp = Column(DateTime(), nullable=True)
25 | bus_id = Column(ForeignKey('bus.id'))
26 | bus = relationship('Bus', backref=backref("journey", uselist=False))
27 | locations = relationship('Location', backref=backref("journey", uselist=True))
28 |
--------------------------------------------------------------------------------
/BusTrack/repository/models/User.py:
--------------------------------------------------------------------------------
1 | from sqlalchemy import Boolean, Column, String, Integer, ForeignKey
2 | from sqlalchemy.orm import relationship, backref
3 | from BusTrack.repository import Base
4 | from BusTrack.repository.models import STRING_LEN_SMALL, STRING_LEN_MEDIUM, STRING_LEN_LARGE, LEN_MOBILE
5 |
6 | class User(Base):
7 | __tablename__ = 'user'
8 |
9 | id = Column(Integer, primary_key=True)
10 | first_name = Column(String(STRING_LEN_MEDIUM))
11 | last_name = Column(String(STRING_LEN_MEDIUM))
12 | phone = Column(String(LEN_MOBILE))
13 | address = Column(String(STRING_LEN_LARGE))
14 | city = Column(String(STRING_LEN_SMALL))
15 | state = Column(String(STRING_LEN_SMALL))
16 | is_active = Column(Boolean, default=True)
17 | role_id = Column(Integer, ForeignKey('user_type.id'))
18 | user_role = relationship("UserType", backref=backref("user", uselist=False))
19 |
20 | full_name = first_name + ' ' + last_name
21 | kids = relationship("Kid", backref=backref("user", uselist=True))
22 |
23 |
--------------------------------------------------------------------------------
/.github/workflows/python-app.yml:
--------------------------------------------------------------------------------
1 | # This workflow will install Python dependencies, run tests and lint with a single version of Python
2 | # For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
3 |
4 | name: Python application
5 |
6 | on:
7 | push:
8 | branches: [ master ]
9 | pull_request:
10 | branches: [ master ]
11 |
12 | jobs:
13 | build:
14 |
15 | runs-on: ubuntu-latest
16 |
17 | steps:
18 | - uses: actions/checkout@v2
19 | - name: Set up Python 3.9
20 | uses: actions/setup-python@v2
21 | with:
22 | python-version: 3.9
23 | - name: Install dependencies
24 | run: |
25 | python -m pip install --upgrade pip
26 | pip install flake8 pytest
27 | if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
28 | - name: run server
29 | run: |
30 | # stop the build if there are Python syntax errors or undefined names
31 | python run.py
32 | - name: Test with pytest
33 | run: |
34 | pytest
35 |
--------------------------------------------------------------------------------
/BusTrack/models/bus.py:
--------------------------------------------------------------------------------
1 | from .. import db,conn
2 | # code for 'bus' table
3 |
4 | class Bus():
5 | def __init__(self, bus_no=None, bus_detail=None):
6 | self.b_no=bus_no
7 | self.detail=bus_detail
8 |
9 |
10 | def get_all(self):
11 | qry='select * from bus'
12 | cur=conn.execute(qry)
13 | return cur.fetchall()
14 |
15 | def add(self):
16 | cur=conn.execute('insert into bus (b_no,detail) values(?,?)',(self.b_no,self.detail))
17 | conn.commit()
18 | return cur.lastrowid
19 |
20 | @staticmethod
21 | def is_unique(bus_id):
22 | # method used in Validation unique entity
23 | # check weather given bus already allocated to Driver table
24 | cur = conn.execute('select * from bus_driver where id=?', (bus_id))
25 | return cur.rowcount == 0
26 |
27 | @staticmethod
28 | def unallocated_bus():
29 | # return buses that are currently unallocated
30 | cur=conn.execute('select id,b_no from bus where id not in (select id from bus_driver)')
31 | return cur.fetchall()
32 |
--------------------------------------------------------------------------------
/BusTrack/controllers/parent/KidProfileController.py:
--------------------------------------------------------------------------------
1 | from flask_restful import Resource, reqparse
2 | from BusTrack.controllers import token_required, get_user, Roles
3 | from BusTrack.services.KidProfileService import KidProfileService
4 |
5 | '''
6 | parser = reqparse.RequestParser()
7 | parser.add_argument('param1')
8 | parser.add_argument('param2')
9 | args = parser.parse_args()
10 | '''
11 |
12 |
13 | class KidProfileController(Resource):
14 |
15 | @token_required([Roles.PARENT])
16 | def get(self, kid_id=None):
17 |
18 | kid_profile_service = KidProfileService()
19 | current_user = get_user()
20 |
21 | if kid_id is None:
22 | # select all kids associated to this parent
23 | result = kid_profile_service.get_kids_for_parent(current_user['user_id'])
24 | else:
25 | result = kid_profile_service.get(kid_id, current_user['user_id'])
26 |
27 | if result is None:
28 | return {'status': 'ok', 'message': 'No record found', 'data': result}
29 | else:
30 | return {'status': 'ok', 'data': result}
31 |
--------------------------------------------------------------------------------
/BusTrack/models/gps.py:
--------------------------------------------------------------------------------
1 | # represent a gps tuple which can be stored in single field in table
2 | # as latitude,longitude
3 | import numbers
4 |
5 | DELIMITER = ','
6 |
7 |
8 | class Gps:
9 | @staticmethod
10 | def get_from_str(gps_tuple_str):
11 | lat = 0
12 | lon = 0
13 | if gps_tuple_str is not None:
14 | try:
15 | (lat, lon) = gps_tuple_str.split(DELIMITER)
16 | lat = float(lat)
17 | lon = float(lon)
18 | if not isinstance(lat, float):
19 | lat = 0
20 | elif not isinstance(lon, float):
21 | lon = 0
22 | print(lat, lon)
23 | except:
24 | print('cant split to lat long')
25 | return (0, 0)
26 | return (lat, lon)
27 |
28 | @staticmethod
29 | def tuple_to_str(lat, lon):
30 | try:
31 | lat = float(lat)
32 | lon = float(lon)
33 | return '%s,%s' % (lat, lon)
34 | except:
35 | print('incorrect gps input')
36 | return '0,0'
37 |
--------------------------------------------------------------------------------
/BusTrack/models/feedback.py:
--------------------------------------------------------------------------------
1 | # handle feedback given by user
2 | from BusTrack import conn
3 |
4 |
5 | class Feedback():
6 | __TABLE__ = 'feedback'
7 |
8 | def __init__(self, name=None, email=None, title=None, message=None, date=None, p_id=None, d_id=None):
9 | self.name = name
10 | self.email = email
11 | self.title = title
12 | self.message = message
13 | self.date = date
14 | self.parent_id = p_id # NOT MUST: provides better functionality if available
15 | self.driver_id = d_id # NOT MUST: provides better functionality if available
16 |
17 | def get_all(self):
18 | cur = conn.execute('select id,name,email,title,message, date(date) as date, time(date) as time from feedback order by id desc limit 40')
19 | return cur.fetchall()
20 |
21 | def add(self):
22 | cur = conn.execute('insert into feedback (name,email,title,message,date,p_id,d_id) values (?,?,?,?,?,?,?)',
23 | (self.name, self.email, self.title, self.message, self.date, self.parent_id, self.driver_id))
24 | conn.commit()
25 | return cur.lastrowid
26 |
--------------------------------------------------------------------------------
/BusTrack/repository/main.py:
--------------------------------------------------------------------------------
1 | from BusTrack.repository import Base
2 | from BusTrack.repository import engine
3 |
4 | # import all relevant db models here.
5 | from BusTrack.repository.models.Bus import Bus
6 | from BusTrack.repository.models.UserType import UserType
7 | from BusTrack.repository.models.User import User
8 | from BusTrack.repository.models.UserLogin import UserLogin
9 | from BusTrack.repository.models.Feedback import Feedback
10 | from BusTrack.repository.models.Kid import Kid
11 | from BusTrack.repository.models.Journey import Journey
12 | from BusTrack.repository.models.Location import Location
13 | from BusTrack.repository.models.Attendance import Attendance
14 |
15 |
16 | def create_database():
17 | print('creating database from given mappings')
18 | Base.metadata.create_all(engine)
19 | Bus.__create_default_bus__()
20 | UserType.__create_default_role__()
21 | tables = [User.__tablename__, UserLogin.__tablename__, Feedback.__tablename__
22 | , Kid.__tablename__, Journey.__tablename__, Location.__tablename__,
23 | Attendance.__tablename__]
24 | print('created mapping for tables:', tables)
25 |
--------------------------------------------------------------------------------
/BusTrack/repository/schema.py:
--------------------------------------------------------------------------------
1 | # contains marshmallow schema models,which should be return as json output on api call
2 | from BusTrack import ma
3 | from marshmallow import fields as f
4 |
5 |
6 | class UserSchema(ma.Schema):
7 | class Meta:
8 | # Fields to expose
9 | fields = ('first_name', 'last_name', 'phone', 'address')
10 |
11 |
12 | class UserLoginSchema(ma.Schema):
13 | class Meta:
14 | fields = ('email', 'phone', 'api_token', 'user_id')
15 |
16 |
17 | class BasicBusSchema(ma.Schema):
18 | class Meta:
19 | fields = ('id', 'name', 'vehicle_number')
20 |
21 |
22 | class KidProfileSchema(ma.Schema):
23 | class Meta:
24 | fields = ('id', 'name', 'section', 'photo', 'parent', 'bus')
25 |
26 | parent = f.Nested(UserSchema)
27 | bus = f.Nested(BasicBusSchema)
28 |
29 |
30 | class KidsProfileSchema(ma.Schema):
31 | class Meta:
32 | fields = ('id', 'name', 'section', 'photo')
33 |
34 |
35 | # prop to export
36 | user_schema = UserSchema()
37 | users_schema = UserSchema(many=True)
38 |
39 | user_login_schema = UserLoginSchema()
40 |
41 | kid_profile_schema = KidProfileSchema()
42 |
43 | kids_profile_schema = KidsProfileSchema(many=True)
44 |
--------------------------------------------------------------------------------
/BusTrack/__init__.py:
--------------------------------------------------------------------------------
1 | from flask import Flask, send_file, abort,Blueprint
2 | from flask_bcrypt import Bcrypt
3 | from flask_marshmallow import Marshmallow
4 | import sqlite3
5 |
6 | app = Flask(__name__, instance_relative_config=True)
7 | ma = Marshmallow(app)
8 |
9 | conn = sqlite3.connect('data_1.db', check_same_thread=False)
10 | conn.isolation_level = None
11 | db = conn.cursor()
12 | bcrypt = Bcrypt(app)
13 |
14 | from BusTrack.views.admin import admin
15 | # from BusTrack.views.driver import driver
16 | # from BusTrack.views.parent import parent
17 |
18 | # add admin blueprint
19 | app.register_blueprint(admin, url_prefix='/admin')
20 |
21 | # using flask restful extension to create api instead of blueprints
22 |
23 |
24 | '''
25 | # add parent blueprint
26 | app.register_blueprint(parent, url_prefix='/api/v1/parent')
27 | # add driver blueprint
28 | app.register_blueprint(driver, url_prefix='/api/v1/driver')
29 |
30 | ### for testing
31 | from BusTrack.controllers.UserLoginController import userLoginController
32 |
33 | app.register_blueprint(userLoginController, url_prefix='/app')
34 | ### for testing
35 | '''
36 |
37 | from BusTrack.views.rest_api import register_rest_api
38 | register_rest_api(app)
39 |
40 | from BusTrack.repository.main import create_database
41 | create_database()
42 |
--------------------------------------------------------------------------------
/BusTrack/forms/adminforms.py:
--------------------------------------------------------------------------------
1 | from flask_wtf import Form
2 | from wtforms import StringField,PasswordField,SelectField
3 | from wtforms.validators import DataRequired,Email
4 | from BusTrack.helpers.validators import Unique
5 | from BusTrack.models.driver import Driver
6 |
7 | '''
8 | Forms to be used in ADMIN web pages
9 | '''
10 |
11 | # Form for /admin/login
12 | class UserPasswordForm(Form):
13 | username=StringField('username',validators=[DataRequired()])
14 | password=PasswordField('password',validators=[DataRequired()])
15 |
16 | # form for /admin/driver
17 | class AddDriverForm(Form):
18 | username = StringField('username', validators=[DataRequired(),
19 | Unique(Driver,message='already exist')])
20 | password = PasswordField('password', validators=[DataRequired()])
21 | name=StringField('name',validators=[DataRequired()])
22 | contact=StringField('contact') # TODO: add phone number validator
23 |
24 | # form for /admin/kid
25 | class AddKidForm(Form):
26 | parent_name=StringField('parent_name',validators=[DataRequired()])
27 | kid_name=StringField('kid_name',validators=[DataRequired()])
28 | email=StringField('email',validators=[DataRequired(),Email()])
29 | kid_section=StringField('kid_section')
30 |
31 |
--------------------------------------------------------------------------------
/BusTrack/static/js/script.js:
--------------------------------------------------------------------------------
1 | // some common constants
2 | var TOAST_TIME=5000;
3 | $(document).ready(function() {
4 | initials();
5 | });
6 |
7 | function my_modal(id,name,email,title,message,date,time) {
8 | // set these values to modal
9 | $('#mod-title').text(title);
10 | $('#mod-other-data').text('By:'+name+' on '+time+' date: '+date);
11 | $('#mod-detail').text(message);
12 | $('#mod-date').text(date);
13 | $('#mod-time').text(time);
14 | $('#mod-reply-but').attr('onclick','my_modal_reply(\''+id+'\',\''+email+'\');');
15 | $('#modal1').modal('open');
16 | }
17 | function my_modal_reply(msg_id,email) {
18 | //send email
19 | var title=$('#mod-input-title').val();
20 | var msg=$('#mod-input-message').val();
21 | message={msg_id:msg_id,email:email,title:title,message:msg};
22 | console.log(message);
23 | $.post( "/admin/api/reply_email",message);
24 | $('#modal1').modal('close');
25 | // show success toast
26 | Materialize.toast('Reply message sent !!!', TOAST_TIME);
27 | }
28 |
29 | function initials() {
30 | Materialize.updateTextFields();
31 | $('.modal').modal();
32 | $(".button-collapse").sideNav();
33 | $('select').material_select();
34 | // set default option
35 | $('.bus:nth-child(1)').prop('selected', true);
36 | }
--------------------------------------------------------------------------------
/BusTrack/controllers/__init__.py:
--------------------------------------------------------------------------------
1 | from flask import request, session, abort
2 | from BusTrack.services.UserLoginService import UserLoginService
3 | from BusTrack.repository.schema import user_login_schema
4 | import BusTrack.helpers.JsonHelper as JsonHelper
5 |
6 |
7 | class Roles:
8 | ADMIN = 'Admin'
9 | PARENT = 'Parent'
10 | DRIVER = 'Driver'
11 |
12 |
13 | # contains authorisation logic for apis
14 |
15 | def token_required(roles):
16 | def actual_function(f):
17 | def wrapper(*args, **kwargs):
18 | # main logic here
19 | login_service = UserLoginService()
20 | if 'auth_token' in request.headers and \
21 | login_service.verify_token(request.headers['auth_token'], roles):
22 | # set user detail to this session
23 | session['user'] = JsonHelper.to_json_serializable(user_login_schema, login_service.user)
24 | else:
25 | return abort(401)
26 |
27 | return f(*args, **kwargs)
28 |
29 | return wrapper
30 |
31 | if type(roles) != list:
32 | raise TypeError("roles must contains list of role from Roles class.")
33 | return actual_function
34 |
35 |
36 | def get_user():
37 | if 'user' in session:
38 | return session['user']
39 |
40 |
41 | def remove_user():
42 | del session['user']
43 |
--------------------------------------------------------------------------------
/BusTrack/services/KidProfileService.py:
--------------------------------------------------------------------------------
1 | from BusTrack.repository import session
2 | from BusTrack.repository.models.User import User
3 | from BusTrack.repository.models.Kid import Kid
4 | from BusTrack.repository.schema import kid_profile_schema, kids_profile_schema
5 | import BusTrack.helpers.JsonHelper as JsonHelper
6 |
7 |
8 | class KidProfileService:
9 | """
10 | Service to handle kids related queries.
11 | """
12 |
13 | def __init__(self, db=session):
14 | self.db = db
15 |
16 | def get(self, kid_id, parent_id=None):
17 | """
18 | Get kid with given kid_id and associated parent_id.
19 | :return kid model.
20 | """
21 | kid = self.db.query(Kid).filter(Kid.id == kid_id).first()
22 | if kid is None:
23 | return
24 | if parent_id is None or kid.parent.id == parent_id:
25 | return JsonHelper.to_json_serializable(kid_profile_schema, kid)
26 |
27 | def get_kids_for_parent(self, parent_id):
28 | """
29 | Get all kids associated to a parent
30 | :param parent_id: parent user_id
31 | :return: list of models.
32 | """
33 | user = self.db.query(User).filter(User.id == parent_id).first()
34 | if user is None or user.kids is None:
35 | return
36 | return JsonHelper.to_json_serializable(kids_profile_schema, user.kids)
37 |
--------------------------------------------------------------------------------
/BusTrack/helpers/SessionHelper.py:
--------------------------------------------------------------------------------
1 | from flask import session
2 | from BusTrack import bcrypt
3 |
4 | ADMIN_LOGIN = 'is_admin_login'
5 | ADMIN_LOGIN_ID = 'admin_id'
6 | TOKEN = 'token'
7 |
8 | '''
9 | Unused method replaced by jinja2 template function
10 | '''
11 | '''
12 | def nav_list():
13 | # items to show in navigation list
14 | nav_logged_in = [('/admin/', 'Home'), ('/admin/driver', 'Add Update Driver'),
15 | ('/admin/student', 'Add Kid'), ('/admin/track', 'Track'),
16 | ('/admin/feedback', 'Feedback'), ('/admin/logout', 'Logout')]
17 | nav_logged_out = [('/admin/', 'Home'), ('/admin/login', 'Login')]
18 |
19 | if is_login_admin():
20 | return nav_logged_in
21 | else:
22 | return nav_logged_out
23 | '''
24 |
25 |
26 | # checks weather admin is logged in
27 | def is_login_admin():
28 | if ADMIN_LOGIN in session:
29 | if session[ADMIN_LOGIN] == True:
30 | return True
31 | else:
32 | return False
33 |
34 | ''''using bcryot to store password hash, key is given in projects config.py'''
35 |
36 | # generate password hash for @password
37 |
38 |
39 | def get_password_hash(password):
40 | return bcrypt.generate_password_hash(password)
41 |
42 |
43 | # check validity of @password with the given @pass_hash
44 | def is_password_correct(pass_hash, password):
45 | # return true if correct
46 | return bcrypt.check_password_hash(pass_hash, password)
47 |
--------------------------------------------------------------------------------
/BusTrack/models/location.py:
--------------------------------------------------------------------------------
1 | from BusTrack import conn
2 | from BusTrack.helpers import utils
3 |
4 |
5 | class Location():
6 | __TABLE_ = 'location'
7 |
8 | def __init__(self, gps=None, journey_id=None):
9 | self.gps = gps
10 | self.time = utils.get_date_full()
11 | self.j_id = journey_id
12 |
13 | def add(self):
14 | cur = conn.execute('insert into location (gps,time,j_id) values(?,?,?) ',
15 | (self.gps, self.time, self.j_id))
16 | conn.commit()
17 | return cur.lastrowid
18 |
19 | # return location point associated with a journey
20 | @staticmethod
21 | def get_location(journey_id):
22 | cur = conn.execute('select * from location where j_id=? ', [journey_id])
23 |
24 | # check if 1 minute passed since last_update
25 | @staticmethod
26 | def is_delta_time_passed(journey_id, prev_time):
27 | # if location have has no record
28 | cur=conn.execute(' select max(id) from location where j_id=?',[journey_id])
29 | res=cur.fetchone()
30 | if res[0] is None:
31 | return True # since first record
32 | else:
33 | cur = conn.execute(
34 | 'select id from location where id=? and time(time)
11 |
12 |
38 |
39 | {% endblock %}
--------------------------------------------------------------------------------
/BusTrack/controllers/UserLoginController.py:
--------------------------------------------------------------------------------
1 | from flask_restful import Resource
2 | from flask import request, session, jsonify
3 | from BusTrack.services.UserLoginService import UserLoginService
4 | from BusTrack.controllers import token_required, Roles, get_user, remove_user
5 |
6 |
7 | class UserLoginController(Resource):
8 | """"
9 | This API controller will handle user login logic for all roles.
10 | """
11 |
12 | def post(self):
13 | """
14 | This is post method for /login api to perform login,
15 | on success user session/token will be stored in database (planning to migrate to redis)
16 | :return success or failure status:
17 | """
18 | req = request.json
19 | user_login_service = UserLoginService(user=req)
20 | return user_login_service.perform_login()
21 |
22 | @token_required([Roles.PARENT, Roles.ADMIN, Roles.DRIVER])
23 | def delete(self):
24 | """
25 | This is delete method for /login api to perform logout operation,
26 | since it is authorisation based app, so this delete function will delete the user
27 | detail from session and api_token from user_login record.
28 | :return success status always.
29 | :return:
30 | """
31 | token = get_user()['api_token']
32 | user_login_service = UserLoginService()
33 | user_login_service.remove_token(token)
34 |
35 | remove_user()
36 |
37 | @token_required([Roles.ADMIN, Roles.PARENT])
38 | def get(self):
39 | """
40 | get user detail from session
41 | :return user model:
42 | """
43 | user = get_user()
44 | return user
45 |
--------------------------------------------------------------------------------
/BusTrack/helpers/utils.py:
--------------------------------------------------------------------------------
1 | import random
2 | import string
3 |
4 |
5 | # some frequent utility function
6 | def rand(length=20):
7 | return ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(length))
8 |
9 |
10 | # get date
11 | # later research about how to store date time in sqlite
12 | def get_date_full():
13 | d = get_local_time()
14 | d = d[0:19]
15 | return d
16 |
17 |
18 | # get date only
19 | def get_date_only():
20 | d = get_local_time()
21 | d = d[0:10]
22 | return d
23 |
24 |
25 | # get current time
26 | def get_time_only():
27 | t = get_local_time()
28 | t = t[11:19]
29 | return t
30 |
31 |
32 | # generate expiry date used to validate token
33 | EXPIRY_IN_DAY = 3
34 |
35 |
36 | def get_expiry_date_full():
37 | import datetime
38 | from pytz import timezone
39 | d = datetime.datetime.now(timezone('Asia/Kolkata')) + datetime.timedelta(days=EXPIRY_IN_DAY)
40 | return str(d)[:19]
41 |
42 |
43 | TIME_DELTA = 1 # 1 minute
44 |
45 |
46 | # use to add location when last_update_time
4 |
5 |
38 |
39 |
40 |
6 |
10 |
11 |
36 |
37 |
7 |
9 | Message and FeedBack
8 | | Name | 13 |Message Title | 14 |Date | 15 |Time | 16 |Read | 17 |
|---|---|---|---|---|
| {{l[1]}} | 23 |{{l[3]}} 24 | 25 | | 26 |{{l[5]}} | 27 |{{l[6]}} | 28 |29 | 31 | | 32 |
41 |
68 |
72 |
73 |
74 | {% endblock %}
75 |
76 |
77 |
78 |
79 |
80 |
--------------------------------------------------------------------------------
/BusTrack/templates/admin/kid.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | {% extends "layout.html" %}
4 | {% block content %}
5 | {# a macro to show fields error #}
6 | {% macro show_error(input_name) %}
7 | {% if input_name in form.errors %}
8 | {{ ' , '.join(form.errors[input_name]) }}
9 | {% endif %}
10 | {% endmacro %}
11 |
12 |
13 |
67 |
68 |
85 | {% endblock %}
--------------------------------------------------------------------------------
/BusTrack/models/Kid.py:
--------------------------------------------------------------------------------
1 | from BusTrack import db, conn
2 |
3 |
4 | class Kid():
5 | __TABLE__ = 'kid'
6 |
7 | def __init__(self, name=None, section=None, photo=None, parent_id=None, bus_id=None, id=None):
8 | self.id = id
9 | self.name = name
10 | self.section = section
11 | self.photo = photo
12 | self.p_id = parent_id # parent id
13 | self.b_id = bus_id
14 |
15 | def get_all(self):
16 | cur = conn.execute('select * from kid')
17 | return cur.fetchall()
18 |
19 | def add_if_not_exist(self):
20 | cur = conn.execute('select * from kid')
21 |
22 | def add(self):
23 | try:
24 | cur = conn.execute('insert into kid (name,section,photo,p_id,b_id) values(?,?,?,?,?)',
25 | (self.name, self.section, self.photo, self.p_id, self.b_id))
26 | conn.commit()
27 | except:
28 | return None
29 | return cur.lastrowid
30 |
31 | # get kids of particular parent
32 | @staticmethod
33 | def get_kids(parent_id):
34 | cur = conn.execute('select * from kid where p_id=?', (parent_id))
35 | return cur.fetchall()
36 |
37 | # ---------------------code used in driver module-----------------------#
38 | # here j_id is known
39 | # get kids who whose attendance is not yet taken for this bus journey
40 | @staticmethod
41 | def get_kid_ids(journey_id):
42 | cur = conn.execute('select kid.id from kid where kid.id not in( \
43 | select kid.id from attendance inner join kid on attendance.k_id=kid.id \
44 | where j_id=?) and kid.b_id=(select journey.b_id from journey where journey.id=?)',
45 | [journey_id, journey_id])
46 | return Kid.id_to_list(cur.fetchall())
47 |
48 | # get kid ids whose dropped present is not yet taken
49 | @staticmethod
50 | def get_kid_drop_not_present(journey_id):
51 | cur = conn.execute('select attendance.k_id from attendance where j_id=? and pick_present=1 \
52 | and drop_present=0 ', [journey_id])
53 | return Kid.id_to_list(cur.fetchall())
54 |
55 | @staticmethod
56 | def id_to_list(cur):
57 | if cur is None:
58 | return []
59 | else:
60 | return [i[0] for i in cur]
61 |
62 | # get image link of this kid ,only those image for which this driver is authorized
63 | @staticmethod
64 | def get_image_for_driver(token, kid_id):
65 | cur = conn.execute('select kid.photo from kid where kid.b_id=(select driver.b_id from driver where token=? \
66 | ) and kid.id=?', [token, kid_id])
67 | r = cur.fetchone()
68 | if r is None:
69 | return r
70 | else:
71 | return r[0]
72 |
73 | # get image link of this kid ,only those image for which this parent is authorized
74 | @staticmethod
75 | def get_image_for_parent(token,kid_id):
76 | cur=conn.execute('select kid.photo from kid inner join parent on kid.p_id=parent.id \
77 | where parent.token=? and kid.id=? ',[token,kid_id])
78 | r = cur.fetchone()
79 | if r is None:
80 | return r
81 | else:
82 | return r[0]
83 |
84 | # ---------------------driver module ends------------------------#
85 | # -------------------- code for parent module--------------------#
86 |
87 |
--------------------------------------------------------------------------------
/BusTrack/templates/admin/driver.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | {% extends "layout.html" %}
4 | {% block content %}
5 | {# a macro to show fields error #}
6 | {% macro show_error(input_name) %}
7 | {% if input_name in form.errors %}
8 | {{ ' , '.join(form.errors[input_name]) }}
9 | {% endif %}
10 | {% endmacro %}
11 |
69 |
72 |
73 |
83 |
84 | Bus allocation Record
70 |
71 | | Kid Name | Parent | Bus Allocated | |
|---|---|---|---|
| {{l[2]}} | {{l[3]}} | {{ l[7] }} | {{l[4]}} | 79 |
12 |
13 |
68 | Major-Project School bus tracking system Backend Python
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 | .
675 |
--------------------------------------------------------------------------------
69 |
94 | {% endblock %}
--------------------------------------------------------------------------------
/BusTrack/templates/layout.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
70 |
73 |
74 |
92 |
93 | Driver Record
71 |
72 | | UserId | 76 |Name | 77 |Bus Allocated | 78 |Contact | 79 |
|---|---|---|---|
| {{l[0]}} | 85 |{{l[1]}} | 86 |{{l[2]}} | 87 |{{l[3]}} | 88 |
24 |
25 |
61 |
62 |
88 |
89 |
90 |
--------------------------------------------------------------------------------
/BusTrack/models/driver.py:
--------------------------------------------------------------------------------
1 | from BusTrack import db, conn
2 | from BusTrack.helpers import dbHelpers
3 | from BusTrack.helpers import utils
4 |
5 |
6 | # code for 'driver' table
7 | class Driver():
8 | def __init__(self, user_id=None, name=None, contact=None, password=None, bus_id=None):
9 | self.name = name
10 | self.contact = contact
11 | self.password = password
12 | self.b_id = bus_id
13 | self.userid = user_id
14 |
15 | def add(self):
16 | cur = conn.execute('insert into driver (name,contact,password,b_id,userid) values (?,?,?,?,?)'
17 | , [self.name, self.contact, self.password, self.b_id, self.userid])
18 | print([self.name, self.contact, self.password, self.b_id, self.userid])
19 | conn.commit()
20 | return cur.lastrowid
21 |
22 | def get_all(self):
23 | cur = conn.execute('select * from driver')
24 | return cur.fetchall()
25 |
26 | @staticmethod
27 | def get_user(userid): # check password
28 | cur = conn.execute(
29 | 'select driver.name,driver.password,bus.b_no,driver.active_ride_j_id, bus.id from driver inner join Bus '
30 | 'on driver.b_id=bus.id where driver.userid=? ', [userid])
31 | user = cur.fetchone()
32 | if user is None:
33 | return False
34 | else:
35 | return user # {1:"pass","3":"active ride","4":"bus_id"}
36 |
37 | @staticmethod
38 | def update_token(token, expires, userid):
39 | cur = conn.execute('update driver set token=?,expires=? where userid=?', [token, expires, userid])
40 | conn.commit()
41 |
42 | @staticmethod
43 | def is_unique(user_id):
44 | # method used in Validation unique entity
45 | # check weather given 'user_id' already exist in Driver table
46 | cur = conn.execute('select * from driver where userid=? ', [user_id]) # pass sequence
47 | return dbHelpers.row_zero(cur)
48 |
49 | @staticmethod
50 | def get_all_allocated():
51 | # registered driver who are assigned a bus
52 | cur = conn.execute('select userid,name, b_no,contact from bus_driver')
53 | return cur.fetchall()
54 |
55 | # check if this token is allocated to any driver and is still valid
56 | @staticmethod
57 | def is_valid_token(token):
58 | date = utils.get_date_full()
59 | cur = conn.execute('select userid from driver where token=? and DATETIME(expires) > DATETIME(?)', (token, date))
60 | user = cur.fetchone()
61 | if user is None:
62 | return False
63 | else:
64 | return True
65 |
66 | # get current active ride detail ,else return None
67 | @staticmethod
68 | def get_active_ride(token):
69 | cur = conn.execute('select active_ride_j_id from driver where token=?', [token])
70 | j_id = cur.fetchone()
71 | if j_id is None:
72 | return None
73 | else:
74 | return j_id[0]
75 |
76 | # check if driver has already completed @j_type ride for @date
77 | @staticmethod
78 | def is_ride_already_completed(userid, j_type, date=utils.get_date_only()):
79 | cur = conn.execute('select * from journey inner join bus on bus.id=journey.b_id inner join driver'
80 | ' on driver.b_id=bus.id where driver.userid=? '
81 | ' and date(journey.date)=date(?) and journey.j_type=? and journey.end is not 0 ', [userid, date, j_type])
82 | res = cur.fetchone()
83 | if res is None:
84 | return False # no ride yet
85 | else:
86 | return True
87 |
88 | @staticmethod
89 | def logout_session(token):
90 | # set end journey time
91 | # set token,expiry and active_b_id to null
92 | cur = conn.cursor()
93 | cur.execute('begin')
94 | cur.execute('update journey set end=? where id=(select active_ride_j_id from driver where token=?)',
95 | (utils.get_date_full(), token))
96 | cur.execute("update driver set active_ride_j_id=?,token=?,expires=? WHERE token=?", ('', '', '', token))
97 | cur.execute('commit')
98 |
--------------------------------------------------------------------------------
/BusTrack/models/Parent.py:
--------------------------------------------------------------------------------
1 | from BusTrack import conn
2 | from BusTrack.helpers import utils
3 |
4 |
5 | class Parent():
6 | __TABLE__ = 'parent'
7 |
8 | def __init__(self, name=None, password=None, email=None, phone=None, home_gps=None):
9 | self.name = name
10 | self.password = password
11 | self.email = email
12 | self.phone = phone
13 | self.home_gps = home_gps
14 |
15 | def get_all(self):
16 | cur = conn.execute('select * from parent')
17 | return cur.fetchall()
18 |
19 | def add(self):
20 | cur = conn.execute('insert into parent (name,password,email,phone,home_gps) values(?,?,?,?,?)',
21 | (self.name, self.password, self.email, self.phone, self.home_gps))
22 | conn.commit()
23 | return cur.lastrowid
24 |
25 | def add_or_get(self):
26 | # refer link:admin.kid
27 | cur = conn.execute('select id from parent where email=? ', [self.email])
28 | res = cur.fetchone()
29 | print(res)
30 | if res is None:
31 | # create new record
32 | res = self.add()
33 | return res
34 | else:
35 | return res[0]
36 |
37 | # get user having email =?
38 | @staticmethod
39 | def get_user(email):
40 | cur = conn.execute('select * from parent where email=?', [email])
41 | if cur.rowcount == 0:
42 | return False
43 | else:
44 | return cur.fetchone()
45 |
46 | @staticmethod
47 | def get_all_parent_with_kid():
48 | # get data from parent_kid view
49 | cur = conn.execute('select * from parent_kid')
50 | print(cur.description)
51 | return cur.fetchall()
52 |
53 | @staticmethod
54 | def get_all_parent_kid_with_bus():
55 | # get data from parent_kid_bus view
56 | cur = conn.execute('select * from parent_kid_bus')
57 | print(cur.description)
58 | return cur.fetchall()
59 |
60 | # -------------- code used in Parent Module--------------#
61 |
62 | # get parent from token
63 | @staticmethod
64 | def get_parent_id(token):
65 | cur = conn.execute('select * from parent where token=? ', [token])
66 | return cur.fetchone()
67 |
68 | @staticmethod
69 | def update_token(email, token, expire):
70 | cur = conn.execute('update parent set token=?,expires=? where email=?',
71 | [token, expire, email])
72 | conn.commit()
73 |
74 | # check if this token is allocated to any driver and is still valid
75 |
76 | @staticmethod
77 | def is_valid_token(token):
78 | date = utils.get_date_full()
79 | cur = conn.execute('select email from parent where token=? and DATETIME(expires) > DATETIME(?)', (token, date))
80 | user = cur.fetchone()
81 | if user is None:
82 | return False
83 | else:
84 | return True
85 |
86 | # check weather @param#k_id belongs to parent having token @param#token
87 | @staticmethod
88 | def is_kidOf(kid_id, token):
89 | cur = conn.execute('select kid.id from kid inner join parent on kid.p_id=parent.id '
90 | 'where kid.id=? and parent.token=? ', [kid_id, token])
91 | res = cur.fetchone()
92 | if res is None:
93 | return False
94 | else:
95 | return True
96 |
97 | @staticmethod
98 | def get_kids(token):
99 | cur = conn.execute('select kid.id,name,section,photo,bus.id,bus.b_no from kid inner join bus on kid.b_id=bus.id where kid.p_id = \
100 | (select parent.id from parent where parent.token=? )', [token])
101 | return Parent.kids_to_obj_list(cur.fetchall())
102 |
103 | @staticmethod
104 | def kids_to_obj_list(cur):
105 | if cur is None:
106 | return None
107 | l = []
108 | for c in cur:
109 | k = {"id": c[0], "name": c[1], "section": c[2], "photo": c[3]}
110 | b = {"bus_id": c[4], "bus_name": c[5]}
111 | k_b = {"kid": k, "bus": b}
112 | l.append(k_b)
113 | return l
114 |
--------------------------------------------------------------------------------
/BusTrack/models/attendance.py:
--------------------------------------------------------------------------------
1 | from .. import conn
2 | from BusTrack.models.Kid import Kid
3 |
4 |
5 | class Attendance():
6 | __TABLE__ = 'attendance'
7 |
8 | def __init__(self, pick_present=0, drop_present=0, kid_id=None, journey_id=None, pick_gps=None, drop_gps=None,
9 | pick_time=None, drop_time=None):
10 | # hold attendance for a kid for particular date
11 | self.k_id = kid_id
12 | # journey id
13 | self.j_id = journey_id
14 | # was kid present during picking
15 | self.pick_present = pick_present
16 | # was kid present during drop
17 | self.drop_present = drop_present
18 | self.pick_gps = pick_gps
19 | self.drop_gps = drop_gps
20 | self.pick_time = pick_time
21 | self.drop_time = drop_time
22 |
23 | def add(self):
24 | if self.k_id == None or self.j_id == None:
25 | assert 'Must provide kid and journey id'
26 | else:
27 | cur = conn.execute('insert into attendance (k_id,j_id,pick_present,drop_present,\
28 | pick_gps,drop_gps,pick_time,drop_time) \
29 | values(?,?,?,?,?,?,?,?)',
30 | (self.k_id, self.j_id, self.pick_present, self.drop_present,
31 | self.pick_gps, self.drop_gps, self.pick_time, self.drop_time))
32 | conn.commit()
33 | return cur.lastrowid
34 |
35 | #--------for pick up time in journey
36 | # return kids whose attendance is taken by driver for this journey
37 | @staticmethod
38 | def get_kid_attended(driver_token):
39 | cur = conn.execute('select * from kid where kid.id in ( \
40 | select attendance.k_id from attendance where attendance.j_id=( \
41 | select driver.active_ride_j_id from driver where driver.token=? )) order by lower(kid.name) asc ', [driver_token])
42 |
43 | return Attendance.to_kid_list(cur.fetchall())
44 |
45 | # return kids whose attendance is not yet taken
46 | @staticmethod
47 | def get_kid_not_attended(driver_token):
48 | cur = conn.execute('select * from kid where kid.id not in ( \
49 | select attendance.k_id from attendance where attendance.j_id=( \
50 | select driver.active_ride_j_id from driver where driver.token=? )) \
51 | and kid.b_id=(select driver.b_id from driver where driver.token=? ) order by lower(kid.name) asc', [driver_token,driver_token])
52 | return Attendance.to_kid_list(cur.fetchall())
53 |
54 | # ---------for drop time in journey
55 | #-----if the kid is picked but not yet dropped
56 | @staticmethod
57 | def get_kid_not_dropped(driver_token):
58 | cur=conn.execute('select * from kid where kid.id in ( \
59 | select attendance.k_id from attendance where attendance.j_id=( \
60 | select driver.active_ride_j_id from driver where driver.token=? )\
61 | and attendance.drop_present=0 ) order by lower(kid.name) asc',[driver_token])
62 | return Attendance.to_kid_list(cur.fetchall())
63 |
64 | #-----get list of kid who is picked and also dropped
65 | @staticmethod
66 | def get_kid_dropped(driver_token):
67 | cur=conn.execute('select * from kid where kid.id in ( \
68 | select attendance.k_id from attendance where attendance.j_id=( \
69 | select driver.active_ride_j_id from driver where driver.token=? )\
70 | and attendance.drop_present=1 ) order by lower(kid.name) asc ',[driver_token])
71 | return Attendance.to_kid_list(cur.fetchall())
72 |
73 | @staticmethod
74 | def to_kid_list(cursor):
75 | if cursor is None:
76 | return None
77 | kids = []
78 | for c in cursor:
79 | id = c[0]
80 | name = c[1]
81 | section = c[2]
82 | photo = c[3]
83 | kid = Kid(id=id, name=name, section=section, photo=photo)
84 | kids.append(kid)
85 | return kids
86 |
87 | # set dropped =1 to attendance table
88 | @staticmethod
89 | def update_drop_attendance(kid_id,drop_gps,drop_time,journey_id):
90 | cur=conn.execute('update attendance set drop_present=1,drop_gps=?,drop_time=? \
91 | where k_id=? and j_id=? ',[drop_gps,drop_time,kid_id,journey_id])
92 | conn.commit()
93 |
94 |
--------------------------------------------------------------------------------
/BusTrack/views/admin.py:
--------------------------------------------------------------------------------
1 | from flask import Blueprint, render_template, jsonify, redirect, url_for, request, flash
2 | from flask import session
3 | from functools import wraps
4 | from BusTrack.helpers import SessionHelper, utils
5 | from BusTrack.forms.adminforms import UserPasswordForm, AddDriverForm, AddKidForm
6 | from BusTrack.models.driver import Driver
7 | from BusTrack.models.bus import Bus
8 | from BusTrack.models.Kid import Kid
9 | from BusTrack.models.Parent import Parent
10 | from BusTrack.models.feedback import Feedback
11 |
12 | admin = Blueprint('admin', __name__)
13 |
14 |
15 | # custom decorator to handle access
16 | def login_required(f):
17 | @wraps(f)
18 | def decorated_function(*args, **kwargs):
19 | if 'is_admin_login' in session:
20 | if session['is_admin_login'] == True:
21 | pass # ok no problem
22 | else:
23 | return redirect(url_for('admin.login', next=request.url))
24 | else:
25 | return redirect(url_for('admin.login', next=request.url))
26 | return f(*args, **kwargs)
27 |
28 | return decorated_function
29 |
30 |
31 | @admin.route('/')
32 | def root():
33 | return render_template('admin/index.html')
34 |
35 |
36 | @admin.route('/index')
37 | def index():
38 | return render_template('admin/index.html')
39 |
40 |
41 | @admin.route('/login', methods=['GET', 'POST'])
42 | def login():
43 | form = UserPasswordForm(request.form)
44 | if form.validate_on_submit() and request.method == 'POST':
45 | # check password and redirect to admin home
46 | from BusTrack import app
47 | if app.config['ADMIN_USERNAME'] == form.username.data and \
48 | SessionHelper.is_password_correct(app.config['ADMIN_PASSWORD'], form.password.data):
49 | session['is_admin_login'] = True
50 | return redirect(request.args.get('next') or url_for('admin.index'))
51 | else:
52 | flash('incorrect credentials')
53 | render_template('admin/login.html', form=form)
54 |
55 | return render_template('admin/login.html', form=form)
56 |
57 |
58 | @admin.route('/driver', methods=['POST', 'GET'])
59 | @login_required
60 | def driver():
61 | # handle driver tasks
62 | form = AddDriverForm(request.form)
63 | # TODO : Disable add when no bus unallocated (for now using front-end logic)
64 | un_alloc = Bus.unallocated_bus()
65 | if form.validate_on_submit() and request.method == 'POST':
66 | # if 'bus' not in request.form:
67 |
68 | # TODO: later add option for update
69 | d = Driver(user_id=form.username.data, bus_id=request.form['bus']
70 | , name=form.name.data, contact=form.contact.data,
71 | password=SessionHelper.get_password_hash(form.password.data))
72 | d.add()
73 | # clear fileds
74 | form.username.data = form.name.data = form.contact.data = ''
75 | # return render_template('admin/driver.html',form=form)
76 | alloc_driver = Driver.get_all_allocated()
77 | return render_template('admin/driver.html', form=form, bus_data=un_alloc, driver_list=alloc_driver)
78 |
79 |
80 | @admin.route('/kid', methods=['GET', 'POST'])
81 | @login_required
82 | def kid():
83 | form = AddKidForm(request.form)
84 |
85 | if form.validate_on_submit() and request.method == 'POST':
86 | if 'bus' in request.form:
87 | rand_pass = utils.rand(6)
88 | # store parent and get its unique id to store it in Kid table
89 | # BUT BUT ,if parent already register then don't re-register instead add this kid to previously added parent
90 | p = Parent(name=form.parent_name.data, password=rand_pass, email=form.email.data)
91 | p_id = p.add_or_get()
92 | k = Kid(name=form.kid_name.data, section=form.kid_section.data, bus_id=request.form['bus'], parent_id=p_id)
93 | from sqlite3 import IntegrityError
94 | k.add()
95 | # clear form field
96 | form.parent_name.data = form.email.data = form.kid_name.data = form.kid_section.data = form.parent_name.data = ''
97 | # TODO: Send this generated password to Parent email
98 |
99 | else:
100 | all_parent_kid = Parent.get_all_parent_kid_with_bus()
101 | all_bus = Bus().get_all()
102 | return render_template('admin/kid.html', form=form, bus_data=all_bus, bus_error='Must Select a Bus',
103 | all_parent_kid=all_parent_kid)
104 | all_parent_kid = Parent.get_all_parent_kid_with_bus()
105 | all_bus = Bus().get_all()
106 | return render_template('admin/kid.html', form=form, bus_data=all_bus, all_parent_kid=all_parent_kid)
107 |
108 |
109 | @admin.route('/feedback', methods=['GET', 'POST'])
110 | @login_required
111 | def feedback():
112 | feed = Feedback().get_all()
113 | return render_template('admin/feeds.html', feed_list=feed)
114 |
115 |
116 | @admin.route('/track', methods=['GET', 'POST'])
117 | @login_required
118 | def show_map():
119 | if request.method == 'GET':
120 | print("get method")
121 | elif request.method == 'POST':
122 | print("post method")
123 | return render_template('/admin/track.html')
124 |
125 |
126 | @admin.route('/api/reply_email', methods=['POST'])
127 | @login_required
128 | def reply_email():
129 | # get data as post
130 | if 'msg_id' in request.form and 'email' in request.form and 'title' in request.form and 'message' in request.form:
131 | # TODO send email using smtp api
132 | return jsonify(success='ok', message='message sent')
133 | else:
134 | return jsonify(success='error', message='insufficient parameters')
135 |
136 |
137 | @admin.route('/logout')
138 | def logout():
139 | session.pop('is_admin_login', None)
140 | return redirect(url_for('admin.login'))
141 |
--------------------------------------------------------------------------------
/BusTrack/models/Rides.py:
--------------------------------------------------------------------------------
1 | from BusTrack.helpers import utils
2 | from BusTrack.models.Parent import Parent
3 | from BusTrack import conn
4 |
5 |
6 | # a special file to handle Rides related stuff
7 | # fetch ride of all kids of a parent
8 | # parent token require
9 | class ActiveRide():
10 | def __init__(self, token, date=utils.get_date_only()):
11 | if token is None or token is '':
12 | raise ValueError('invalid token') # error 403
13 | self.token = token
14 | self.date = date # default today if not provided
15 | self.is_active = True
16 |
17 | # get active ride for each kid
18 | def get_active_ride(self):
19 | kids = Parent.get_kids(self.token) # may be None
20 | if kids is None:
21 | raise ValueError('invalid token') # error 403
22 |
23 | rides = []
24 | for kid_bus in kids:
25 | kid = kid_bus['kid']
26 | res = self.__sql__(kid['id'])
27 | if res is not None:
28 | rides.append({"kid": kid, "journey_id": res[0], "journey_type": res[1], "current_gps": res[2],
29 | "start_time": res[3], "start_gps": res[4]})
30 | return rides
31 |
32 | # return single kid status , weather today's ride is completed or active
33 | def get_single_status(self, kid_id):
34 | res = self.__sql__(kid_id)
35 | if res is None:
36 | return 'no active ride' # no active
37 | else:
38 | return 'ride is active ' # yes active
39 |
40 |
41 | def __sql__(self, kid_id):
42 | cur = conn.execute('select journey.id,journey.j_type ,journey.gps,attendance.pick_time,\
43 | attendance.pick_gps from attendance inner join journey on attendance.j_id=journey.id \
44 | where date(attendance.pick_time)=date(?) and attendance.k_id=? \
45 | and attendance.drop_present=0 limit 1 ', [self.date, kid_id])
46 | return cur.fetchone()
47 |
48 |
49 | # get all recent rides associated to this kid
50 | def get_recent_rides(self, kid_id):
51 | cur = conn.execute('select journey.id,journey.j_type ,attendance.pick_time,'
52 | 'attendance.pick_gps ,attendance.drop_time,attendance.drop_gps,attendance.drop_present , journey.gps '
53 | 'from attendance inner join journey on attendance.j_id=journey.id '
54 | 'where attendance.k_id=? order by attendance.id desc limit 50 ', [kid_id])
55 | res = cur.fetchall()
56 | if res is None:
57 | return []
58 | else:
59 | l = []
60 | for r in res:
61 | l.append(
62 | {"journey_id": r[0], "journey_type": r[1], "start_time": r[2], "start_gps": r[3], "end_time": r[4],
63 | "end_gps": r[5], "completed": r[6],"current_gps":r[7]})
64 | return l
65 |
66 |
67 | # a special class to handle bus status
68 | # check the bus current location if it is to be arrived kid's home
69 | # scenario:
70 | # * Bus driver login to app when driver to pick student from their home to school
71 | # * SO here journey_type=0 (from home to school)
72 | # * now check in attendance table weather kid is already picked up, if not then
73 | # * show bus status as arriving (send current location and distance)
74 |
75 | class BusArriving():
76 | def __init__(self, token):
77 | self.token = token
78 | if token is None or token is '':
79 | raise ValueError('Invalid Token')
80 |
81 | # return a str message about bus arriving status
82 | def arriving_buses(self):
83 | kids = Parent.get_kids(self.token)
84 | # iterate for each kid
85 | arr = []
86 | for k in kids:
87 | k_id = k['kid']['id']
88 | b_id = k['bus']['bus_id']
89 | res = self.__get_journey__(k_id, b_id)
90 | if res is not None:
91 | res['name'] = k['kid']['name']
92 | arr.append(res)
93 | return arr
94 |
95 | # gets journey detail of arriving bus , for this bus on active ride
96 | def __get_journey__(self, kid_id, bus_id):
97 | cur = conn.execute(
98 | 'select journey.id,journey.gps,journey.last_update from journey inner join driver on '
99 | 'journey.id=driver.active_ride_j_id '
100 | ' where driver.b_id=? and j_type=0 ',
101 | [bus_id])
102 | res = cur.fetchone()
103 | if res is None:
104 | # no journey exist
105 | return None
106 | else:
107 | cur = conn.execute('select id from attendance where k_id=? and j_id=? ', [kid_id, res[0]])
108 | res_2 = cur.fetchone()
109 | # if exist NO record, it means kid is still waiting for bus
110 | if res_2 is None:
111 | return {"id": res[0], "current_gps": res[1], "last_update": res[2], "bus_id": bus_id, "kid_id": kid_id}
112 | else:
113 | # kids journey is already started
114 | return None
115 |
116 | # check if bus is arriving for this kid
117 | def arriving_for_kid(self, kid_id, bus_id):
118 | res = self.__get_journey__(kid_id, bus_id)
119 | if res is None:
120 | return False
121 | else:
122 | return res
123 |
124 |
125 | class Track:
126 | def __init__(self, p_token, kid_id):
127 | self.token = p_token
128 | self.kid_id = kid_id
129 |
130 | # get current location of bus
131 | def get_latest_location(self):
132 | cur = conn.execute('select journey.gps,journey.last_update from journey where journey.id= ( '
133 | 'select driver.active_ride_j_id from driver inner join kid on kid.b_id=driver.b_id '
134 | 'inner join parent on parent.id=kid.p_id where parent.token=? and kid.id=? ) and '
135 | 'journey.end=0',
136 | [self.token, self.kid_id])
137 | return cur.fetchone()
138 |
139 | # get all location in this journey
140 | def get_all_locations(self):
141 | cur = conn.execute('select location.id,location.gps,location.time from location where location.j_id= ( '
142 | ' select driver.active_ride_j_id from driver inner join kid on kid.b_id=driver.b_id '
143 | 'inner join parent on parent.id=kid.p_id where parent.token=? and kid.id=? ) order by '
144 | 'location.id desc limit 100',
145 | [self.token, self.kid_id])
146 | res = cur.fetchall()
147 | if res is None:
148 | return []
149 | else:
150 | return [{"id":i[0],"gps": i[1], "time": i[2]} for i in res]
151 |
--------------------------------------------------------------------------------
/BusTrack/views/parent.py:
--------------------------------------------------------------------------------
1 | from flask import Blueprint, make_response, render_template, request, jsonify, abort, send_file
2 | from BusTrack.models.Rides import ActiveRide, BusArriving, Track
3 | from BusTrack.models.Parent import Parent
4 | from BusTrack.helpers import SessionHelper, utils
5 | from BusTrack.models.Kid import Kid
6 | from BusTrack.models.feedback import Feedback
7 | from functools import wraps
8 |
9 | parent = Blueprint('parent', __name__)
10 |
11 | # method to check valid parent and return access token
12 | '''
13 | request:
14 | {
15 | "username":"uname",
16 | password:"pass"
17 | }
18 | response:
19 | {
20 | "status":"ok|error",
21 | "message":"error type"
22 | "token":"valid_till",
23 | "name":"parent name",
24 | "email","phone",
25 | }
26 | '''
27 |
28 |
29 | @parent.route('/access_token', methods=['POST'])
30 | def login():
31 | js = request.json
32 | if js is not None:
33 | if 'username' in js and 'password' in js:
34 | email = js['username']
35 | _pass = js['password']
36 | parent = Parent.get_user(email)
37 | if parent is None:
38 | return make_response(jsonify(status='error', message='invalid user'), 403)
39 | name = parent[1]
40 | phone = parent[3]
41 | pass_hash = parent[4]
42 | if pass_hash is not False and SessionHelper.is_password_correct(pass_hash, _pass):
43 | # ok correct user
44 | m_token = utils.rand(40)
45 | m_expire = utils.get_expiry_date_full()
46 | # update this token
47 | Parent.update_token(email, m_token, m_expire)
48 | return jsonify(status='ok', message='ok login', token=m_token, expires=m_expire, name=name, phone=phone,
49 | email=email)
50 | else:
51 | return make_response(jsonify(status='error', message='invalid user'), 403)
52 | else:
53 | return jsonify(status='error', message='incorrect parameters')
54 | else:
55 | return jsonify(status='error', message='only json body is allowed')
56 |
57 |
58 | # verify token
59 | def token_required(f):
60 | @wraps(f)
61 | def decorated_function(*args, **kwargs):
62 | if 'token' in request.args and Parent.is_valid_token(request.args['token']):
63 | pass
64 | else:
65 | return make_response(jsonify(status='error', message='unauthorized user'), 403)
66 |
67 | return f(*args, **kwargs)
68 |
69 | return decorated_function
70 |
71 |
72 | # return kids detail of this parent
73 | @parent.route('/get_kids', methods=['GET', 'POST'])
74 | @token_required
75 | def get_my_kids():
76 | return jsonify(kids=Parent.get_kids(request.args['token']), status='ok', message='ok')
77 |
78 |
79 | # get all active ride for kids of this parent
80 | @parent.route('/active_rides')
81 | @token_required
82 | def get_kid_status():
83 | try:
84 | r = ActiveRide(request.args['token'])
85 | if 'kid_id' in request.args:
86 | # request for only 1 kid
87 | # TODO: check only authorized parent, can access rides only for his kids
88 | kid_id = request.args['kid_id']
89 | return jsonify(rides=r.get_single_status(kid_id), status='ok', message='ok fetched')
90 | else:
91 | return jsonify(rides=r.get_active_ride(), status='ok', message='ok fetched')
92 | except:
93 | return make_response(jsonify(status='error'), 403)
94 |
95 |
96 | # get all rides weather completed or incomplete associated to this kid
97 | @parent.route('/recent_rides', methods=['GET', 'POST'])
98 | @token_required
99 | def get_recent_ride():
100 | # requires param kid_id
101 | if 'kid_id' in request.args:
102 | kid_id = request.args['kid_id']
103 | token = request.args['token']
104 | # if parent is authorised for this kid
105 | if not Parent.is_kidOf(kid_id, token):
106 | return make_response(jsonify(status='error', message='un-authorized access'), 403)
107 | try:
108 | a = ActiveRide(token)
109 | return jsonify(rides=a.get_recent_rides(kid_id), status='ok', message='fetched recent rides')
110 | except:
111 | return make_response(jsonify(status='error'), 403)
112 | else:
113 | return jsonify(status='error', message='incorrect request')
114 |
115 |
116 | # fetch kid photo
117 | @parent.route('/photo_kid')
118 | @token_required
119 | def get_kid_photo():
120 | if 'kid_id' in request.args:
121 | k_id = request.args['kid_id']
122 | token = request.args['token']
123 | img_name = Kid.get_image_for_parent(token, k_id)
124 | if img_name is None:
125 | abort(404)
126 | else:
127 | from BusTrack import app
128 | final_image = app.config['IMAGE_KID'] + img_name
129 | # import os
130 | # filename = os.path.join(app.root_path,img_name)
131 | try:
132 | return send_file(final_image, mimetype='image/jpeg')
133 | except:
134 | abort(404)
135 | else:
136 | abort(404)
137 |
138 |
139 | # get feedback from parent
140 | @parent.route('/feedback', methods=['POST'])
141 | @token_required
142 | def feedback():
143 | js = request.json
144 | if 'title' in js and 'detail' in js:
145 | token = request.args['token']
146 | title = js['title']
147 | detail = js['detail']
148 | date = utils.get_date_full()
149 | p = Parent.get_parent_id(token)
150 | p_id = p[0]
151 | name = p[1]
152 | email = p[2]
153 | f = Feedback(name=name, email=email, title=title, message=detail, date=date, p_id=p_id)
154 | f.add()
155 | return jsonify(status='ok', message='feedback sent')
156 | else:
157 | return jsonify(status='error', message='incorrect request')
158 |
159 |
160 | # get list of arriving bus for the kids of this parent
161 | @parent.route('/arriving', methods=['GET'])
162 | @token_required
163 | def arriving_bus():
164 | # if 'kid_id' in request.args:
165 | token = request.args['token']
166 | r = BusArriving(token)
167 | return jsonify(status='ok', buses=r.arriving_buses())
168 |
169 |
170 | # get current gps status for bus
171 | @parent.route('/location', methods=['GET', 'POST'])
172 | @token_required
173 | def latest_location():
174 | if 'kid_id' in request.args:
175 | token = request.args['token']
176 | kid_id = request.args['kid_id']
177 | t = Track(token, kid_id)
178 | res = t.get_latest_location()
179 | if res is None:
180 | return jsonify(status='completed', message='Ride already completed')
181 | else:
182 | return jsonify(status='ok', gps=res[0], last_update=res[1])
183 | else:
184 | return jsonify(status='error', message='incorrect parameters')
185 |
186 |
187 | # get all location associated to a journey
188 | @parent.route('/locations', methods=['GET'])
189 | @token_required
190 | def all_location():
191 | if 'kid_id' in request.args:
192 | kid_id = request.args['kid_id']
193 | token = request.args['token']
194 | t = Track(token, kid_id)
195 | res = t.get_all_locations()
196 | return jsonify(status='ok', locations=res)
197 | else:
198 | return jsonify(status='error', message='incorrect parameters')
199 |
200 |
201 | # upload image of a kid
202 | @parent.route('/upload',methods=['GET','POST'])
203 | @token_required
204 | def upload_image():
205 | token=request.args['token']
206 | if 'kid_id' in request.args and 'file' in request.files:
207 | kid_id=request.args['kid_id']
208 | image=request.files['file']
209 | file_name=image.filename
210 | image.save(file_name)
211 |
212 |
--------------------------------------------------------------------------------
/BusTrack/views/driver.py:
--------------------------------------------------------------------------------
1 | from flask import Blueprint, make_response, request, jsonify, abort, send_file, send_from_directory
2 | from BusTrack.models.driver import Driver
3 | from BusTrack.models.journey import Journey
4 | from BusTrack.models.gps import Gps
5 | from BusTrack.models.attendance import Attendance
6 | from BusTrack.models.location import Location
7 | from BusTrack.models.Kid import Kid
8 | from BusTrack.helpers import SessionHelper, utils
9 | from functools import wraps
10 |
11 | driver = Blueprint('driver', __name__)
12 |
13 | # method to check valid driver and return access token to be used by him
14 | '''
15 | # request object
16 | {
17 | username:"username",
18 | password:"password"
19 | }
20 |
21 | # response object
22 | {
23 | status:"ok|error"
24 | valid_till:"duration of expiry",
25 | token:"send generated access token",
26 | name:"name of driver",
27 | bus:"bus number"
28 | message:"String message responding status related to success or failure."
29 | }
30 | '''
31 |
32 |
33 | @driver.route('/access_token', methods=['POST'])
34 | def login():
35 | # require username,password as json
36 | js = request.json
37 | if js is not None:
38 | if 'username' in js and 'password' in js and 'journey_type' in js:
39 | u_id = js['username']
40 | _pass = js['password']
41 | j_type = js['journey_type']
42 | # validate j_type
43 | if j_type not in [0, 1]:
44 | return jsonify(status="error", message="Incorrect journey type")
45 |
46 | user = Driver.get_user(u_id)
47 | if not user:
48 | return make_response(jsonify(status='error', message='Invalid Credential'), 403)
49 | name = user[0]
50 | pass_hash = user[1]
51 | bus_no = user[2]
52 |
53 | if pass_hash is not False and SessionHelper.is_password_correct(pass_hash, _pass):
54 | # ok correct user
55 | # make sure, if similar ride is not already completed by this driver
56 | if Driver.is_ride_already_completed(u_id, j_type):
57 | return jsonify(status='error', message='ride already completed for today.')
58 | # get active ride
59 | active_ride = user[3]
60 | # generate a random token
61 | m_token = utils.rand(40)
62 | m_expire = utils.get_expiry_date_full()
63 | Driver.update_token(m_token, m_expire, u_id)
64 | if active_ride is None or active_ride is '':
65 | # no active session, start new session
66 | # and create new journey and set it
67 | bus_id = user[4]
68 | Journey.trans_create_journey(j_type, utils.get_date_full(), bus_id, u_id)
69 | else:
70 | # no need to create new journey
71 | pass
72 | return jsonify(status="ok", message="Correct Credentials", token=m_token, valid_till=m_expire,
73 | name=name, bus=bus_no)
74 | else:
75 | return make_response(jsonify(status="error", message="Invalid Credential"), 403)
76 | else:
77 | return jsonify(status="error", message="Incorrect Request")
78 | else:
79 | return jsonify(status="error", message="Only Json Body is allowed")
80 |
81 | # - a decorator to check validity of token
82 |
83 |
84 | def token_required(f):
85 | @wraps(f)
86 | def decorated_function(*args, **kwargs):
87 | if 'token' in request.args and Driver.is_valid_token(request.args['token']):
88 | pass
89 | else:
90 | return make_response(jsonify(status='error', message='unauthorized user'), 403)
91 |
92 | return f(*args, **kwargs)
93 |
94 | return decorated_function
95 |
96 |
97 | # add gps data of this driver
98 | '''
99 | #request object
100 | ..api/v1/driver/add_gps?token="mToken"
101 | {
102 | lat:"latitude",
103 | lon:"longitude",
104 | }
105 |
106 | # response object
107 | {
108 | status:"ok|error",
109 | message:"error message if any"
110 | }
111 | '''
112 |
113 |
114 | @driver.route('/add_gps', methods=['POST'])
115 | @token_required
116 | def add_gps():
117 | js = request.json
118 | if 'lat' in js and 'lon' in js:
119 | token = request.args['token']
120 | lat = js['lat']
121 | lon = js['lon']
122 | # add location to this active journey
123 | print(lat, lon)
124 | j_id = Driver.get_active_ride(request.args['token'])
125 | if j_id is None or j_id is '':
126 | return jsonify(status='error', message='unauthorized user or inactive session')
127 | else:
128 | # add location to location table
129 | # check if 1 minute passed since last update
130 | if Location.is_delta_time_passed(j_id, utils.get_prev_time()):
131 | # now add location
132 | l = Location(Gps.tuple_to_str(lat, lon), j_id)
133 | l.add()
134 | print("adding location...")
135 | # update gps table
136 | Journey.update_gps(j_id, Gps.tuple_to_str(lat, lon))
137 |
138 | return jsonify(status="ok", message="Gps data added")
139 | else:
140 | return jsonify(status='error', message='Incorrect parameters')
141 |
142 |
143 | # logout for driver
144 | @driver.route('/logout', methods=['GET', 'POST'])
145 | @token_required
146 | def logout():
147 | # set this journey_id to null for this driver
148 | # and also set end time
149 | token = request.args['token']
150 | # check all attendance stuff are already done by driver
151 | Driver.logout_session(token)
152 | return jsonify(status='ok')
153 |
154 |
155 | # get list of kids in bus at pick time
156 | # 1) list of kids whose attendance is already taken ?present=1
157 | # 2) list of kids whom attendance is not yet taken ?present=0
158 | @driver.route('/get_kids', methods=['GET', 'POST'])
159 | @token_required
160 | def get_kids():
161 | if 'present' in request.args:
162 | # but make sure a ride session exists
163 | j_id = Driver.get_active_ride(request.args['token'])
164 | if j_id is None or j_id is '':
165 | return jsonify(status='error', message='No active ride.')
166 | present = request.args['present']
167 | token = request.args['token']
168 | if present is '1' or present is 1:
169 | kids = Attendance.get_kid_attended(token)
170 | return jsonify(status='ok', kids=kids_json(kids))
171 | elif present is '0' or present is 0:
172 | kids = Attendance.get_kid_not_attended(token)
173 | return jsonify(status='ok', kids=kids_json(kids))
174 | else:
175 | return jsonify(status='error', message='present arg can be 0 or 1')
176 | else:
177 | return jsonify(status='error', message='incorrect request')
178 |
179 |
180 | # get list of kids at drop time
181 | # 1) kids who are not yet dropped ?dropped=0
182 | # 2) kids who are already dropped ?dropped=1
183 | @driver.route('/get_kids_dropped', methods=['GET', 'POST'])
184 | @token_required
185 | def get_kids_by_dropping():
186 | if 'dropped' in request.args:
187 | # but make sure a ride session exists
188 | j_id = Driver.get_active_ride(request.args['token'])
189 | if j_id is None or j_id is '':
190 | return jsonify(status='error', message='No active ride.')
191 | dropped = request.args['dropped']
192 | token = request.args['token']
193 | if dropped is '1' or dropped is 1:
194 | kids = Attendance.get_kid_dropped(token)
195 | return jsonify(status='ok', kids=kids_json(kids))
196 | elif dropped is '0' or dropped is 0:
197 | kids = Attendance.get_kid_not_dropped(token)
198 | return jsonify(status='ok', kids=kids_json(kids))
199 | else:
200 | return jsonify(status='error', message='present arg can be 0 or 1')
201 | else:
202 | return jsonify(status='error', message='incorrect request')
203 |
204 |
205 | # make attendance function
206 | # for pick up
207 | '''
208 | --request format
209 | {
210 | "kid_ids":[1,2,3,4,...],
211 | "lat":12.5,
212 | "lon":53.254
213 | }
214 | # send ids of kid
215 | --response
216 | "status":"ok","message":"msg.."
217 | '''
218 |
219 |
220 | @driver.route('/add_pick_attendance', methods=['POST'])
221 | def pick_attendance():
222 | js = request.json
223 | if 'kid_ids' in js and 'lat' in js and 'lon' in js:
224 | ids = js['kid_ids']
225 | lat = js['lat']
226 | lon = js['lon']
227 | gps = Gps.tuple_to_str(lat, lon)
228 | time = utils.get_date_full()
229 | token = request.args['token']
230 | j_id = Driver.get_active_ride(token)
231 | if j_id is None or j_id is '':
232 | return jsonify(status='error', message='Cant add,as not active ride')
233 | else:
234 | # filter valid ids
235 | id_from_db = Kid.get_kid_ids(j_id)
236 | ids_set = set(ids)
237 | ids_db_set = set(id_from_db)
238 | ids_valid = list(ids_set & ids_db_set) # intersection of kid ids
239 | for id in ids_valid:
240 | atten = Attendance(pick_present=1, kid_id=id, journey_id=j_id, pick_gps=gps, pick_time=time)
241 | atten.add()
242 | return jsonify(status='ok', message='Attendance taken')
243 | else:
244 | return jsonify(status='error', message='incorrect request')
245 |
246 |
247 | @driver.route('/add_drop_attendance', methods=['POST'])
248 | def drop_attendance():
249 | js = request.json
250 | if 'kid_ids' in js and 'lat' in js and 'lon' in js:
251 | ids = js['kid_ids']
252 | lat = js['lat']
253 | lon = js['lon']
254 | gps = Gps.tuple_to_str(lat, lon)
255 | time = utils.get_date_full()
256 | token = request.args['token']
257 | j_id = Driver.get_active_ride(token)
258 | if j_id is None or j_id is '':
259 | return jsonify(status='error', message='Cant add,since not active ride')
260 | else:
261 | # filter valid ids
262 | id_from_db = Kid.get_kid_drop_not_present(j_id)
263 | ids_set = set(ids)
264 | ids_db_set = set(id_from_db)
265 | ids_valid = list(ids_set & ids_db_set) # intersection of kid ids
266 | for id in ids_valid:
267 | Attendance.update_drop_attendance(id, gps, time, j_id)
268 | return jsonify(status='ok', message='Attendance taken')
269 | else:
270 | return jsonify(status='error', message='incorrect request')
271 |
272 |
273 | # convert kids list to json compatible dictionary-list
274 | def kids_json(kids):
275 | lst = []
276 | for k in kids:
277 | dic = {'name': k.name, 'section': k.section, 'id': k.id}
278 | # TODO: create logic to create image link
279 | # dic['photo']
280 | lst.append(dic)
281 | return lst
282 |
283 |
284 | @driver.route('/photo_kid')
285 | @token_required
286 | def get_kid_photo():
287 | if 'kid_id' in request.args:
288 | k_id = request.args['kid_id']
289 | token = request.args['token']
290 | img_name = Kid.get_image_for_driver(token, k_id)
291 | if img_name is None:
292 | abort(404)
293 | else:
294 | from BusTrack import app
295 | final_image = app.config['IMAGE_KID'] + img_name
296 | try:
297 | return send_file(final_image, mimetype='image/jpeg')
298 | except:
299 | abort(404)
300 | else:
301 | abort(404)
302 |
303 |
304 | # get information about ride completed by this driver
305 | '''
306 | request:get_rides?token=xyz...
307 |
308 | response:
309 | {
310 | "rides":[{
311 | "start_time":"time","end_time":"time","duration":"calculate it on front end",
312 | "type":"1 or 0",
313 |
314 | },..]
315 | }
316 | '''
317 |
--------------------------------------------------------------------------------
/BusTrack/static/fonts_/Roboto/LICENSE.txt:
--------------------------------------------------------------------------------
1 |
2 | Apache License
3 | Version 2.0, January 2004
4 | http://www.apache.org/licenses/
5 |
6 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
7 |
8 | 1. Definitions.
9 |
10 | "License" shall mean the terms and conditions for use, reproduction,
11 | and distribution as defined by Sections 1 through 9 of this document.
12 |
13 | "Licensor" shall mean the copyright owner or entity authorized by
14 | the copyright owner that is granting the License.
15 |
16 | "Legal Entity" shall mean the union of the acting entity and all
17 | other entities that control, are controlled by, or are under common
18 | control with that entity. For the purposes of this definition,
19 | "control" means (i) the power, direct or indirect, to cause the
20 | direction or management of such entity, whether by contract or
21 | otherwise, or (ii) ownership of fifty percent (50%) or more of the
22 | outstanding shares, or (iii) beneficial ownership of such entity.
23 |
24 | "You" (or "Your") shall mean an individual or Legal Entity
25 | exercising permissions granted by this License.
26 |
27 | "Source" form shall mean the preferred form for making modifications,
28 | including but not limited to software source code, documentation
29 | source, and configuration files.
30 |
31 | "Object" form shall mean any form resulting from mechanical
32 | transformation or translation of a Source form, including but
33 | not limited to compiled object code, generated documentation,
34 | and conversions to other media types.
35 |
36 | "Work" shall mean the work of authorship, whether in Source or
37 | Object form, made available under the License, as indicated by a
38 | copyright notice that is included in or attached to the work
39 | (an example is provided in the Appendix below).
40 |
41 | "Derivative Works" shall mean any work, whether in Source or Object
42 | form, that is based on (or derived from) the Work and for which the
43 | editorial revisions, annotations, elaborations, or other modifications
44 | represent, as a whole, an original work of authorship. For the purposes
45 | of this License, Derivative Works shall not include works that remain
46 | separable from, or merely link (or bind by name) to the interfaces of,
47 | the Work and Derivative Works thereof.
48 |
49 | "Contribution" shall mean any work of authorship, including
50 | the original version of the Work and any modifications or additions
51 | to that Work or Derivative Works thereof, that is intentionally
52 | submitted to Licensor for inclusion in the Work by the copyright owner
53 | or by an individual or Legal Entity authorized to submit on behalf of
54 | the copyright owner. For the purposes of this definition, "submitted"
55 | means any form of electronic, verbal, or written communication sent
56 | to the Licensor or its representatives, including but not limited to
57 | communication on electronic mailing lists, source code control systems,
58 | and issue tracking systems that are managed by, or on behalf of, the
59 | Licensor for the purpose of discussing and improving the Work, but
60 | excluding communication that is conspicuously marked or otherwise
61 | designated in writing by the copyright owner as "Not a Contribution."
62 |
63 | "Contributor" shall mean Licensor and any individual or Legal Entity
64 | on behalf of whom a Contribution has been received by Licensor and
65 | subsequently incorporated within the Work.
66 |
67 | 2. Grant of Copyright License. Subject to the terms and conditions of
68 | this License, each Contributor hereby grants to You a perpetual,
69 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
70 | copyright license to reproduce, prepare Derivative Works of,
71 | publicly display, publicly perform, sublicense, and distribute the
72 | Work and such Derivative Works in Source or Object form.
73 |
74 | 3. Grant of Patent License. Subject to the terms and conditions of
75 | this License, each Contributor hereby grants to You a perpetual,
76 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
77 | (except as stated in this section) patent license to make, have made,
78 | use, offer to sell, sell, import, and otherwise transfer the Work,
79 | where such license applies only to those patent claims licensable
80 | by such Contributor that are necessarily infringed by their
81 | Contribution(s) alone or by combination of their Contribution(s)
82 | with the Work to which such Contribution(s) was submitted. If You
83 | institute patent litigation against any entity (including a
84 | cross-claim or counterclaim in a lawsuit) alleging that the Work
85 | or a Contribution incorporated within the Work constitutes direct
86 | or contributory patent infringement, then any patent licenses
87 | granted to You under this License for that Work shall terminate
88 | as of the date such litigation is filed.
89 |
90 | 4. Redistribution. You may reproduce and distribute copies of the
91 | Work or Derivative Works thereof in any medium, with or without
92 | modifications, and in Source or Object form, provided that You
93 | meet the following conditions:
94 |
95 | (a) You must give any other recipients of the Work or
96 | Derivative Works a copy of this License; and
97 |
98 | (b) You must cause any modified files to carry prominent notices
99 | stating that You changed the files; and
100 |
101 | (c) You must retain, in the Source form of any Derivative Works
102 | that You distribute, all copyright, patent, trademark, and
103 | attribution notices from the Source form of the Work,
104 | excluding those notices that do not pertain to any part of
105 | the Derivative Works; and
106 |
107 | (d) If the Work includes a "NOTICE" text file as part of its
108 | distribution, then any Derivative Works that You distribute must
109 | include a readable copy of the attribution notices contained
110 | within such NOTICE file, excluding those notices that do not
111 | pertain to any part of the Derivative Works, in at least one
112 | of the following places: within a NOTICE text file distributed
113 | as part of the Derivative Works; within the Source form or
114 | documentation, if provided along with the Derivative Works; or,
115 | within a display generated by the Derivative Works, if and
116 | wherever such third-party notices normally appear. The contents
117 | of the NOTICE file are for informational purposes only and
118 | do not modify the License. You may add Your own attribution
119 | notices within Derivative Works that You distribute, alongside
120 | or as an addendum to the NOTICE text from the Work, provided
121 | that such additional attribution notices cannot be construed
122 | as modifying the License.
123 |
124 | You may add Your own copyright statement to Your modifications and
125 | may provide additional or different license terms and conditions
126 | for use, reproduction, or distribution of Your modifications, or
127 | for any such Derivative Works as a whole, provided Your use,
128 | reproduction, and distribution of the Work otherwise complies with
129 | the conditions stated in this License.
130 |
131 | 5. Submission of Contributions. Unless You explicitly state otherwise,
132 | any Contribution intentionally submitted for inclusion in the Work
133 | by You to the Licensor shall be under the terms and conditions of
134 | this License, without any additional terms or conditions.
135 | Notwithstanding the above, nothing herein shall supersede or modify
136 | the terms of any separate license agreement you may have executed
137 | with Licensor regarding such Contributions.
138 |
139 | 6. Trademarks. This License does not grant permission to use the trade
140 | names, trademarks, service marks, or product names of the Licensor,
141 | except as required for reasonable and customary use in describing the
142 | origin of the Work and reproducing the content of the NOTICE file.
143 |
144 | 7. Disclaimer of Warranty. Unless required by applicable law or
145 | agreed to in writing, Licensor provides the Work (and each
146 | Contributor provides its Contributions) on an "AS IS" BASIS,
147 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
148 | implied, including, without limitation, any warranties or conditions
149 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
150 | PARTICULAR PURPOSE. You are solely responsible for determining the
151 | appropriateness of using or redistributing the Work and assume any
152 | risks associated with Your exercise of permissions under this License.
153 |
154 | 8. Limitation of Liability. In no event and under no legal theory,
155 | whether in tort (including negligence), contract, or otherwise,
156 | unless required by applicable law (such as deliberate and grossly
157 | negligent acts) or agreed to in writing, shall any Contributor be
158 | liable to You for damages, including any direct, indirect, special,
159 | incidental, or consequential damages of any character arising as a
160 | result of this License or out of the use or inability to use the
161 | Work (including but not limited to damages for loss of goodwill,
162 | work stoppage, computer failure or malfunction, or any and all
163 | other commercial damages or losses), even if such Contributor
164 | has been advised of the possibility of such damages.
165 |
166 | 9. Accepting Warranty or Additional Liability. While redistributing
167 | the Work or Derivative Works thereof, You may choose to offer,
168 | and charge a fee for, acceptance of support, warranty, indemnity,
169 | or other liability obligations and/or rights consistent with this
170 | License. However, in accepting such obligations, You may act only
171 | on Your own behalf and on Your sole responsibility, not on behalf
172 | of any other Contributor, and only if You agree to indemnify,
173 | defend, and hold each Contributor harmless for any liability
174 | incurred by, or claims asserted against, such Contributor by reason
175 | of your accepting any such warranty or additional liability.
176 |
177 | END OF TERMS AND CONDITIONS
178 |
179 | APPENDIX: How to apply the Apache License to your work.
180 |
181 | To apply the Apache License to your work, attach the following
182 | boilerplate notice, with the fields enclosed by brackets "[]"
183 | replaced with your own identifying information. (Don't include
184 | the brackets!) The text should be enclosed in the appropriate
185 | comment syntax for the file format. We also recommend that a
186 | file or class name and description of purpose be included on the
187 | same "printed page" as the copyright notice for easier
188 | identification within third-party archives.
189 |
190 | Copyright [yyyy] [name of copyright owner]
191 |
192 | Licensed under the Apache License, Version 2.0 (the "License");
193 | you may not use this file except in compliance with the License.
194 | You may obtain a copy of the License at
195 |
196 | http://www.apache.org/licenses/LICENSE-2.0
197 |
198 | Unless required by applicable law or agreed to in writing, software
199 | distributed under the License is distributed on an "AS IS" BASIS,
200 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
201 | See the License for the specific language governing permissions and
202 | limitations under the License.
203 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | GNU GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc.
63 |
86 |
87 |
64 |
65 |
85 |
66 |
67 | School Bus Tracking System {{admin}}
68 |
69 |
70 |
71 |
72 |
73 | {% block content%}
74 |
75 | {% endblock %}
76 |
77 |
78 |
79 |
80 | Developed by Rajat Sahu.
82 |
83 |
84 |