def c_show_feed_items(self):
feeditems = None
if len(self.value) == 3:
if self.value[0] == -1:
search_qry = self.value[2]
with session_scope() as session:
feeditems = md.search_items(session, search_qry)
else:
feed = self.value[1]
with session_scope() as session:
feeditems = md.get_items(session, feed['feed_id'])
self.wMain.values = [i for i in feeditems]
self.wMain.display()
def c_show_feed_items(self):
feeditems = None
if len(self.value) == 3:
if self.value[0] == -1:
search_qry = self.value[2]
with session_scope() as session:
feeditems = md.search_items(session, search_qry)
else:
feed = self.value[1]
with session_scope() as session:
feeditems = md.get_items(session, feed['feed_id'])
self.wMain.values = [i for i in feeditems]
self.wMain.display()
def get_data(self, date):
with db.session_scope() as session:
CheckCallBacks.check_double(date, session)
CheckCallBacks.check_status(date, session)
# TODO удалить это
CheckCallBacks.lead_log(date, session)
def add_domain(self, domain_name, domain_server):
with session_scope(self.session) as session:
domain = Domain(domain_name=domain_name,
domain_server=domain_server)
session.add(domain)
return domain
def get_admin_tasks():
with db.session_scope() as session:
try:
page = int(request.args.get('page', 1))
except ValueError:
page = 1
per_page = 10
task_count = session.query(db.Task)\
.filter(db.Task.finished_rating == None).filter(db.Task.garbage_flag != True).count()
tasks = session.query(db.Task)\
.filter(db.Task.finished_rating == None).filter(db.Task.garbage_flag != True)\
.order_by(db.Task.datetime, db.Task.id)\
.limit(per_page)\
.offset((page-1)*per_page).all()
for task in tasks:
task.keyword = session.query(db.Keyword).filter(db.Keyword.id == task.keyword_id).first().keyword
task.answered = session.query(db.Answer).filter(db.Answer.task_id == task.id).count()
pagination = Pagination(page=page,
total=task_count,
search=False,
per_page=per_page,
bs_version=3)
return render_template('admin.tasks.html',
tasks=tasks,
pagination=pagination)
def check(data):
if data.get('type') == 'playing' and data.get(
'PlaySessionStateNotification'):
sess = data.get('PlaySessionStateNotification')[0]
offset = 60000 # just check the first 60 sec
if offset > sess.get('viewOffset', 0):
ratingkey = sess.get('ratingKey')
sessionkey = sess.get('sessionKey')
with session_scope() as se:
try:
item = se.query(Preprocessed).filter_by(
ratingKey=ratingkey).one()
LOG.debug('Found %s in the db with offset %s' %
(item.prettyname, item.offset))
if item.offset:
POOL.apply_async(client_jump_to,
args=(item.offset, sessionkey))
return
except NoResultFound:
pass
if ratingkey not in IN_PROG:
IN_PROG.append(ratingkey)
POOL.apply_async(task, args=(ratingkey, sessionkey))
def saveitem(self, **kwargs):
try:
siteid = web.conv(int, kwargs.get('id'), '')
except:
return web.render(error=traceback(),
title='site #%s' % kwargs.get('id'))
if 'save' in kwargs:
with db.session_scope() as session:
try:
site = session.query(db.Site).get(int(siteid))
if not site:
site = db.Site(id=int(siteid))
session.add(site)
site.lon = web.conv(float, kwargs.get('lon'))
site.lat = web.conv(float, kwargs.get('lat'))
if None in (site.lon, site.lat):
raise ValueError('The site has no coordinates')
if site.lon > 180 or site.lat > 180:
site.lat, site.lon = proj.UTMtoLL(
23, site.lat, site.lon, '32N')
site.name = kwargs.get('name')
site.height = web.conv(float, kwargs.get('height'))
site.icon = kwargs.get('icon')
site.comment = kwargs.get('comment')
except:
return web.render('empty.html',
error=traceback(),
title='site #%s' % siteid).render(
'html', doctype='html')
raise web.HTTPRedirect('./%s' % siteid)
def get_index():
with db.session_scope() as session:
num_keywords = session.query(db.Keyword).count()
num_resolved_tasks = session.query(db.Task).filter(db.Task.finished_rating != None).count()
return render_template('index.html',
num_keywords=num_keywords,
num_resolved_tasks=num_resolved_tasks)
def c_delete_feed(self, *args, **keywords):
if npyscreen.notify_yes_no(
'Are you sure you want to remove this feed?',
title='Confirm Delete'):
with session_scope() as session:
md.delete_feed(session, self.parent.value[1]['feed_id'])
self.parent.parentApp.switchFormPrevious()
def host_signup(
email: str,
password: str,
name: str,
primary_affiliation: int,
reason: str = None
) -> Tuple[Optional['UserData'], Optional[str], bool]:
with session_scope() as session:
if PrimaryAffiliation.get_by_id(session,
primary_affiliation) is not None:
user = User.create(
session,
User(email=email,
password=password,
name=name,
primary_affiliation=primary_affiliation))
if user is not None:
code = None
threshold = int(get_property('user.threshold'))
if threshold > 0:
code = UserVerification.add(session, user.id).code
set_property('user.threshold', str(threshold - 1))
host_request = UserHostRequest(
user=user.id,
primary_affiliation=primary_affiliation,
reason=reason)
session.add(host_request)
return UserData(user), code, True
return None, None, True
return None, None, False
def from_id(cls, id: int):
with db.session_scope() as s:
u = s.query(db.User).get(id)
if u is None:
raise ValueError('User not found.')
return cls.from_db(u)
def get(id: int) -> Optional[Any]: # Optional[SkillTag]
with db.session_scope() as s:
t = s.query(db.SkillTag).get(id)
if t is None:
return None
return SkillTag.from_db(t)
def create(self) -> Optional[SkillTag]:
with db.session_scope() as s:
# check name
exists = s.query(db.SkillTag).filter(db.SkillTag.name == self.name)
if exists.count() > 0:
raise HTTPException(status_code=status.HTTP_409_CONFLICT)
parent = None
if self.parent_id is not None:
parent = s.query(db.SkillTag).get(self.parent_id)
if parent is None:
raise HTTPException(status.HTTP_404_NOT_FOUND,
'Parent id not found')
parent = parent.id
already_exists = s.query(
db.SkillTag).filter(db.SkillTag.name == self.name).count()
if already_exists > 0:
raise HTTPException(status.HTTP_429_TOO_MANY_REQUESTS,
'Tag already exists')
skilltag = db.SkillTag(
name=self.name,
parent_id=parent,
)
s.add(skilltag)
s.commit()
return SkillTag.from_db(skilltag)
def save(self, **kwargs):
name = kwargs.get('name')
person = kwargs.get('person')
comment = kwargs.get('comment')
if name is None or person is None or name is '':
raise web.HTTPRedirect(
'/project/add?error=Not all form fields were set')
with db.session_scope() as session:
person = db.Person.get(session, person)
if person is None:
raise RuntimeError(
'Server Error. Please contact the Administrator')
new_project = db.Project(
name=name, person_responsible=person, comment=comment)
session.add(new_project)
session.flush()
# For the user interface
persons = session.query(db.Person)
persons = persons.filter(db.Person.access_level > 3)
error = ''
res = web.render('project_from_id.html', project=new_project,
persons=persons, error=error).render('html', doctype='html')
return res
def default(self, project_id=None, error=None):
with db.session_scope() as session:
if project_id is not None and str(project_id).isdigit():
project_from_id = session.query(db.Project).get(project_id)
if project_from_id is None:
error = 'Warning: There was an error with the id \'%s\'. ' \
'Please choose a project out of the ' \
'list!' % project_id
res = self.render_projects(session, error)
else:
persons = session.query(db.Person)
persons = persons.filter(db.Person.access_level > 3)
error = ''
res = web.render('project_from_id.html',
project=project_from_id,
persons=persons, error=error) \
.render('html', doctype='html')
elif project_id is None:
res = self.render_projects(session, error)
else:
res = self.render_projects(session)
return res
def get_all_domains(self):
with session_scope(self.session) as session:
results = []
for d in session.query(Domain.domain_name).all():
results.append(d.domain_name)
return results
def create_password_reset_token(self,
owner: int,
expires: datetime = None):
assert owner, 'Owner required'
assert expires is None or expires >= datetime.utcnow(
), 'Expiration must be in the future'
issued = datetime.utcnow()
expires = expires or datetime.utcnow() + timedelta(hours=24)
with session_scope() as session:
user = User.get_by_id(session, owner)
roles = [role.name for role in user.roles]
key = user.password
token = jwt.encode(payload={
'own': owner,
'roles': ','.join(roles),
'iss': self.issuer,
'iat': issued,
'exp': expires,
},
key=key,
algorithm=self.alg,
headers={'tok': 'pas'})
return token
def get_possible_affiliations():
with session_scope() as session:
return [
PrimaryAffiliationData(aff)
for aff in PrimaryAffiliation.get_all(session)
]
return None
def post_task_answer(task_id):
#http://main-tuaic13.rhcloud.com/api/tasks/157/answers
with db.session_scope() as session:
task = session.query(db.Task).filter(db.Task.id == task_id).first()
if not task:
return jsonify(error='Task not found'), 404
raw_answer = utils.get_raw_answer(request)
if not raw_answer:
return jsonify(error='Error parsing json'), 400
worker_id = raw_answer['user']
worker = session.query(db.Worker).filter(db.Worker.id == worker_id).first()
if not worker:
worker = db.Worker(worker_id, 0, 0)
session.add(worker)
session.commit()
if worker.blocked == 1:
return jsonify(error='Unfortunately, your account has been blocked'), 401
answer = db.Answer(task, worker, raw_answer['answer'])
session.add(answer)
session.commit()
if len(task.answers) == task.answers_requested:
task.calculate_rating()
session.add(task)
session.commit()
task.rate_workers()
session.commit()
return jsonify(answer.as_dict()), 200
def accept_user_referral(user_email: str, reference_email: str) -> bool:
with session_scope() as session:
requester = User.get_by_email(session, user_email)
reference = User.get_by_email(session, reference_email)
if requester is None or reference is None:
return False
UserReferral()
def test_query_data_package_get_datasets(self):
models = [CanCM4TestDataset,MaurerTas,MaurerTasmax]
with db.session_scope() as session:
for m in models: m().insert(session)
dataset = session.query(db.Dataset).filter_by(name='Maurer 2010').one()
category = session.query(db.DatasetCategory).filter_by(name='Observational').one()
fields = [c.field[0] for c in dataset.container]
dp = db.DataPackage(field=fields,name='Test Package',description='For testing! Duh...',dataset_category=category)
session.add(dp)
dataset = session.query(db.Dataset).filter_by(name='Maurer 2010').one()
category = session.query(db.DatasetCategory).filter_by(name='GCMs').one()
fields = [c.field[0] for c in dataset.container]
dp = db.DataPackage(field=fields,name='Test Package GCMs',description='For testing! Duh...',dataset_category=category)
session.add(dp)
session.commit()
dq = DataQuery()
ret = dq.get_package_datasets(package_name='Test Package')
rds = [ocgis.RequestDataset(**k) for k in ret['dataset']]
for rd in rds: rd.inspect_as_dct()
with self.assertRaises(MultipleResultsFound):
dq.get_package_datasets()
def get_admin_keywords():
with db.session_scope() as session:
keywords = session.query(db.Keyword).all()
ratings = {}
ranks = {}
rank = 1
for kw_obj in keywords:
keyword = kw_obj.keyword
rating = calc_avg_sentiment(session, keyword, 20)
if rating is not None:
ratings[keyword] = "{0:.2f}".format(rating)
else:
ratings[keyword] = "None"
sorted_ratings = sorted(ratings.iteritems(), key=operator.itemgetter(1))
rank = 1
for keyword, _ in sorted_ratings:
ranks[keyword] = rank
rank += 1
return render_template('admin.keywords.html',
keywords=keywords,
ratings=ratings,
ranks=ranks)
def c_update_all(self, *args, **keywords):
npyscreen.notify("Updating all feeds...", title='Status')
with session_scope() as session:
updates = md.update_all_feeds(session)
npyscreen.notify("{} updates applied.".format(updates), title='Status')
time.sleep(0.75)
self.c_show_feeds()
def query(company, days):
with db.session_scope() as session:
took_me_ms = int(round(time.time() * 1000))
result = calc_avg_sentiment(session, company, days)
took_me_ms = int(round(time.time() * 1000)) - took_me_ms
if result is not None:
rating = result
if rating == None:
return jsonify(message=\
"""Sorry. No sentiment information is stored \
for %s. Either you mistyped the company or yahoo finance does not \
contain articles about the compnay/product!""" % company)
rating = format(rating, '.2f')
details = {
"message": "The average sentiment of {0} is '{1}'.".format(company, rating),
"rating":rating,
"keyword":company,
"interval":"[0..10]. towards 0 corresponds to negative, whereas 10 is positive",
"timespan":"the last %d day(s)" % days
}
if request.args.get('d') is not None:
details['ms'] = took_me_ms
return jsonify(**details)
else:
return jsonify(message=\
"""Sorry. No sentiment information is stored \
for %s. Either you mistyped the company or yahoo finance does not \
contain articles about the compnay/product!""" % company)
async def get_message(id: int):
with db.session_scope() as s:
msg: Optional[db.Message] = s.query(db.Message).get(id)
if msg is None:
raise HTTPException(status.HTTP_404_NOT_FOUND)
return schema.Message.from_db(msg)
async def get_messages_length(thread_id: int):
with db.session_scope() as s:
t = s.query(db.Thread).get(thread_id)
if t is None:
raise HTTPException(status.HTTP_404_NOT_FOUND, 'Thread not found')
return len(t.messages)
def engine():
engine = local_engine()
engine.execute("DROP TABLE IF EXISTS transactions;")
engine.execute("DROP TABLE IF EXISTS categories;")
engine.execute("DROP TABLE IF EXISTS transaction_types;")
engine.execute("DROP TABLE IF EXISTS accounts;")
Base.metadata.create_all(engine)
with session_scope(engine) as session:
# See Transaction Types
session.add_all(
[TransactionType(name="Debit"),
TransactionType(name="Credit")])
# Seed Categories
session.add_all([
Category(name="Uncategorized"),
Category(name="Travel"),
Category(name="Going Out"),
Category(name="Utilities"),
Category(name="Rent"),
Category(name="Paycheck"),
])
# Seed Account
session.add(Account(name="Chase Checking 7526"))
yield engine
def process_to_db(media, theme=None, vid=None, offset=None):
"""Process a plex media item to the db
Args:
media (Episode obj):
theme: path to the theme.
vid: path to the stripped wav of the media item.
offset: where in the video file did the theme end.
"""
LOG.debug('Started to process %s', media._prettyfilename())
if theme is None:
theme = download_theme(media)
if vid is None:
vid = convert_and_trim(check_file_access(media), fs=11025, trim=600)
if offset is None:
global HT
start, end = get_offset_end(vid, HT)
else:
end = offset
if end is not None:
with session_scope() as se:
p = Preprocessed(show_name=media.grandparentTitle,
ep_title=media.title,
offset=end,
duration=media.duration,
ratingKey=media.ratingKey,
grandparentRatingKey=media.grandparentRatingKey,
prettyname=media._prettyfilename(),
updatedAt=media.updatedAt)
se.add(p)
LOG.debug('Added %s to db', media._prettyfilename())
def actors_list():
with session_scope() as session:
if request.method == 'GET':
actors = session.query(tables.Actor).all()
result = {
'actors': [actor.to_dict() for actor in actors]
}
return result
else:
request_data = request.get_json(force=True)
birthday = datetime.strptime(
request_data['birthday'], '%Y-%m-%d'
) if request_data.get('birthday') else None
new_actor = tables.Actor(
surname=request_data['surname'],
name=request_data['name'],
lastname=request_data.get('lastname'),
birthdate=birthday
)
session.add(new_actor)
session.commit()
response = make_response({'message': 'actor created'}, 201)
response.headers['Location'] = f"/actors/{new_actor.actor_id}"
return response
def get_variable_or_index_dataset(self,*args,**kwds):
'''
Same parameters as `get_variable_or_index`. This method must return a
single row.
:raises: NoResultFound, MultipleResultsFound
:rtype: list containing a single dictionary
:returns: A dictionary with two keys: 'dataset' and 'metadata'. The 'dataset'
key contains a list of dictionaries suitable to pass as a single argument
to `ocgis.RequestDatasetCollection`. The 'metadata' key contains description
and other fields such as 'time_range'.
'''
with db.session_scope() as session:
kwds['session'] = session
query = self._get_variable_or_index_query_(*args,**kwds)
field = session.query(db.Field).filter(db.Field.fid == query.one().fid).one()
dataset = field.get_request_dataset_kwargs()
ret = {'dataset':[dataset],
'metadata':{'description':{'long_name':field.clean_variable.description,
'dataset':field.container.dataset.description,
'dataset_category':field.container.dataset.dataset_category.description},
'time_range':[field.container.time_start,field.container.time_stop]}}
return(ret)
def send_previous_day_leaders(channel):
now = datetime.datetime.now()
if "BLACKOUT_DATES" in config:
blackout_dates = config.BLACKOUT_DATES
else:
blackout_dates = []
if now.isoweekday() in (6, 7) or now.date() in blackout_dates:
return
if now.isoweekday() == 1:
previous_day = now - datetime.timedelta(days=3)
else:
previous_day = now - datetime.timedelta(days=1)
with session_scope() as session:
table = value_bot.get_leaders_table(session, "all", previous_day.day, previous_day.month, previous_day.year)
if table:
content = table.get_string()
else:
content = "No leaders found"
channel_id = slack.get_channel_id(channel)
if channel_id:
message = SlackPreformattedMessage(channel_id, content, "Yesterday's Leaders")
message.send(slack)
def test_query_data_package(self):
models = [CanCM4TestDataset,MaurerTas,MaurerTasmax]
with db.session_scope() as session:
for m in models: m().insert(session)
dataset = session.query(db.Dataset).filter_by(name='Maurer 2010').one()
category = session.query(db.DatasetCategory).filter_by(name='Observational').one()
fields = [c.field[0] for c in dataset.container]
dp = db.DataPackage(field=fields,name='Test Package',description='For testing! Duh...',dataset_category=category)
session.add(dp)
dataset = session.query(db.Dataset).filter_by(name='Maurer 2010').one()
category = session.query(db.DatasetCategory).filter_by(name='GCMs').one()
fields = [c.field[0] for c in dataset.container]
dp = db.DataPackage(field=fields,name='Test Package GCMs',description='For testing! Duh...',dataset_category=category)
session.add(dp)
session.commit()
dq = query.DataQuery()
ret = dq.get_package()
self.assertEqual(ret,{'dataset_category': [u'GCMs', u'Observational'], 'package_name': [u'Test Package', u'Test Package GCMs']})
with self.assertRaises(NoResultFound):
dq.get_package(package_name='foo')
ret = dq.get_package(package_name='Test Package GCMs')
rds = [ocgis.RequestDataset(**k) for k in ret]
for rd in rds: rd.inspect_as_dct()
ret = dq.get_package(time_range=[datetime.datetime(1980,2,1),datetime.datetime(1985,3,4)])
self.assertEqual(ret,{'dataset_category': [u'GCMs', u'Observational'], 'package_name': [u'Test Package', u'Test Package GCMs']})
with self.assertRaises(NoResultFound):
dq.get_package(time_range=[datetime.datetime(1900,2,1),datetime.datetime(1901,3,4)])
def retrieve():
instances = []
with session_scope() as session:
for instance in session.query(Entry).order_by(Entry.id):
print instance
instances.append(str(instance))
return instances
def add_location(id: int,
latitude: float,
longitude: float,
time: 'datetime' = None):
with session_scope() as session:
session.add(
UserLocation(user=id, lat=latitude, long=longitude, time=time))
def init_cache():
with session_scope() as session:
properties = Property.get_cacheable(session)
for prop in properties:
logging.debug(f'property: {prop.name}')
__property_cache[prop.name] = prop.value
logging.debug(f'initialized: {__property_cache}')
def set_sprinkler_on_duration(sprinkler_id, seconds):
with db.session_scope() as session:
sprinkler = db.get_sprinkler(session, sprinkler_id)
_set_sprinkler_state(session, sprinkler, True)
LOGGER.info("%s will go off in %d seconds", sprinkler, seconds)
callback = functools.partial(_go_off, sprinkler.id)
_call_later(callback, sprinkler.id, seconds)
def get_package(self,*args,**kwds):
'''
:param dataset_category: The name of the dataset category.
:type dataset_category: str
:param package_name: The name of the package.
:type dataset_category: str
:raises: NoResultFound
:returns: A dictionary with keys corresponding to options. The key values are lists of options.
:rtype: dict
'''
with db.session_scope() as session:
kwds['session'] = session
query = self._get_package_query_(*args,**kwds)
if query.count() >= 1:
dataset_category = list(set([obj.dataset_category.name for obj in query]))
dataset_category.sort()
package_name = [obj.name for obj in query]
package_name.sort()
ret = {'dataset_category':dataset_category,
'package_name':package_name}
for v in ret.itervalues(): v.sort()
else:
raise(NoResultFound)
return(ret)
def sync_engagement(fb_client, last_id, max_count):
with session_scope() as session:
for i in range(0, max_count, 50):
urls = _get_urls(session, last_id, 50)
if len(urls) == 0:
return
engagements, next_req = fb_client.get_objects(
urls=[u[1] for u in urls], fields='engagement')
for e in engagements:
session.add(map_engagement(e))
if len(urls) < 50:
return
if i % 1000 == 0:
session.flush()
last_id = urls[-1][0]
if next_req == False:
print('[fb] interrupting next request due to API rate limits!')
return
def update_user_password(id: int, password: str) -> bool:
with session_scope() as session:
user = User.get_by_id(session, id)
if user is None:
raise MissingUserError(f"User not found with id: {id}")
user.password = password
return True
async def fetch_users_list():
with session_scope() as s:
users = s.query(models.User).all() # type: models.User
user_list = []
for user in users:
user_list.append(map_model_to_user(user))
return user_list
def add_to_email_list(email: str) -> bool:
assert email is not None
with session_scope() as session:
if not EmailList.find_by_email(session, email):
session.add(EmailList(email=email))
return True
return False
def remove_from_email_list(email: str) -> bool:
assert email is not None
with session_scope() as session:
if EmailList.find_by_email(session, email):
EmailList.remove(session, email)
return True
return False
def c_update_all(self, *args, **keywords):
npyscreen.notify("Updating all feeds...", title = 'Status')
with session_scope() as session:
updates = md.update_all_feeds(session)
npyscreen.notify("{} updates applied.".format(updates), title = 'Status')
time.sleep(0.75)
self.c_show_feeds()
def server_search(to_visit_sites, start_point):
with session_scope() as session:
while len(to_visit_sites):
helper = to_visit_sites.pop(0)
response = requests.get(helper)
soup = BeautifulSoup(response.content, 'html.parser')
r = requests.head(helper)
server_info = r.headers.get("server")
if server_info is None:
server_info = "NO SERVER FOUND"
info = session.query(Server).filter(Server.name == helper).one_or_none()
if info is None:
ser = Server(name=helper, server=server_info)
session.add(ser)
session.commit()
for link in soup.find_all('a'):
to_be_added = link.get('href')
if to_be_added is not None and to_be_added not in to_visit_sites:
if to_be_added.startswith('http') and ".bg" in to_be_added:
to_visit_sites.append(to_be_added)
print(to_be_added)
elif to_be_added.startswith("link"):
to_be_added = start_point + to_be_added
to_visit_sites.append(to_be_added)
print(to_be_added)
def on_ok(self, * args, **keywords):
global sec_per_word
time_to_read = (datetime.datetime.utcnow() - self.start_read).total_seconds()
with session_scope() as session:
md.mark_as_read(session, dict(self.value)['feeditem_id'], self.word_count, time_to_read)
sec_per_word = md.update_read_speed(session)
self.parentApp.switchFormPrevious()
def get_open_tasks():
try:
page = int(request.args.get("page",1))
except ValueError:
page = 1
with db.session_scope() as sess:
per_page = 10
task_count = sess.query(db.OpenTask)\
.filter(db.OpenTask.solved == False).count()
open_tasks = sess.query(db.OpenTask)\
.order_by(db.OpenTask.datetime.asc(), func.substr(db.OpenTask.id, 0, func.length(db.OpenTask.id) - 2))\
.filter(db.OpenTask.solved == False)\
.offset((page-1) * per_page).limit(per_page)\
.all()
pagination = Pagination(page=page,
total=task_count,
search=False,
per_page=per_page,
bs_version=3)
return render_template("task_list.html",
tasks = open_tasks,
pagination = pagination)
def task():
j = sanitize_post_task(request.get_json(force=True,silent=True))
if not j:
example = { "id":"123",
"task_description":"Is company mentioned positive/neutral/negative in the following paragraph?",
"task_text":"lorem ipsum ...",
"answer_possibilities":["yes","no","neutral"],
"callback_link":"http://localhost:5000/webook",
"price":12.34 }
return json.dumps({ 'error': 'provide a valid json body!', 'example': example }), 400
with db.session_scope() as session:
tid = j['id']
if session.query(db.OpenTask).filter(db.OpenTask.id == tid).count() != 0:
return json.dumps({ 'error': 'id already exists' }), 400
answers = j['answer_possibilities']
answer = None
if type(answers) is type([]):
answer = "|".join(answers)
elif answers == 'text':
answer = "text"
else:
return json.dumps({ 'error': 'answer_possibilities must either be of type list ["yes","no",...] or "text"' }), 400
open_task = db.OpenTask(j['id'], j['task_description'], j['task_text'], answer, j['callback_link'], j['price'])
session.add(open_task)
session.commit()
result = { 'error': None, 'success': True }
return json.dumps(result)
def set_garbage():
j = sanitize_set_garbage(request.get_json(force=True,silent=True))
if not j:
example = json.dumps({ "id":"123",
"price_bonus":12.34 })
return json.dumps({ 'error': ('provide a valid json body! example: %s' % (example,)) }), 400
with db.session_scope() as session:
tid = j['id']
try:
task = session.query(db.OpenTask).filter(db.OpenTask.id == tid).one()
except NoResultFound:
return json.dumps({ 'error': 'id does not exists' }), 400
except MultipleResultsFound:
return json.dumps({ 'error': 'more than one result found' }), 400
logger.info("set garbage called with task id %d", task.id)
session.delete(task)
session.commit()
result = { 'error': None, 'success': True }, 200
return json.dumps(result)
def post_solve_task():
with db.session_scope() as sess:
if "answer" not in request.form:
logger.error("solving task %s. failed no answer", str(task_id))
flash("Task was not rated. No answer provided. Here is a new task!", "danger")
return redirect(url_for("get_solve_task",r="t"))
if "user_id" not in request.form:
logger.error("solving task %s. failed no userid", str(task_id))
flash("You did not provide your user_id. Here is a new task! Try again.", "danger")
return redirect(url_for("get_solve_task",r="t"))
if "task_id" not in request.form:
logger.error("solving task %s. failed no taskid", str(task_id))
flash("Internal failure. Here is a new task!", "danger")
return redirect(url_for("get_solve_task",r="t"))
answer = request.form["answer"]
task_id = request.form["task_id"]
user_id = request.form["user_id"]
if user_id is None or user_id.strip() == "":
logger.error("solving task %s. failed no username", str(task_id))
flash("You did not provide your user_id. Here is a new task! Try again.", "danger")
return redirect(url_for("get_solve_task",r="t"))
session['user_id'] = user_id
try:
task = sess.query(db.OpenTask).filter(db.OpenTask.id == task_id).one()
except NoResultFound:
logger.error("solving task %s. failed 3", str(task_id))
flash("Internal failure. Here is a new task!", "danger")
return redirect(url_for("get_solve_task",r="t"))
post_body = { "id": task_id, "answer": answer, "user": user_id }
headers = {'content-type':'application/json'}
try:
result = requests.post(task.callback_link, data=json.dumps(post_body), headers=headers, timeout=10)
if result.status_code != requests.codes.ok:
if result.status_code == 401:
logger.error("solving task %s. failed worker blocked", str(task_id))
flash("Check your account status! You are not authorised to solve this task", "warning")
return redirect(url_for("index"))
else:
logger.error("solving task %s. failed 4", str(task_id))
flash("Internal error 4! Could not finish task. Here is a new one!","danger")
except Exception:
logger.error("solving task %s. failed 5", str(task_id))
flash("Internal error 5! Could not finish task. Here is a new one!","danger")
return redirect(url_for("get_solve_task",r="t"))
logger.info("solved task %s correctly", str(task_id))
task.solved = True
sess.commit()
flash("Solved task. Here is a new one!", "success")
return redirect(url_for("get_solve_task",r="t"))
def get_history(sprinkler_id):
with db.session_scope() as session:
sprinkler = db.get_sprinkler(session, sprinkler_id)
runs = db.get_runs(session, sprinkler.id)
return [{
'at' : run.at.strftime(DATETIME_PATTERN),
'duration' : "{0} minutes".format(run.duration // 60),
} for run in runs]
def report_data(self, date_start, date_end):
cb = CheckCallBacks()
with db.session_scope() as session:
not_called_count_list = [cb.not_called_count(date_start, date_end, dept_num, session) for dept_num in
range(len(config.DEPARTMENTS))]
not_called_list = cb.not_called(date_start, date_end, session)
late_called_list = cb.late_called(date_start, date_end, session)
return {'num_leads': not_called_count_list, 'lost_leads': not_called_list, 'late_leads': late_called_list}
def test_query_limiting(self):
models = [CanCM4TestDataset,MaurerTas,MaurerTasmax]
with db.session_scope() as session:
for m in models: m().insert(session)
dq = query.DataQuery()
ret = dq.get_variable_or_index('variable',
long_name='Near-Surface Air Temperature')
self.assertDictEqual(ret,{'long_name': [u'Near-Surface Air Temperature'], 'time_frequency': [u'day'], 'dataset_category': [u'GCMs', u'Observational'], 'dataset': [u'CanCM4', u'Maurer 2010']})
def log(name=None):
if request.method == 'GET':
return render_template('log.html')
with db.session_scope() as session:
session.add(LogEntry(level=request.form['level'],
created=dt.now(),
message=request.form['message']))
session.commit()
return redirect(url_for('logs'))
def get_solve_task():
with db.session_scope() as sess:
task_id = request.args.get('task')
if task_id:
task = sess.query(db.OpenTask).filter(db.OpenTask.id == task_id).first()
else:
task = sess.query(db.OpenTask).filter(db.OpenTask.solved == False).order_by(func.random()).limit(1).first()
user_id = session.get("user_id") or ""
return render_template("solve_task.html", task=task, user_id=user_id)
def get_search():
with db.session_scope() as session:
q = request.args.get('q', '')
keyword = session.query(db.Keyword).filter(func.lower(db.Keyword.keyword) == func.lower(q)).first()
if not keyword:
return render_template('search.html', q=q)
if keyword.num_mentions(session) == 0:
return render_template('search.html', q=q)
return redirect(url_for('get_keyword', k=keyword.keyword))
def test_query_empty(self):
models = [CanCM4TestDataset,MaurerTas,MaurerTasmax]
with db.session_scope() as session:
for m in models: m().insert(session)
dq = query.DataQuery()
with self.assertRaises(NoResultFound):
ret = dq.get_variable_or_index('variable',
time_range=[datetime.datetime(1900,2,3),
datetime.datetime(1901,3,4)])
def test_query_time_range(self):
models = [CanCM4TestDataset,MaurerTas,MaurerTasmax]
with db.session_scope() as session:
for m in models: m().insert(session)
dq = query.DataQuery()
ret = dq.get_variable_or_index('variable',
time_range=[datetime.datetime(1980,2,3),
datetime.datetime(1990,3,4)])
target = {'long_name': [u'Near-Surface Air Temperature', u'Near-Surface Maximum Air Temperature'], 'time_frequency': [u'day'], 'dataset_category': [u'Observational'], 'dataset': [u'Maurer 2010']}
self.assertDictEqual(ret,target)
def get_data(self, date):
"""
This method gets all data from ads and adds it to DB
"""
with db.session_scope() as session:
adwords = {'adw': [self.sc.request_adwords(date, dept) for dept in range(len(config.DEPARTMENTS))]}
direct = {'drt': [self.sc.request_direct(date, dept) for dept in range(len(config.DEPARTMENTS))]}
self.sc.parse(adwords, date, session)
self.sc.parse(direct, date, session)
def report_data(self, date_start, date_end):
"""
This method returns a list of data by departments
"""
with db.session_scope() as session:
ctr = [self.sc.report_ctr(date_start, date_end, dept, session) for dept in range(len(config.DEPARTMENTS))]
cpc = [self.sc.report_cpc(date_start, date_end, dept, session) for dept in range(len(config.DEPARTMENTS))]
return {'ctr': ctr, 'cpc': cpc}
def get_sprinklers():
with db.session_scope() as session:
sprinklers = db.get_sprinklers(session)
data = [{
'id' : sprinkler.id,
'name' : sprinkler.name,
'port' : sprinkler.port,
'pin' : sprinkler.pin,
'description' : sprinkler.description
} for sprinkler in sprinklers]
return data
