def setUp(self):
self.account_info = {
"name": "Fiona",
"password": "******",
"gender": 'F',
"weight": 56,
"height": 176,
"activity_level": 3,
"age": 23,
"recomended_calories": 0,
"recomended_proteins": 0,
"recomended_carbs": 0,
"recomended_fats": 0,
"percent_proteins": 0.4,
"percent_carbs": 0.4,
"percent_fats": 0.2
}
self.tester_account = Account(models.connect())
self.tester_account.add(self.account_info)
self.account = self.tester_account.get_by_name("Fiona")
self.tester = ConsumedFood(models.connect())
self.multiplier = 3.5
self.info = {
"name": "peanut butter",
"quantity": 100,
"calories": 578,
"proteins_g": 29.1,
"carbs_g": 11.8,
"fats_g": 46.1
}
def open(self, user_oid, username):
models.connect()
self.subscribe_pk = None
try:
user = models.User.objects.get(pk=user_oid)
if username == user.username:
self.user = user
else:
self.user = None
except:
self.user = None
print(user_oid, username)
print(self.user)
if username == "admin" and self.user == None:
if settings.HERMES_API_KEY.split('-')[0] == user_oid:
class Admin:
def __init__(self):
self.owner = 0
self.is_admin = True
self.user = Admin()
if not self.user:
return
self.runCallback('open', None)
def eomReceived(self):
header = ""
header_done = False
message = ""
for line in self.lines:
if header_done:
message += line + "\r\n"
continue
if line == "":
header_done = True
continue
header += line + "\r\n"
thisHeader = line.split(": ", 1)
headers = Parser().parsestr(header)
self.lines = None
connect()
domain = get_or_create_domain(self.user.dest.domain)
user = get_or_create_user(self.user.dest.local, domain)
Mail(user=user,
ts=datetime.datetime.now(),
envelopeHeloHost=self.user.helo[0],
envelopeHeloAddress=self.user.helo[1],
envelopeFrom=str(self.user.orig),
envelopeTo=str(self.user.dest),
headerFrom=headers["from"] or "",
headerSubject=headers["subject"] or "",
headers=header,
body=message)
return defer.succeed(None)
def eomReceived(self):
header = ""
header_done = False
message = ""
for line in self.lines:
if header_done:
message += line + "\r\n"
continue
if line == "":
header_done = True
continue
header += line + "\r\n"
thisHeader = line.split(": ", 1)
headers = Parser().parsestr(header)
self.lines = None
connect()
domain = get_or_create_domain(self.user.dest.domain)
user = get_or_create_user(self.user.dest.local, domain)
Mail(
user = user,
ts = datetime.datetime.now(),
envelopeHeloHost = self.user.helo[0],
envelopeHeloAddress = self.user.helo[1],
envelopeFrom = str(self.user.orig),
envelopeTo = str(self.user.dest),
headerFrom = headers["from"] or "",
headerSubject = headers["subject"] or "",
headers = header,
body = message
)
return defer.succeed(None)
def _main():
cli = _get_cli()
models.connect(recreate=cli.recreate)
for listener in settings.SCANS:
if listener.get('enabled', True):
_process_listener(listener, cli.log)
def get(self):
models.connect()
users = {"users": models.HermesUser.objects().to_json()}
self.set_header('Content-Type', 'application/json')
self.set_header("Access-Control-Allow-Origin", settings.PARENT_DOMAIN)
self.set_header("Access-Control-Allow-Credentials", "true")
self.write(users)
def __call__(self, environ, start_response):
self.request = Request(environ)
handler, args = self.find_handler()
if not handler:
raise HTTPNotFound('No handler defined for %s (%s)' % (self.request.path_info, self.request.method))
if not args:
args = ()
# Prepare database connection
connect()
response = handler(self, self.request, *args)
if not response:
response = Response() # Provide an empty response
# Base WSGI app shoud be session agnostic
# self.session = dict()
#
# if SESSION_KEY in environ:
# self.session = environ[SESSION_KEY]
# else:
# self.session = {} # Fail soft
#log.debug('Response for call %s is %s' % (self.request.path_info, type(response)))
return response(environ, start_response)
def setUp(self):
self.account_info = {
"name": "Fiona",
"password": "******",
"gender": 'F',
"weight": 56,
"height": 176,
"activity_level": 3,
"age": 23,
"recomended_calories": 0,
"recomended_proteins": 0,
"recomended_carbs": 0,
"recomended_fats": 0,
"percent_proteins": 0.4,
"percent_carbs": 0.4,
"percent_fats": 0.2
}
self.tester_account = Account(models.connect())
self.tester_account.add(self.account_info)
self.account = self.tester_account.get_by_name("Fiona")
self.tester = ConsumedFood(models.connect())
self.multiplier = 3.5
self.info = {
"name": "peanut butter",
"quantity": 100,
"calories": 578,
"proteins_g": 29.1,
"carbs_g": 11.8,
"fats_g": 46.1
}
def __call__(self, environ, start_response):
connect()
# New session manager instance each time
manager = SessionManager(environ, **self.kwargs)
# Add a session object to wrapped app
self.app.session = manager.session
#environ[SESSION_KEY] = manager.session
# Initial response to a cookie session
def initial_response(environ, start_response):
def session_response(status, headers, exc_info=None):
manager.set_cookie(headers)
return start_response(status, headers, exc_info)
return self.app(environ, session_response)
try:
# Return initial response if new or session id is random
if manager.is_new:
return initial_response(environ, start_response)
return self.app(environ, start_response)
# Always close session
finally:
manager.close()
def get(self):
models.connect()
users = {
"users": models.HermesUser.objects().to_json()
}
self.set_header('Content-Type', 'application/json')
self.set_header("Access-Control-Allow-Origin", settings.PARENT_DOMAIN)
self.set_header("Access-Control-Allow-Credentials", "true")
self.write(users)
def update_all():
t = tvdb_api.Tvdb()
db = models.connect()
shows = db.query(Show).all()
for s in shows:
add_episodes(s.show_id, t, db, True)
db.remove()
def SearchDbForShow(list_of_shows):
db = models.connect()
source = db.query(ScanURL).filter(ScanURL.media_type == "index").first()
if source:
browser = LinkRetrieve.source_login(source)
if browser is None:
ActionLog.log('%s could not logon' % source.login_page)
else:
for show_searcher in [l for l in list_of_shows if not l.retrieved]:
config = db.query(models.Config).first()
matching_indexes = []
for search_text in show_searcher.search_list: # all potential links to list
matching_indexes.extend(db.query(LinkIndex).filter(LinkIndex.link_text.like('%' + search_text + '%')).filter(LinkIndex.link_text.like('%' + show_searcher.episode_code + '%')).all())
if len(matching_indexes) > 0:
for match in matching_indexes:
tv_response = browser.get(match.link_url)
if tv_response.status_code == 200:
episode_soup = tv_response.soup
episode_links = LinkRetrieve.get_download_links(episode_soup, config, source.domain, config.hd_format)
# check to make sure links are active
for l in episode_links:
link_response = browser.get(l)
if link_response.status_code == 404:
episode_links = None
break
if episode_links:
LinkRetrieve.process_tv_link(db, config, show_searcher, episode_links)
break # since we got the download, we can break out of the loop
def add_episodes(series_id, t=None, db=None, is_mass_update=False):
if t is None:
t = tvdb_api.Tvdb()
if db is None:
db = models.connect()
episodes = t[series_id].search('')
update_show = db.query(Show).filter(Show.show_id == series_id).first()
update_show.banner = t[series_id]['banner'] if t[series_id]['banner'] != None else ''
models.ActionLog.log('Updating "%s"' % update_show.show_name)
update_show.episodes.delete()
db.commit()
# if update_show.episodes.count() > 0:
# # update unaired show first with new names & air date
# for db_episode in [s for s in update_show.episodes if s.status == 'Pending']:
# # find the episode ID in tv_db episode listing
# updated_episode_list = [x for x in episodes if x['id'] == str(db_episode.id)]
# if len(updated_episode_list) > 0:
# updated_episode = updated_episode_list[0]
# db_episode.air_date = None if updated_episode['firstaired'] is None else \
# datetime.datetime.strptime(updated_episode['firstaired'], '%Y-%m-%d').date()
# db_episode.episode_name = str(updated_episode).replace('<', '').replace('>', '')
#
# # get episodes that aren't in the show's episode collection but are in the tvdb response
# episodes = [x for x in episodes if update_show.episodes.filter(Episode.id == int(x['id'])).count() == 0 and x['seasonnumber'] != '0']
for e in episodes:
if e['seasonnumber'] == '0':
continue
else:
if e['firstaired'] is None:
first_aired = None
else:
first_aired = datetime.datetime.strptime(e['firstaired'], '%Y-%m-%d').date()
if is_mass_update:
if first_aired is not None and first_aired >= datetime.date.today():
episode_retrieved = 'Pending'
else:
episode_retrieved = 'Retrieved'
else:
if first_aired is not None and first_aired >= datetime.date.today() + datetime.timedelta(-2):
episode_retrieved = 'Pending'
elif first_aired is None:
episode_retrieved = 'Pending'
else:
episode_retrieved = 'Retrieved'
new_episode = Episode(id=e['id'], season_number=e['seasonnumber'], episode_number=e['episodenumber'],
air_date=first_aired, episode_name=str(e).replace('<', '').replace('>', ''),
status=episode_retrieved, show=update_show)
db.add(new_episode)
db.commit()
def __call__(self, environ, start_response):
self.request = Request(environ)
handler, args = self.find_handler()
if not handler:
raise HTTPNotFound('No handler defined for %s (%s)' % (self.request.path_info, self.request.method))
if not args:
args = ()
# Prepare database connection
connect()
response = handler(self, self.request, *args)
if not response:
response = Response() # Provide an empty response
return response(environ, start_response)
def get_user(cls, email=None, id=None):
"""
Returns a dictionary of the user data. Must provide either an email or an id.
"""
db = connect()
try:
#logging.info('Attempting to get the user via the email ' + str(email) + ' or the id ' + str(id) + '.')
query = db.query(_User)
if email is not None:
query = query.filter(_User.email == email)
elif id is not None:
query = query.filter(_User.id == id)
else:
raise AttributeError(
'You must supply an email or user_id (from the database) in order to get the user.'
)
user = query.one().__dict__
user['sold'] = db.query(_Transaction).filter(
_Transaction.seller_id == user['id']).count()
user['purchased'] = db.query(_Transaction).filter(
_Transaction.buyer_id == user['id']).count()
user['listed_for_sale'] = db.query(_BookListing).filter(
_BookListing.user_id == user['id']).filter(
_BookListing.listing_type == 'For Sale').filter(
_BookListing.active == '1').count()
user['listed_for_purchase'] = db.query(_BookListing).filter(
_BookListing.user_id == user['id']).filter(
_BookListing.listing_type == 'Wanted').filter(
_BookListing.active == '1').count()
user['reviews'] = db.query(
_UserReview.rating, _UserReview.comments,
_UserReview.date_posted, _User.first_name, _User.last_name,
_User.email, _User.username, _User.id).join(
_User, _User.id == _UserReview.reviewer_id).filter(
_UserReview.reviewee_id == user['id']).all()
db.close()
#print(user)
return user
except NoResultFound:
logging.info('User not found.')
db.close()
return None
except MultipleResultsFound:
logging.debug(
'Multiple accounts found for this email, this shouldn\' happen.... :-('
)
db.rollback()
db.close()
return False
except:
logging.debug(
'A different error occured than was expected.... What to do?')
db.rollback()
db.close()
raise
return None
def setUp(self):
self.tester = Food(models.connect())
self.info = {
"name": "peanut butter",
"quantity": 100,
"calories": 578,
"proteins_g": 29.1,
"carbs_g": 11.8,
"fats_g": 46.1
}
def __call__(self, environ, start_response):
self.request = Request(environ)
handler, args = self.find_handler()
if not handler:
raise HTTPNotFound('No handler defined for %s (%s)' %
(self.request.path_info, self.request.method))
if not args:
args = ()
# Prepare database connection
connect()
response = handler(self, self.request, *args)
if not response:
response = Response() # Provide an empty response
return response(environ, start_response)
def setUp(self):
self.tester = Food(models.connect())
self.info = {
"name": "peanut butter",
"quantity": 100,
"calories": 578,
"proteins_g": 29.1,
"carbs_g": 11.8,
"fats_g": 46.1
}
def post(self):
"""
creates new HermesUser object
>>> POST /api/v1/users {"api_key":<settings.HERMES_API_KEY>,
"owner":<model.HermesUser.pk>,
"username":<model.HermesUser.username>,
"i_am": <profile_type>
}
<<< {
"oid":"XXXXXXXXXXXXXXX",
"user": <models.HermesUser>
}
On errors:
<<< {}
"""
api_key = self.get_argument("api_key")
if api_key != settings.HERMES_API_KEY:
self.write({})
owner = self.get_argument("owner")
username = self.get_argument("username")
is_admin = eval(self.get_argument('is_admin'))
is_moderator = eval(self.get_argument('is_moderator'))
is_expert = eval(self.get_argument('is_expert'))
print(is_admin, is_moderator, is_admin)
models.connect()
models.User.objects(owner=owner).delete()
user = models.User(owner=owner, username=username,
is_admin=is_admin, is_expert=is_expert, is_moderator=is_moderator)
user.save()
output = {
"oid": str(user.pk),
"user": user.to_json()
}
print("Created" + user.to_json())
self.set_header('Content-Type', 'application/json')
self.set_header("Access-Control-Allow-Origin", settings.PARENT_DOMAIN)
self.set_header("Access-Control-Allow-Credentials", "true")
self.write(output)
def post(self):
"""
creates new HermesUser object
>>> POST /api/v1/users {"api_key":<settings.HERMES_API_KEY>,
"owner":<model.HermesUser.pk>,
"username":<model.HermesUser.username>,
"i_am": <profile_type>
}
<<< {
"oid":"XXXXXXXXXXXXXXX",
"user": <models.HermesUser>
}
On errors:
<<< {}
"""
api_key = self.get_argument("api_key")
if api_key != settings.HERMES_API_KEY:
self.write({})
owner = self.get_argument("owner")
username = self.get_argument("username")
is_admin = eval(self.get_argument('is_admin'))
is_moderator = eval(self.get_argument('is_moderator'))
is_expert = eval(self.get_argument('is_expert'))
print(is_admin, is_moderator, is_admin)
models.connect()
models.User.objects(owner=owner).delete()
user = models.User(owner=owner,
username=username,
is_admin=is_admin,
is_expert=is_expert,
is_moderator=is_moderator)
user.save()
output = {"oid": str(user.pk), "user": user.to_json()}
print("Created" + user.to_json())
self.set_header('Content-Type', 'application/json')
self.set_header("Access-Control-Allow-Origin", settings.PARENT_DOMAIN)
self.set_header("Access-Control-Allow-Credentials", "true")
self.write(output)
def post(self):
"""
POST /api/v1/login {"oid":<models.HermesUser.oid>,
"username":<model.HermesUser.username>}
"""
self.set_header('Content-Type', 'application/json')
self.set_header("Access-Control-Allow-Origin", settings.PARENT_DOMAIN)
self.set_header("Access-Control-Allow-Credentials", "true")
models.connect()
pk = self.get_argument("oid")
username = self.get_argument("username")
user = models.HermesUser.objects(pk=pk)
if not user:
self.write({'login': False})
user = user[0]
if user.username == username:
self.write({'login': True})
else:
self.write({'login': False})
def post(self):
"""
POST /api/v1/login {"oid":<models.HermesUser.oid>,
"username":<model.HermesUser.username>}
"""
self.set_header('Content-Type', 'application/json')
self.set_header("Access-Control-Allow-Origin", settings.PARENT_DOMAIN)
self.set_header("Access-Control-Allow-Credentials", "true")
models.connect()
pk = self.get_argument("oid")
username = self.get_argument("username")
user = models.HermesUser.objects(pk=pk)
if not user:
self.write({'login': False})
user = user[0]
if user.username == username:
self.write({'login': True})
else:
self.write({'login': False})
def login(cls, user_name, password):
if Account.match_user_password(cls.session, user_name, password):
cls.session = connect()
cls.food_record = Food(cls.session)
cls.account = Account(cls.session)
cls.consumed_food = ConsumedFood(cls.session)
cls.statistics = Statistics(cls.session)
cls.loaded_user = cls.account.get_by_name(user_name)
cls.logged_in = True
else:
# Wrong account or password!
return None
def login(cls, user_name, password):
if Account.match_user_password(cls.session, user_name, password):
cls.session = connect()
cls.food_record = Food(cls.session)
cls.account = Account(cls.session)
cls.consumed_food = ConsumedFood(cls.session)
cls.statistics = Statistics(cls.session)
cls.loaded_user = cls.account.get_by_name(user_name)
cls.logged_in = True
else:
# Wrong account or password!
return None
def __call__(self, environ, start_response):
request = Request(environ)
handler, args = self._find_handler(request)
if not handler:
raise HTTPNotFound('No handler defined for %s (%s)' % (request.path_info, request.method))
if not args:
args = ()
# Save request object for handlers
self.request = request
self.application_url = request.application_url
connect()
response = handler(*args)
if not response:
response = Response() # Provide an empty response
close()
return response(environ, start_response)
def __call__(self, environ, start_response):
request = Request(environ)
handler, args = self._find_handler(request)
if not handler:
raise HTTPNotFound('No handler defined for %s (%s)' %
(request.path_info, request.method))
if not args:
args = ()
# Save request object for handlers
self.request = request
self.application_url = request.application_url
connect()
response = handler(*args)
if not response:
response = Response() # Provide an empty response
close()
return response(environ, start_response)
def get_random_tunes():
engine, Session = connect()
session = Session()
# Get some random albums
songs = session.query(Song).order_by(func.random()).limit(10).all()
res = {"data": [song.to_dict() for song in songs]}
res = {"data":[]}
for song in songs:
s = song.to_dict()
s['album_title'] = song.album.title
s['venue'] = song.album.venue
res['data'].append(s)
session.close()
return jsonify(res)
def list():
"""
Le listing et le formulaire d'ajout de todo
"""
db_session = connect(True)
form = TodoForm()
# GET de base pour obtenir les TODOS au départ
data = {
"todos": db_session.query(Todo).filter_by(done=0).all(),
"form": form
}
return render_template("list.html", **data)
def __call__(self, environ, start_response):
connect()
# New session manager instance each time
manager = SessionManager(environ, **self.kwargs)
# Add a session object to wrapped app
self.app.session = manager.session
# Initial response to a cookie session
def initial_response(environ, start_response):
def session_response(status, headers, exc_info=None):
manager.set_cookie(headers)
return start_response(status, headers, exc_info)
return self.app(environ, session_response)
try:
# Return initial response if new or session id is random
if manager.is_new:
return initial_response(environ, start_response)
return self.app(environ, start_response)
# Always close session
finally:
manager.close()
def ban_user(cls, user_id):
try:
db = connect()
result = db.query(_User).filter(_User.id == user_id).one()
result.is_banned = 1
db.commit()
for listing in db.query(_BookListing).filter(
_BookListing.user_id == user_id).all():
listing.active = 0
db.commit()
db.close()
except:
db.rollback()
db.close()
raise
def change_admin(cls, user_id):
try:
db = connect()
result = db.query(_User).filter(_User.id == user_id).one()
if result.is_admin == 1:
result.is_admin = 0
else:
result.is_admin = 1
db.commit()
db.close()
except:
db.rollback()
db.close()
raise
return user_id
def setUp(self):
self.tester = Account(models.connect())
self.account_password = Account.crypt("48da3cu7")
self.info = {
"name": "Fiona",
"password": self.account_password,
"gender": 'F',
"weight": 56,
"height": 176,
"activity_level": 3,
"age": 23,
"recomended_calories": 0,
"recomended_proteins": 0,
"recomended_carbs": 0,
"recomended_fats": 0,
"percent_proteins": 0.4,
"percent_carbs": 0.4,
"percent_fats": 0.2
}
self.tester.add(self.info)
def done(pk):
# Controller pour rendre un TODO fait avec un post
if pk:
db_session = connect(True)
current_todo = db_session.query(Todo).filter_by(id=pk).first()
current_todo.done = True
db_session.commit()
data = {
"id": pk
}
js_response = make_response(
render_template("done.js", **data).replace("\n", "")
)
js_response.headers["Content-Type"] = "text/javascript; charset=utf-8"
return js_response
return "", 400
def add_book(cls, google_id):
"""
Adds a book to the database, or checks whether it is already there.
In either case, a book_id is returned.
"""
try:
db = connect()
query = db.query(_Book).filter(_Book.google_id == google_id)
if query.count() > 0:
result = query.first()
return result.id
book = cls.find_book(google_id=google_id)
if book is None:
return None
if 'subtitle' not in book:
book['subtitle'] = ''
new_book = _Book(
google_id=google_id,
google_link=book['selfLink'],
title=book['title'],
subtitle=book['subtitle'],
authors=book['authors'],
publisher=book['publisher'],
description=book['description'],
ISBN_10=book['ISBN_10'],
ISBN_13=book['ISBN_13'],
pages=book['pageCount'],
small_thumbnail=book['imageLinks']['smallThumbnail'],
thumbnail=book['imageLinks']
['thumbnail']) # published_date=book['publishedDate'],
db.add(new_book)
db.commit()
book_id = new_book.id
db.close()
return book_id
except:
logging.debug("Something went wrong when inserting the book. :-(")
db.rollback()
db.close()
raise
def startup():
conf = {
'/': {
'tools.sessions.on': True,
'tools.staticdir.root': os.path.abspath(os.getcwd()),
'tools.db.on': True
},
'/static': {
'tools.staticdir.on': True,
'tools.staticdir.dir': 'static'
}
}
config_session = models.connect()
config = config_session.query(models.Config).first()
if config is None:
config = models.Config()
config_session.add(config)
config_session.commit()
cherrypy.config.update({
'server.socket_host': config.ip,
'server.socket_port': int(config.port),
})
# config_session.remove()
scan_refresh_scheduler.add_job(LinkRetrieve.handle_downloads, 'cron', hour='*/' + str(config.scan_interval),
id='scan_job', misfire_grace_time=60)
scan_refresh_scheduler.add_job(Utils.update_all, 'cron', day_of_week=config.refresh_day,
hour=str(config.refresh_hour), id='refresh_job', misfire_grace_time=60)
scan_refresh_scheduler.start()
models.SAEnginePlugin(cherrypy.engine).subscribe()
cherrypy.tools.db = models.SATool()
cherrypy.tree.mount(Infringer(), '/', conf)
cherrypy.engine.start()
webbrowser.get().open(
'http://%s:%s' % (cherrypy.config['server.socket_host'], str(cherrypy.config['server.socket_port'])))
cherrypy.engine.block()
def login_user(cls, email, username, firstName, lastName):
"""
Gets the user from the datastore, adds the user if not already there.
We'll use the autoadd for now since that's how most SSO operations work.
"""
db = connect()
try:
#logging.info('Attempting to login with email: ' + email)
result = db.query(_User).filter(_User.email == email).one()
result.last_login = datetime.datetime.now()
db.commit()
db.close()
return True
except NoResultFound:
logging.info('User not found, creating one!')
db.add(
_User(email=email,
username=username,
first_name=firstName,
last_name=lastName,
last_login=datetime.datetime.now()))
db.commit()
db.close()
return True
except MultipleResultsFound:
logging.debug(
'Multiple accounts found for this email, this shouldn\' happen.... :-('
)
db.rollback()
db.close()
return False
except:
logging.debug(
'A different error occured than was expected.... What to do?')
db.rollback()
db.close()
raise
def main():
engine, Session = models.connect()
session = Session()
add_albums = []
add_songs = []
with open('umphscraper/data.json', 'r') as f:
read = f.read()
data = json.loads(read)
for album in data:
if not album['tracks']:
continue
add_albums.append(
models.Album(
title=album['title'],
lineage=album['lineage'],
venue=album['venue'],
transferred_by=album['transferred_by'],
taped_by=album['taped_by'],
date=(album['date'] or None),
source=album['source'],
archive_org_id=album['id']
)
)
for song in album['tracks']:
add_songs.append(
models.Song(
title=song['title'],
length=song['length'],
filename=song['filename'],
size=(song['size'] or 0),
album_id=album['id']
)
)
session.add_all(add_albums + add_songs)
session.commit()
session.close()
def create():
# Controller de création d'un todo avec un PUT
form = TodoForm(request.form)
if request.method == 'PUT' and form.validate():
db_session = connect(True)
newTodo = Todo()
newTodo.title = form.title.data
newTodo.done = False
db_session.add(newTodo)
db_session.commit()
todo_data = {
"id": newTodo.id,
"title": newTodo.title,
"done": newTodo.done
}
data = {
"form": form,
"todo_html": render_template(
"todo.html",
**todo_data
).replace("\n", "")
}
js_response = make_response(
render_template("list.js", **data).replace("\n", "")
)
js_response.headers["Content-Type"] = "text/javascript; charset=utf-8"
return js_response
return "", 400
def main():
engine, Session = models.connect()
models.add_tables(models.Base, engine)
config_basic = config['BASIC']
AMQP_Host = config['AMQP']['AMQP_Host']
AMQP_Exchange = config['AMQP']['AMQP_Exchange']
AMQP_Exchange_Type = config['AMQP']['AMQP_Exchange_Type']
AMQP_Auth_Queue = config_auth['AMQP_Queue']
AMQP_Email_Queue = config['EMAIL']['AMQP_Queue']
AMQP_Profile_Queue = config['PROFILE']['AMQP_Queue']
Session_Duration = config_basic['Session_Duration']
JWT_Secret = config_basic['JWT_Secret']
# Connecting to PostgreSQL DB.
while True:
try:
engine = connect()
Base.metadata.bind = engine
DBSession = sessionmaker(bind=engine)
session = DBSession()
break
except Exception as err:
print("[x] Auth Service PostgreSQL Not Ready Yet...")
print('[x] Auth Service DB Connnection Established...')
while True:
try:
# Connecting to Message Broker
message_broker = pika.BlockingConnection(
pika.ConnectionParameters(host=AMQP_Host))
break
except Exception as err:
from flask import Flask, render_template, redirect, session, g
from forms import SignupForm, LoginForm
from models import db, connect, Users
app = Flask(__name__)
connect(app)
app.config[
'SECRET_KEY'] = '\xa6\x9f\xd7\x85X\xe9\x01\x12\x17\xa8\x1c\xdafL[\xadlL\x93Gc\xed\xd2w'
app.config['SQLALCHEMY_DATABASE_URI'] = "postgres:///salesman"
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_ECHO'] = True
db.create_all()
CURR_USER_KEY = "current_user"
@app.before_request
def add_user_to_g():
"""If we're logged in, add curr user to Flask global."""
if CURR_USER_KEY in session:
g.user = Users.query.get(session[CURR_USER_KEY])
else:
g.user = None
def do_login(user):
"""Log in user."""
session[CURR_USER_KEY] = user.userID
def test_match_user_password_true(self):
self.assertTrue(
self.tester.match_user_password(models.connect(),
"Fiona",
self.account_password))
def test_match_user_password_false(self):
self.assertFalse(
self.tester.match_user_password(models.connect(),
"Fiona",
"wrong_password"))
#!/usr/bin/env python # -*- coding: utf-8 -*- from models import Partition, Node, DATABASE_PATH, create_tables, clear_tables, connect from shortcuts import ( degree, degree_distribution, diameter, eccentricity, clustering, average_clustering, transitivity, degree_centrality, closeness_centrality, betweenness_centrality ) from calculator import calculate, calculate_concurrent try: connect() except: # dies silently pass
import re
import sys
import falcon
import json
import logging
from peewee import IntegrityError
from playhouse.shortcuts import model_to_dict
from wsgiref import simple_server
from models import Todo, SnoozeAll, TodoList
import models
DEFAULT_LIST = 'Reminders'
count = 0
models.connect()
def get_module_logger(mod_name):
"""
To use this, do logger = get_module_logger(__name__)
"""
logger = logging.getLogger(mod_name)
handler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s [%(name)-12s] %(levelname)-8s %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
return logger
rowDict[column.name] = str(getattr(row, column.name))
for key in realData:
if not isinstance(realData[key], list):
self.assertEqual(str(realData[key]), rowDict[key])
def test_series_3(self):
realData = series[2]
assert len(realData) == 16
series_table = get_series_table(meta, con)
select_clause = series_table.select(series_table.c.id == realData["id"])
rows = select_clause.execute()
row = rows.fetchone()
rowDict = {}
for column in series_table.columns:
rowDict[column.name] = str(getattr(row, column.name))
for key in realData:
if not isinstance(realData[key], list):
self.assertEqual(str(realData[key]), rowDict[key])
# ----
# main
# ----
if __name__ == '__main__':
con, meta = connect("charlesgong", "Charles")
main()
mail_content = unicode(quopri.decodestring(mail.headers + "\r\n" +
mail.body),
'utf-8',
errors='ignore')
return render_template('show_mail.html', **locals())
@app.route("/<user>@<domain>/<int:mail_id>/delete/")
@app.route("/<user>/<int:mail_id>/delete/")
def delete_mail(user, mail_id, domain=settings.MY_DOMAINS[0]):
try:
mail = list(
Mail.select(
AND(
Mail.q.user == User.select(
AND(User.q.name == user, Domain.q.name == domain))[0],
Mail.q.id == mail_id)))[0]
except IndexError:
abort(404)
#if divmod((datetime.datetime.now() - mail.ts).total_seconds(), 60)[0] > 10:
if (datetime.datetime.now() - mail.ts) > datetime.timedelta(seconds=600):
abort(403)
Mail.delete(mail_id)
return redirect(url_for('list_mail', user=user, domain=domain))
if __name__ == "__main__":
connect()
app.debug = settings.DEBUG
app.run()
def connect(db=DATABASE_URI):
global connected
if not connected:
models.connect(db)
connected = True
data = editor.get_data()
project = models.Project.create(data)
project.save()
self.projects.load_all()
self.projects.setCurrentIndex(self.projects.findText(project.name))
return True
else:
return False
def on_update_project(self):
self.projects.load_all()
def on_build_tree(self):
project = self.projects.current_obj()
project.build_tree()
def change_project(self):
project = self.projects.current_obj()
if project:
self.shot_manager.set_project(project)
if __name__ == "__main__":
models.connect()
app = QtGui.QApplication(sys.argv)
tvm_manager = TVManager()
tvm_manager.resize(1024, 800)
tvm_manager.show()
sys.exit(app.exec_())
def connectDB(dbs):
#connect to the database via models
print('setting up DB...')
models.connect(dbs)
return
"""
Saves categories scraped into db
"""
with open("./data/data.tsv", 'r') as category_reader:
category_reader = csv.reader(category_reader, delimiter='\t')
for line in category_reader:
line[1] = line[1].replace('[', "").replace(']',"")
organizations, authors, titles, start_date, duration = line
category = models.Category()
category.organization = organizations
category.author = authors
category.title = titles
category.start_date = start_date
category.duration = duration
try:
session.add(category)
session.commit()
except:
session.rollback()
raise
finally:
session.close()
#return category
def main(session):
process_item_to_db(session)
if __name__ == '__main__':
session = models.connect()
main(session)
import time
import itertools
import models
import os
from models import User
from models.user import UserPreferenceModel
from learning.algorithm import DummyAlgorithm, AlgorithmLibrary, KeywordAlgorithm
from learning.processing import ProducerThread, ConsumerThread, SingleProducerProcess
models.connect(os.environ.get('DATABASE_URI'))
class UserCoordinator(ProducerThread):
def work(self):
for user in User.select():
if self.produce(user.id):
self._logger.info('Producing user %s.' % user.id)
time.sleep(10)
class ScoringWorker(ConsumerThread):
def __init__(self, worker_id, task_queue, completed_queue):
ConsumerThread.__init__(self, worker_id, task_queue, completed_queue)
self._library = AlgorithmLibrary([DummyAlgorithm(), KeywordAlgorithm()])
def consume(self, user_id):
user = User.get(id=user_id)
self._logger.info('Consuming user %s.', user.id)
articles = list(user.all_articles())
from models import connect, load_schema, Person, Pet
connect(':memory:')
load_schema('ex45.sql')
def test_create():
p = Person('Emil', 'Raubach', 46)
p.create()
p.read()
