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":