def create_factory(name):
name_clean = to_pascal_case(name)
test_stub = """import factory
from app.utils import db
from app.models.{name} import {name_clean}
# Any Table fields that cannot be generated by factory.Faker() should be defined out here and used inside the class.
# This is a limitation on how factory-boy serializes args created in the Factory class.
# example
# fake_cohort_position = 'Vice President'
class {name_clean}Factory(factory.alchemy.SQLAlchemyModelFactory):
class Meta:
model = {name_clean}
sqlalchemy_session = db.session
id = factory.Sequence(lambda n: n)
# name = factory.Faker('name')
# cohort_position = fake_cohort_position
""".format(name_clean=name_clean, name=name)
factory_file_path = "factories/{}_factory.py".format(name)
write_file(factory_file_path, test_stub)
return name_clean, factory_file_path
pass
def create_model(name):
name_clean = to_pascal_case(name)
model_stub = """from .base_model import BaseModel, db
class {model_name}(BaseModel):
__tablename__ = '{table_name}'
""".format(model_name=name_clean, table_name=inflect_engine.plural(name))
model_file_path = "app/models/{}.py".format(name)
write_file(model_file_path, model_stub)
return name_clean, model_file_path
def create_controller(name):
name_clean = to_pascal_case(name)
controller_stub = """from app.controllers.base_controller import BaseController
class {name}Controller(BaseController):
def __init__(self, request):
BaseController.__init__(self, request)
""".format(name=name_clean)
controller_file_path = "app/controllers/{}_controller.py".format(name)
write_file(controller_file_path, controller_stub)
return name_clean, controller_file_path
def create_repo(name):
name_clean = to_pascal_case(
name) #''.join(list(map(lambda x: x.capitalize(), name.split('_'))))
repo_stub = """from app.repositories.base_repo import BaseRepo
from app.models.{name} import {name_clean}
class {name_clean}Repo(BaseRepo):
def __init__(self):
BaseRepo.__init__(self, {name_clean})""".format(name=name,
name_clean=name_clean)
repo_file_path = "app/repositories/{}_repo.py".format(name)
write_file(repo_file_path, repo_stub)
return name_clean, repo_file_path
def create_test(name, test_path=None):
name_clean = to_pascal_case(name)
test_file_path = "tests"
if test_path:
os.makedirs(os.path.join(test_file_path, test_path),
mode=0o777,
exist_ok=True)
test_file_path = os.path.join(test_file_path, test_path)
test_stub = """from tests.base_test_case import BaseTestCase
class {name}(BaseTestCase):
def setUp(self):
self.BaseSetUp()
""".format(name=name_clean)
test_file_path = "{}/{}.py".format(test_file_path, name)
write_file(test_file_path, test_stub)
return name_clean, test_file_path
def decorated(*args, **kwargs):
if request.method == "GET":
return f(*args, **kwargs)
if not request.json:
return (
make_response(
jsonify(
{"msg": "Bad Request - Request Must be JSON Formatted"}
)
),
400,
)
payload = request.get_json()
if payload:
# Loop through all validation rules
for rule in rules:
rule_array = rule.split("|")
request_key = rule_array[0]
validators = rule_array[1].split(":")
# If the key is not in the request payload, and required is not part of the validator rules,
# Continue the loop to avoid key errors.
if request_key not in payload and "required" not in validators:
continue
# Loop all validators specified in the current rule
for validator in validators:
if (
validator == "int"
and type(payload[request_key]) is str
and not payload[request_key].isdigit()
):
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} must be integer".format(
request_key
)
}
)
),
400,
)
if validator == "float":
try:
float(payload[request_key])
except Exception:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} must be float".format(
request_key
)
}
)
),
400,
)
if (
validator == "required" and request_key not in payload
) or payload[request_key] == "":
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} is required".format(
request_key
)
}
)
),
400,
)
if validator.find("max") > -1:
max_value = int(validator.split("-")[1])
if int(payload[request_key]) > max_value:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} can only have a max value of {}".format(
request_key, max_value
)
}
)
),
400,
)
if validator.find("min") > -1:
min_value = int(validator.split("-")[1])
if int(payload[request_key]) < min_value:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} can only have a min value of {}".format(
request_key, min_value
)
}
)
),
400,
)
if validator.find("length") > -1:
length_value = int(validator.split("-")[1])
if len(str(payload[request_key])) > length_value:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} can only have a len of {}".format(
request_key, length_value
)
}
)
),
400,
)
if validator == "exists":
import importlib
from app.utils import to_pascal_case
repo_name = rule_array[2]
column_name = rule_array[3]
rep = "app.repositories.{}_repo".format(repo_name)
print("rep =>", rep)
import pdb
pdb.set_trace()
mod = importlib.import_module(rep)
repo_class = getattr(
mod, "{}Repo".format(to_pascal_case(repo_name))
)
repo = repo_class()
if type(payload[request_key]) == int:
v = repo.find_first(
**{column_name: payload[request_key]}
)
if not v:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} contains invalid {}(s) for {} table ".format(
request_key,
column_name,
repo_name,
)
}
)
),
400,
)
if type(payload[request_key]) == list:
for val in payload[request_key]:
v = repo.find_first(**{column_name: val})
if not v:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} contains invalid {}(s) for {} table ".format(
request_key,
column_name,
repo_name,
)
}
)
),
400,
)
if validator == "date" or validator == "time":
mapper = {
"date": {
"formatter": "%Y-%m-%d",
"format": "YYYY-MM-DD",
"type": "date",
},
"time": {
"formatter": "%H:%M",
"format": "Hrs:Mins. Eg 17:59",
"type": "time",
},
}
formatter = mapper.get(validator)
try:
datetime.strptime(
payload[request_key], formatter.get("formatter")
)
except Exception:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} should be valid {}. Format: {}".format(
request_key,
formatter.get("type"),
formatter.get("format"),
)
}
)
),
400,
)
if (
validator == "list"
and type(payload[request_key]) is not list
):
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} must be a list".format(
request_key
)
}
)
),
400,
)
if validator == "list_int":
if type(payload[request_key]) is not list:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} must be a list".format(
request_key
)
}
)
),
400,
)
for val in payload[request_key]:
if type(val) is not int:
return (
make_response(
jsonify(
{
"msg": "Bad Request - [{}] in list must be integer".format(
val
)
}
)
),
400,
)
# Validate enums
if Security.validate_enums(
validator, request_key, payload[request_key]
):
return Security.validate_enums(
validator, request_key, payload[request_key]
)
# validate emails
if Security.validate_email(validator, payload[request_key]):
return Security.validate_email(
validator, payload[request_key]
)
# validate urls
if Security.validate_url(validator, payload[request_key]):
return Security.validate_url(
validator, payload[request_key]
)
return f(*args, **kwargs)
def decorated(*args, **kwargs):
if not request.args:
return (
make_response(
jsonify(
{
"msg": "Bad Request - Request Must be Properly Formatted"
}
)
),
400,
)
arguments = request.args
if arguments:
for rule in rules:
rule_array = rule.split("|")
request_key = rule_array[0]
validators = rule_array[1].split(":")
# If the key is not in the request arguments, and required is not part of the validator rules,
# Continue the loop to avoid key errors.
if (
request_key not in arguments
and "required" not in validators
):
continue
# Loop all validators specified in the current rule
for validator in validators:
if (
validator == "int"
and type(arguments[request_key]) is str
and not arguments[request_key].isdigit()
):
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} must be integer".format(
request_key
)
}
)
),
400,
)
if validator == "range":
if ":" in arguments[request_key]:
elements_compare = arguments[request_key].split(":")
else:
return (
make_response(
jsonify(
{
"msg": "Bad Request - There must be a `:` separating the dates"
}
)
),
400,
)
try:
first_date = datetime.strptime(
str(elements_compare[0]), "%Y-%m-%d"
)
second_date = datetime.strptime(
str(elements_compare[1]), "%Y-%m-%d"
)
except Exception:
return (
make_response(
jsonify(
{
"msg": "Bad Request - dates {} and {} should be valid dates.Format: YYYY-MM-DD".format(
str(elements_compare[0]),
str(elements_compare[1]),
)
}
)
),
400,
)
if first_date > second_date:
return (
make_response(
jsonify(
{
"msg": "Bad Request - Start Date [{}] must be less than End Date[{}]".format(
first_date, second_date
)
}
)
),
400,
)
if validator == "float":
try:
float(arguments[request_key])
except Exception:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} must be float".format(
request_key
)
}
)
),
400,
)
if (
validator == "required" and request_key not in arguments
) or arguments[request_key] == "":
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} is required".format(
request_key
)
}
)
),
400,
)
if validator.find("max") > -1:
max_value = int(validator.split("-")[1])
if int(arguments[request_key]) > max_value:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} can only have a max value of {}".format(
request_key, max_value
)
}
)
),
400,
)
if validator.find("min") > -1:
min_value = int(validator.split("-")[1])
if int(arguments[request_key]) < min_value:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} can only have a min value of {}".format(
request_key, min_value
)
}
)
),
400,
)
if validator.find("length") > -1:
length_value = int(validator.split("-")[1])
if len(str(arguments[request_key])) > length_value:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} can only have a len of {}".format(
request_key, length_value
)
}
)
),
400,
)
if validator == "enum_options":
mapper = {
"action_type": ActionType,
"channels": Channels,
}
if not mapper.get(request_key, None):
return (
make_response(
jsonify(
{
"msg": "Bad Request - Invalid search field {}".format(
request_key
)
}
)
),
400,
)
if not mapper.get(request_key).has_value(
arguments[request_key]
):
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} can only have options: {}".format(
request_key,
str(
[
item.name
for item in mapper.get(
request_key
)
]
).strip("[]"),
)
}
)
),
400,
)
if validator == "exists":
import importlib
from app.utils import to_pascal_case
repo_name = rule_array[2]
column_name = rule_array[3]
rep = "app.repositories.{}_repo".format(repo_name)
import pdb
pdb.set_trace()
mod = importlib.import_module(rep)
repo_class = getattr(
mod, "{}Repo".format(to_pascal_case(repo_name))
)
repo = repo_class()
if type(arguments[request_key]) == int:
v = repo.find_first(
**{column_name: arguments[request_key]}
)
if not v:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} contains invalid {}(s) for {} table ".format(
request_key,
column_name,
repo_name,
)
}
)
),
400,
)
if type(arguments[request_key]) == list:
for val in arguments[request_key]:
v = repo.find_first(**{column_name: val})
if not v:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} contains invalid {}(s) for {} table ".format(
request_key,
column_name,
repo_name,
)
}
)
),
400,
)
if validator == "date":
try:
datetime.strptime(
arguments[request_key], "%Y-%m-%d"
)
except Exception:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} should be valid date. Format: YYYY-MM-DD".format(
request_key
)
}
)
),
400,
)
if (
validator == "list"
and type(arguments[request_key]) is not list
):
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} must be a list".format(
request_key
)
}
)
),
400,
)
if validator == "list_int":
if type(arguments[request_key]) is not list:
return (
make_response(
jsonify(
{
"msg": "Bad Request - {} must be a list".format(
request_key
)
}
)
),
400,
)
for val in arguments[request_key]:
if type(val) is not int:
return (
make_response(
jsonify(
{
"msg": "Bad Request - [{}] in list must be integer".format(
val
)
}
)
),
400,
)
return f(*args, **kwargs)
def decorated(*args, **kwargs):
if not request.args:
return make_response(
jsonify({
'msg':
'Bad Request - Request Must be Properly Formatted'
})), 400
arguments = request.args
if arguments:
for rule in rules:
rule_array = rule.split('|')
request_key = rule_array[0]
validators = rule_array[1].split(':')
# If the key is not in the request arguments, and required is not part of the validator rules,
# Continue the loop to avoid key errors.
if request_key not in arguments and 'required' not in validators:
continue
# Loop all validators specified in the current rule
for validator in validators:
if validator == 'int' and type(arguments[request_key]) is str \
and not arguments[request_key].isdigit():
return make_response(
jsonify({
'msg':
'Bad Request - {} must be integer'.
format(request_key)
})), 400
if validator == 'range':
if ':' in arguments[request_key]:
elements_compare = arguments[
request_key].split(':')
else:
return make_response(
jsonify({
'msg':
'Bad Request - There must be a `:` separating the dates'
})), 400
try:
first_date = datetime.strptime(
str(elements_compare[0]), '%Y-%m-%d')
second_date = datetime.strptime(
str(elements_compare[1]), '%Y-%m-%d')
except Exception as e:
return make_response(
jsonify({
'msg':
'Bad Request - dates {} and {} should be valid dates.\
Format: YYYY-MM-DD'.format(str(elements_compare[0]),
str(elements_compare[1]))
})), 400
if first_date > second_date:
return make_response(
jsonify({
'msg':
'Bad Request - Start Date [{}] must be less than End Date[{}]'
.format(first_date, second_date)
})), 400
if validator == 'float':
try:
float(arguments[request_key])
except Exception as e:
return make_response(
jsonify({
'msg':
'Bad Request - {} must be float'.
format(request_key)
})), 400
if (validator == 'required' and request_key not in arguments) \
or arguments[request_key] == '':
return make_response(
jsonify({
'msg':
'Bad Request - {} is required'.format(
request_key)
})), 400
if validator.find('max') > -1:
max_value = int(validator.split('-')[1])
if int(arguments[request_key]) > max_value:
return make_response(
jsonify({
'msg':
'Bad Request - {} can only have a max value of {}'
.format(request_key, max_value)
})), 400
if validator.find('min') > -1:
min_value = int(validator.split('-')[1])
if int(arguments[request_key]) < min_value:
return make_response(
jsonify({
'msg':
'Bad Request - {} can only have a min value of {}'
.format(request_key, min_value)
})), 400
if validator.find('length') > -1:
length_value = int(validator.split('-')[1])
if len(str(arguments[request_key])
) > length_value:
return make_response(
jsonify({
'msg':
'Bad Request - {} can only have a len of {}'
.format(request_key, length_value)
})), 400
if validator == 'enum_options':
mapper = {
'action_type': ActionType,
'channels': Channels
}
if not mapper.get(request_key, None):
return make_response(
jsonify({
'msg':
'Bad Request - Invalid search field {}'
.format(request_key)
})), 400
if not mapper.get(request_key).has_value(
arguments[request_key]):
return make_response(
jsonify({
'msg':
'Bad Request - {} can only have options: {}'
.format(
request_key,
str([
item.name for item in
mapper.get(request_key)
]).strip('[]'))
})), 400
if validator == 'exists':
import importlib
from app.utils import to_pascal_case
repo_name = rule_array[2]
column_name = rule_array[3]
rep = 'app.repositories.{}_repo'.format(
repo_name)
mod = importlib.import_module(rep)
repo_class = getattr(
mod,
'{}Repo'.format(to_pascal_case(repo_name)))
repo = repo_class()
if type(arguments[request_key]) == int:
v = repo.find_first(
**
{column_name: arguments[request_key]})
if not v:
return make_response(
jsonify({
'msg':
'Bad Request - {} contains invalid {}(s) for {} table '
.format(
request_key, column_name,
repo_name)
})), 400
if type(arguments[request_key]) == list:
for val in arguments[request_key]:
v = repo.find_first(
**{column_name: val})
if not v:
return make_response(
jsonify({
'msg':
'Bad Request - {} contains invalid {}(s) for {} table '
.format(
request_key,
column_name, repo_name)
})), 400
if validator == 'date':
try:
datetime.strptime(arguments[request_key],
'%Y-%m-%d')
except Exception as e:
return make_response(
jsonify({
'msg':
'Bad Request - {} should be valid date. Format: YYYY-MM-DD'
.format(request_key)
})), 400
if validator == 'list' and type(
arguments[request_key]) is not list:
return make_response(
jsonify({
'msg':
'Bad Request - {} must be a list'.
format(request_key)
})), 400
if validator == 'list_int':
if type(arguments[request_key]) is not list:
return make_response(
jsonify({
'msg':
'Bad Request - {} must be a list'.
format(request_key)
})), 400
for val in arguments[request_key]:
if type(val) is not int:
return make_response(
jsonify({
'msg':
'Bad Request - [{}] in list must be integer'
.format(val)
})), 400
return f(*args, **kwargs)
def decorated(*args, **kwargs):
if not request.json:
return make_response(
jsonify({
'msg':
'Bad Request - Request Must be JSON Formatted'
})), 400
payload = request.get_json()
if payload:
# Loop through all validation rules
for rule in rules:
rule_array = rule.split('|')
request_key = rule_array[0]
validators = rule_array[1].split(':')
# If the key is not in the request payload, and required is not part of the validator rules,
# Continue the loop to avoid key errors.
if request_key not in payload and 'required' not in validators:
continue
# Loop all validators specified in the current rule
for validator in validators:
if validator == 'int' and type(
payload[request_key]
) is str and not payload[request_key].isdigit():
return make_response(
jsonify({
'msg':
'Bad Request - {} must be integer'.
format(request_key)
})), 400
if validator == 'float':
try:
float(payload[request_key])
except Exception as e:
return make_response(
jsonify({
'msg':
'Bad Request - {} must be float'.
format(request_key)
})), 400
if (validator == 'required'
and request_key not in payload
) or payload[request_key] == '':
return make_response(
jsonify({
'msg':
'Bad Request - {} is required'.format(
request_key)
})), 400
if validator.find('max') > -1:
max_value = int(validator.split('-')[1])
if int(payload[request_key]) > max_value:
return make_response(
jsonify({
'msg':
'Bad Request - {} can only have a max value of {}'
.format(request_key, max_value)
})), 400
if validator.find('min') > -1:
min_value = int(validator.split('-')[1])
if int(payload[request_key]) < min_value:
return make_response(
jsonify({
'msg':
'Bad Request - {} can only have a min value of {}'
.format(request_key, min_value)
})), 400
if validator.find('length') > -1:
length_value = int(validator.split('-')[1])
if len(str(
payload[request_key])) > length_value:
return make_response(
jsonify({
'msg':
'Bad Request - {} can only have a len of {}'
.format(request_key, length_value)
})), 400
if validator == 'exists':
import importlib
from app.utils import to_pascal_case
repo_name = rule_array[2]
column_name = rule_array[3]
rep = 'app.repositories.{}_repo'.format(
repo_name)
mod = importlib.import_module(rep)
repo_class = getattr(
mod,
'{}Repo'.format(to_pascal_case(repo_name)))
repo = repo_class()
if type(payload[request_key]) == int:
v = repo.find_first(
**{column_name: payload[request_key]})
if not v:
return make_response(
jsonify({
'msg':
'Bad Request - {} contains invalid {}(s) for {} table '
.format(
request_key, column_name,
repo_name)
})), 400
if type(payload[request_key]) == list:
for val in payload[request_key]:
v = repo.find_first(
**{column_name: val})
if not v:
return make_response(
jsonify({
'msg':
'Bad Request - {} contains invalid {}(s) for {} table '
.format(
request_key,
column_name, repo_name)
})), 400
if validator == 'date' or validator == 'time':
mapper = {
'date': {
'formatter': '%Y-%m-%d',
'format': 'YYYY-MM-DD',
'type': 'date',
},
'time': {
'formatter': '%H:%M',
'format': 'Hrs:Mins. Eg 17:59',
'type': 'time'
}
}
formatter = mapper.get(validator)
try:
datetime.strptime(
payload[request_key],
formatter.get('formatter'))
except Exception as e:
return make_response(
jsonify({
'msg':
'Bad Request - {} should be valid {}. Format: {}'
.format(request_key,
formatter.get('type'),
formatter.get('format'))
})), 400
if validator == 'list' and type(
payload[request_key]) is not list:
return make_response(
jsonify({
'msg':
'Bad Request - {} must be a list'.
format(request_key)
})), 400
if validator == 'list_int':
if type(payload[request_key]) is not list:
return make_response(
jsonify({
'msg':
'Bad Request - {} must be a list'.
format(request_key)
})), 400
for val in payload[request_key]:
if type(val) is not int:
return make_response(
jsonify({
'msg':
'Bad Request - [{}] in list must be integer'
.format(val)
})), 400
# Validate enums
if Security.validate_enums(validator, request_key,
payload[request_key]):
return Security.validate_enums(
validator, request_key,
payload[request_key])
# validate emails
if Security.validate_email(validator,
payload[request_key]):
return Security.validate_email(
validator, payload[request_key])
# validate urls
if Security.validate_url(validator,
payload[request_key]):
return Security.validate_url(
validator, payload[request_key])
return f(*args, **kwargs)
def decorated(*args, **kwargs):
if not request.json:
return make_response(jsonify({'msg': 'Bad Request - Request Must be JSON Formatted'})), 400
payload = request.get_json()
if payload:
# Loop through all validation rules
for rule in rules:
rule_array = rule.split('|')
request_key = rule_array[0]
validators = rule_array[1].split(':')
# If the key is not in the request payload, and required is not part of the validator rules,
# Continue the loop to avoid key errors.
if request_key not in payload and 'required' not in validators:
continue
# Loop all validators specified in the current rule
for validator in validators:
if validator == 'int' and type(payload[request_key]) is str and not payload[request_key].isdigit():
return make_response(
jsonify({'msg': 'Bad Request - {} must be integer'.format(request_key)})), 400
if validator == 'float':
try:
float(payload[request_key])
except Exception as e:
return make_response(
jsonify({'msg': 'Bad Request - {} must be float'.format(request_key)})), 400
if (validator == 'required' and request_key not in payload) or payload[request_key] == '':
return make_response(
jsonify({'msg': 'Bad Request - {} is required'.format(request_key)})), 400
if validator.find('max') > -1:
max_value = float(validator.split('-')[1])
if float(payload[request_key]) > max_value:
return make_response(jsonify({
'msg': 'Bad Request - {} must have a max value of {}'.format(
request_key, max_value)})), 400
if validator.find('min') > -1:
min_value = float(validator.split('-')[1])
if float(payload[request_key]) < min_value:
return make_response(jsonify({
'msg': 'Bad Request - {} must have a min value of {}'.format(
request_key, min_value)})), 400
if validator.find('length') > -1:
length_value = int(validator.split('-')[1])
if len(str(payload[request_key])) > length_value:
return make_response(jsonify({
'msg': 'Bad Request - {} can only have a length of {}'.format(
request_key, length_value)})), 400
if validator == 'exists' or validator == 'exist':
import importlib
from app.utils import to_pascal_case
repo_name = rule_array[2]
column_name = rule_array[3]
rep = 'app.repositories.{}_repo'.format(repo_name)
mod = importlib.import_module(rep)
repo_class = getattr(mod, '{}Repo'.format(to_pascal_case(repo_name)))
repo = repo_class()
if type(payload[request_key]) == list:
for val in payload[request_key]:
v = repo.find_first(**{column_name: val, 'is_deleted': False})
if not v:
return make_response(jsonify({
'msg': 'Bad Request - {} contains invalid {}(s) for {} table '.format(
request_key, column_name,
repo_name)})), 400
else:
v = repo.find_first(**{column_name: payload[request_key]})
if not v:
return make_response(jsonify({
'msg': 'Bad Request - {} contains invalid {}(s) for {} table '.format(
request_key, column_name,
repo_name)})), 400
if validator == 'notexist' or validator == 'not_exist' or validator == 'not-exist':
import importlib
from app.utils import to_pascal_case
repo_name = rule_array[2]
column_name = rule_array[3]
rep = 'app.repositories.{}_repo'.format(repo_name)
mod = importlib.import_module(rep)
repo_class = getattr(mod, '{}Repo'.format(to_pascal_case(repo_name)))
repo = repo_class()
if type(payload[request_key]) == list:
for val in payload[request_key]:
v = repo.find_first(**{column_name: val})
if v:
return make_response(jsonify({
'msg': 'Bad Request - One or more {} already exists in {} table '.format(
request_key, repo_name)})), 400
else:
v = repo.find_first(**{column_name: payload[request_key]})
if v:
return make_response(jsonify({
'msg': 'Bad Request - {} already exists in {} table '.format(request_key,
repo_name)})), 400
if validator == 'date':
try:
datetime.strptime(payload[request_key], '%Y-%m-%d')
except Exception as e:
return make_response(jsonify({
'msg': 'Bad Request - {} should be valid date. Format: YYYY-MM-DD'.format(
request_key)})), 400
if validator == 'list' and (
type(payload[request_key]) is not list or len(payload[request_key]) < 1):
return make_response(jsonify(
{'msg': 'Bad Request - {} must be a non empty list'.format(request_key)})), 400
if validator == 'list_int':
if type(payload[request_key]) is not list:
return make_response(jsonify(
{'msg': 'Bad Request - {} must be a list'.format(
request_key)})), 400
if len(payload[request_key]) < 1:
return make_response(
jsonify({'msg': 'Bad Request - {} list is empty'.format(request_key)})), 400
for val in payload[request_key]:
if type(val) is not int:
return make_response(jsonify(
{'msg': 'Bad Request - [{}] in list must be integer'.format(val)})), 400
return f(*args, **kwargs)