def check_item_exists(**kwargs):
if 'name' in kwargs:
item = s.query(Group).filter(and_(
Group.nombre_grupo == kwargs['name'], Group.id_tipo_grupo == 1)).first()
if item is None:
return False
return True
if 'group' in kwargs:
item = s.query(Group).filter(and_(
Group.id_grupo == kwargs['group'], Group.id_tipo_grupo == 1)).first()
if item is None:
return False
return True
def check_item_exists(**kwargs):
if 'user_account' in kwargs and 'group' in kwargs:
item = s.query(Membership).filter(
and_(Membership.id_usuario == kwargs['user_account'],
Membership.id_grupo == kwargs['group'])).first()
if item is None:
return False
return True
elif 'membership' in kwargs:
item = s.query(Membership).filter(
Membership.id_miembro == kwargs['membership']).first()
if item is None:
return False
return True
def get_user_by_mail(mail):
if not mail:
raise InvalidArgument('El campo mail no puede estar vacio o nulo')
user = s.query(User).filter(User.email_address == mail).first()
if not user:
raise ResourceConflict('Este usuario no existe')
return user
def get_list():
item_list = s.query(Group).all()
if not item_list:
error = [404, {'message': 'No existen grupos',
'action': 'Realice una nueva consulta'}]
return True, error
return False, item_list
def get_list_by_group(self, group, user):
error, role = self.get_role(group, user)
if error:
resp = role
return True, resp
if role is not 1 and role is not 2:
error = [
403, {
'message':
'No cuenta con permisos de administrador o creador para aceder a este recurso',
'action':
'Solicite la vinculacion como administrador a este grupo'
}
]
return True, error
item_list = s.query(Membership).filter(
Membership.id_grupo == group).all()
if not item_list:
error = [
404, {
'message':
'No se encontraron membresias activas en este grupo',
'action': 'Invite a sus contactos a unirse a este grupo'
}
]
return True, error
return False, item_list
def search_product(keywords):
print('Original list: ', keywords)
keywords = unidecode(keywords).lower()
keyword_list = re.split("[^a-zA-Z0-9á-ú']+", keywords)
keyword_list = collections.OrderedDict.fromkeys(keyword_list)
keyword_list = [
keyword for keyword in keyword_list
if not (keyword is '' or len(keyword) <= 2)
]
print('Processed list: ', keyword_list)
mfr_kw_filter = [
Brand.brand_name.ilike("%" + kw + "%") for kw in keyword_list
]
mfrs = s.query(Brand.brand_id).filter(or_(*mfr_kw_filter)).all()
print('Brand list ', [mfr.id_fabricante for mfr in mfrs])
cat_kw_filter = [
ProductCategory.product_category_name.ilike("%" + kw + "%")
for kw in keyword_list
]
categories = s.query(ProductCategory.product_category_id).filter(
or_(*cat_kw_filter)).all()
print('Category list ', [cat.id_categoria for cat in categories])
keyword_filter = [
unaccent(Product.product_name).ilike("%" + keyword + "%")
for keyword in keyword_list
]
keyword_filter.extend([Product.brand_id == kw for kw in mfrs])
keyword_filter.extend(
[Product.product_category_id == kw for kw in categories])
items = s.query(
Product,
func.concat(Brand.brand_name, ' ', Product.product_name, ' ',
ProductCategory.product_category_name)).join(Brand).join(
ProductCategory).filter(or_(*keyword_filter)).all()
for item in items:
print('Query:', item[1].lower())
print('Keywords:', keywords.lower())
item[0].search_similarity_index = difflib.SequenceMatcher(
None, item[1].lower().split(), keywords.split()).quick_ratio()
items.sort(key=lambda item1: item[0].search_similarity_index, reverse=True)
return items
def get_item(item_id):
item = s.query(Group).filter(
Group.id_grupo == item_id).first()
if not item:
error = [404, {'message': 'Este grupo no existe',
'action': 'Realice una nueva consulta'}]
return True, error
return False, item
def get_item(item_id):
item = s.query(Relationship).filter(
Relationship.id_relacion == item_id).first()
if not item:
error = [404, {'message': 'Esta relación no existe',
'action': 'Realice una nueva consulta'}]
return True, error
return False, item
def get_list_by_user(user):
item_list = s.query(Relationship).filter(
Relationship.id_usuario == user).all()
if not item_list:
error = [404, {'message': 'No se encontraron relaciones',
'action': 'Encuentre a un amigo'}]
return True, error
return False, item_list
def get_user_by_id(id_user):
if not id_user:
raise InvalidArgument(
'El campo user_account id no puede estar vacio o nulo')
user = s.query(User).filter(User.user_id == id_user).first()
if not user:
raise ResourceConflict('Este usuario no existe')
return user
def check_item_exists(user1, user2):
item = s.query(Relationship).filter(or_(and_(
Relationship.id_usuario == user1,
Relationship.id_usuario_amigo == user2), and_(
Relationship.id_usuario == user2,
Relationship.id_usuario_amigo == user1))).first()
if item is None:
return False
return True
def get_standard_basket(user):
raw_basket = s.query(
StandardBasket,
Stock).filter(StandardBasket.user_id == user).join(Stock).all()
basket = []
for basket_item, inventory in raw_basket:
basket_item.inventory = inventory
basket.append(basket_item)
return basket
def check_schedule_exists_by_warehouse(warehouse, day):
if not warehouse:
raise InvalidArgument('El campo warehouse no puede estar vacio o nulo')
if not day:
raise InvalidArgument('El campo day no puede estar vacio o nulo')
if s.query(StoreHours).filter(
and_(StoreHours.store_id == warehouse,
StoreHours.day == day)).first():
raise ResourceConflict(
'Este horario ya se encuentra asociado al almacen')
return {'success': True}, 200, {'ContentType': 'application/json'}
def get_item(item_id):
item = s.query(ProductOrder).filter(
ProductOrder.product_order_id == item_id).first()
if not item:
error = [
404, {
'message': 'Esta orden no existe',
'action': 'Realice una nueva consulta'
}
]
return True, error
return False, item
def get_service_provider(wh):
active_sp = s.query(
ServiceProviderSchedule.id_prestador_servicio,
func.ST_X(ServiceProvider.ultima_ubicacion),
func.ST_Y(ServiceProvider.ultima_ubicacion)
).join(ServiceProvider).filter(
and_(ServiceProviderSchedule.id_almacen == wh,
ServiceProviderSchedule.inicio < datetime.datetime.now(),
ServiceProviderSchedule.fin > datetime.datetime.now())).all()
selected_sp = None
return False, selected_sp
def get_item(item_id, user):
item = s.query(Membership).filter(
and_(Membership.id_grupo == item_id,
Membership.id_usuario == user)).first()
if not item:
error = [
404, {
'message': 'Esta membresia no existe',
'action': 'Realice una nueva consulta'
}
]
return True, error
return False, item
def get_inventory_quantity_by_id(stock_item_id):
inventory_inputs = s.query(func.sum(
StockInput.stock_input_quantity)).filter(
StockInput.stock_item_id == stock_item_id)
inventory_outputs = s.query(func.sum(
StockOutput.stock_output_quantity)).filter(
StockOutput.stock_item_id == stock_item_id)
inventory_sold = s.query(
func.sum(ProductOrderItem.product_order_item_quantity)).filter(
ProductOrderItem.product_order_item_quantity == stock_item_id)
'''Doble for para desempaquetar el tuple dentro de lista, resultado de query '''
inventory_quantity = 0
for inventory_input, in inventory_inputs:
for inventory_output, in inventory_outputs:
for sold, in inventory_sold:
if inventory_input is None:
inventory_input = 0
if inventory_output is None:
inventory_output = 0
if sold is None:
sold = 0
inventory_quantity = inventory_input - inventory_output - sold
return inventory_quantity
def get_active_service_provider(wh):
sp_list = s.query(ServiceProviderSchedule).filter(
and_(ServiceProviderSchedule.id_almacen == wh,
ServiceProviderSchedule.inicio < datetime.datetime.now(),
ServiceProviderSchedule.fin > datetime.datetime.now())).all()
if not sp_list:
error = [
404, {
'message': 'No existen transportadores activos',
'action': 'Realice de nuevo la confirmación de la orden'
}
]
return True, error
return False, sp_list
def get_address_list_by_user_location(id_user, location):
if not id_user or '':
raise InvalidArgument('El campo id_user no puede estar vacio')
if not location or '':
raise InvalidArgument('El campo location no puede estar vacio')
addresses = s.query(
UserLocation,
UserLocation.gps.ST_Distance_Sphere('POINT({} {})'.format(
location[0], location[1]))).filter(
and_(
UserLocation.gps.ST_Distance_Sphere('POINT({} {})'.format(
location[0], location[1])) <= 1000,
UserLocation.user_id == id_user))
return addresses
def get_role(group, user):
item = s.query(Membership).filter(
and_(Membership.id_grupo == group,
Membership.id_usuario == user)).first()
if not item:
error = [
404, {
'message':
'No hace parte de este grupo o el grupo no existe',
'action':
'Solicite su vinculación a este grupo o realice una '
'nueva consulta con un grupo existente'
}
]
return True, error
return False, item.id_rol_grupo
def get_warehouse_by_location(location):
if not location or '':
raise InvalidArgument('El campo location no puede estar vacio')
warehouses = s.query(
Store,
StoreLocation.store_gps.ST_Distance_Sphere('POINT({} {})'.format(
location[0], location[1]))).join(StoreLocation).filter(
StoreLocation.store_gps.ST_Distance_Sphere(
'POINT({} {})'.format(location[0], location[1])) <= 2000)
whs = []
for wh in warehouses:
wh[0].distancia = wh[1]
whs.append(wh[0])
print('Almacenes dentro de rango =>',
[(wh.store_name, wh.distancia) for wh in whs])
return whs
def username_generator(name, size=6, chars=string.digits):
if re.match("[a-zA-Z0-9]+", unidecode(name).replace(" ", "")) is None:
raise InvalidArgument(
'El campo name debe tener al menos una letra o numero')
name = unidecode(name).lower()
nameproc = name.split(" ")
if nameproc.__len__() >= 2:
name = nameproc[0] + '-' + nameproc[1]
elif nameproc.__len__() == 1:
name = nameproc[0]
else:
name = 'retailproj'
username = name + "-" + ''.join(random.choice(chars) for _ in range(size))
if s.query(User).filter(User.username == username).first():
try:
return username_generator(name)
except RecursionError:
return username_generator(name, size=size + 1)
return username
def get_list_by_user(user, rq_user):
item_list = s.query(Membership).filter(
Membership.id_usuario == user).all()
if rq_user is not user:
error = [
403, {
'message':
'No cuenta con los permisos acceder a este recurso',
'action': 'Realice otra consulta'
}
]
return True, error
if not item_list:
error = [
404, {
'message':
'No se encontraron membresias',
'action':
'Solicite la vinculacion a algun grupo o cree uno nuevo'
}
]
return True, error
return False, item_list
def check_user_not_exists_by_mail(mail):
if not mail:
raise InvalidArgument('El campo mail no puede estar vacio o nulo')
if s.query(User).filter(User.email_address == mail).first():
raise ResourceConflict(
'Este correo electronico ya se encuentra asociado a una cuenta')
def check_user_not_exists_by_id(item_id):
if not item_id:
raise InvalidArgument('El campo item_id no puede ser vacio o nulo')
if s.query(User).filter(User.user_id == item_id).first():
raise ResourceConflict(
'Este user_account id ya se encuentra asociado a una cuenta')
def check_user_not_exists_by_username(username):
if not username:
raise InvalidArgument('El campo username no puede estar vacio o nulo')
if s.query(User).filter(User.username == username).first():
raise ResourceConflict(
'Este nombre de usuario ya se encuentra asociado a una cuenta')
def get_list_by_relationship(rs):
return s.query(RelationshipStatus).filter(
RelationshipStatus.id_relacion == rs).order_by(
RelationshipStatus.id_estado_relacion.desc()).all()
def check_user_not_exists_by_phone(phone):
if not phone:
raise InvalidArgument('El campo phone no puede estar vacio o nulo')
if s.query(User).filter(User.phone_number == phone).first():
raise ResourceConflict(
'Este numero de telefono ya se encuentra asociado a una cuenta')
def get_address_list_by_user(id_user):
if not id_user or '':
raise InvalidArgument('El campo id_user no puede estar vacio')
return s.query(UserLocation).filter(UserLocation.user_id == id_user).all()
def get_address_by_id(item_id):
location_item = s.query(
UserLocation, func.ST_X(UserLocation.gps), func.ST_Y(UserLocation.gps),
func.ST_AsText(UserLocation.gps)).filter(
UserLocation.user_address_id == item_id).first()
return location_item
