def get_rules(valid_users_list, valid_teams_list):
# Audit log attributes needs to meet the following rules.
rules = {
constant.USER_ATTRIBUTE: [Required, In(valid_users_list), Length(5, maximum=100)],
constant.TEAM_ATTRIBUTE: [Required, In(valid_teams_list), Length(5, maximum=100)],
constant.COMPONENT_ATTRIBUTE:[Required, Length(5, maximum=100), Pattern(name_regex)],
constant.SUB_COMPONENT_ATTRIBUTE:[Required, Length(5, maximum=100), Pattern(name_regex)]
}
return rules
def paramsvalidator(payload):
rules = {
"name": [InstanceOf(str)],
"uuid": [
If(
InstanceOf(str),
Then(
Pattern(
"\w\w\w\w\w\w\w\w-\w\w\w\w-\w\w\w\w-\w\w\w\w-\w\w\w\w\w\w\w\w\w\w\w\w"
)))
], # Example UUID = 8243c413-2575-461e-87e8-5f203c611223
"rarity": [
If(InstanceOf(str),
Then(In(["Epic", "Legendary", "Rare", "Uncommon", "Common"])))
],
"hex_type":
[If(InstanceOf(str), Then(In(["Card", "Equipment", "Pack"])))],
"hex_set": [
If(
InstanceOf(str),
Then(
In([
"AI Only Cards", "Armies of Myth", "AZ1", "AZ2",
"Dead of Winter", "Frostheart",
"Frostheart Core Commons", "Herofall", "Primal Dawn",
"PvE 01 Universal Card Set", "Scars of War",
"Set01 Kickstarter", "Set01 PvE Arena",
"Set01 PvE Holiday", "Set03 PvE Promo",
"Set04 PvE Promo", "Set05 PvE Promo",
"Set06 PvE Promo", "Set07 PvE Promo",
"Set08 PvE Promo", "Shards of Fate",
"Shattered Destiny"
])))
],
"limit":
[If(InstanceOf(int), Then(InstanceOf(int)))
], # teger - Limits the quantity of returned results (default: 25)
"offset":
[If(InstanceOf(int), Then(InstanceOf(int)))
], #Integer - Skips offset articles before returning (default: 0)
"contains": [If(InstanceOf(str), Then(InstanceOf(bool)))],
"currency": [If(InstanceOf(str),
Then(In(["Gold", "Platinum"])))], # In Game currency
"start": [
Pattern("\d\d\d\d-\d\d-\d\d")
], # String - A valid date representation, such as "2016-01-01" (default: the date for the time of the request in CET timezone - 31 days)
"end": [
Pattern("\d\d\d\d-\d\d-\d\d")
] # String - same as above (default: the date of the time of the request in CET timezone)
}
results = validate(rules, payload)
return results.valid
def get_rules(valid_users_list, valid_teams_list, valid_component_list,
valid_sub_component_list):
# Audit log attributes needs to meet the following rules.
rules = {
constant.USER_ATTRIBUTE: [Required, In(valid_teams_list)],
constant.TEAM_ATTRIBUTE: [Required, In(valid_users_list)],
constant.COMPONENT_ATTRIBUTE: [Required,
In(valid_sub_component_list)],
constant.SUB_COMPONENT_ATTRIBUTE: [
Required,
Pattern(alpha_numeric_regex),
Not(In(valid_component_list))
]
}
return rules
def validator_doc(doc_data):
results = {}
result_errors = {}
validation = {
'doc_tab': [Required, In(tab)],
'model_id':
[Required,
Length(0, maximum=50), lambda x: isinstance(x, str)],
'doc_content': [Required, lambda x: isinstance(x, list)]
}
res = validate(validation, doc_data)
result_errors.update(res.errors)
if isinstance(doc_data['doc_content'], list):
for content in doc_data['doc_content']:
validation = {
'language': [Required, In(language)],
'doc_name': [
Required,
Length(0, maximum=50), lambda x: isinstance(x, str)
],
'content_title': [
Required,
Length(0, maximum=200), lambda x: isinstance(x, str)
],
'developer':
[Length(0, maximum=50), lambda x: isinstance(x, str)],
'brief_intro': [lambda x: isinstance(x, dict)],
'method': [lambda x: isinstance(x, dict)],
'model_evaluation': [lambda x: isinstance(x, dict)],
'data_set_size': [lambda x: isinstance(x, dict)],
'ethnicity': [lambda x: isinstance(x, dict)],
'limitation': [lambda x: isinstance(x, dict)],
'return_params': [lambda x: isinstance(x, dict)],
'state_explain': [lambda x: isinstance(x, dict)],
'example_result': [lambda x: isinstance(x, dict)],
'ref': [lambda x: isinstance(x, list)]
}
content_res = validate(validation, content)
result_errors.update(content_res.errors)
valid = True
if result_errors:
valid = False
results['errors'] = result_errors
results['valid'] = valid
return results
def check_exists(self):
users = User.all()
self.messages({'username': '******'})
self.request.request_variables[
'username'] = self.request.request_variables['username'].lower()
return self.validate({
'username': [
Required,
Not(In(users.pluck('name').map(lambda item: item.lower())))
]
})
def validate_input(self, data):
users = User.all()
rules = {
'name': [Required, Not(Blank()), Length(3)],
'email': [Required,
Not(Blank()),
Not(In(users.pluck('email')))],
'password': [Required, Not(Blank()),
Length(6)],
}
return validate(rules, data)
def is_ws_msg_valid(self, from_user_id, data):
obj = json.loads(data)
if 'type' not in obj:
LOG.error("user {0} ###is_ws_msg_valid### type is not existed".format(self.client_id))
return False
rules = {
"target": [Required, Pattern('[\S]{1,300}')],
"payload": [Required, Pattern('[\s]{0,}[\S]{1,}')],
"type": [In(["txt", "audio", "img"])]
}
if obj['type'] == 'img':
rules.update({
"width": [Range(1, 10000)],
"height": [Range(1, 10000)],
})
validate_result = validate(rules, obj)
if not validate_result.valid:
LOG.error("user {0} ###is_ws_msg_valid #### msg format is not valid, {1}".format(self.client_id, obj))
return False
if obj['target']:
try:
t = obj['target'].split(':')
if t[0] == 'user':
# check target user is friend
user_key = "{0}:friendlist".format(from_user_id)
f = self.r.zscan(user_key, 0, t[1], 1)
if not f and len(f[1]) == 0:
LOG.error("user {0} ###is_ws_msg_valid###sender and receiver is not friend.".format(
self.client_id))
return False
elif t[0] == 'room':
# check is member of group
room_key = "room:{0}".format(t[1])
f = self.r.sscan_iter(room_key, from_user_id, 1)
if not f and len(f[1]) == 0:
LOG.error("user {0} ###is_ws_msg_valid###sender is not member of group".format(self.client_id))
return False
else:
LOG.error("user {0} ###is_ws_msg_valid### target is not correct".format(self.client_id))
return False
except ValueError:
LOG.error("user {0} ###is_ws_msg_valid### target content error".format(self.client_id))
return False
else:
LOG.error("user {0} ###is_ws_msg_valid### target is not exist".format(self.client_id))
return False
return True
def login(self):
users = User.all()
self.messages({
'username': '******',
'password': '******',
})
return self.validate({
'username': [
Required,
Length(1, 35),
In(users.pluck('email').map(lambda item: item.lower()))
],
'password': [Required, Length(1)]
})
def register(self):
users = User.all()
self.messages({
'email':
'That email already exists',
'username':
'******'
})
return self.validate({
'username': [Required, Length(3, 20)],
'email': [Required,
Length(1),
Not(In(users.pluck('email')))],
'password': [Required]
})
def validate_item(item,sources=None,verbose=True):
'''validate_item will validate a single item objects, intended to go in as a field to
a POST. For more than one item, use validate_items wrapper
:param item: the item object. Must include the following:
:param sources: a list of valid item sources (eg ["pacs"])
:param verbose: if True, prints out valid True messages. False (errors) always printed
:: notes
{
# generic attribute/values just to store, not interpreted
"id":"123123123123123", // mandatory
# the issuer for the above id
# mandatory, or maybe optional with default of "stanford" or "unspecified"
"id_source":"pacs",
# when the id was looked up, to help with changed/merged ids
# optional with default of current timestamp?
"id_timestamp":"2016-01-30T17:15:23.123Z",
# optional key/value attributes, will be stored as-is if provided, but not used or interpreted
# values will be updated/replaced if sent multiple times (last received wins)
# any existing values will be preserved if not explicitly set here; set empty string to remove
"custom_fields":{
"image_type":"x-ray",
"resolution":"high"
}
'''
if sources == None:
sources = item_sources
# These are the rules for an item
rules = {
"id": [Required, Pattern("^[A-Za-z0-9_-]*$")], # pattern
"id_source": [Required, In(sources)], # must be in item sources
"id_timestamp": [Required,Pattern(timestamp)],
}
valid,message = validate(rules, item)
if verbose == True:
bot.debug("identifier %s data structure valid: %s" %(item['id'],valid))
if valid == False:
bot.error(message)
if verbose == True:
print(item)
return valid
def receive_items(items):
'''receive items will validate reception of an items list.
:param items: the items list from a response
HTTP 200
'items': [
{
'id_source': 'GE PACS',
'jittered_timestamp': '2016-01-15T17:15:23.123Z',
'id': 'A654321',
'suid': '103e'
}
]
'''
expected_fields = [
'id_source', 'jittered_timestamp', 'suid', 'id', 'custom_fields'
]
if not isinstance(items, list):
bot.error("Items must be a list")
return False
# These are the rules for each uidEntity
rules = {
"id": [Required, Pattern("^[A-Za-z0-9_-]*$")], # pattern
"suid": [Required, Pattern("^[A-Za-z0-9_-]*$")], # the suid
"id_source": [Required, In(item_sources)], # must be in person sources
"jittered_timestamp": [Required, Pattern(timestamp)]
}
for item in items:
# Validate required fields
valid, message = validate(rules, item)
if valid == False:
bot.error(message)
return valid
# Validate fields returned in response
if not validate_fields(expected_fields, item.keys()):
return False
return valid
def validar_login(self,request):
header_controller=HeaderController()
login_model=LoginModel()
estado_header,codigo_header=header_controller.validar_header(request.headers)
if(estado_header == True):
token=request.headers['Authorization']
verificartoken=Token()
estado_token,codigo_token=verificartoken.validar_token_fb(token)
if estado_token == True:
validaciones=Validaciones();
estado_json,codigo_json=validaciones.validar_json(request)
if estado_json:
rules = {
"uid_cliente": [Required],
"tipo_cliente": [Required,In(["ADMIN", "GERENTE", "ADMIN_TIENDAS", "CLIENTES"])],
}
respuesta=validate(rules, request.json)
if(respuesta[0]):
estado_vacio,codigo_vacio=validaciones.validar_campos_vacios(request.json)
if estado_vacio:
uid_cliente=request.json['uid_cliente']
tipo_cliente=request.json['tipo_cliente']
estado_login,codigo_model=login_model.validarlogin(uid_cliente,tipo_cliente)
if estado_login:
if tipo_cliente == 'ADMIN_TIENDAS':
return {'estado':True,'mensaje':'login exitoso','uid_tienda':codigo_model}
else:
return {'estado':True,'mensaje':'login exitoso'}
else:
return {'estado':False,'codigo':codigo_model}
else:
return {'estado':False,'codigo':codigo_vacio}
else:
codigo = generador.validarGuardarInformacionError("000","validar si trae los parametros necesario- no se enviaron los parametros- login_controller","post",'')
return {'estado':False,'codigo':codigo}
else:
return {'estado':False,'codigo':codigo_json}
else:
return {'estado':False,'codigo':codigo_token}
else:
return {'estado':False,'codigo':codigo_header}
def test_valid():
rules = {
"foo": [Required, Length(8,8)], # foo must be exactly equal to 123
"bar": [Required, Truthy()], # bar must be equivalent to True
"baz": [In(["spam", "eggs", "bacon"])], # baz must be one of these options
"qux": [Not(Range(1, 100))] # qux must not be a number between 1 and 100 inclusive
}
# then this following dict would pass:
passes = {
"foo": '20191027',
"bar": True, # or a non-empty string, or a non-zero int, etc...
"baz": "sp2am",
"qux": 101
}
valid,errors = validate(rules,passes) # 姿势 2
print valid
print errors
print type(valid)
print type(errors)
def validate_identifiers(identifiers,id_sources=None,item_sources=None,verbose=True):
'''validate_identifiers will validate one or more identifier objects,
intended to go in as a field to a POST
:param identifiers: the identifiers object.
:param verbose: verbose output for items
:param identifier_sources: a list of one or more identifier sources.
:param item_sources: a list of one or more item sources
If either not defined, default to use standards
:: notes
{
# mandatory key for uniquely identifying the person
"id":"1234567-8",
# the issuer for the above id
# mandatory, or maybe optional with default of "stanford" or "unspecified"
"id_source":"stanford",
# when the id was looked up, to help with changed/merged ids
# optional with default of current timestamp?
"id_timestamp":"2016-01-30T17:15:23.123Z",
# optional key/value attributes, will be stored as-is if provided, but not used or interpreted
# values will be updated/replaced if sent multiple times (last received wins)
# any existing values will be preserved if not explicitly set here; set empty string to remove
"custom_fields":{
"first_name":"Joe",
"last_name":"Smith",
"dob":"1970-02-28"
}
'''
if id_sources == None:
id_sources = identifier_sources
# These are the rules for a person
rules = {
"id": [Required, Pattern("^[A-Za-z0-9_-]*$")], # pattern
"id_source": [Required, In(id_sources)], # must be in person sources
"id_timestamp": [Required,Pattern(timestamp)],
}
if not isinstance(identifiers,dict):
bot.error("Identifiers data structure must be dictionary.")
return False
if "identifiers" not in identifiers:
bot.error("identifiers key not found in data structure.")
items = identifiers['identifiers']
if not isinstance(items,list):
bot.error("Items in identifiers data structure must be list.")
return False
for item in items:
valid,message = validate(rules, item)
if valid == False:
bot.error(message)
return valid
if "items" in item:
validate_items(item['items'],sources=item_sources)
bot.debug("Identifiers data structure valid: %s" %valid)
return valid
def registrar_producto(self, request):
estado_header, codigo_header = header_controller.validar_header(
request.headers)
if estado_header:
token = request.headers['Authorization']
estado_token, codigo_token = verificartoken.validar_token_fb(token)
if estado_token:
estado_json, codigo_json = validaciones.validar_json(request)
if estado_json:
rules = {
"uid_usuario": [Required],
"nombre_producto": [Required],
"referencia_producto": [Required],
"precio_producto": [Required],
"cantidad_producto": [Required],
"producto_imagen": [Required],
"descripcion": [Required],
"categoria": [
Required,
In([
"aseo", "bebidas", "bebidas-alcoholicas",
"carnes", "lacteos", "pasabocas", "frutas",
"medicamentos", "mascotas"
])
]
}
respuesta = validate(rules, request.json)
if (respuesta[0]):
estado_vacio, codigo_vacio = validaciones.validar_campos_vacios(
request.json)
if estado_vacio:
uid_usuario = request.json['uid_usuario']
estado_uid_token, codigo_uid_token = validaciones.validar_uid_token(
uid_usuario, codigo_token)
if estado_uid_token:
estado_permiso, codigo_permiso = validaciones.validar_permiso_admin_gerente_admintienda(
uid_usuario)
if estado_permiso:
referencia_producto = request.json[
'referencia_producto']
estado_referencia, codigo_referencia = validaciones.validar_referencia_producto(
referencia_producto)
if estado_referencia:
producto_model = ProductoModel()
estado_guardar_producto, codigo_guardar_producto = producto_model.registrar_producto(
request.json)
if estado_guardar_producto:
return {
'estado':
estado_guardar_producto,
'mensaje':
'su producto se guardo con exitoso'
}
else:
return {
'estado': False,
'codigo':
codigo_guardar_producto
}
else:
return {
'estado': False,
'codigo': codigo_referencia
}
else:
return {
'estado': False,
'codigo': codigo_permiso
}
else:
return {
'estado': False,
'codigo': codigo_uid_token
}
else:
return {'estado': False, 'codigo': codigo_vacio}
else:
codigo = generador.validarGuardarInformacionError(
"000",
"validar si trae los parametros necesario- no se enviaron los parametros- producto_controller",
"post", '')
return {'estado': False, 'codigo': codigo}
else:
return {'estado': False, 'codigo': codigo_json}
else:
return {'estado': False, 'codigo': codigo_token}
else:
return {'estado': False, 'codigo': codigo_header}
def validate_check(conf_data):
"""Validate configuration file.
Parameters
----------
conf_data: dict
Dictionary containing all parameters and objects.
Returns
-------
conf_data: dict
Dictionary containing all parameters and objects.
"""
"""
TODO:
- Add more checks for correctness of values in the config file.
- Throw appropriate error.
- Change to try-catch.
- Check '' or None for datapath
"""
rules_generator = {
"choice": [
Required,
In([
"gan", "cgan", "wgan", "wgan_gp", "dcgan", "custom", "seq_gan"
])
]
}
rules_discriminator = {
"choice": [
Required,
In([
"gan", "cgan", "wgan", "wgan_gp", "dcgan", "custom", "seq_gan"
])
]
}
rules_model = {}
rules = {"data_path": [Required, Truthy()]}
validation_1 = validate(rules_generator, conf_data['generator'])
validation_2 = validate(rules_discriminator, conf_data['discriminator'])
validation_3 = validate(rules, conf_data)
#validation_4 = validate(rules_model,conf_data['GAN_model'])
#if (validation_1[0] and validation_2[0] and validation_3[0] and validation_4[0]) == False:
if (validation_1[0] and validation_2[0] and validation_3[0]) == False:
print("Errors")
print("------")
if validation_1[0] is False:
print("Generator --> ")
print(validation_1[1])
if validation_2[0] is False:
print("Discriminator --> ")
print(validation_2[1])
if validation_3[0] is False:
print("Others --> ")
print(validation_3[1])
# if validation_4[0] is False:
# print ("Model --> ")
# print (validation_4[1])
exit()
def receive_identifiers(response):
'''receive identifiers will validate reception of an identifiers response.
This should be a list
:param response: the response list of identifiers
:: notes
successful response:
HTTP 200
[
{'jittered_timestamp': '2016-01-30T17:15:23.123Z',
'id': '12345678',
'suid': '103e',
'id_source': 'Stanford MRN',
'custom_fields': [
{'key': 'studySiteID', 'value': '78329'}],
'items': [
{
'id_source': 'GE PACS',
'jittered_timestamp': '2016-01-15T17:15:23.123Z',
'id': 'A654321',
'suid': '103e'}
]}
]
'''
# These fields are expected, but not required. We will error
# if any fields are present outside this scope
expected_fields = [
'items', 'id_source', 'jittered_timestamp', 'suid', 'id',
'custom_fields'
]
if not isinstance(response, list):
bot.error("Response must be a list")
return False
# These are the rules for each uidEntity
rules = {
"id": [Required, Pattern("^[A-Za-z0-9_-]*$")], # pattern
"suid": [Required, Pattern("^[A-Za-z0-9_-]*$")], # the suid
"id_source": [Required,
In(identifier_sources)], # must be in identifer sources
"jittered_timestamp": [Required, Pattern(timestamp)]
}
for item in response:
# Validate required fields
valid, message = validate(rules, item)
if valid == False:
bot.error(message)
return valid
# Validate fields returned in response
if not validate_fields(expected_fields, item.keys()):
return False
# Validate items
if "items" in item:
if not receive_items(item['items']):
return False
bot.debug("Identifiers data structure valid: %s" % valid)
return valid
def registrar_usuario_adm(self, request):
estado_header, codigo_header = header_controller.validar_header(
request.headers)
if estado_header:
token = request.headers['Authorization']
estado_token, codigo_token = verificartoken.validar_token_fb(token)
if estado_token:
estado_json, codigo_json = validaciones.validar_json(request)
if estado_json:
rules = {
"uid_usuario": [Required],
"nombre_usuario_registrar": [Required],
"apellido_usuario_registrar": [Required],
"telefono_usuario_registrar": [Required],
"correo_usuario_registrar": [Required],
"password_usuario_registrar": [Required],
"tipo_usuario_registrar":
[Required, In(["GERENTE", "ADMIN_TIENDAS"])]
}
respuesta = validate(rules, request.json)
if (respuesta[0]):
estado_vacio, codigo_vacio = validaciones.validar_campos_vacios(
request.json)
if estado_vacio:
uid_usuario = request.json['uid_usuario']
estado_uid_token, codigo_uid_token = validaciones.validar_uid_token(
uid_usuario, codigo_token)
if estado_uid_token:
correo_usuario = request.json[
'correo_usuario_registrar']
telefono_usuario = request.json[
'telefono_usuario_registrar']
estado_email_telefono, codigo_email_telefono = validaciones.validar_email_telefono(
correo_usuario, telefono_usuario)
if estado_email_telefono:
tipo_usuario = request.json[
'tipo_usuario_registrar']
if tipo_usuario == 'GERENTE':
estado_permisoadmin, codigo_permisoadmin = validaciones.validar_tipo_admin(
uid_usuario)
if estado_permisoadmin:
registrar_model = RegistrarModel()
estado_registrar, codigo_registrar = registrar_model.registrar_usuario_cliente(
request.json, tipo_usuario)
if estado_registrar:
return {
'estado': estado_registrar,
'mensaje':
'registro existoso'
}
else:
{
'estado': False,
'codigo': codigo_registrar
}
else:
return {
'estado': False,
'codigo': codigo_permisoadmin
}
elif tipo_usuario == 'ADMIN_TIENDAS':
estado_permisoadmingerente, codigo_permisoadmingerente = validaciones.validar_tipo_admin_gerente(
uid_usuario)
if estado_permisoadmingerente:
registrar_model = RegistrarModel()
estado_registrar, codigo_registrar = registrar_model.registrar_usuario_cliente(
request.json, tipo_usuario)
if estado_registrar:
return {
'estado': estado_registrar,
'mensaje':
'registro existoso'
}
else:
{
'estado': False,
'codigo': codigo_registrar
}
else:
return {
'estado':
False,
'codigo':
codigo_permisoadmingerente
}
else:
return {
'estado': False,
'codigo': codigo_email_telefono
}
else:
return {
'estado': False,
'codigo': codigo_uid_token
}
else:
return {'estado': False, 'codigo': codigo_vacio}
else:
codigo = generador.validarGuardarInformacionError(
"000",
"validar si trae los parametros necesario- no se enviaron los parametros- registrar_controller",
"post", '')
return {'estado': False, 'codigo': codigo}
else:
return {'estado': False, 'codigo': codigo_json}
else:
return {'estado': False, 'codigo': codigo_token}
else:
return {'estado': False, 'codigo': codigo_header}
def registrar_tienda(self, request):
estado_header, codigo_header = header_controller.validar_header(
request.headers)
if estado_header:
token = request.headers['Authorization']
estado_token, codigo_token = verificartoken.validar_token_fb(token)
if estado_token:
estado_json, codigo_json = validaciones.validar_json(request)
if estado_json:
rules = {
"uid_usuario": [Required],
"nombre_tienda_registrar": [Required],
"latitud_tienda": [Required],
"longitud_tienda": [Required],
"zona_influencia": [Required,
In([1, 2, 3, 4, 5])],
}
respuesta = validate(rules, request.json)
if (respuesta[0]):
estado_vacio, codigo_vacio = validaciones.validar_campos_vacios(
request.json)
if estado_vacio:
uid_usuario = request.json['uid_usuario']
estado_uid_token, codigo_uid_token = validaciones.validar_uid_token(
uid_usuario, codigo_token)
if estado_uid_token:
estado_permisoadmingerente, codigo_permisoadmingerente = validaciones.validar_tipo_admin_gerente(
uid_usuario)
if estado_permisoadmingerente:
latitud_tienda = request.json[
'latitud_tienda']
longitud_tienda = request.json[
'longitud_tienda']
estado_cordenadas, codigo_cordenadas = validaciones.validar_cordenadas(
latitud_tienda, longitud_tienda)
if estado_cordenadas:
zona_influencia = request.json[
'zona_influencia']
estado_zona_influencia, codigo_zona_influencia = validaciones.validar_zona_influencia(
zona_influencia)
if estado_zona_influencia:
registrar_model = RegistrarModel()
estado_registrar, codigo_registrar = registrar_model.registrar_tienda(
request.json)
if estado_registrar:
return {
'estado': True,
'mensaje':
'registro exitoso'
}
else:
return {
'estado': False,
'codigo': codigo_registrar
}
else:
return {
'estado': False,
'codigo':
codigo_zona_influencia
}
else:
return {
'estado': False,
'codigo': codigo_cordenadas
}
else:
return {
'estado': False,
'codigo': codigo_permisoadmingerente
}
else:
return {
'estado': False,
'codigo': codigo_uid_token
}
else:
return {'estado': False, 'codigo': codigo_vacio}
else:
codigo = generador.validarGuardarInformacionError(
"000",
"validar si trae los parametros necesario- no se enviaron los parametros- registrar_controller",
"post", '')
return {'estado': False, 'codigo': codigo}
else:
return {'estado': False, 'codigo': codigo_json}
else:
return {'estado': False, 'codigo': codigo_token}
else:
return {'estado': False, 'codigo': codigo_header}
def actualizar_estado_pedido(self, request):
estado_header, codigo_header = header_controller.validar_header(
request.headers)
if estado_header:
token = request.headers['Authorization']
estado_token, codigo_token = verificartoken.validar_token_fb(token)
if estado_token:
estado_json, codigo_json = validaciones.validar_json(request)
if estado_json:
rules = {
"uid_usuario": [Required],
"uid_pedido": [Required],
"estado_pedido": [
Required,
In([
"En tienda", "En despacho", "En reparto",
"Entregado"
])
],
}
respuesta = validate(rules, request.json)
if (respuesta[0]):
estado_vacio, codigo_vacio = validaciones.validar_campos_vacios(
request.json)
if estado_vacio:
uid_usuario = request.json['uid_usuario']
estado_uid_token, codigo_uid_token = validaciones.validar_uid_token(
uid_usuario, codigo_token)
if estado_uid_token:
estado_permiso, codigo_permiso = validaciones.validar_permiso_admin_gerente_admintienda(
uid_usuario)
if estado_permiso:
pedido_model = PedidoModel()
estado_registrar_pedido, codigo_registrar_pedido = pedido_model.actualizar_estado_pedido(
request.json)
if estado_registrar_pedido:
return {
'estado': estado_registrar_pedido,
'mensaje': codigo_registrar_pedido
}
else:
return {
'estado': False,
'codigo': codigo_registrar_pedido
}
else:
return {
'estado': False,
'codigo': codigo_permiso
}
else:
return {
'estado': False,
'codigo': codigo_uid_token
}
else:
return {'estado': False, 'codigo': codigo_vacio}
else:
codigo = generador.validarGuardarInformacionError(
"000",
"validar si trae los parametros necesario- no se enviaron los parametros- producto_controller",
"post", '')
return {'estado': False, 'codigo': codigo}
else:
return {'estado': False, 'codigo': codigo_json}
else:
return {'estado': False, 'codigo': codigo_token}
else:
return {'estado': False, 'codigo': codigo_header}