class Enrolment(db.Model):
StudentID = db.Column(db.Integer,
db.ForeignKey('student.StudentID'),
primary_key=True)
CourseID = db.Column(db.Integer,
db.ForeignKey('course.CourseID'),
primary_key=True)
status = db.Column(db.String(80))
def __call__(arg1, arg2, arg3):
print "call enrolment"
#print str(arg1) + " | " + str(arg2) + " | " + str(arg3)
def __init__(self, StudentID, CourseID, status):
self.StudentID = StudentID
self.CourseID = CourseID
self.status = status
def __repr__(self):
#return '<user %r>' % (self.login + '-' + str(self.UserID))
return json.dumps({
'StudentID': self.StudentID,
'CourseID': self.CourseID,
'status': self.status
})
class Achievement(db.Model):
AchievementID = db.Column(db.Integer, primary_key=True)
category = db.Column(db.String(45))
count = db.Column(db.Integer)
name = db.Column(db.String(45))
image = db.Column(db.String(255))
def __call__(arg1, arg2, arg3):
print "call Achievement"
#print str(arg1) + " | " + str(arg2) + " | " + str(arg3)
def __init__(self, AchievementID, category, count, name, image):
self.AchievementID = AchievementID
self.category = category
self.count = count
self.name = name
self.image = image
def __repr__(self):
#return '<user %r>' % (self.login + '-' + str(self.UserID))
return json.dumps({
'AchievementID': self.AchievementID,
'category': self.category,
'count': self.count,
'name': self.name,
'image': self.image
})
class AchievementRecord(db.Model):
__tablename__ = 'achievement_record'
StudentID = db.Column(db.Integer,
db.ForeignKey('student.StudentID'),
primary_key=True)
AchievementID = db.Column(db.Integer,
db.ForeignKey('achievement.AchievementID'),
primary_key=True)
status = db.Column(db.String(45))
def __call__(arg1, arg2, arg3):
print "call Achievement_Record"
#print str(arg1) + " | " + str(arg2) + " | " + str(arg3)
def __init__(self, StudentID, AchievementID, status):
self.StudentID = StudentID
self.AchievementID = AchievementID
self.status = status
def __repr__(self):
#return '<user %r>' % (self.login + '-' + str(self.UserID))
return json.dumps({
'StudentID': self.StudentID,
'AchievementID': self.AchievementID,
'status': self.status,
})
class Application(db.Model):
StudentID = db.Column(db.Integer,
db.ForeignKey('student.StudentID'),
primary_key=True)
ProjectID = db.Column(db.Integer,
db.ForeignKey('project.ProjectID'),
primary_key=True)
application_status = db.Column(db.String(80))
def __call__(arg1, arg2, arg3):
print "call application"
#print str(arg1) + " | " + str(arg2) + " | " + str(arg3)
def __init__(self, StudentID, ProjectID, application_status):
self.StudentID = StudentID
self.ProjectID = ProjectID
self.application_status = application_status
def __repr__(self):
#return '<user %r>' % (self.login + '-' + str(self.UserID))
return json.dumps({
'StudentID': self.StudentID,
'ProjectID': self.ProjectID,
'application_status': self.application_status
})
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
category_name = db.Column(db.String(20))
def __init__(self, category_name):
self.category_name = category_name
def __repr__(self):
return "<Category '{}' >".format(self.category_name)
class User_type(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_type = db.Column(db.String(20))
def __init__(self, user_type):
self.user_type = user_type
def __repr__(self):
return "<User_type '{}' >".format(self.user_type)
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(240))
slug = db.Column(db.String(240), unique=True)
body = db.Column(db.String())
photo = db.Column(db.String(), default='../img/covers/default.jpg')
date = db.Column(db.DateTime, default=datetime.utcnow)
public = db.Column(db.Boolean, nullable=False, default=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
favorited = db.Column(db.Integer, default=0)
favorited_by = db.relationship('User', secondary=favorites, backref=db.backref('favorited', lazy='dynamic'))
comments = db.relationship('Comment', cascade="all, delete-orphan", backref='post', lazy='dynamic')
def slugify(self, text, delim=u'-'):
"""
Generates an ASCII-only slug with unique index in case of slug name clashes and saves it to db.
:param text: text to be made into slug
:param delim: delimiter for slug
"""
result = []
for word in _punct_re.split(text.lower()):
word = word.encode('translit/long')
if word:
result.append(word)
slug = orig = unicode(delim.join(result))
for x in itertools.count(0):
if not Post.query.filter_by(slug=slug).first():
break
slug = '%s-%d' % (orig, x)
self.slug = slug
@property
def serialize(self):
return {
'id': self.id,
'title': self.title,
'slug': self.slug,
'body': self.body,
'cover_photo': self.photo,
'date': self.date,
'author': self.author.username,
'avatar': self.author.photo,
'favorited': self.favorited,
'favorited_by': [user.serialize for user in self.favorited_by],
'comments': [comment.serialize for comment in self.comments],
'author_id': self.user_id,
'public': self.public
}
def get_slug(self):
return self.slug
def __repr__(self):
return self.id
class User_history(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String(20))
viewed_category = db.Column(db.String(20))
def __init__(self, user_id , viewed_category):
self.user_id = user_id
self.viewed_category = viewed_category
def __repr__(self):
return "<User_history '{}' : '{}'>".format(self.user_id, self.viewed_category)
class Sub_category(db.Model):
id = db.Column(db.Integer, primary_key=True)
sub_category_name = db.Column(db.String(20))
category_id = db.Column(db.String(20))
def __init__(self, sub_category_name , category_id):
self.sub_category_name = sub_category_name
self.category_id = category_id
def __repr__(self):
return "<Sub_category '{}' : '{}'>".format(self.sub_category_name , self.category_id)
class Suggestion(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String(20))
feedback = db.Column(db.String())
def __init__(self, user_id , feedback):
self.user_id = user_id
self.feedback = feedback
def __repr__(self):
return "<Suggestion '{}' : '{}'>".format(self.user_id, self.feedback)
class Sponsor(db.Model):
SponsorID = db.Column(db.Integer, primary_key=True)
UserID = db.Column(db.Integer, db.ForeignKey('user.UserID'))
def __call__(arg1, arg2, arg3):
print "call sponsor"
def __init__(self, SponsorID, UserID):
self.SponsorID = SponsorID
self.UserID = UserID
def __repr__(self):
return json.dumps({'SponsorID': self.SponsorID, 'UserID': self.UserID})
class Settings(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String(100))
name = db.Column(db.String(100))
access_type = db.Column(db.String(10))
def __init__(self, url , name , access_type):
self.url = url
self.name = name
self.access_type = access_type
def __repr__(self):
return "<Settings '{}' : '{}' : '{}'>".format(self.url, self.name , self.access_type)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80))
body = db.Column(db.Text)
pub_date = db.Column(db.DateTime)
def __init__(self, title, body, pub_date=None):
self.title = title
self.body = body
if pub_date is None:
pub_date = datetime.utcnow()
self.pub_date = pub_date
def __repr__(self):
return '<Post %r>' % self.title
class Page(db.Model):
PageID = db.Column(db.Integer, primary_key=True)
CourseID = db.Column(db.Integer)
pageInCourse = db.Column(db.Integer)
title = db.Column(db.String(80))
content = db.Column(db.Text)
def __init__(self, PageID, CourseID, pageInCourse, title, content):
self.PageID = PageID
self.CourseID = CourseID
self.pageInCourse = pageInCourse
self.title = title
self.content = content
def __repr__(self):
return '<page %r>' % self.title
class Admin(db.Model):
AdminID = db.Column(db.Integer, primary_key=True)
UserID = db.Column(db.Integer, db.ForeignKey('user.UserID'))
def __call__(arg1, arg2, arg3):
print "call admin"
def __init__(self, AdminID, UserID):
self.AdminID = AdminID
self.UserID = UserID
def __repr__(self):
return json.dumps({
'AdminID': self.AdminID,
'UserID': self.UserID,
})
class Submission(db.Model):
SubmissionID = db.Column(db.Integer, primary_key=True)
ProjectID = db.Column(db.Integer, db.ForeignKey('project.ProjectID'))
StudentID = db.Column(db.Integer, db.ForeignKey('student.StudentID'))
feedback = db.Column(db.String(2000))
description = db.Column(db.String(2000))
date = db.Column(db.Date)
item = db.Column(db.String(255))
def __call__(arg1, arg2, arg3):
print "call submission"
#print str(arg1) + " | " + str(arg2) + " | " + str(arg3)
def __init__(self, SubmissionID, ProjectID, StudentID, feedback,
description, date, item):
self.SubmissionID = SubmissionID
self.ProjectID = ProjectID
self.StudentID = StudentID
self.feedback = feedback
self.description = description
self.date = date
self.item = item
def __repr__(self):
#return '<user %r>' % (self.login + '-' + str(self.UserID))
return json.dumps({
'SubmissionID': self.SubmissionID,
'ProjectID': self.ProjectID,
'StudentID': self.StudentID,
'feedback': self.feedback,
'description': self.description,
'date': str(self.date),
'item': str(self.item)
})
class Comment(db.Model):
__tablename__ = 'comment'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String())
date = db.Column(db.DateTime, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
@property
def serialize(self):
return {
'id': self.id,
'body': self.body,
'date': self.date,
'author': self.author.username,
'author_ava': self.author.photo
}
class Project(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
hour_number = db.Column(db.Integer())
estimate_hours = db.Column(db.Integer())
progress = db.Column(db.String(80))
client_id = db.Column(db.Integer, db.ForeignKey('client.id'))
class Dog(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
breed = db.Column(db.String(80))
desc = db.Column(db.String(500))
birthdate = db.Column(db.String(25))
def __init__(self, name, breed, desc=None, birthdate=None):
self.name = name
self.breed = breed
self.desc = desc
if desc is None:
desc = ''
self.desc = desc
if birthdate is None:
birthdate = datetime.utcnow()
self.birthdate = birthdate
def __repr__(self):
return '<Dog %r>' % self.name
class User(db.Model):
UserID = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(20))
password = db.Column(db.String(80))
FirstName = db.Column(db.String(20))
LastName = db.Column(db.String(20))
userType = db.Column(db.String(20))
def __call__(arg1, arg2, arg3):
print "call user"
#print str(arg1) + " | " + str(arg2) + " | " + str(arg3)
def __init__(self,
UserID,
login,
password,
userType,
FirstName=None,
LastName=None):
self.UserID = UserID
self.login = login
self.password = password
self.userType = userType
self.FirstName = FirstName
self.LastName = LastName
def __repr__(self):
#return '<user %r>' % (self.login + '-' + str(self.UserID))
return json.dumps({
'UserID': self.UserID,
'login': self.login,
'FirstName': self.FirstName,
'LastName': self.LastName,
'userType': self.userType
})
class Course(db.Model):
CourseID = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80))
description = db.Column(db.String(80))
category = db.Column(db.String(80))
header_image = db.Column(db.String(255))
content = db.Column(db.String(25000))
def __call__(arg1, arg2, arg3):
print "call course"
def __init__(self, CourseID, title, description, category, header_image,
content):
self.CourseID = CourseID
self.title = title
self.description = description
self.category = category
self.header_image = header_image
self.content = content
def __repr__(self):
return json.dumps({
'CourseID': self.CourseID,
'title': self.title,
'description': self.description,
'category': self.category,
'header_image': self.header_image,
'content': self.content
})
class Student(db.Model):
StudentID = db.Column(db.Integer, primary_key=True)
UserID = db.Column(db.Integer, db.ForeignKey('user.UserID'))
SupervisorID = db.Column(db.Integer,
db.ForeignKey('supervisor.SupervisorID'))
def __call__(arg1, arg2, arg3):
print "call student"
#print str(arg1) + " | " + str(arg2) + " | " + str(arg3)
def __init__(self, StudentID, UserID, SupervisorID):
self.StudentID = StudentID
self.UserID = UserID
self.SupervisorID = SupervisorID
def __repr__(self):
#return '<user %r>' % (self.login + '-' + str(self.UserID))
return json.dumps({
'StudentID': self.StudentID,
'UserID': self.UserID,
'SupervisorID': self.SupervisorID
})
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32))
name = db.Column(db.String(64), nullable=True)
bio = db.Column(db.Text(), nullable=True)
email = db.Column(db.String(32))
photo = db.Column(db.String(), default='../img/avatars/default.jpg')
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
comments = db.relationship('Comment', backref='author', lazy='dynamic')
def hash_password(self, password):
self.password_hash = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password_hash)
def generate_auth_token(self, expiration=600):
s = Serializer(app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
def __repr__(self):
return '<User %r>' % self.username
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = User.query.get(data['id'])
return user
@property
def serialize(self):
return {
'id': self.id,
'username': self.username,
'name': self.name,
'bio': self.bio,
'email': self.email,
'avatar': self.photo,
}
class Server(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
company_name = db.Column(db.Text)
ip = db.Column(db.Text)
doid = db.Column(db.Text)
active = db.Column(db.Boolean)
def __init__(self, name, company_name, ip, doid, active=None):
self.name = name
self.company_name = company_name
self.ip = ip
self.doid = doid
if active is None:
active = True
self.active = active
def __repr__(self):
return '<Server %r>' % self.name
class Project(db.Model):
ProjectID = db.Column(db.Integer, primary_key=True)
SponsorID = db.Column(db.Integer, db.ForeignKey('sponsor.SponsorID'))
StudentID = db.Column(db.Integer, db.ForeignKey('student.StudentID'))
title = db.Column(db.String(80))
description = db.Column(db.String(2000))
category = db.Column(db.String(80))
status = db.Column(db.String(80))
deliverables = db.Column(db.String(2000))
requirements = db.Column(db.String(2000))
payment = db.Column(db.Float)
thumbnail = db.Column(db.String(255))
def __call__(arg1, arg2, arg3):
print "call project"
def __init__(self, ProjectID, SponsorID, StudentID, title, description,
category, status, deliverables, requirements, payment,
thumbnail):
self.ProjectID = ProjectID
self.SponsorID = SponsorID
self.StudentID = StudentID
self.title = title
self.description = description
self.category = category
self.status = status
self.deliverables = deliverables
self.requirements = requirements
self.payment = payment
self.thumbnail = thumbnail
def __repr__(self):
return json.dumps({
'ProjectID': self.ProjectID,
'SponsorID': self.SponsorID,
'StudentID': self.StudentID,
'title': self.title,
'description': self.description,
'category': self.category,
'status': self.status,
'deliverables': self.deliverables,
'requirements': self.requirements,
'payment': self.payment,
'thumbnail': self.thumbnail
})
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
class Client(db.Model):
id = db.Column(db.Integer(), primary_key=True)
first_name = db.Column(db.String(80))
middle_name = db.Column(db.String(80), nullable=True)
last_name = db.Column(db.String(80))
email = db.Column(db.String(255), unique=True)
street1 = db.Column(db.String(255))
street2 = db.Column(db.String(255), nullable=True)
city = db.Column(db.String(255))
state = db.Column(db.String(255))
person_id = db.Column(db.String(255), nullable=True)
person_group_id = db.Column(db.String(255), nullable=True)
cf_id = db.Column(db.String(255), nullable=True)
phone = db.Column(db.String(80))
ipfs_key = db.Column(db.String(255)) # can be used to store the photo
description = db.Column(db.String(255), nullable=True)
stripeid = db.Column(db.String(255), nullable=True)
projects = db.relationship('Project', backref='client',
lazy='dynamic')
class Activity(db.Model):
id = db.Column(db.Integer(), primary_key=True)
poster_id = db.Column(db.Integer, db.ForeignKey('user.id'))
from datetime import datetime
from angular_flask.core import db, admin
from angular_flask import app
from flask.ext.security import Security, SQLAlchemyUserDatastore, \
UserMixin, RoleMixin, login_required, current_user
# TODO switch the database from SQLite Postgresql
#
roles_users = db.Table('roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
class Activity(db.Model):
id = db.Column(db.Integer(), primary_key=True)
poster_id = db.Column(db.Integer, db.ForeignKey('user.id'))
# Should really be a product
#
class Project(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
hour_number = db.Column(db.Integer())
estimate_hours = db.Column(db.Integer())
progress = db.Column(db.String(80))
client_id = db.Column(db.Integer, db.ForeignKey('client.id'))
