def test_view_widgets(self):
# this test 3 valued widgets where valid values are 'yes', 'no' or '-'
# '-' is shown when no value given
client = self.app.test_client()
with self.app.test_request_context():
session = database.get_session()
row = database.ReportRow()
row.update(self.report_data)
session.save(row)
session.commit()
view_response = client.get('/reports/%s/' % row.id)
# clone self.report_data dict
data = dict(self.report_data)
del data[u'details_publisher']
with self.app.test_request_context():
session = database.get_session()
row.update(data)
session.save(row)
session.commit()
# no value given, look for '-'
label = 'Published by'
value = '-'
self.assertTrue(
common.search_label_value(label, value, view_response.data))
def restaurant_add_update_category():
user = get_user()
if (user):
restaurant = Restaurant.get_from_id(user.restaurant_id)
if (restaurant):
name = get_header("name")
id = get_header_int("id")
if (name and len(name) <= 50):
if (is_int(id)):
category = Category.get_from_id(restaurant, id)
if (category):
if (get_header("remove")):
category.remove()
else:
category.name = name
get_session().commit()
return "true"
else:
abort(404)
else:
Category.add(name, restaurant)
return "true"
else:
abort(400)
else:
abort(404)
else:
abort(404)
def test_view_widgets(self):
# this test 3 valued widgets where valid values are 'yes', 'no' or '-'
# '-' is shown when no value given
client = self.app.test_client()
with self.app.test_request_context():
session = database.get_session()
row = database.ReportRow()
row.update(self.report_data)
session.save(row)
session.commit()
view_response = client.get('/reports/%s/' %row.id)
# clone self.report_data dict
data = dict(self.report_data)
del data[u'details_publisher']
with self.app.test_request_context():
session = database.get_session()
row.update(data)
session.save(row)
session.commit()
# no value given, look for '-'
label = 'Published by'
value = '-'
self.assertTrue(common.search_label_value(label, value, view_response.data))
def cancel_order():
client = get_client()
if (client):
orderId = get_header_int("orderId")
if (orderId):
order = Order.get_from_id(orderId)
if (order):
if (order.status != 2 and order.status != -1):
if (order.client_id == client.id):
order.status = -1
get_session().commit()
return "true"
else:
abort(401)
else:
abort(401)
else:
abort(404)
else:
abort(400)
else:
abort(401)
def restaurant_add_update_product():
user = get_user()
if (user):
restaurant = Restaurant.get_from_id(user.restaurant_id)
if (restaurant):
name = get_header("name")
description = get_header("description")
price = get_header_float("price")
id = get_header_int("id")
if (is_int(id)):
product = Product.get_from_id(id)
if (product):
if (get_header("remove")):
product.remove()
else:
if (name and description and is_float(price)
and len(name) <= 50
and len(description) <= 100):
product.name = name
product.description = description
product.price = price
get_session().commit()
else:
abort(400)
return "true"
else:
abort(404)
else:
categoryId = get_header_int("category")
if (is_int(categoryId) and len(name) <= 50
and len(description) <= 100):
category = Category.get_from_id(restaurant, categoryId)
if (category):
Product.add(name, description, price, restaurant,
category)
return "true"
else:
abort(404)
else:
abort(400)
else:
abort(404)
else:
abort(404)
def name_new_event():
schema = [
'event_name',
'email',
'event_target',
'event_type',
'handle',
'path',
'platform',
'referrer',
'user_id',
]
event_json = request.get_json() or {}
logging.warn(event_json)
if 'event_name' not in event_json:
return 'Missing event_name in json', 400
session = database.get_session()
name = event_json['event_name']
existing = session.query(models.EventName)
existing = existing.filter_by(event_name=name).first()
if existing:
session.delete(existing)
session.commit()
text_query = 'SELECT upsert_event_name({});'.format(', '.join(
'f_{col} := :{col}'.format(col=col) for col in schema))
session.execute(text_query, {col: event_json.get(col) for col in schema})
session.commit()
session.close()
return jsonify({'ok': True}), 200
def get_popular_events():
session = database.get_session()
query = session.query(
func.count(models.Event.id),
models.Event.event_type,
models.Event.event_target,
).group_by(
models.Event.event_type,
models.Event.event_target,
).order_by(func.count(models.Event.id).desc()).limit(100)
events = query.all()
event_names = session.query(models.EventName).limit(1000).all()
events_dict = models.values_to_dicts(events,
column_names=('count', 'event_type',
'event_target'))
# TODO: This quadratic thing is baaad
for event in events_dict:
for name_row in event_names:
if name_row.event_type not in ('xNULL', event['event_type']):
continue
if name_row.event_target not in ('xNULL', event['event_target']):
continue
event['event_name'] = name_row.event_name
break
session.close()
return jsonify(events_dict)
def report_delete(report_id):
if flask.request.method == 'POST':
session = database.get_session()
reviews_list = database.get_seris_reviews_list(report_id)
if reviews_list:
# TODO change when multiple reviews will be implemented
session.table(database.SerisReviewRow) \
.delete(reviews_list[0].id)
report_row = database.get_report_or_404(report_id)
title = report_row['details_original_name']
session.table(database.ReportRow).delete(report_id)
session.commit()
action = 'deleted'
contributor_id = getattr(flask.g, 'user_id')
contributor_name = '%s %s' % (getattr(
flask.g, 'user_first_name'), getattr(flask.g, 'user_last_name'))
contributor_profile = (
'http://www.eionet.europa.eu/directory/user?uid=%s' %
contributor_id)
send_notification_mail(None, title, action, contributor_profile,
contributor_name, contributor_id)
flask.flash("Report deleted.", "success")
url = flask.url_for('views.report_list')
country = flask.request.args.get('country')
if country:
url = url + '?country=' + country
region = flask.request.args.get('region')
if region:
url = url + '?region=' + region
return flask.redirect(url)
def create_rack(owner, volume):
"""
Создание пустой серверной стойки
:param owner: Владелец (selectel | иной собственник)
:param volume: Тип стойки (10 | 20)
:return: id новой стойки
"""
tmp_session = get_session()
try:
owner = MAIN_OWNER if owner.lower() == MAIN_OWNER else 'other owner'
if tmp_session is None:
raise OSError
new_rack = Rack(date_creation=datetime.now(),
date_last_changes=datetime.now(),
owner=owner,
address=SELECTEL_ADDR,
volume=ENABLED_VOLUME.get(volume, 10))
tmp_session.add(new_rack)
tmp_session.commit()
module_logger.info('Новая серверная стойка успешно создана.')
return new_rack.id
except OSError:
module_logger.error(
'Ошибка в назначении прав доступа к файловой директории.')
except Exception as err:
module_logger.error(
"Ошибка операции создания новой серверной стойки. %s" % str(err))
finally:
tmp_session.close()
def add_server_to_rack(server_id, rack_id, new=False):
"""
Добавление сервера в стойку
:param server_id: сервер
:param rack_id: id стойки куда перемещаем сервер
:return: id
"""
tmp_session = get_session()
try:
rack = tmp_session.query(Rack).get(int(rack_id))
server = tmp_session.query(Server).get(int(server_id))
# если перемещаем ранее созданный сервер
if not new:
check_free_slots(rack)
server.rack_id = None
tmp_session.commit()
rack.servers.append(server)
tmp_session.commit()
module_logger.info(
'В серверную стойку с id={0} добавлен сервер с id={1}'.format(
str(rack_id), str(server_id)))
return server.id
except Exception as err:
module_logger.error(err)
finally:
tmp_session.close()
def create_and_add_server(rack_id, server_ip, ram):
"""
Создание нового сервера и добавление его в серверную стойку.
:param rack_id: id стойки
:param server_ip: назначенный ip
:param ram: объем оперативной памяти
:return: id созданного сервера
"""
tmp_session = get_session()
try:
rack = tmp_session.query(Rack).get(int(rack_id))
check_free_slots(rack)
new_server = Server(date_creation=datetime.now(),
date_last_changes=datetime.now(),
server_ip=check_ip(server_ip),
server_ram=ram,
server_core=SEVER_STANDART_CORE,
optical_port=False,
status=SEVER_STATUS_LIST[START_SERVER_STATUS])
tmp_session.add(new_server)
tmp_session.commit()
module_logger.info('Создан новый сервер с id=%s' % str(new_server.id))
add_server_to_rack(new_server.id, rack.id, new=True)
return new_server.id
except AttributeError:
module_logger.error('Ошибка указания ip создаваемого сервера.')
return False
except Exception as err:
module_logger.error(err)
return False
finally:
tmp_session.close()
def remove(self):
for product in Product.get_from_category(self):
product.remove()
session = get_session()
session.delete(self)
session.commit()
def get_items(level_id):
session = get_session()
items = session.query(ItemsTable).filter_by(level_id=level_id).all()
players_items = session.query(PlayersItemsTable).filter_by(
level_id=level_id)
data = {'open': [], 'complete': []}
for item in items:
if item.id in [x.item_id for x in players_items]:
continue
answer = json.loads(item.answer)
data['open'].append({
"id": item.id,
"item_type": item.item_type,
"question": item.question,
"bonus": True if answer['bonus'] else False
})
for item in players_items:
data['complete'].append({
"id": item.item_id,
"item_type": item.item.item_type,
"question": item.item.question,
"solved": item.player.name
})
return data
def process_response(**kwargs):
print json.dumps(kwargs)
# save response
session = db.get_session(kwargs["session_id"])
question = db.get_question(session["survey_id"],
session["question_ordernumber"])
question_id = question["id"]
response = ""
if str(question_id) in kwargs:
response = kwargs[str(question_id)]
if question["type"] in {"1", "M", "O", "JN"}:
if question["type"] == "M":
response = ",".join(response)
db.save_response(session["id"], question_id, response)
if "next" in kwargs:
c = db.next_question(kwargs["session_id"])
print "wat is c?", c
while c and not check_condition(session["id"]):
c = db.next_question(kwargs["session_id"])
if "back" in kwargs:
c = db.prev_question(kwargs["session_id"])
while c and not check_condition(session["id"]):
c = db.prev_question(kwargs["session_id"])
return render_survey(kwargs["session_id"])
def data_import(file):
logging.basicConfig()
with open(file, "r") as f:
data = json.loads(f.read())
session = database.get_session()
for item in data:
# NULL objects for country => ""
if item["personal_country"].strip() == "NULL":
item["personal_country"] = ""
if item["representing_country"].strip() == "NULL":
item["representing_country"] = ""
person = schema.PersonSchema.from_flat(item)
if person.validate():
log.info("Person %r added." %
person.find("personal/first_name")[0].value)
session.save(database.PersonRow(person.flatten()))
else:
# import pdb; pdb.set_trace()
log.error("Person is not valid.")
log.error("%s" % item)
for element in person.all_children:
log.error("%r, %r" % (element.name, element.errors))
session.commit()
def main():
args = _parse_args()
session = get_session(args.url_path)
#configs = session.query(Config).filter(Config.param.like("%solver%")).all()
tasks = args.tasks
if not isinstance(tasks, list):
tasks = [tasks]
resetted_tasks = []
for task in tasks:
resetted_tasks.append(
session.query(Task).filter(Task.id == task).one())
to_delete = []
for task in resetted_tasks:
if args.deletejobs:
task_jobs = task.jobs
to_delete = to_delete + task_jobs
task.status = Task.STATUS_OPTIONS.CREATED
if task.parent is not None:
task.parent.status = Task.STATUS_OPTIONS.CREATED
if input(
f"{len(to_delete)} jobs will be reset for tasks {tasks} and the tasks will be reset. Sure? y/[n]: "
).lower() == "y":
for job in to_delete:
if job.solution is not None:
session.delete(job.solution)
job.solution = None
session.commit()
def get_session():
cookie = get_cookie()
if "session" not in cookie:
return None
session_id = cookie["session"].value
session = database.get_session(session_id)
return session
def cloud_data(self):
with database.get_session() as session:
try:
# Make sure we actually query all data (including all relations) as the session will be closed afterwards and a lazy evaluation is only possible after reattaching to a session
return session.query(CloudDef).filter(CloudDef.clouddef_id == self.clouddef_id).options(joinedload("*")).one()
except (NoResultFound, MultipleResultsFound):
raise app_exceptions.UnknownCloudException()
def remove():
db = database.get_session()
# This function is basically identical to the user addition function.
# We use the get_session method to create a connection with the database.
# Next we get the value of the username that was entered in the form
# using the request library that comes with flask.
username = request.form['username']
# Next we use the query method to search the table User and we filter our query by the username we got above.
# More documentation on querying and just general sqlalchemy knowledge can be found at
# http://docs.sqlalchemy.org/en/latest/orm/tutorial.html#querying
# After that we just use the built in delete method to remove the user and then
# we have to make sure we commit after that to make the deletion permanent.
user = db.query(schema.User).filter_by(username=username).first()
user_auth = db.query(schema.Auth).filter_by(username=username).first()
if user:
db.delete(user)
if user_auth:
db.delete(user_auth)
else:
pass
db.commit()
db.close()
return redirect(url_for('removeuser'))
else:
return redirect(url_for('no_user'))
def main():
config = _load_config()
session = get_session(config.url_path)
graphs = []
if config.seed is None:
seed = int(np.random.default_rng(None).integers(np.array([2**63]))[0])
config.seed = seed
else:
seed = int(config.seed)
gen = np.random.default_rng(seed)
counter = 0
assert len(config.vertex_shape) % 2 == 0
shapes = np.array(config.vertex_shape).reshape(round(len(config.vertex_shape)/2), 2)
l_shapes = len(shapes)
for n in range(config.min_n, config.max_n):
size = config.cel_min
while size <= config.cel_max:
for i in range(config.repetitions):
graphs.append(create_random_celest_graph(n,vertex_shape=shapes[counter % l_shapes], celest_bounds=(size,size+config.cel_range), seed=gen))
counter += 1
size += config.cel_step
task = Task(name=config.name, task_type="CelestialGraphInstances", status=Task.STATUS_OPTIONS.FINISHED)
# Convert the namespace config into database config
task_config_holder = ConfigHolder.fromNamespace(config, task=task, ignored_attributes=["url_path", "name", "config"])
task.jobs = [TaskJobs(graph=graph, task=task) for graph in graphs]
session.add(task)
session.commit()
print(counter, "instances were created. Corresponding task is", task.id)
def work(interval):
"""
This is where the work is done
@param interval: The interval between two calls if there are no request
"""
logger.debug('Worker Running!')
loop = asyncio.get_event_loop()
session = database.get_session()
request = get_request()
if request is None:
loop.call_later(interval, work, interval)
logger.debug('Waiting for Request, check again in %s seconds.' % interval)
return False
try:
logger.info('Calculating Hash for: %s' % request)
request = session.merge(request)
fhash = calculate_hash(request.server.ip, request.server.port, request.server.id)
file = File(name=fix_encoding(request.name), folder=request.folder, mtime=request.mtime,
size=request.size,
host=request.host, hash=fhash)
session.add(file)
session.delete(request.server)
session.delete(request)
session.commit()
except Exception as e:
logger.exception(e)
session.rollback()
loop.call_soon(work, interval)
return True
def add_task_result(task_result):
''' This will be called from a client and executed on the master '''
logger.debug("Got task_result result -> adding to DB")
try:
# This will be called from the celery worker and not from the main module, therefore we need to make sure, that the DB is initialized
database.setup_db()
with database.get_session() as session:
# T
inst = session.query(Task).filter(Task.task_id == task_result.task_id)
result = inst.one()
result.completed = task_result.completed
result.output = task_result.output
result.build_logs = ''.join(task_result.build_logs)
result.exception = task_result.exception
result.traceback = task_result.traceback
result.worker_hostname = task_result.hostname
result.exit_code = task_result.exit_code
result.duration = task_result.duration
session.commit()
except:
logger.error(traceback.format_exc())
return False
return True
def modify_category(category_id):
"""Modify the category.
You can only modify a category if you are logged.
Args:
category_id: Id of the category that will be modified.
Returns:
An html form if its a GET request, or redirects to the main page if
its a POST request.
"""
if 'credentials' in flask.session:
if not flask.session['credentials']:
flask.abort(403)
else:
flask.abort(403)
db_session = database.get_session()
prepare_login()
category = db_session.query(database.Category).get(category_id)
if category is None:
flask.abort(404)
if flask.request.method == 'GET':
return flask.render_template('edit_category.html',
category=category)
elif flask.request.method == 'POST':
try:
category.name = flask.request.form['name']
except KeyError:
flask.abort(400)
db_session.commit()
return flask.redirect(flask.url_for('show_catalog'))
def get_request():
"""
@return: a random request guarantied to be locked and unique
"""
session = database.get_session()
me = Host.by_name(socket.gethostname(), session)
if me.region is not None:
# noinspection PyComparisonWithNone,PyPep8
query = session.query(HashRequest).join(HashRequest.host).join(Host.region).filter(
and_(HashRequest.locked == False, HashRequest.server != None,
Region.id == me.region.id)).order_by(func.random()).with_for_update()
else:
# noinspection PyComparisonWithNone,PyPep8
query = session.query(HashRequest).join(HashRequest.host).filter(
and_(HashRequest.locked == False, HashRequest.server != None,
HashRequest.host == me)).order_by(func.random()).with_for_update()
try:
request = query.first()
if request is None:
return None
request.locked = True
session.commit()
return request
except Exception as error:
session.rollback()
raise error
finally:
session.close()
def update_fee_using_relations():
session = database.get_session()
for meeting_row in database.find('meeting'):
meeting_schema = schema.MeetingSchema.from_flat(meeting_row)
fees = meeting_schema['fees']
for fee in fees:
try:
fee_model = (models.Fee.select()
.where(data__contains={'id': str(fee['id'].value)})
.where(meeting=meeting_row.id)
.get())
except models.Fee.DoesNotExist:
fee_data = fee.flatten()
fee_data = [(re.sub('(fees_\d+_)', '', k), v)
for k, v in fee_data]
fee_model = models.Fee()
fee_model.meeting = meeting_row.id
fee_model.data = {}
fee_model.data.update(fee_data)
fee_model.save()
meeting_schema['fees'].set(None)
meeting_row.clear()
meeting_row.update(meeting_schema.flatten())
session.save(meeting_row)
session.commit()
def new_category():
"""Creates a new category.
You can only create a category if you are logged.
Returns:
An html form if its a GET request, or redirects to the main page if
its a POST request.
"""
if 'credentials' in flask.session:
if not flask.session['credentials']:
flask.abort(403)
else:
flask.abort(403)
db_session = database.get_session()
prepare_login()
if flask.request.method == 'GET':
return flask.render_template('new_category.html')
elif flask.request.method == 'POST':
try:
category = database.Category(
name=flask.request.form['name']
)
except KeyError:
flask.abort(400)
db_session.add(category)
db_session.commit()
return flask.redirect(flask.url_for('show_catalog'))
def visualize_solutions_overview_second_batch():
from database import Task, TaskJobs, Config, Graph, get_session, CelestialGraph, AngularGraphSolution
from instance_evolver import GraphGenome
from utils import visualize_graph_2d, visualize_min_sum_sol_2d, visualize_solution_2d
from matplotlib import pyplot as plt
session = get_session("angular.db")
from utils.visualization import visualize_solution_scatter, VisTypes
min_sum_tasks = session.query(Task).filter(Task.parent_id == 45).all()
local_min_sum_tasks = session.query(Task).filter(
Task.parent_id == 40).all()
makespan_tasks = session.query(Task).filter(
Task.parent_id == 30, ~Task.name.like("%Reduced%")).all()
min_sum_jobs = session.query(TaskJobs).filter(
TaskJobs.task_id.in_([t.id for t in min_sum_tasks])).all()
local_min_sum_jobs = session.query(TaskJobs).filter(
TaskJobs.task_id.in_([t.id for t in local_min_sum_tasks])).all()
makespan_jobs = session.query(TaskJobs).filter(
TaskJobs.task_id.in_([t.id for t in makespan_tasks])).all()
#visualize_solution_scatter(min_sum_jobs, "Bla", vis_type=VisTypes.All, logscale=True, loc=9)
#visualize_solution_scatter(local_min_sum_jobs, "Bla", vis_type=VisTypes.All, logscale=True, loc=9)
visualize_solution_scatter(makespan_jobs,
"Bla",
vis_type=VisTypes.All,
logscale=True,
loc=9)
print("finished")
def settings_phrases(meeting_id):
session = database.get_session()
meeting = sugar.get_object_or_404(models.Meeting, id=meeting_id)
if flask.request.method == 'POST':
form_data = dict(schema.PhraseSchema.from_defaults().flatten())
form_data.update(flask.request.form.to_dict())
phrase_schema = schema.PhraseSchema.from_flat(form_data)
if phrase_schema.validate():
phrase = (models.Phrase.select()
.where(data__contains={'id': str(phrase_schema['id'].value)})
.where(meeting=meeting_id).get())
phrase.data.clear()
phrase.data.update(phrase_schema.flatten())
phrase.save()
flask.flash('Phrase saved', 'success')
else:
flask.flash(u'Errors in phrase information', 'error')
phrases = meeting.get_phrases
return {
'language': refdata.language,
'phrases': phrases,
'meeting': meeting,
}
def delete_category(category_id):
"""Deletes the category.
You can only delete a category if you are logged and the category is
empty.
Args:
category_id: Id of the category to be deleted.
Returns:
Return an html form if its a GET request, or redirects to the main
page if its a POST request.
"""
if 'credentials' in flask.session:
if not flask.session['credentials']:
flask.abort(403)
else:
flask.abort(403)
db_session = database.get_session()
prepare_login()
category = db_session.query(database.Category).get(category_id)
if category is None:
flask.abort(404)
if flask.request.method == 'GET':
return flask.render_template('delete_category.html',
category=category)
elif flask.request.method == 'POST':
if not category.items:
db_session.delete(category)
db_session.commit()
return flask.redirect(flask.url_for('show_catalog'))
else:
flask.abort(500)
def visualize_sols_inst_gen():
from database import Task, TaskJobs, Config, Graph, get_session, CelestialGraph, AngularGraphSolution
from utils import visualize_graph_2d, visualize_min_sum_sol_2d, visualize_solution_2d
session = get_session("angular_copy.db")
with session.no_autoflush:
task = session.query(Task).filter(Task.task_type == "CelestialGraphInstances").one()
task_jobs = session.query(TaskJobs).filter(TaskJobs.task == task).all()
cel_graphs_old = session.query(CelestialGraph)\
.filter(CelestialGraph.id.in_([job.graph_id for job in task_jobs]), CelestialGraph.vert_amount <= 8)\
.all()
cel_graphs = [i for i in cel_graphs_old if i.id in [44,68,81,82,96,1, 21, 12, 3]]
min_sum_sols = [session.query(AngularGraphSolution).filter(AngularGraphSolution.graph_id == cel.id, AngularGraphSolution.is_optimal == True, AngularGraphSolution.solution_type == "min_sum").all() for cel in cel_graphs]
local_min_sum_sols = [session.query(AngularGraphSolution).filter(AngularGraphSolution.graph_id == cel.id, AngularGraphSolution.is_optimal == True, AngularGraphSolution.solution_type == "local_min_sum").all() for cel in cel_graphs]
makespan_sols = [session.query(AngularGraphSolution).filter(AngularGraphSolution.graph_id == cel.id, AngularGraphSolution.is_optimal == True, AngularGraphSolution.solution_type == "makespan").all() for cel in cel_graphs]
for g, min_s, l_s, m_s in zip(cel_graphs, min_sum_sols, local_min_sum_sols, makespan_sols):
print("Graph-id", g.id)
visualize_graph_2d(g)
if min_s:
print("Minsum:")
visualize_min_sum_sol_2d(min_s[0])
if l_s:
print("LocalMinSum")
visualize_min_sum_sol_2d(l_s[0])
if m_s:
print("Makespan")
visualize_solution_2d(m_s[0])
return
def intialize():
session['logged_in'] = False
#creates the database for the driver schedule. the if statement checks to see if the database already exists and passes if it does, otherwise it creates the database.
db = database.get_session()
if db.query(schema.Schedule).filter_by(id=1).first():
db.close()
else:
session['logged_in'] = False
monday = schema.Schedule(day="Monday")
tuesday = schema.Schedule(day="Tuesday")
wednesday = schema.Schedule(day="Wednesday")
thursday = schema.Schedule(day="Thursday")
friday = schema.Schedule(day="Friday")
saturday = schema.Schedule(day="Saturday")
sunday = schema.Schedule(day="Sunday")
db.add(monday)
db.add(tuesday)
db.add(wednesday)
db.add(thursday)
db.add(friday)
db.add(saturday)
db.add(sunday)
db.commit()
db.close()
def get_from_name_password(username, password):
session = get_session()
hashedPassword = pbkdf2_sha256.hash(password)
result = session.query(User).filter(User.username == username).filter(User.password == password).all()
if (len(result) > 0):
return result[0]
def modify_category(category_id):
"""Modify the category.
You can only modify a category if you are logged.
Args:
category_id: Id of the category that will be modified.
Returns:
An html form if its a GET request, or redirects to the main page if
its a POST request.
"""
if 'credentials' in flask.session:
if not flask.session['credentials']:
flask.abort(403)
else:
flask.abort(403)
db_session = database.get_session()
prepare_login()
category = db_session.query(database.Category).get(category_id)
if category is None:
flask.abort(404)
if flask.request.method == 'GET':
return flask.render_template('edit_category.html',
category=category)
elif flask.request.method == 'POST':
try:
category.name = flask.request.form['name']
except KeyError:
flask.abort(400)
db_session.commit()
return flask.redirect(flask.url_for('show_catalog'))
def main():
config = _load_config()
session = get_session(config.url_path)
if config.seed is None:
seed = int(np.random.default_rng(None).integers(np.array([2**63]))[0])
config.seed = seed
else:
seed = int(config.seed)
gen = np.random.default_rng(seed)
if config.fixed_edges:
graphs = _fixed_generation(config, gen)
else:
graphs = _probability_generation(config, gen)
task = Task(name=config.name,
task_type="GeometricGraphInstances",
status=Task.STATUS_OPTIONS.FINISHED)
# Convert the namespace config into database config
task_config_holder = ConfigHolder.fromNamespace(
config, task=task, ignored_attributes=["url_path", "name", "config"])
task.jobs = [TaskJobs(graph=graph, task=task) for graph in graphs]
session.add(task)
session.commit()
print(len(task.jobs), "instances were created. Corresponding task is",
task.id)
def _merge_job(json_data, job_id=None):
if json_data is None or not 'name' in json_data or not 'clouddef_id' in json_data:
return json_status(False, 400, "Missing required parameters")
with database.get_session() as session:
new_job = Job(job_id=job_id,
clouddef_id=json_data.get('clouddef_id'),
run_layer_id=json_data.get('run_layer_id', None),
script_id=json_data.get('script_id', None),
source_datadef_id=json_data.get('source_datadef_id',
None),
destination_datadef_id=json_data.get(
'destination_datadef_id', None),
name=json_data.get('name'),
task_timeout=json_data.get('task_timeout', 0))
if new_job.run_layer_id == "0": new_job.run_layer_id = None
if new_job.script_id == "0": new_job.script_id = None
# Merge will automatically add a new instance if the primary key does not already exist
new_job = session.merge(new_job)
session.commit()
return json_status(True,
url=api_restful.url_for(JobApi,
job_id=new_job.job_id))
def new_category():
"""Creates a new category.
You can only create a category if you are logged.
Returns:
An html form if its a GET request, or redirects to the main page if
its a POST request.
"""
if 'credentials' in flask.session:
if not flask.session['credentials']:
flask.abort(403)
else:
flask.abort(403)
db_session = database.get_session()
prepare_login()
if flask.request.method == 'GET':
return flask.render_template('new_category.html')
elif flask.request.method == 'POST':
try:
category = database.Category(name=flask.request.form['name'])
except KeyError:
flask.abort(400)
db_session.add(category)
db_session.commit()
return flask.redirect(flask.url_for('show_catalog'))
def delete_category(category_id):
"""Deletes the category.
You can only delete a category if you are logged and the category is
empty.
Args:
category_id: Id of the category to be deleted.
Returns:
Return an html form if its a GET request, or redirects to the main
page if its a POST request.
"""
if 'credentials' in flask.session:
if not flask.session['credentials']:
flask.abort(403)
else:
flask.abort(403)
db_session = database.get_session()
prepare_login()
category = db_session.query(database.Category).get(category_id)
if category is None:
flask.abort(404)
if flask.request.method == 'GET':
return flask.render_template('delete_category.html',
category=category)
elif flask.request.method == 'POST':
if not category.items:
db_session.delete(category)
db_session.commit()
return flask.redirect(flask.url_for('show_catalog'))
else:
flask.abort(500)
def main():
if not is_debug_env():
print(
"No debugger detected! This file is inteded to run with debugger. Proceed without with care"
)
arguments = _parse_args()
session = get_session(arguments.url_path)
error_jobs = session.query(TaskJobs).join(AngularGraphSolution)\
.filter(AngularGraphSolution.error_message != None).order_by(TaskJobs.task_id).all()
print(
f"{len(error_jobs)} found. Will now start resolve these instances...")
prev_task = None
for job in tqdm.tqdm(error_jobs, desc="Resolvng error solutions"):
if prev_task is None or prev_task != job.task:
config = ConfigHolder(job.task)
solver = ALL_SOLVER[config.solver](**config.solver_args)
prev_task = job.task
sol = solver.solve(job.graph)
if sol.error_message is None:
old_sol = job.solution
session.delete(old_sol)
job.solution = sol
session.commit()
else:
print(
f"Still error message for job {job} with message: {sol.error_message}"
)
session.commit()
def _merge_cloud(json_data, clouddef_id=None):
if json_data is None or not 'name' in json_data or not 'cloudprovider_id' in json_data:
return json_status(False, 400, "Missing required parameters")
with database.get_session() as session:
new_cloud = CloudDef(
name=json_data.get('name'),
cloudprovider_id=json_data.get('cloudprovider_id'),
virtual_device_layer_id=json_data.get('virtual_device_layer_id',
None),
test_layer_id=json_data.get('test_layer_id', None),
client_startup_parameters=json_data.get(
'client_startup_parameters', None))
if str(new_cloud.virtual_device_layer_id) == "0":
new_cloud.virtual_device_layer_id = None
if str(new_cloud.test_layer_id) == "0": new_cloud.test_layer_id = None
if clouddef_id is not None:
new_cloud.clouddef_id = clouddef_id
new_cloud = session.merge(new_cloud)
session.commit()
_merge_ec2(json_data, new_cloud)
return json_status(True,
url=api_restful.url_for(
CloudApi, clouddef_id=new_cloud.clouddef_id))
def download(db_id):
session = database.get_session()
try:
db_file = session.get_db_file(db_id)
except KeyError:
flask.abort(404)
return flask.Response(''.join(db_file.iter_data()), # TODO stream response
mimetype="application/octet-stream")
def create_mock_app():
from manage import create_app
import database
app = create_app()
app.config["TESTING"] = True
app.config["DATABASE_URI"] = get_testing_db_uri()
app.config["FRAME_URL"] = None
database.initialize_app(app)
with app.test_request_context():
database.get_session().create_all()
def app_teardown():
with app.test_request_context():
database.get_session().drop_all()
return app, app_teardown
def update_persons_using_relations():
session = database.get_session()
for person_row in database.find('person', meeting_id='1'):
meeting_id = person_row.pop('meeting_id')
person_id = person_row.id
models.PersonMeeting.create(meeting=meeting_id, person=person_id)
session.save(person_row)
session.commit()
def edit_catalog_item(category_name, item_id):
"""Allows the edition of a catalog item.
Shows an edit form if is a GET request, and changes the information of
the item if is a POST request. You can only edit an item if you were
the one that created it or if the item has no owner (gplus_id is None).
Args:
category_name: Name of the current category.
item_id: Id of the item that will be edited.
Returns:
An html form if its a GET request, or redirects to the item if is a
POST request.
"""
if 'credentials' in flask.session:
if not flask.session['credentials']:
flask.abort(403)
else:
flask.abort(403)
db_session = database.get_session()
prepare_login()
item = db_session.query(database.Item).get(item_id)
if item is None:
flask.abort(404)
if flask.request.method == 'GET':
try:
if (flask.session['gplus_id'] == item.gplus_id):
categories = db_session.query(database.Category).all()
return flask.render_template('edit_item.html',
category_name=category_name,
categories=categories,
item=item)
else:
flask.abort(404)
except KeyError:
flask.abort(401)
elif flask.request.method == 'POST':
try:
if (flask.session['gplus_id'] == item.gplus_id):
item.name = flask.request.form['name']
item.description = flask.request.form['description']
filename = file_upload.save_upload()
if filename:
if item.image:
file_upload.delete_upload(item.image)
item.image = filename
else:
flask.abort(403)
except KeyError:
flask.abort(401)
db_session.commit()
return flask.redirect(flask.url_for('show_catalog_item',
category_name=category_name,
item_id=item_id))
def photo(person_id):
session = database.get_session()
person_row = database.get_person_or_404(person_id)
try:
db_file = session.get_db_file(int(person_row["photo_id"]))
except KeyError:
flask.abort(404)
return flask.Response(''.join(db_file.iter_data()), # TODO stream response
mimetype="application/octet-stream")
def update_participants_none_to_empty_values():
session = database.get_session()
for p in database.get_all("person"):
for k,v in p.items():
#convert None to empty strings
if v == u'None':
p[k] = u''
session.save(p)
session.commit()
def scrape():
session = get_session()
new_zimmers = 0
for link in get_links():
try:
session.query(WgZimmer).filter(WgZimmer.link == link).one()
except NoResultFound:
new_zimmers += 1
save_new_zimmer(link, session)
print str(new_zimmers) + " new rooms found"
def delete_catalog_item(category_name, item_id):
"""Allows the deletion of a catalog item.
Shows a delete confirmation in a GET request, and deletes the item on a
POST request. You can only delete an item if you were the one that
created it or if the item has no owner (gplus_id is None).
Args:
category_name: Name of the current category.
item_id: Id of the item that will be deleted.
Returns:
An html form if its a GET request, or redirects to the item if is a
POST request.
"""
try:
if not flask.session['credentials']:
flask.abort(403)
except KeyError:
flask.abort(403)
db_session = database.get_session()
prepare_login()
item = db_session.query(database.Item).get(item_id)
if item is None:
flask.abort(404)
if flask.request.method == 'GET':
try:
if (flask.session['gplus_id'] == item.gplus_id):
categories = db_session.query(database.Category).all()
return flask.render_template('delete_item.html',
category_name=category_name,
categories=categories,
item=item)
else:
flask.abort(403)
except KeyError:
flask.abort(401)
elif flask.request.method == 'POST':
try:
if (flask.session['gplus_id'] == item.gplus_id):
if item.image:
file_upload.delete_upload(item.image)
db_session.delete(item)
else:
flask.abort(403)
except KeyError:
flask.abort(401)
db_session.commit()
return flask.redirect(flask.url_for('show_category_items',
category_name=category_name))
def test_delete(self):
client = self.app.test_client()
with self.app.test_request_context():
session = database.get_session()
row = database.ReportRow(name="v323x,3240543#%")
session.save(row)
session.commit()
post_response = client.post("reports/%s/delete/" %row.id)
list_response = client.get('/reports/')
self.assertFalse( "v323x,3240543#%" in list_response.data)
self.assertIn("Report deleted.", list_response.data)
def delete(staff_id):
staff = schema.Staff.get_or_404(staff_id)
session = database.get_session()
response = {
"status": "success",
"url": flask.url_for("staff.home", staff_id=staff_id)
}
session['staff'].delete(staff_id)
session.commit()
return flask.json.dumps(response)
def report_delete(report_id):
if flask.request.method == 'POST':
session = database.get_session()
reviews_list = database.get_seris_reviews_list(report_id)
if reviews_list:
#TODO change when multiple reviews will be implemented
session.table(database.SerisReviewRow) \
.delete(database.get_seris_reviews_list(report_id)[0].id)
session.table(database.ReportRow).delete(report_id)
session.commit()
flask.flash("Report deleted.", "success")
return flask.redirect(flask.url_for('views.report_list'))
def update_staff_members_passwords():
session = database.get_session()
app = flask.current_app
staff_members = [i for i in database.get_all("staff")]
for account in app.config["ACCOUNTS"]:
staff_member = [i for i in staff_members if i.get("email") == account[0]]
if staff_member:
staff_member = staff_member[0]
staff_member["password"] = sugar.make_hash(account[1])
session.save(staff_member)
session.commit()
def _scan_folder(self, folder: Path):
"""
@param folder: a Folder
"""
logger.debug('Scanning Folder: %s' % folder)
session = database.get_session(new_engine=False)
try:
FilesystemObject.by_uri('%s::%s' % (config.HOSTNAME, folder), session)
except NoResultFound:
self._add_child(folder)
finally:
session.close()
for child_name in listdir(str(folder)):
self._queue.put(folder / child_name)
def new_catalog_item(category_name):
"""Adds a new item to the chosen category.
Shows a insert form if is a GET request, and inserts a new item to the
database on a POST request. You can only create an item if you are
logged.
Args:
category_name: Name of the category which the new item will belong.
Returns:
An html form if is a GET request, or redirects to the catalog if
ifs a POST request.
"""
if 'credentials' in flask.session:
if not flask.session['credentials']:
flask.abort(403)
else:
flask.abort(403)
db_session = database.get_session()
prepare_login()
if flask.request.method == 'GET':
categories = db_session.query(database.Category).all()
return flask.render_template('new_item.html',
categories=categories,
category_name=category_name)
elif flask.request.method == 'POST':
categories = db_session.query(database.Category).all()
category = db_session.query(database.Category).filter(
database.Category.name == category_name
).one()
try:
item = database.Item(
name=flask.request.form['name'],
description=flask.request.form['description'],
image=file_upload.save_upload(),
gplus_id=flask.session['gplus_id'],
category_id=category.id
)
except KeyError:
flask.abort(401)
db_session.add(item)
db_session.commit()
return flask.redirect(flask.url_for('show_category_items',
category_name=category_name))
def update_participants_region():
session = database.get_session()
countries = [schema.Country.from_flat(c) for c in database.get_all("country")]
countries = {c["iso"].value: c["region"].value for c in countries}
for p in database.get_all("person"):
try:
region = int(p['representing_region'])
if region == 0:
region = None
except ValueError:
region = None
if not region and p["representing_country"]:
p["representing_region"] = countries[p["representing_country"]]
session.save(p)
session.commit()
def main():
logging.root.setLevel(logging.INFO)
logging.info("Starting up email queue")
session = database.get_session(config.database)
provider = providers.get_provider(config.provider)
processor = queue.QueueProcessor(config, session, provider)
try:
while not interrupted:
logging.debug("checking email queue")
processor.process()
time.sleep(config.queue.getfloat('sleep_seconds', 10))
except Exception as e:
logging.critical(e.message)
finally:
database.close_connection()
def document_file_delete(meeting_id, document_id, lang):
meeting = sugar.get_object_or_404(models.Meeting, id=meeting_id)
response = {'status': 'success'}
document_row = database.get_or_404('document', document_id)
document_schema = schema.DocumentSchema.from_flat(document_row)
file_id = int(document_schema['doc_id'][lang].value)
document_schema['doc_id'][lang].set(None)
document_schema['filename'][lang].set(None)
document_row.clear()
document_row.update(document_schema.flatten())
session = database.get_session()
session.del_db_file(file_id)
session.save(document_row)
session.commit()
return flask.json.dumps(response)
def updat_resolution_order():
session = database.get_session()
conf_regex = re.compile('(\d+)\.(\d+)')
for resolution in database.get_all('resolution'):
if conf_regex.search(resolution['number']):
first_number = conf_regex.search(resolution['number']).group(1)
second_number = conf_regex.search(resolution['number']).group(2)
if len(first_number) == 1:
first_number = '0' + first_number
if len(second_number) == 1:
second_number = '0' + second_number
resolution['order'] = first_number + '-' + second_number
else:
print 'error', resolution['number']
session.save(resolution)
session.commit()
def serve_until_stopped(self):
"""
Does at it says
"""
import select
global DBSession
logging.basicConfig(handlers=(SQLAlchemyHandler(), ))
DBSession = database.get_session()
abort = 0
while not abort:
rd, wr, ex = select.select([self.socket.fileno()], [], [],
self.timeout)
if rd:
self.handle_request()
abort = self.abort
def document_delete(meeting_id, document_id):
meeting = sugar.get_object_or_404(models.Meeting, id=meeting_id)
document = schema.Document.get_or_404(document_id)
response = {
'status': 'success',
'url': flask.url_for('meeting.documents', meeting_id=meeting.id)
}
doc_ids = [int(id) for id in document['doc_id'].values() if id]
session = database.get_session()
for d in doc_ids:
session.del_db_file(d)
session['document'].delete(document_id)
session.commit()
return flask.json.dumps(response)
def update_activity_what_id():
session = database.get_session()
activity = [a for a in database.get_all("activity")]
persons = [schema.Person.from_flat(p) for p in database.get_all("person")]
persons = {p.name: p.id for p in persons}
def replace_title(name):
for i in ("Mr", "Ms", "M", "Mme.", "Sra.", "Sr."):
name = name.replace(i, "")
return name.strip()
for a in activity:
p = persons.get(a["what"], None) or persons.get(replace_title(a["what"]), None)
if p:
a["what_id"] = str(p)
session.save(a)
session.commit()
