def get_for_utilizer():
if roles_required(["utilizer"]) == 400:
return jsonify({"msg": "no access"}), 400
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
num = request.json['num']
series = request.json['series']
try:
returned_data = blank_model.read({"num": num, "series": series})
from models.usages_register import UsagesRegisterModel
usages_register_model = UsagesRegisterModel(
PostgresConnection().get_connection())
usages_register = usages_register_model.custom_query(
"SELECT * FROM usages_register "
"WHERE num_blank = %s "
"AND series_blank = \'%s\'" % (num, series))
from models.code_usages_blank import CodeUsagesBlankModel
code_usages_blank_model = CodeUsagesBlankModel(
PostgresConnection().get_connection())
code_usages_blank = code_usages_blank_model.custom_query(
"SELECT * FROM code_usages_blank "
"WHERE code = %s" % (usages_register['code_usage']))
except Exception as e:
return jsonify({"msg": str(e)}), 400
return jsonify({
"statusCode": usages_register['code_usage'],
"statusPhrase": code_usages_blank['text_representation'],
"dateUsing": usages_register['date_usage']
}), 200
class Controller(object):
def __init__(self):
self._connection = PostgresConnection().get_connection()
self._cursor = self._connection.cursor(cursor_factory=DictCursor)
self._create_tables()
self._code_usages_blank_model = CodeUsagesBlankModel(self._connection)
self._notarius_model = NotariusModel(self._connection)
self._blank_model = BlankModel(self._connection)
self._usages_register_model = UsagesRegisterModel(self._connection)
self._users_model = UsersModel(self._connection)
self._journal_actions_model = JournalActionsModel(self._connection)
self._verifications_register_model = VerificationsRegisterModel(
self._connection)
self._users_model.generate_data(5000)
self._notarius_model.generate_data(5000)
self._blank_model.generate_data(5000)
self._usages_register_model.generate_data(5000)
self._journal_actions_model.generate_data(5000)
self._verifications_register_model.generate_data(5000)
self._code_usages_blank_model.generate_data(5000)
# self._users_model.generate_data(100)
@property
def connection(self):
return self._connection
def _create_tables(self):
file_path = path.join(path.dirname(path.abspath(__file__)),
'../create_tables.sql')
with open(file_path, 'r') as f:
sql = f.read()
self._cursor.execute(sql)
self._connection.commit()
def test(self):
notarius_model = NotariusModel(PostgresConnection().get_connection())
notarius_amount = notarius_model.amount()[0]
num_card = random_int()
returned_data = notarius_model.create({
"type": False,
"status": 'status',
"date_status_update": date.today(),
"num_certificate": 'num_certificate',
"num_card": num_card,
"name": 'name',
"name_organization": 'name_organization',
"region": 'region',
"contacts": 'contacts',
"notarius_region": 'notarius_region',
"additional_info": 'additional_info',
"date_issue_certificate": date.today(),
"date_issue_card": date.today(),
"date_reg_region": date.today(),
"location": 'location'
})
assert (notarius_amount + 1 == notarius_model.amount()[0])
notarius = notarius_model.read({'id': returned_data['id']})
assert (notarius['num_card'] == num_card)
new_num_card = random_int()
notarius_model.update({"num_card": new_num_card}, {'id': returned_data['id']})
notarius = notarius_model.read({'id': returned_data['id']})
assert (notarius['num_card'] == new_num_card)
notarius_model.delete({'id': returned_data['id']})
assert (notarius_model.read({'id': returned_data['id']}) is None)
def test(self):
users_model = UsersModel(PostgresConnection().get_connection())
users_amount = users_model.amount()[0]
username = random_string()
password = random_string()
returned_data = users_model.create({
"name": "name",
"role": 1,
"date_registration": date.today(),
"username": username,
"pwd_hash": password,
"pwd_salt": uuid.uuid4().hex,
"date_last_update": date.today(),
"status": True
})
assert (users_amount + 1 == users_model.amount()[0])
user = users_model.read({'username': username})
assert (user['role'] == 1)
new_username = random_string()
users_model.update({"username": new_username},
{"id": returned_data['id']})
user = users_model.read({"username": new_username})
assert (user is not None)
users_model.delete({"id": returned_data['id']})
assert (users_model.read({"username": new_username}) is None)
def test(self):
journal_actions_model = JournalActionsModel(
PostgresConnection().get_connection())
journal_actions_amount = journal_actions_model.amount()[0]
action_type = random_int()
returned_data = journal_actions_model.create({
"user_id":
users_returned_data['id'],
"action_date":
date.today(),
"action_type":
action_type,
"row_affected":
'row_affected',
"old_value":
'old_value',
"new_value":
'new_value'
})
assert (journal_actions_amount +
1 == journal_actions_model.amount()[0])
journal_actions = journal_actions_model.read(
{'id': returned_data['id']})
assert (journal_actions['action_type'] == action_type)
new_action_type = random_int()
journal_actions_model.update({"action_type": new_action_type},
{'id': returned_data['id']})
journal_actions = journal_actions_model.read(
{'id': returned_data['id']})
assert (journal_actions['action_type'] == new_action_type)
journal_actions_model.delete({'id': returned_data['id']})
assert (journal_actions_model.read({'id': returned_data['id']}) is
None)
def test(self):
verifications_register_model = VerificationsRegisterModel(
PostgresConnection().get_connection())
verifications_register_amount = verifications_register_model.amount(
)[0]
num_blank = random_int()
returned_data = verifications_register_model.create({
"num_blank":
num_blank,
"series_blank":
random_string(),
"user_id":
notary_returned_data['id'],
"date_verification":
date.today()
})
assert (verifications_register_amount +
1 == verifications_register_model.amount()[0])
verifications_register = verifications_register_model.read(
{'id': returned_data['id']})
assert (verifications_register['num_blank'] == num_blank)
new_num_blank = random_int()
verifications_register_model.update({"num_blank": new_num_blank},
{'id': returned_data['id']})
verifications_register = verifications_register_model.read(
{'id': returned_data['id']})
assert (verifications_register['num_blank'] == new_num_blank)
verifications_register_model.delete({'id': returned_data['id']})
assert (verifications_register_model.read({'id': returned_data['id']})
is None)
def test(self):
usages_register_model = UsagesRegisterModel(
PostgresConnection().get_connection())
usages_register_amount = usages_register_model.amount()[0]
num_blank = random_int()
returned_data = usages_register_model.create({
"num_blank":
num_blank,
"series_blank":
"series_blank",
"date_usage":
date.today(),
"code_usage":
auxiliary_data['code'],
"additional_info":
"additional_info"
})
assert (usages_register_amount +
1 == usages_register_model.amount()[0])
usages_register = usages_register_model.read(
{'id': returned_data['id']})
assert (usages_register['num_blank'] == num_blank)
new_num_blank = random_int()
usages_register_model.update({"num_blank": new_num_blank},
{'id': returned_data['id']})
usages_register = usages_register_model.read(
{'id': returned_data['id']})
assert (usages_register['num_blank'] == new_num_blank)
usages_register_model.delete({'id': returned_data['id']})
assert (usages_register_model.read({'id': returned_data['id']}) is
None)
def generate():
if roles_required(["admin", "registrar"]) == 400:
return jsonify({"msg": "no access"}), 400
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
try:
num = request.json['number']
users_model = UsersModel(PostgresConnection().get_connection())
notarius_model = NotariusModel(PostgresConnection().get_connection())
blank_model = BlankModel(PostgresConnection().get_connection())
usages_register_model = UsagesRegisterModel(
PostgresConnection().get_connection())
journal_actions_model = JournalActionsModel(
PostgresConnection().get_connection())
verifications_register_model = VerificationsRegisterModel(
PostgresConnection().get_connection())
code_usages_blank_model = CodeUsagesBlankModel(
PostgresConnection().get_connection())
users_model.generate_data(num)
notarius_model.generate_data(num)
blank_model.generate_data(num)
usages_register_model.generate_data(num)
journal_actions_model.generate_data(num)
verifications_register_model.generate_data(num)
code_usages_blank_model.generate_data(num)
except Exception as e:
return jsonify({"msg": str(e)}), 400
return jsonify({"msg": "data generated"}), 200
def __init__(self):
self._connection = PostgresConnection().get_connection()
self._cursor = self._connection.cursor(cursor_factory=DictCursor)
self._create_tables()
self._code_usages_blank_model = CodeUsagesBlankModel(self._connection)
self._notarius_model = NotariusModel(self._connection)
self._blank_model = BlankModel(self._connection)
self._usages_register_model = UsagesRegisterModel(self._connection)
self._users_model = UsersModel(self._connection)
self._journal_actions_model = JournalActionsModel(self._connection)
self._verifications_register_model = VerificationsRegisterModel(
self._connection)
self._users_model.generate_data(5000)
self._notarius_model.generate_data(5000)
self._blank_model.generate_data(5000)
self._usages_register_model.generate_data(5000)
self._journal_actions_model.generate_data(5000)
self._verifications_register_model.generate_data(5000)
self._code_usages_blank_model.generate_data(5000)
def test(self):
blank_model = BlankModel(PostgresConnection().get_connection())
blank_amount = blank_model.amount()[0]
num = random_int()
series = random_string(2)
returned_data = blank_model.create({
"num": num,
"series": series,
"notarius_id": notary_returned_data['id'],
"date_receiving": date.today(),
})
assert (blank_amount + 1 == blank_model.amount()[0])
blank = blank_model.read({"num": num, "series": series})
assert (blank['num'] == num)
blank_model.delete({"num": num, "series": series})
assert (blank_model.read({"num": num, "series": series}) is None)
def test(self):
code_usages_blank_model = CodeUsagesBlankModel(
PostgresConnection().get_connection())
code_usages_blank_amount = code_usages_blank_model.amount()[0]
code = random_int()
returned_data = code_usages_blank_model.create({
"code":
code,
"text_representation":
'text_representation'
})
assert (code_usages_blank_amount +
1 == code_usages_blank_model.amount()[0])
code_register = code_usages_blank_model.read({'code': code})
assert (code_register['text_representation'] == 'text_representation')
new_code = random_int()
code_usages_blank_model.update({"code": new_code}, {'code': code})
code_register = code_usages_blank_model.read({'code': new_code})
assert (code_register['code'] == new_code)
code_usages_blank_model.delete({'code': new_code})
assert (code_usages_blank_model.read({'code': new_code}) is None)
from datetime import date
from flask import Blueprint, request, jsonify
from flask_jwt_extended import jwt_required
from blueprints.annotations.roles_required import roles_required
from models.verifications_register import VerificationsRegisterModel
from connection import PostgresConnection
verifications_register_model = VerificationsRegisterModel(PostgresConnection().get_connection())
verifications_register = Blueprint('verifications_register', __name__)
@verifications_register.route('/create', methods=['POST'])
@jwt_required
def create():
if roles_required(["admin", "registrar"]) == 400:
return jsonify({"msg": "no access"}), 400
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
request_json = request.json
try:
returned_data = verifications_register_model.create({
"num_blank": request_json['num_blank'],
"series_blank": request_json['series_blank'],
"user_id": request_json['user_id'],
"date_verification": date.today()
})
except Exception as e:
return jsonify({"msg": str(e)}), 400
import unittest
import uuid
from datetime import date
from connection import PostgresConnection
from models.journal_actions import JournalActionsModel
from models.users import UsersModel
from random_data_generators import (random_int, random_string)
users_model = UsersModel(PostgresConnection().get_connection())
users_returned_data = {'id': 0}
class TestJournalActions(unittest.TestCase):
def setUp(self):
returned_data = users_model.create({
"name": "name",
"role": 1,
"date_registration": date.today(),
"username": random_string(),
"pwd_hash": random_string(),
"pwd_salt": uuid.uuid4().hex,
"date_last_update": date.today(),
"status": True
})
users_returned_data['id'] = returned_data['id']
def test(self):
journal_actions_model = JournalActionsModel(
PostgresConnection().get_connection())
journal_actions_amount = journal_actions_model.amount()[0]
import unittest
from datetime import date
from connection import PostgresConnection
from models.blank import BlankModel
from models.notarius import NotariusModel
from random_data_generators import (random_int, random_string)
notarius_model = NotariusModel(PostgresConnection().get_connection())
notary_returned_data = {'id': 0}
class TestBlank(unittest.TestCase):
def setUp(self):
returned_data = notarius_model.create({
"type": False,
"status": 'status',
"date_status_update": date.today(),
"num_certificate": 'num_certificate',
"num_card": 1,
"name": 'name',
"name_organization": 'name_organization',
"region": 'region',
"contacts": 'contacts',
"notarius_region": 'notarius_region',
"additional_info": 'additional_info',
"date_issue_certificate": date.today(),
"date_issue_card": date.today(),
"date_reg_region": date.today(),
"location": 'location'
prob1 = 0
prob2 = 0
for x in all_teams[team1]:
if x['getting_to'] == slot:
prob1 = x['probability']
break
for x in all_teams[team2]:
if x['getting_to'] == slot:
prob2 = x['probability']
break
return prob1 * prob2
if __name__ == '__main__':
conn = PostgresConnection()
#seasons = Seasons.find_all_seasons(conn)
seasons = Seasons.find_latest_season(conn)
curr_season = seasons[0][SeasonEnum.season].strip()
teams = Teams.find_all_teams(conn)
team_count = len(teams)
all_slots = {}
all_teams = {}
ranked_teams = RankedTeams.find_ranks(conn)
from datetime import date
from flask import Blueprint, request, jsonify
from flask_jwt_extended import jwt_required
from blueprints.annotations.roles_required import roles_required
from models.blank import BlankModel
from connection import PostgresConnection
blank_model = BlankModel(PostgresConnection().get_connection())
blank = Blueprint('blank', __name__)
@blank.route('/create', methods=['POST'])
@jwt_required
def create():
if roles_required(["admin", "registrar"]) == 400:
return jsonify({"msg": "no access"}), 400
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
request_json = request.json
try:
returned_data = blank_model.create({
"num":
request_json["num"],
"series":
request_json["series"],
"notarius_id":
request_json["notarius_id"],
"date_receiving":
def populate(table: str):
with open(args.csv_file, 'r') as csv_data:
with PostgresConnection() as cursor:
logging.info("Inserting data. That can take some time")
headers = next(csv_data).strip().split(',')
cursor.copy_from(file=csv_data, table=table, sep=',', columns=headers)
from datetime import date
from flask import Blueprint, request, jsonify
from flask_jwt_extended import jwt_required
from blueprints.annotations.roles_required import roles_required
from models.journal_actions import JournalActionsModel
from connection import PostgresConnection
journal_actions_model = JournalActionsModel(PostgresConnection().get_connection())
journal_actions = Blueprint('journal_actions', __name__)
@journal_actions.route('/create', methods=['POST'])
@jwt_required
def create():
if roles_required(["admin", "registrar"]) == 400:
return jsonify({"msg": "no access"}), 400
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
request_json = request.json
try:
returned_data = journal_actions_model.create({
"user_id": request_json['user_id'],
"action_date": request_json['action_date'],
"action_type": request_json['action_type'],
"row_affected": request_json['row_affected'],
"old_value": request_json['old_value'],
"new_value": request_json['new_value']
})
except Exception as e:
import unittest
from datetime import date
from connection import PostgresConnection
from models.usages_register import UsagesRegisterModel
from models.code_usages_blank import CodeUsagesBlankModel
from random_data_generators import (random_int, random_string)
auxiliary_model = CodeUsagesBlankModel(PostgresConnection().get_connection())
auxiliary_data = {'code': 0}
class TestUsagesRegisterModel(unittest.TestCase):
def setUp(self):
returned_data = auxiliary_model.create({
"code":
random_int(100),
"text_representation":
'text_representation'
})
auxiliary_data['code'] = returned_data['code']
def test(self):
usages_register_model = UsagesRegisterModel(
PostgresConnection().get_connection())
usages_register_amount = usages_register_model.amount()[0]
num_blank = random_int()
returned_data = usages_register_model.create({
"num_blank":
num_blank,
"series_blank":