def post(self):
data = request.json
current_user = UserModel.find_by_login(data.get('login'))
if not current_user:
abort(
401,
'El usuario con login {} no existe'.format(data.get('login')))
if UserModel.verify_hash(data['password'], current_user.password):
if not current_user.activated:
abort(401, 'El usuario no está activado')
expires = timedelta(days=1)
created_access_token = create_access_token(identity=current_user,
expires_delta=expires)
## db = firestore.client()
## doc_ref = db.collection(u'ingreso_{}'.format(current_user.login)).document(
## datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
## doc_ref.set({
## u'usuario': current_user.login,
## u'fecha_entrada': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
## })
return {'id_token': created_access_token}, 201
else:
abort(401, 'Credenciales incorrectas')
def get(self):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
data = parser.parse_args()
if data['proyecto_raiz']:
proyectos_obj = obtener_proyectos_root_por_organizacion(
organizacion_id=current_user.organizationId)
else:
if data['id_seccion']:
proyectos_obj = obtener_productos_por_id_seccion(
organizacion_id=current_user.organizationId,
id_seccion=data['id_seccion'])
else:
if data['padre_id'] is None:
proyectos_obj = obtener_proyectos_por_organizacion(
organizacion_id=current_user.organizationId)
else:
proyectos_obj = obtener_proyectos_por_padreId(
organizacion_id=current_user.organizationId,
padre_id=data['padre_id'])
proyectos = [proyecto.to_dict() for proyecto in proyectos_obj]
return proyectos
def delete(self, proyecto_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
proyecto = obtener_proyecto_por_id(
organizacion_id=current_user.organizationId,
proyecto_id=proyecto_id)
if proyecto is None:
abort(
404,
'No existe un proyecto con ese Id para la organización del usuario'
)
try:
proyecto.delete()
except Exception as exception:
abort(
500,
'Error del servidor al tratar de borrar el proyecto con el Id: {}'
.format(proyecto_id))
return {
'message':
'Proyecto with id: {} successfully deleted'.format(proyecto_id)
}, 200
def post(self, contrato_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
try:
if current_user.has_authority(
AUTHORITY_ADMIN) or current_user.has_authority(
AUTHORITY_ROOT):
contract = obtener_contrato_por_contrato_id(contrato_id)
else:
contract = obtener_contrato_por_contrato_id_y_correo_vendedor(
correo_vendedor=current_user.email,
contrato_id=contrato_id)
if not contract:
abort(404, 'No se encontró el contrato con ese Id')
data = request.json
pay = agregar_pago_real(contrato_id=contrato_id, data=data)
return pay.to_dict()
except Exception as exception:
abort(
500,
'Error del servidor al generar el pago real para ese contrato')
def put(self, proyecto_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
proyecto_obj = obtener_proyecto_por_id(
organizacion_id=current_user.organizationId,
proyecto_id=proyecto_id)
if proyecto is None:
return {
'message': 'Proyecto {} doesnt exist'.format(proyecto_id)
}, 401
data = request.json
proyecto_obj.nombre = data.get('nombre')
proyecto_obj.descripcion = data.get('descripcion')
proyecto_obj.correoCreador = data.get('correoCreador')
proyecto_obj.idSeccion = data.get('idSeccion')
proyecto_obj.svgId = data.get('svgId')
proyecto_obj.organizacionId = data.get('organizacionId')
proyecto_obj.padreId = data.get('padreId')
try:
edited_proyecto = proyecto_obj.save()
except Exception as exception:
abort(
500,
'Error del servidor al tratar de borrar el proyecto con el Id: {}'
.format(proyecto_id))
return edited_proyecto.to_dict()
def get(self, contrato_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
try:
if current_user.has_authority(
AUTHORITY_ADMIN) or current_user.has_authority(
AUTHORITY_ROOT):
contract = obtener_contrato_por_contrato_id(contrato_id)
else:
contract = obtener_contrato_por_contrato_id_y_correo_vendedor(
correo_vendedor=current_user.email,
contrato_id=contrato_id)
if not contract:
abort(404, 'No se encontró el contrato con ese Id')
pagos_programados_objs = contract.pagosProgramados
pagos_programados = [
pago_programado.to_dict()
for pago_programado in pagos_programados_objs
]
return pagos_programados
except Exception as exception:
abort(
500,
'Error del servidor al recuperar los pagos programados para ese contrato'
)
def put(self, contrato_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
argumentos = desactivar_parser.parse_args()
if argumentos['desactivar']:
try:
if current_user.has_authority(
AUTHORITY_ADMIN) or current_user.has_authority(
AUTHORITY_ROOT):
contract = obtener_contrato_por_contrato_id(contrato_id)
else:
contract = obtener_contrato_por_contrato_id_y_correo_vendedor(
correo_vendedor=current_user.email,
contrato_id=contrato_id)
if not contract:
abort(404, 'No se encontró el contrato con ese Id')
contract = desactivar_contrato(contrato_id)
return contract.to_dict
except Exception as exception:
abort(500, 'Error del servidor al desactivar el contrato')
else:
abort(501, 'el método no está implementado')
def post(self):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
if not current_user.has_authority(
AUTHORITY_ADMIN) and not current_user.has_authority(
AUTHORITY_ROOT):
abort(
401,
'No se cuentan con los permisos necesarios para crear un producto'
)
data = request.json
try:
product = crear_producto(
organizacion_id=current_user.organizationId,
proyecto_id=data.get('proyectoId'),
correo_creador=current_user.email,
id_seccion=data.get('idSeccion'),
nombre=data.get('nombre'),
descripcion=data.get('descripcion'),
precio=data.get('precio'),
tipo_de_producto=data.get('tipoDeProducto'),
estatus=data.get('estatus'),
valores_campos=data.get('valoresCampos'),
fotos=data.get('fotos'),
archivos=data.get('archivos'))
return product.to_dict()
except Exception as exception:
abort(500, 'Error del servidor al guardar el producto')
def get(self):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
data = buscar_productos_parser.parse_args()
try:
if data['proyectoId']:
if current_user.has_authority(
AUTHORITY_ADMIN) or current_user.has_authority(
AUTHORITY_ROOT):
productos_obj = obtener_productos_por_proyecto_id(
data['proyectoId'])
else:
productos_obj = obtener_productos_por_organizacion_id_y_proyecto_id(
organizacion_id=current_user.organizationId,
proyecto_id=data['proyectoId'])
else:
if data['id_seccion']:
productos_obj = obtener_productos_por_id_seccion(
id_seccion=data['idSeccion'])
else:
if current_user.has_authority(
AUTHORITY_ADMIN) or current_user.has_authority(
AUTHORITY_ROOT):
productos_obj = obtener_productos()
else:
productos_obj = obtener_productos_por_organizacion_id(
organizacion_id=current_user.organizationId)
productos = [producto.to_dict() for producto in productos_obj]
return productos
except Exception as exception:
abort(500, 'Error del servidor al recuperar los productos')
def get(self):
user_login = get_jwt_identity()
current_user = UserModel.find_by_login(user_login)
if not current_user:
abort(401, 'El usuario con login {} no existe'.format(user_login))
else:
return current_user.to_json()
def editar_usuario(id: int, first_name: str, last_name: str,
organization_id: str, authorities: List[str]) -> UserModel:
user = UserModel.find_by_id(id)
requested_authorities = []
for authority_str in authorities:
authority = AuthorityModel.find_by_authority_name(authority_str)
if authority is not None:
requested_authorities.append(authority)
user.firstName = first_name
user.lastName = last_name
user.organizationId = organization_id
# se quitan las categorias que el usuario pueda tener y que no vengan en las categorias solicitadas
for authority in user.authorities:
if authority not in requested_authorities:
user.authorities.remove(authority)
# se agregan las categorias nuevas que no tenga ya el usuario pero que vengan en la solicitud
for authority in requested_authorities:
if authority not in user.authorities:
user.authorities.append(authority)
user.save_to_db()
return user
def post(self):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
data = request.json
if current_user.has_authority(
AUTHORITY_ADMIN) or current_user.has_authority(AUTHORITY_ROOT):
client = obtener_cliente_por_id(data.get('clienteId'))
else:
client = obtener_cliente_por_id_correo_vendedor(
correo_vendedor=current_user.email,
cliente_id=data.get('clienteId'))
if not client:
abort(404, 'No existe el cliente con ese Id')
product = obtener_producto_por_id(data.get('productoId'))
if not product:
abort(404, 'No existe un producto con ese Id')
try:
contract = crear_contrato(
tipo=data.get('tipo'),
cliente_id=data.get('clienteId'),
producto_id=data.get('productoId'),
correo_vendedor=current_user.email,
dias_validez=data.get('diasValidez'),
pagos_programados=data.get('pagosProgramados'))
return contract.to_dict()
except Exception as exception:
abort(500, 'Error del servidor al crear el contrato')
def reset_database():
from remanager_back.data_auth.models import UserModel, AuthorityModel, RevokedTokenModel
db.drop_all()
db.create_all()
if not UserModel.find_by_login('admin'):
mongo_init()
init_database_values()
def put(self):
user_login = get_jwt_identity()
current_user = UserModel.find_by_login(user_login)
if not current_user:
abort(401, 'El usuario con login {} no existe'.format(user_login))
data = change_pss_parser.parse_args()
if not UserModel.verify_hash(data['old_password'],
current_user.password):
abort(401, 'El password anterior no coincide')
current_user.password = UserModel.generate_hash(data['new_password'])
current_user.save_to_db()
return {'message': 'El password se ha cambiado correctamente'}
def crear_usuario(login: str, password: str, first_name: str, last_name: str,
email: str, organization_id: str,
authorities: List[str]) -> UserModel:
user = UserModel(login=login,
password=UserModel.generate_hash(password),
firstName=first_name,
lastName=last_name,
email=email,
organizationId=organization_id,
activated=False)
for authority_str in authorities:
authority = AuthorityModel.find_by_authority_name(authority_str)
if authority is not None:
user.authorities.append(authority)
user.save_to_db()
return user
def get(self, proyecto_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
proyecto_obj = obtener_proyecto_por_id(
organizacion_id=current_user.organizationId,
proyecto_id=proyecto_id)
if proyecto_obj is None:
abort(
404,
'No existe un proyecto con ese Id para la organización del usuario'
)
return proyecto_obj.to_dict()
def delete(self, svg_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
if not current_user.has_authority(AUTHORITY_ADMIN):
abort(401, 'No tiene permisos para realizar esta acción')
try:
borrar_svg(svg_id)
return {'message': 'svg borrado exitosamente'}
except Exception as exception:
abort(500, 'Error del servidor al borrar el svg')
def get(self, svg_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
try:
svg_obj = obtener_svg_por_id(svg_id)
if not svg_obj:
abort(404, 'No existe un svg con ese id')
return svg_obj.to_dict()
except Exception as exception:
abort(500, 'Error del servidor al recuperar el svg')
def get(self, proyecto_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
try:
productos_objs = obtener_productos_por_proyecto_id(
proyecto_id=proyecto_id)
productos = [producto.to_dict() for producto in productos_objs]
return productos
except Exception as exception:
abort(
500,
'Error del servidor al recuperar los productos del proyecto')
def put(self, svg_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
if not current_user.has_authority(AUTHORITY_ADMIN):
abort(401, 'No tiene permisos para realizar esta acción')
data = request.data
try:
svg_obj = editar_svg(svg_id=svg_id, data=data)
return svg_obj.to_dict()
except Exception as exception:
abort(500, 'Error del servidor al editar el svg')
def get(self):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
if not current_user.has_authority(AUTHORITY_ADMIN):
abort(401, 'No tiene permisos para realizar esta acción')
try:
svgs_objs = obtener_todos_los_svgs()
svgs = [svg_obj.to_dict() for svg_obj in svgs_objs]
return svgs
except Exception as exception:
abort(500, 'Error del servidor al recuperar los svgs')
def get(self):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
if current_user.has_authority(AUTHORITY_ADMIN):
clientes_obj = obtener_todos_los_clientes_por_organizacion_id(
organizacion_id=current_user.organizationId)
else:
clientes_obj = obtener_clientes_por_correo_vendedor(
correo_vendedor=current_user.email)
clientes = [cliente.to_dict() for cliente in clientes_obj]
return clientes
def get(self, cliente_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
if current_user.has_authority(
AUTHORITY_ADMIN) or current_user.has_authority(AUTHORITY_ROOT):
cliente = obtener_cliente_por_id(cliente_id=cliente_id)
else:
cliente = obtener_cliente_por_id_correo_vendedor(
correo_vendedor=current_user.email, cliente_id=cliente_id)
if not cliente:
abort(404, 'No existe ningún cliente con ese Id')
return cliente.to_dict()
def get(self, producto_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
if current_user.has_authority(
AUTHORITY_ADMIN) or current_user.has_authority(AUTHORITY_ROOT):
product = obtener_producto_por_id(producto_id=producto_id)
else:
product = obtener_producto_por_id_y_organizacion_id(
producto_id=producto_id,
organizacion_id=current_user.organizationId)
if not product:
abort(404, 'No se encontró un producto con ese Id')
return product.to_dict()
def get(self):
user_login = get_jwt_identity()
current_user = UserModel.find_by_login(user_login)
if not current_user:
abort(401, 'El usuario con login {} no existe'.format(user_login))
else:
if not current_user.organizationId:
abort(404, 'el usuario no tiene una organizacion asociada')
else:
organization = obtener_organizacion_por_id(
current_user.organizationId)
if not organization:
abort(401, 'La organización del usuario no existe')
return organization.to_dict()
def delete(self, contrato_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
if not current_user.has_authority(
AUTHORITY_ADMIN) and not current_user.has_authority(
AUTHORITY_ROOT):
abort(
403,
'No cuenta con los permisos necesarios para realizar esta acción'
)
try:
borrar_contrato(contrato_id)
return {'message': 'Contrato borrado exitosamente'}
except Exception as exception:
abort(500, 'Error del servidor al borrar el contrato')
def get(self):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
try:
if current_user.has_authority(
AUTHORITY_ADMIN) or current_user.has_authority(
AUTHORITY_ROOT):
contratos_objs = obtener_contratos()
else:
contratos_objs = obtener_contratos_por_correo_vendedor(
correo_vendedor=current_user.email)
contratos = [contrato.to_dict() for contrato in contratos_objs]
return contratos
except Exception as exception:
abort(500, 'Error del servidor al recuperar los clientes')
def delete(self, producto_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
if not current_user.has_authority(
AUTHORITY_ADMIN) and not current_user.has_authority(
AUTHORITY_ROOT):
abort(
401,
'No se cuentan con los permisos necesarios para borrar el producto'
)
try:
borrar_producto_por_id(producto_id)
except Exception as exception:
abort(500, 'Error del servidor al borrar el producto')
return {'message': 'Producto borrado exitosamente'}
def delete(self, cliente_id):
login = get_jwt_identity()
current_user = UserModel.find_by_login(login)
if current_user.has_authority(
AUTHORITY_ADMIN) or current_user.has_authority(AUTHORITY_ROOT):
cliente = obtener_cliente_por_id(cliente_id=cliente_id)
else:
cliente = obtener_cliente_por_id_correo_vendedor(
correo_vendedor=current_user.email, cliente_id=cliente_id)
if not cliente:
abort(404, 'No existe ningún cliente con ese Id')
try:
borrar_cliente_por_id(cliente_id=cliente_id)
except Exception as exception:
abort(500, 'Error del servidor al borrar el cliente')
return {'message': 'Cliente borrado exitosamente'}
def put(self):
data = request.json
user_to_edit = UserModel.find_by_login(data.get('login'))
if not user_to_edit:
abort(
401,
'El usuario con login {} no existe'.format(data.get('login')))
else:
user_to_edit.firstName = data.get('firstName')
user_to_edit.lastName = data.get('lastName')
try:
user_to_edit.save_to_db()
return {
'message': 'User {} was edited'.format(user_to_edit.login)
}
except:
abort(
500,
'Error del servidor al editar el usuario con login {}'.
format(data.get('login')))