def __init__(self):
self.lado_dictionary = {
"izquierdo": 1,
"derecho": 2
}
self.tipo_dictionary = {
"anterior": 1,
"total": 2,
"adaptacion": 3,
}
self.__sql_helper = MySqlHelper()
self.__string_helper = StringHelper()
def __init__(self, entity):
self.__sql_helper = MySqlHelper()
self.__string_helper = StringHelper()
self.dictionary = {
"marcas": SpMarcas,
"colores": SpColores,
"tamanios": SpTamanios,
"modelos": SpModelos,
"materiales": SpMaterial,
"protecciones": SpProteccion,
"lentes": SpLentes,
}
self.__constant = self.__entity_helper(entity)
def __init__(self):
self.__sql_helper = MySqlHelper()
self.__empresa_servicio = EmpresaService()
self.__string_helper = StringHelper()
self.dictionary = {
"ventas": SpCharts.chart1,
"enfermedades": SpCharts.chart2,
"isos": SpCharts.chart3,
}
class GeneralService:
def __init__(self, entity):
self.__sql_helper = MySqlHelper()
self.__string_helper = StringHelper()
self.dictionary = {
"marcas": SpMarcas,
"colores": SpColores,
"tamanios": SpTamanios,
"modelos": SpModelos,
"materiales": SpMaterial,
"protecciones": SpProteccion,
"lentes": SpLentes,
}
self.__constant = self.__entity_helper(entity)
def register(self, descripcion):
if not descripcion:
raise ValueError("Missing description")
descripcion = self.__string_helper.build_string(descripcion)
args = (descripcion, )
self.__sql_helper.sp_set(self.__constant.Register, args)
def active_status(self, primary_key, is_deactivation=False):
if not primary_key:
raise ValueError("Missing argument")
if not isinstance(primary_key, int):
raise ValueError("Invalid type")
primary_key = str(primary_key)
args = (primary_key, )
if is_deactivation:
self.__sql_helper.sp_set(self.__constant.Deactivate, args)
else:
self.__sql_helper.sp_set(self.__constant.Activate, args)
def get(self, key):
data = self.__sql_helper.sp_get(self.__constant.GetAll)
for row in data:
row["Descripcion"] = unquote(row["Descripcion"])
return serialize_data_set(data, key)
def __entity_helper(self, entity):
if not isinstance(entity, str):
raise ValueError("Invalid type")
return self.dictionary[entity]
class ArmazonService:
def __init__(self):
self.__sql_helper = MySqlHelper()
self.__string_helper = StringHelper()
def register_and_get(self, data):
marca_id = data['MarcaId']
color_id = data['ColorId']
tamanio_id = data['TamanioId']
modelo_id = data['ModeloId']
detalle = data['DetalleEnArmazon']
args = (marca_id, color_id, tamanio_id, modelo_id)
for arg in args:
if not isinstance(arg, int):
raise ValueError("Invalid data")
# TODO Validate if all IDs exists
if not isinstance(detalle, str):
raise ValueError("Invalid argument for detalle")
detalle = self.__string_helper.build_string(detalle)
arguments = list(args)
arguments.append(detalle)
args = tuple(arguments)
data = self.__sql_helper.sp_get(SpArmazon.Register_and_get, args, True)
return serialize_data_set(data)
def get_summary(self, venta_id):
if not isinstance(venta_id, int):
raise ValueError("Invalid Id")
args = (str(venta_id), )
data = self.__sql_helper.sp_get(SpArmazon.Get_summary, args, True)
if not data:
return False
return serialize_data_set(data)
def __init__(self):
self.__sql_helper = MySqlHelper()
self.__empresa_servicio = EmpresaService()
self.__string_helper = StringHelper()
class BeneficiariosService:
def __init__(self):
self.__sql_helper = MySqlHelper()
self.__empresa_servicio = EmpresaService()
self.__string_helper = StringHelper()
def create_beneficiario(self, empresa_id, data):
nombres = data['Nombres']
ape_pat = data['ApellidoPaterno']
ape_mat = data['ApellidoMaterno']
fecha_nac = data['FechaNacimiento']
ocupacion = data['Ocupacion']
if not self.__empresa_servicio.validate_empresa(empresa_id):
raise KeyError("Empresa no encontrada")
if not nombres or not ape_mat or not ape_pat or not fecha_nac or not ocupacion:
raise ValueError("Datos faltantes")
nombres = self.__string_helper.build_string(nombres)
ape_pat = self.__string_helper.build_string(ape_pat)
ape_mat = self.__string_helper.build_string(ape_mat)
fecha_nac = self.__string_helper.build_string(fecha_nac)
ocupacion = self.__string_helper.build_string(ocupacion)
empresa_id = str(empresa_id)
args = (nombres, ape_pat, ape_mat, fecha_nac, ocupacion, empresa_id)
self.__sql_helper.sp_set(SpBeneficiario.Register, args)
def get_beneficiario_by_empresa(self, empresa_id):
if not self.__empresa_servicio.validate_empresa(empresa_id):
raise KeyError("Empresa no encontrada")
args = (str(empresa_id), )
data = self.__sql_helper.sp_get(SpBeneficiario.get_by_empresa, args)
return serialize_data_set(data, "Beneficiarios")
def validate_existance(self, beneficiario_id):
if not isinstance(beneficiario_id, int):
return False
args = (str(beneficiario_id), )
data = self.__sql_helper.sp_get(SpBeneficiario.Validate, args, True)
if data['count'] == 0:
return False
return True
def get_names_by_id(self, beneficiario_id):
if not isinstance(beneficiario_id, int):
raise ValueError("Id inválido")
args = (str(beneficiario_id), )
data = self.__sql_helper.sp_get(SpBeneficiario.get_name_by_id, args, True)
return serialize_data_set(data, "Nombres")
def update_beneficiario(self, beneficiario_id, data):
nombres = data['Nombres']
ape_pat = data['ApellidoPaterno']
ape_mat = data['ApellidoMaterno']
fecha_nac = data['FechaNacimiento']
ocupacion = data['Ocupacion']
if not nombres or not ape_mat or not ape_pat or not fecha_nac or not ocupacion:
raise ValueError("Datos faltantes")
nombres = self.__string_helper.build_string(nombres)
ape_pat = self.__string_helper.build_string(ape_pat)
ape_mat = self.__string_helper.build_string(ape_mat)
fecha_nac = self.__string_helper.build_string(fecha_nac)
ocupacion = self.__string_helper.build_string(ocupacion)
beneficiario_id = str(beneficiario_id)
args = (beneficiario_id, nombres, ape_pat, ape_mat, fecha_nac, ocupacion)
self.__sql_helper.sp_set(SpBeneficiario.Update, args)
def __init__(self):
self.__sql_helper = MySqlHelper()
self.__string_helper = StringHelper()
class EmpresaService:
def __init__(self):
self.__sql_helper = MySqlHelper()
self.__string_helper = StringHelper()
def create_empresa(self, data):
nombre = data['Nombre']
domicilio = data['Domicilio']
telefono = data['Telefono']
if not nombre:
raise ValueError("Missing names")
nombre = self.__string_helper.build_string(nombre)
domicilio = self.__string_helper.build_string(domicilio)
telefono = self.__string_helper.build_string(telefono)
args = (nombre, domicilio, telefono)
self.__sql_helper.sp_set(SpEmpresas.Register, args)
def update_empresa(self, empresa_id, data):
nombre = data['NombreEmpresa']
domicilio = data['Domicilio']
telefono = data['Telefono']
if not nombre:
raise ValueError("Missing names")
nombre = self.__string_helper.build_string(nombre)
domicilio = self.__string_helper.build_string(domicilio)
telefono = self.__string_helper.build_string(telefono)
args = (str(empresa_id), nombre, domicilio, telefono)
self.__sql_helper.sp_set(SpEmpresas.Update, args)
def validate_empresa(self, empresa_id):
empresa_id = int(empresa_id)
args = (str(empresa_id), )
validation = self.__sql_helper.sp_get(SpEmpresas.Validate, args, True)
if validation['count(*)'] == 1:
return True
return False
def get_empresas(self, token):
empresas = self.__sql_helper.sp_get(SpEmpresas.Get_all)
empresas = self.__filter_empresas(empresas, token)
return serialize_data_set(empresas, "Empresas")
def get_by_folio(self, folio):
folio = self.__string_helper.build_string(folio)
args = (folio, )
data = self.__sql_helper.sp_get(SpEmpresas.Get_by_folio, args, True)
if not data:
return "Empresa not found"
return serialize_data_set(data)
def get_by_venta(self, venta_id):
args = (str(venta_id), )
data = self.__sql_helper.sp_get(SpEmpresas.Get_by_sale, args, True)
if not data:
return "Empresa not found"
return serialize_data_set(data)
def __filter_empresas(self, empresas, token):
restricted = self.__load_user_restrictions(token)
if restricted:
founded = []
for empresa in empresas:
retriction = {"Empresa": empresa["NombreEmpresa"]}
if retriction in restricted:
founded.append(empresa)
if founded:
for item in founded:
empresas.remove(item)
return empresas
def __load_user_restrictions(self, token):
token = self.__string_helper.build_string(token)
args = (token, )
return self.__sql_helper.sp_get(
reglasConstants.Get_Empresas_restrictions, args)
class OjoService:
def __init__(self):
self.lado_dictionary = {
"izquierdo": 1,
"derecho": 2
}
self.tipo_dictionary = {
"anterior": 1,
"total": 2,
"adaptacion": 3,
}
self.__sql_helper = MySqlHelper()
self.__string_helper = StringHelper()
def register_and_get_single(self, lado, data):
lado_id =self.lado_dictionary[lado]
esfera = data['Esfera']
cilindro = data['Cilindro']
eje = data['Eje']
adiccion = data['Adiccion']
args = (lado_id, esfera, cilindro, eje, adiccion)
for arg in args:
if not are_characters_valid(arg):
raise ValueError("Sólo pueden añadirse datos númericos")
esfera = self.__string_helper.build_string(str(esfera))
cilindro= self.__string_helper.build_string(str(cilindro))
eje = self.__string_helper.build_string(str(eje))
adiccion = self.__string_helper.build_string(str(adiccion))
args = (lado_id, esfera, cilindro, eje, adiccion)
data = serialize_data_set(self.__sql_helper.sp_get(SpOjos.Register_and_get_Single, args, True))
return data
def register_and_get_pair(self, data, tipo):
tipo_id = self.tipo_dictionary[tipo]
izquierdo_id = data['IzquierdoId']
derecho_id = data['DerechoId']
dp_lejos = data['DpLejos']
obl = data['Obl']
args = (izquierdo_id, derecho_id, tipo_id, dp_lejos, obl)
for arg in args:
if not are_characters_valid(arg):
raise ValueError("Sólo pueden añadirse datos númericos")
dp_lejos = self.__string_helper.build_string(str(dp_lejos))
obl = self.__string_helper.build_string(str(obl))
args = (izquierdo_id, derecho_id, tipo_id, dp_lejos, obl)
data = serialize_data_set(self.__sql_helper.sp_get(SpOjos.Register_and_get_pair, args, True))
return data
def get_single(self, ojo_id):
if not isinstance(ojo_id, int):
raise ValueError("Invalid ojo id")
args = (ojo_id, )
data = self.__sql_helper.sp_get(SpOjos.Get_single, args, True)
if not data:
return False
return serialize_data_set(data)
def get_pair(self, pair_id):
if not isinstance(pair_id, int):
raise ValueError("Invalid ojo id")
args = (pair_id,)
data = self.__sql_helper.sp_get(SpOjos.Get_pair, args, True)
if not data:
return False
return serialize_data_set(data)
class ExamenService:
def __init__(self):
self.__sql_helper = MySqlHelper()
self.__string_helper = StringHelper()
def register(self, data):
folio = data['Folio']
beneficiario_id = data['BeneficiarioId']
anterior_id = data['AnteriorId']
total_id = data['TotalId']
adaptacion_id = data['AdaptacionId']
fecha_examen = data['FechaExamen']
requiere_lentes = data['RequiereLentes']
compro_lentes = data['ComproLentes']
enfermedad_id = data['EnfermedadId']
observaciones = data['Observaciones']
if not isinstance(requiere_lentes, int) or not isinstance(compro_lentes, int) or not folio or not isinstance(beneficiario_id, int) or not isinstance(enfermedad_id, int):
raise ValueError("Incorrect type values")
folio = self.__string_helper.build_string(folio)
fecha_examen = self.__string_helper.build_string(fecha_examen)
if observaciones:
observaciones = self.__string_helper.build_string(observaciones)
args = (folio, beneficiario_id, anterior_id, total_id, adaptacion_id, fecha_examen, requiere_lentes,
compro_lentes, enfermedad_id, observaciones)
self.__sql_helper.sp_set(SpExamen.Register, args)
def get_by_beneficiatio(self, beneficiario_id):
if not isinstance(beneficiario_id, int):
raise ValueError("Invalid beneficiario")
args = (str(beneficiario_id), )
data = self.__sql_helper.sp_get(SpExamen.Get_by_beneficiario, args)
if not data:
return False
data = serialize_data_set(data)
return data
def get_by_folio(self, folio):
if not folio:
raise ValueError("Missing folio")
if len(folio) > 10:
raise ValueError("Invalid folio")
args = (self.__string_helper.build_string(folio), )
data = self.__sql_helper.sp_get(SpExamen.Get_by_folio, args, True)
if not data:
return False
data = serialize_data_set(data)
return data
def get_summary_by_empresa(self, empresa_id):
if not isinstance(empresa_id, int):
raise ValueError("Invalid Id")
args = (str(empresa_id), )
data = self.__sql_helper.sp_get(SpExamen.Get_summary_by_empresa, args)
return serialize_data_set(data, "Examenes")
def update(self, data):
folio = data['Folio']
beneficiario_id = data['BeneficiarioId']
anterior_id = data['AnteriorId']
total_id = data['TotalId']
adaptacion_id = data['AdaptacionId']
requiere_lentes = data['RequiereLentes']
compro_lentes = data['ComproLentes']
enfermedad_id = data['EnfermedadId']
observaciones = data['Observaciones']
if not isinstance(requiere_lentes, int) or not isinstance(compro_lentes, int) or not folio or not isinstance(
beneficiario_id, int) or not isinstance(enfermedad_id, int):
raise ValueError("Incorrect type values")
folio = self.__string_helper.build_string(folio)
if observaciones:
observaciones = self.__string_helper.build_string(observaciones)
args = (folio, beneficiario_id, anterior_id, total_id, adaptacion_id, requiere_lentes,
compro_lentes, enfermedad_id, observaciones)
self.__sql_helper.sp_set(SpExamen.Update_by_folio, args)
def get_folios (self, empresa_id):
if not isinstance(empresa_id, int):
raise ValueError("Invalid Id")
args = (empresa_id, )
data = self.__sql_helper.sp_get(SpExamen.Get_folios, args)
return serialize_data_set(data, "Folios")
def get_beneficiario_by_folio(self, folio):
folio = self.__string_helper.build_string(folio)
args = (folio, )
data = self.__sql_helper.sp_get(SpExamen.Get_beneficiario_by_folio, args, True)
return serialize_data_set(data)
class UsersService:
def __init__(self):
self.__sql_helper = MySqlHelper()
self.__string_helper = StringHelper()
def create_user(self, user_name, password, token):
if not self.is_admin(token):
raise AssertionError(
"User registration can only be made by admins")
if not self.__validate_string(user_name):
raise ValueError("Invalid username")
if not self.__validate_string(password):
raise ValueError("Username must contain more than 5 letters")
user_name = self.__string_helper.build_string(user_name)
password = self.__string_helper.build_string(self.__encrypt(password))
token = self.__string_helper.build_string(
self.__encrypt(password + str(datetime.now())))
args = (user_name, password, token)
self.__sql_helper.sp_set(SpUsers.Register, args)
def user_authentication(self, user_name, password):
if not self.__validate_string(user_name):
raise ValueError("Invalid username")
if not self.__validate_string(password):
raise ValueError("Username must contain more than 5 letters")
password = self.__string_helper.build_string(self.__encrypt(password))
user_name = self.__string_helper.build_string(user_name)
args = (user_name, password)
token = self.__sql_helper.sp_get(SpUsers.Authenticate, args, True)
return serialize_data_set(token)
def token_validation(self, token):
if len(str(token)) != 40:
return False
token = self.__string_helper.build_string(token)
args = (token, )
result = self.__sql_helper.sp_get(SpUsers.Authorize, args, True)
if result['Result'] == 1:
return True
return False
def get_name(self, token):
token = self.__string_helper.build_string(token)
args = (token, )
data = self.__sql_helper.sp_get(SpUsers.Get_name, args, True)
return data["userName"]
def is_admin(self, token):
token = self.__string_helper.build_string(token)
args = (token, )
data = self.__sql_helper.sp_get(SpUsers.Is_Admin, args, True)
if data["Admin"] == 1:
return True
return False
@staticmethod
def __encrypt(string):
string = hashlib.sha1(string.encode('utf-8')).hexdigest()
return string
@staticmethod
def __validate_string(string):
if len(str(string)) < 5:
return False
if not string:
return False
return True
class VentaService:
def __init__(self):
self.__sql_helper = MySqlHelper()
self.__string_helper = StringHelper()
self.__empresa_service = EmpresaService()
self.__user_service = UsersService()
def register_and_get(self, data):
folio_examen = data['Folio']
total_venta = data['TotalVenta']
anticipo = data['Anticipo']
periodicidad = data['Periodicidad']
fecha_venta = data['FechaVenta']
armazon_id = data['ArmazonId']
material_id = data['MaterialId']
proteccion_id = data['ProteccionId']
lente_id = data['LenteId']
beneficiario_id = data['BeneficiarioId']
tipo_id = data['TipoVentaId']
number_of_payments = data['NumeroPagos']
if folio_examen:
if self.is_folio_repeated(folio_examen):
raise ValueError("Este folio ya pertenece a una venta")
if not isinstance(armazon_id, int) or not isinstance(material_id, int) or not isinstance(proteccion_id, int) \
or not isinstance(lente_id, int) or not isinstance(beneficiario_id, int)\
or not isinstance(tipo_id, int) or not isinstance(number_of_payments, int):
raise ValueError("Missing reference from product")
if not folio_examen:
folio_examen = "null"
else:
folio_examen = self.__string_helper.build_string(folio_examen)
fecha_venta = self.__string_helper.build_string(fecha_venta)
total_venta = str(total_venta)
anticipo = str(anticipo)
periodicidad = str(periodicidad)
armazon_id = str(armazon_id)
material_id = str(material_id)
proteccion_id = str(proteccion_id)
lente_id = str(lente_id)
beneficiario_id = str(beneficiario_id)
number_of_payments = str(number_of_payments)
tipo_id = str(tipo_id)
args = (folio_examen, total_venta, anticipo, periodicidad, fecha_venta,
armazon_id, material_id, proteccion_id, lente_id,
beneficiario_id, tipo_id, number_of_payments)
data = self.__sql_helper.sp_get(SpVentas.Register_and_get, args, True)
return serialize_data_set(data)
def get_summary_by_company(self, empresa_id):
if not isinstance(empresa_id, int):
raise ValueError("Invalid id")
if not self.__empresa_service.validate_empresa(empresa_id):
return False
args = (str(empresa_id), )
data = self.__sql_helper.sp_get(SpVentas.Get_summary_by_empresa, args)
if not data:
return False
for row in data:
row["Material"] = unquote(row["Material"])
row["Proteccion"] = unquote(row["Proteccion"])
row["Lente"] = unquote(row["Lente"])
data = serialize_data_set(data, "Ventas")
return data
def payment_register(self, venta_id, data, name):
monto = data['Monto']
fecha = data['FechaAbono']
if not isinstance(venta_id, int):
raise ValueError("Invalid venta id")
if not isinstance(monto, float) and not isinstance(monto, int):
raise ValueError("Invalid value for monto")
if not isinstance(fecha, str):
raise ValueError("Invalid value for fecha")
if not isinstance(name, str):
raise ValueError("Invalid value for name")
if not self.__can_make_payment(venta_id, monto):
raise ValueError("No se pudo registrar abono, saldo negativo")
fecha = self.__string_helper.build_string(fecha)
name = self.__string_helper.build_string(name)
args = (venta_id, monto, fecha, name)
self.__sql_helper.sp_set(SpVentas.Bill_registration, args)
def get_payments_by_venta(self, venta_id):
if not isinstance(venta_id, int):
raise ValueError("Invalid id")
args = (str(venta_id), )
data = self.__sql_helper.sp_get(SpVentas.Get_abono_by_venta, args)
if not data:
return False
return serialize_data_set(data)
def __can_make_payment(self,
venta_id,
monto,
is_updating=False,
abono_id=0):
args = (venta_id, )
data = self.__sql_helper.sp_get(SpVentas.Get_total_of_sale, args, True)
if not data:
raise ValueError("Venta inexistente")
total_venta = data['total']
data = self.__sql_helper.sp_get(SpVentas.Get_abono_sum_by_venta, args,
True)
if not data['sum(Monto)']:
data['sum(Monto)'] = 0
if is_updating:
current_monto = self.__sql_helper.sp_get(SpVentas.Get_monto,
(str(abono_id), ), True)
data['sum(Monto)'] = data['sum(Monto)'] - current_monto["Monto"]
total_abonos = float(data['sum(Monto)'])
total_abonos = total_abonos + monto
if total_venta == total_abonos:
self.paid_switch(venta_id)
return total_venta >= total_abonos
def delete_payment(self, payment_id, token):
if not isinstance(payment_id, int):
raise ValueError("Id inválido")
if not self.__user_service.is_admin(token):
raise ValueError(
"No tienes los permisos para realizar esta acción")
args = (str(payment_id), )
self.__sql_helper.sp_set(SpVentas.Delete_abono, args)
def is_folio_repeated(self, folio):
folio = self.__string_helper.build_string(folio)
args = (folio, )
data = self.__sql_helper.sp_get(SpVentas.Validate_folio, args, True)
if data['count(*)'] == 0:
return False
return True
def paid_switch(self, venta_id, marking_as_paid=True):
if not isinstance(venta_id, int) or venta_id == 0:
raise ValueError("Invalid Id")
args = (str(venta_id), )
if marking_as_paid:
self.__sql_helper.sp_set(SpVentas.Mark_as_paid, args)
else:
self.__sql_helper.sp_set(SpVentas.Mark_as_unpaid, args)
def __can_be_deleted(self, venta_id):
venta_id = str(venta_id)
data = self.__sql_helper.sp_get(SpVentas.Can_delete, (venta_id, ),
True)
return data["total"] == 0
def delete_sale(self, venta_id):
if not isinstance(venta_id, int):
raise ValueError("Invalid venta id")
if not self.__can_be_deleted(venta_id):
raise AttributeError(
"Esta venta no puede ser borrada porque ya existen abonos registrados ligados a ella"
)
venta_id = str(venta_id)
self.__sql_helper.sp_set(SpVentas.Delete, (venta_id, ))
def get_balance_summary(self, empresa_id):
args = (str(empresa_id), )
data = self.__sql_helper.sp_get(SpVentas.Get_sales_summary, args, True)
data["Abonos"] = self.__sql_helper.sp_get(
SpVentas.Get_payments_summary, args, True)["Montos"]
real_balance = self.__sql_helper.sp_get(SpVentas.Get_real_balance,
args, True)
data["TotalFake"] = real_balance["TotalFake"]
data["AnticiposFake"] = real_balance["AnticiposFake"]
return serialize_data_set(data)
def payment_update(self, abono_id, data, token):
monto = data['Monto']
fecha = data['FechaAbono']
if not self.__user_service.is_admin(token):
raise ValueError(
"No tienes los permisos para realizar esta acción")
if not isinstance(abono_id, int):
raise ValueError("Invalid abono id")
if not isinstance(monto, float) and not isinstance(monto, int):
raise ValueError("Invalid value for monto")
if not isinstance(fecha, str):
raise ValueError("Invalid value for fecha")
venta = self.__sql_helper.sp_get(SpVentas.Get_sale_by_abono,
(str(abono_id), ), True)
venta_id = venta["Id"]
if not self.__can_make_payment(venta_id, monto, True, abono_id):
raise ValueError("No se pudo actualizar abono, saldo negativo")
fecha = self.__string_helper.build_string(fecha)
args = (abono_id, fecha, monto)
self.__sql_helper.sp_set(SpVentas.Update_payment, args)