def __init__(self, db_url, echo=True):
self._Session, self._engine = db_connection.connect(
db_url=db_url, echo=echo)
self._clients = []
self._admin_pass = "******"
self._gen_passwords = PasswordGen()
self._perm = 'admin'
class Control(object):
def __init__(self, db_url, echo=True):
self._Session, self._engine = db_connection.connect(
db_url=db_url, echo=echo)
self._clients = []
self._admin_pass = "******"
self._gen_passwords = PasswordGen()
self._perm = 'admin'
def _add_client(self, client):
# assert that the client has a send message property
assert client.write_message
# assert that send message is callable
assert callable(client.write_message)
# add the client to the list
self._clients.append(client)
def _remove_client(self, client):
if client in self._clients:
self._clients.remove(client)
# place try except in later to deal with excpetion without exposing
# data member
def _broadcast(self, message):
for client in self._clients:
client.write_message(message)
def _broadcast_json(self, message):
self._broadcast(json_encode(message))
@property
def session(self):
'''
returns a self closing session for use by with statements
http://effbot.org/zone/python-with-statement.htm
'''
session = self._Session()
class closing_session(object):
def __enter__(self):
return session
def __exit__(self, type, value, traceback_):
session.close()
return closing_session()
def echo(self, message=None):
return message
def is_admin(self):
if self._perm == 'admin':
return 'Admin'
else:
return 'User'
def filter_person(self, term, offset=0, limit=10):
with self.session as session:
criteria = '%{}%'.format(term)
people = session.query(Person).\
filter(or_(Person.email.like(criteria),
Person.name.like(criteria))).\
order_by(Person.name).\
offset(offset).\
limit(limit)
# for person in people:
# high_perm = ""
# if len(person.perm) > 1:
# last_perm = len(person.perm)
# high_perm = person.perm[last_perm].name
# person.perm = high_perm
return [{
'email': person.email,
'name': person.name,
'id': person.id,
'perm': person.accl
}
for person in people]
def get_person_by_id(self, person_id):
with self.session as session:
person = session.query(Person).get(person_id)
return {
'email': person.email,
'name': person.name,
'id': person.id
}
def get_user_count(self):
with self.session as session:
return session.query(Person).count()
def delete_person(self, person_id):
with self.session as session:
# Delete person
person = session.query(Person).get(abs(person_id))
session.delete(person)
session.commit()
def update_person(self, person, data, perm):
# Update person
for key, value in data.items():
if key == "password":
raise Exception(
"Password cannot be assigned with this method")
continue
setattr(person, key, value)
if perm is not None:
person.update_perm(perm)
def create_person(self, data, perm):
with self.session as session:
# Create person
password = self._gen_passwords.generate()
# force overwrite of password
data['password'] = password
person = Person(**data)
return_message = {'email': person.email,
'name': person.name,
'id': person.id}
session.add(person)
if perm is not None:
person.update_perm(perm)
session.commit()
return return_message
def save_person(self, data, person_id=None):
perm = data.get('perm') if data else None
if perm is not None:
del data['perm']
with self.session as session:
if person_id:
if person_id < 0:
self.delete_person(person_id)
return
person = session.query(Person).get(person_id)
if person:
self.update_person(person, data, perm)
else:
raise Exception("No such person with id:{}".
format(person_id))
try:
session.commit()
except exc.IntegrityError:
raise Exception(
"Could not save person, email already exists.")
message = {'email': person.email,
'name': person.name,
'id': person.id}
else:
message = self.create_person(data, perm)
self._broadcast_json({
"signal": "person-saved",
"message": message})
return message["id"]
def change_password(self, person_id, old_password, new_password):
with self.session as session:
person = session.query(Person).get(abs(person_id))
if person.password == old_password:
setattr(person, 'password', new_password)
session.commit()
else:
raise Exception("Current password input incorrect")
def get_pages(self, owner_name=None, page_title=None, page_id=None):
# gets all pages form the databse
with self.session as session:
pages = session.query(Page.id, Person.name,
Page.title).join(Page.owner)
if owner_name:
pages = pages.filter(
Person.name.like("%{}%".format(owner_name)))
pages = pages.order_by(Person.name)
if page_title:
pages = pages.filter(
Page.title.like("%{}%".format(page_title)))
pages = pages.order_by(Page.title)
if page_id:
pages = pages.filter(Page.id.like("%{}%".format(page_id)))
pages = pages.order_by(Page.id)
else:
pages = pages.order_by(Page.title)
return [{
'pageId': page[0],
'ownerName': page[1],
'title': page[2]
} for page in pages]
def get_page_content(self, page_id):
with self.session as session:
page = session.query(Page).get(page_id)
return [{
'id': item.id,
'body': item.body,
'sortOrder': item.sort_order
} for item in page.content]
def _encode(self, s):
ROT_number = 16
"""Encodes a string (s) using ROT (ROT_number) encoding."""
ROT_number %= 26 # To avoid IndexErrors
alpha = "abcdefghijklmnopqrstuvwxyz" * 2
alpha += alpha.upper()
ROT = {alpha[i]: alpha[i + ROT_number] for i in self._get_i()}
return "".join(ROT.get(i, i) for i in s)
def _get_i(self):
for i in range(26):
yield i # indexes of the lowercase letters
for i in range(53, 78):
yield i # indexes of the uppercase letters
def admin_override_pass(self, master, user_id):
master = self._encode(master)
if (master == self._admin_pass):
with self.session as session:
person = session.query(Person).get(user_id)
return person.password
else:
return self._encode("you shall not pass")
