def test_current_user_field(self):
user = User.objects.get(username="******")
CuserMiddleware.set_user(user)
TestModel.objects.create(name="TEST")
CuserMiddleware.del_user()
test_instance = TestModel.objects.get(name="TEST")
self.assertEqual(test_instance.creator, user)
def get_queryset(self, *args, **kwargs):
self.app = app_from_object(self)
self.model = class_from_string(self, self.kwargs['model'])
# Communicate the request user to the models (Django doesn't make this easy, need cuser middleware)
CuserMiddleware.set_user(self.request.user)
# If the URL has GET parameters (following a ?) then self.request.GET
# will contain a dictionary of name: value pairs that FilterSet uses
# construct a new filtered queryset.
self.filterset = None
self.format = get_list_display_format(self.request.GET)
self.ordering = get_ordering(self)
self.queryset = self.model.objects.all()
if len(self.request.GET) > 0 or len(
self.request.session.get("filter", {})) > 0:
fs = get_filterset(self)
# If there is a filter specified in the URL
if not fs is None:
self.filterset = fs
self.queryset = fs.filter()
if (self.ordering):
self.queryset = self.queryset.order_by(*self.ordering)
self.count = len(self.queryset)
return self.queryset
def test_current_user_field(self):
user = User.objects.get(username="******")
CuserMiddleware.set_user(user)
TestModel.objects.create(name="TEST")
CuserMiddleware.del_user()
test_instance = TestModel.objects.get(name="TEST")
self.assertEqual(test_instance.creator, user)
def setUpTestData(cls):
cls.user = User.objects.create_user(
username="******", email="", password="******"
)
cls.user_repr = repr(cls.user)
CuserMiddleware.set_user(cls.user)
cls.pet = Pet.objects.create(name="Catz", age=12)
cls.human = Human.objects.create(name="George", age=42, height=175)
cls.human_repr = repr(cls.human)
def setUpTestData(cls):
cls.user = User.objects.create_user(
username="******", email="", password="******"
)
cls.user_repr = repr(cls.user)
CuserMiddleware.set_user(cls.user)
cls.pet = Pet.objects.create(name="Catz", age=12)
cls.human = Human.objects.create(name="George", age=42, height=175)
cls.human_repr = repr(cls.human)
def setUp(self):
self.user = User.objects.create_user(
username="******", email="", password="******"
)
self.user_repr = repr(self.user)
CuserMiddleware.set_user(self.user)
self.pet = Pet.objects.create(name="Catz", age=12)
self.pet2 = Pet.objects.create(name="Catzou", age=1)
self.human = Human.objects.create(name="George", age=42, height=175)
self.human.pets.add(self.pet)
self.human_repr = repr(self.human)
def setUp(self):
self.user = User.objects.create_user(
username="******", email="", password="******"
)
self.user_repr = repr(self.user)
CuserMiddleware.set_user(self.user)
self.pet = Pet.objects.create(name="Catz", age=12)
self.pet2 = Pet.objects.create(name="Catzou", age=1)
self.human = Human.objects.create(name="George", age=42, height=175)
self.human.pets.add(self.pet)
self.human_repr = repr(self.human)
def get_queryset(self, *args, **kwargs):
if settings.DEBUG:
log.debug(
f"Getting Queryset for List View. Process ID: {os.getpid()}.")
if len(self.request.GET) > 0:
log.debug(f"GET parameters:")
for key, val in self.request.GET.items():
log.debug(f"\t{key}={val}")
else:
log.debug(f"No GET parameters!")
self.app = app_from_object(self)
self.model = class_from_string(self, self.kwargs['model'])
# Communicate the request user to the models (Django doesn't make this easy, need cuser middleware)
CuserMiddleware.set_user(self.request.user)
self.format = get_list_display_format(self.request.GET)
self.ordering = get_ordering(self)
self.filterset = None # Default
fs = None
if len(self.request.GET) > 0 or len(
self.request.session.get("filter", {})) > 0:
# If the URL has GET parameters (following a ?) then self.request.GET
# will contain a dictionary of name: value pairs that FilterSet uses
# construct a new filtered queryset.
fs = get_filterset(self)
# If there is a filter specified in the URL
if fs:
self.filterset = fs
self.queryset = fs.filter()
else:
self.queryset = self.model.objects.all()
if (self.ordering):
self.queryset = self.queryset.order_by(*self.ordering)
if settings.DEBUG:
log.debug(f"ordering = {self.ordering}")
log.debug(
f"filterset = {self.filterset.get_specs() if self.filterset else None}"
)
self.count = len(self.queryset)
return self.queryset
def bodega_actual():
user = CuserMiddleware.get_user()
cuenta = Cuenta.objects.filter(pk=user.pk).first()
if cuenta:
return cuenta.bodega
# end if
return None
def pre_save(self, model_instance, add):
if add or not self.add_only:
user = CuserMiddleware.get_user()
if user:
setattr(model_instance, self.attname, user.pk)
return user.pk
return super(CurrentUserField, self).pre_save(model_instance, add)
def published(self):
user = CuserMiddleware.get_user()
if user.is_superuser:
books = self
else:
books = self.filter(published=True)
return books
def clean(self):
super(CitaMedicaFormSupra, self).clean()
if not hasattr(self, 'instance'):
user = CuserMiddleware.get_user()
paciente = usuarios.Paciente.objects.filter(id=user.id).first()
if not paciente:
form.ValidationError("Necesita ser un paciente para crear una cita")
def get_queryset(self):
qs = super(AnswerListView, self).get_queryset()
user = CuserMiddleware.get_user()
slug = self.kwargs.get('slug', None)
survey = get_object_or_404(Survey.objects.published(), slug=slug)
qs = qs.user_survey(user=user, survey=survey)
return qs
def __init__(self, *args, **kwargs):
super(NoSerialForm, self).__init__(*args, **kwargs)
user = CuserMiddleware.get_user()
cuenta = inv.Cuenta.objects.filter(pk=user.pk).first()
if cuenta and self.fields.has_key('noserial'):
self.fields['noserial'].queryset = inv.ActivoNoSerial.objects.filter(bodega=cuenta.bodega)
# end if
def clean(self):
data = self.cleaned_data
noserial = geo.GeoNoSerial.objects.filter(geoactivo=data['geoactivo'], noserial=data['noserial']).first()
if noserial:
raise forms.ValidationError("Ya tiene asignado/a una %s" % (data['noserial'].nombre))
else:
return data
# end if
# end def
def clean_cantidad(self):
if self.cleaned_data['cantidad']:
cantidad = self.cleaned_data['cantidad']
noserial = self.cleaned_data['noserial']
if noserial:
if noserial.cantidad - cantidad < 0:
raise forms.ValidationError("La cantidad maxima disponible es %d" % (cantidad))
# end if
return cantidad
# end if
return forms.ValidationError("Seleccione un activo no serial")
# end if
return forms.ValidationError("Este campo es requerido")
def update(self, instance, validated_data):
if not instance:
return self.create(validated_data)
#end if
user = CuserMiddleware.get_user()
service = venta.Service.objects.filter(userservice__user = user).first()
order = instance
if 'bill' in validated_data:
order.bill = validated_data['bill']
#end if
if 'client' in validated_data:
order.client = validated_data['client']
#end if
if 'canceled' in validated_data:
order.canceled = validated_data['canceled']
#end if
order.service = service
order.save()
if 'products' in validated_data:
order.products.all().delete()
for item in validated_data['products']:
itemorder = venta.ItemOrder.objects.create(product=item['product'], count=item['count'])
order.products.add(itemorder)
#end for
#end if
return order
def get_object(self, *args, **kwargs):
self.app = app_from_object(self)
self.model = class_from_string(self, self.kwargs['model'])
# Communicate the request user to the models (Django doesn't make this easy, need cuser middleware)
CuserMiddleware.set_user(self.request.user)
self.pk = self.kwargs['pk']
self.obj = get_object_or_404(self.model, pk=self.kwargs['pk'])
self.format = get_object_display_format(self.request.GET)
self.success_url = reverse_lazy('list',
kwargs={'model': self.kwargs['model']})
collect_rich_object_fields(self)
return self.obj
def get_avatar_queryset(self):
""" Fetch special avatars if the user is an admin."""
user = CuserMiddleware.get_user()
avatar_queryset = DiventiAvatar.objects.all().order_by('-staff_only')
if not user or not user.is_staff:
avatar_queryset = avatar_queryset.filter(staff_only=False)
return avatar_queryset
def delete(self, request, *args, **kwargs):
self.object = self.get_object()
self.object.eliminado = True
user = CuserMiddleware.get_user()
self.object.eliminado_por = user
self.object.save()
return HttpResponse(status=200)
def in_collection(self):
user = CuserMiddleware.get_user()
if user.is_authenticated():
item_set = self.collectionitem_set.filter(collection__user=user)
return item_set.count() > 0
else:
return False
def unread_dialogs():
user = CuserMiddleware.get_user()
if user.is_authenticated():
d_count = get_unread_messages_count(user.id)
if d_count > 0:
return "+{}".format(d_count)
return ""
def user_has_promoted(self):
# Fetch the logged user thanks to a dedicated middleware
user = CuserMiddleware.get_user()
if user in self.promotions.all():
return True
else:
return False
def get_fields(self, request, obj):
fields = super(BillAdmin, self).get_fields(request, obj)
user = CuserMiddleware.get_user()
service = Service.objects.filter(userservice__user = user).first()
if service:
fields.remove('service')
return fields
def increase_activity(self, date, issue=None, decrease=False):
actor = CuserMiddleware.get_user()
# handle user activity, if there is a current user
if actor and not isinstance(actor, AnonymousUser):
user_activity = json.loads(actor.activity)
iss = 'None'
if issue:
iss = issue.get_ticket_identifier()
if decrease:
if self.name_short in user_activity:
user_activity[self.name_short].pop()
else:
if self.name_short in user_activity:
user_activity[self.name_short].append((date.isoformat(), iss))
else:
user_activity[self.name_short] = []
user_activity[self.name_short].append((date.isoformat(), iss))
actor.activity = json.dumps(user_activity)
actor.save()
# delete cache
cache.delete('action_data_'+actor.username)
cache.delete('action_data_'+actor.username+'_'+self.name_short)
# handle project activity
activity_dict = json.loads(self.activity)
if isinstance(activity_dict, dict):
activity_dict = []
if decrease:
activity_dict.pop()
else:
activity_dict.append(date.isoformat())
self.activity = json.dumps(activity_dict)
self.save()
return
def user_collection(self, user):
current_user = CuserMiddleware.get_user() # The user that is operating in the session
products = self.filter(customers=user)
if current_user != user: # Hide non-published products if the user is not visiting his own profile
products = products.published()
products = products.prefetch()
return products
def save_model(self, request, obj, form, change): user = CuserMiddleware.get_user() service = Service.objects.filter(userservice__user = user).first() if service: obj.service = service #end if super(ClientAdmin, self).save_model(request, obj, form, change)
def is_owned(self):
user = CuserMiddleware.get_user()
if user is None:
return False
if user.is_staff:
return True
return self.owners.filter(id=user.pk).exists()
def get_queryset(self, request):
queryset = super(DepartamentoAdmin, self).get_queryset(request)
user = CuserMiddleware.get_user()
if not request.user.is_superuser:
queryset = queryset.filter(empresa__empresa=user)
# end if
return queryset
def bodega_actual():
user = CuserMiddleware.get_user()
cuenta = Cuenta.objects.filter(pk=user.pk).first()
if cuenta:
return cuenta.bodega
# end if
return None
def update_admin_fields(self):
'''
Update the CoGs admin fields on an object (whenever it is saved).
'''
now = timezone.now()
usr = CuserMiddleware.get_user()
if hasattr(self, "last_edited_by"):
self.last_edited_by = usr
if hasattr(self, "last_edited_on"):
self.last_edited_on = now
if hasattr(self, "last_edited_on_tz"):
self.last_edited_on_tz = str(get_current_timezone())
# We infer that if the object has pk it was being edited and if it has none it was being created
if self.pk is None:
if hasattr(self, "created_by"):
self.created_by = usr
if hasattr(self, "created_on"):
self.created_on = now
if hasattr(self, "created_on_tz"):
self.created_on_tz = str(get_current_timezone())
def published(self):
user = CuserMiddleware.get_user()
if user.is_superuser:
chapters = self
else:
chapters = self.filter(chapter_book__published=True)
chapters = chapters.book()
return chapters
def delete(self, *args, **kwargs):
TrackingEvent.objects.create(
operation=TrackingEvent.DELETE,
user=CuserMiddleware.get_user(),
date=now(),
obj=self,
)
super().delete(*args, **kwargs)
def save(self, *args, **kwargs):
user = CuserMiddleware.get_user()
cuenta = Cuenta.objects.filter(pk=user.pk).first()
if cuenta:
self.creado_por = cuenta
self.salida = cuenta.bodega
super(SalidaInsumo, self).save(*args, **kwargs)
self.activos.update(bodega=None)
def save(self, *args, **kwargs):
user = CuserMiddleware.get_user()
cuenta = Cuenta.objects.filter(pk=user.pk).first()
if cuenta:
self.destino = cuenta.bodega
acta = super(EntradaInsumo, self).save(*args, **kwargs)
self.activos.update(bodega=self.destino)
return acta
def save(self, *args, **kwargs):
user = CuserMiddleware.get_user()
cuenta = Cuenta.objects.filter(pk=user.pk).first()
if cuenta:
self.destino = cuenta.bodega
acta = super(EntradaInsumo, self).save(*args, **kwargs)
self.activos.update(bodega=self.destino)
return acta
def __init__(self, *args, **kwargs):
super(ReviewForm, self).__init__(*args, **kwargs)
user = CuserMiddleware.get_user()
if not user.is_anonymous():
try:
self.fields['name'].initial = UserProfile.objects.get(user=user).get_full_name()
except UserProfile.DoesNotExist:
pass
def save(self, *args, **kwargs):
if self.pk is None:
super().save(*args, **kwargs)
self.owners.add(CuserMiddleware.get_user())
elif self.is_owned():
super().save(*args, **kwargs)
else:
raise PermissionDenied()
def save(self, *args, **kwargs):
user = CuserMiddleware.get_user()
cuenta = Cuenta.objects.filter(pk=user.pk).first()
if cuenta:
self.creado_por = cuenta
self.salida = cuenta.bodega
super(SalidaInsumo, self).save(*args, **kwargs)
self.activos.update(bodega=None)
def get_object(self, *args, **kwargs):
self.model = class_from_string(self, self.kwargs['model'])
self.pk = self.kwargs['pk']
# Communicate the request user to the models (Django doesn't make this easy, need cuser middleware)
CuserMiddleware.set_user(self.request.user)
# Get the ordering
self.ordering = get_ordering(self)
# Get Neighbour info for the object browser
self.filterset = get_filterset(self)
neighbours = get_neighbour_pks(self.model,
self.pk,
filterset=self.filterset,
ordering=self.ordering)
# Support for incoming next/prior requests via a GET
if 'next' in self.request.GET or 'prior' in self.request.GET:
self.ref = get_object_or_404(self.model, pk=self.pk)
# If requesting the next or prior object look for that
# FIXME: Totally fails for Ranks, the get dictionary fails when there are ties!
# Doesn't generalise well at all. Must find a general way to do this for
# arbitrary orders. Still should specify orders in models that create unique
# ordering not reliant on pk break ties.
if neighbours:
if 'next' in self.request.GET and not neighbours[1] is None:
self.pk = self.object_browser[1]
elif 'prior' in self.request.GET and not neighbours[0] is None:
self.pk = self.object_browser[0]
self.obj = get_object_or_404(self.model, pk=self.pk)
self.kwargs["pk"] = self.pk
else:
self.obj = get_object_or_404(self.model, pk=self.pk)
# Add this information to the view (so it's available in the context).
self.object_browser = neighbours
self.format = get_object_display_format(self.request.GET)
collect_rich_object_fields(self)
return self.obj
def __init__(self, *args, **kwargs):
super(SalidaInsumoForm, self).__init__(*args, **kwargs)
user = CuserMiddleware.get_user()
cuenta = inventario.Cuenta.objects.filter(pk=user.pk).first()
if cuenta:
self.fields['activos'].queryset = ActivoInsumo.objects.filter(
Q(bodega=cuenta.bodega, vendido=False) | Q(salidainsumo=self.instance))
self.fields['destino'].queryset = Bodega.objects.all().exclude(id=cuenta.bodega.id)
def clean(self):
if self.instance.pk == None:
user = CuserMiddleware.get_user()
cuenta = inventario.Cuenta.objects.filter(pk=user.pk).first()
if cuenta:
return super(ActivoInsumoForm, self).clean()
else:
raise forms.ValidationError("Necesita tener una cuenta de bodega para registrar el activo no serial")
def clean(self):
if self.instance.pk == None:
user = CuserMiddleware.get_user()
cuenta = inv.Cuenta.objects.filter(pk=user.pk).first()
if cuenta:
self.instance.creado_por = cuenta
return super(GeoActivoForm, self).clean()
else:
raise forms.ValidationError("Necesita tener una cuenta para crear el Apta de Salida")
def clean(self):
if self.instance.pk == None:
user = CuserMiddleware.get_user()
cuenta = inventario.Cuenta.objects.filter(pk=user.pk).first()
if cuenta:
self.instance.creado_por = cuenta
return super(EntradaInsumoForm, self).clean()
else:
raise forms.ValidationError("Necesita tener una cuenta de bodega para registrar la entrada de insumos")
def clean(self):
if self.instance.pk == None:
user = CuserMiddleware.get_user()
cuenta = inventario.Cuenta.objects.filter(pk=user.pk).first()
if cuenta:
self.instance.bodega = cuenta.bodega
return super(ActaRequisicionForm, self).clean()
else:
raise forms.ValidationError("Necesita tener una cuenta de bodega para crear el Apta de Requisicion")
def get_agency(user=None):
from agencies.models import Agency
if not user:
user = CuserMiddleware.get_user()
try:
agency = user.agent_profile.agency
except:
agency = Agency.objects.get(id=settings.DEFAULT_AGENCY_ID)
return agency
def create(self, validated_data):
user = CuserMiddleware.get_user()
service = venta.Service.objects.filter(userservice__user = user).first()
row = {
'name': validated_data['name'],
'service': service,
'image': validated_data['image']
}
return venta.Category.objects.create(**row)
def get_queryset(self):
qs = super(NoteViewSet, self).get_queryset()
user = CuserMiddleware.get_user()
if user:
if user.is_superuser:
return qs
else:
return qs.filter(agency=get_agency())
else:
return qs.filter(agency=get_agency())
def __init__(self, *args, **kwargs):
super(GeoActivoForm, self).__init__(*args, **kwargs)
user = CuserMiddleware.get_user()
cuenta = inv.Cuenta.objects.filter(pk=user.pk).first()
if self.instance.pk == None:
if cuenta:
self.fields['activo'].queryset = inv.Activo.objects.filter(instalado=False, activado=True,
bodega=cuenta.bodega)
else:
self.fields['activo'].queryset = inv.Activo.objects.filter(instalado=False, activado=True)
def get_queryset(self):
qs = super(LeadPropertyDetail, self).get_queryset()
user = CuserMiddleware.get_user()
if user:
if user.is_superuser:
return qs
else:
return qs.filter(agency=get_agency())
else:
return qs.filter(agency=get_agency())
def get_queryset(self):
qs = super(PropertyViewSet, self).get_queryset()
user = CuserMiddleware.get_user()
if user:
if user.is_superuser:
return qs.filter(approved=True)
else:
return qs.filter(agency=get_agency(), approved=True)
else:
return qs.filter(agency=get_agency(), approved=True)
def get_query_set(self):
qs = super(AgencyIsolatedHstoreManager, self).get_query_set()
user = CuserMiddleware.get_user()
if user:
if user.is_superuser:
return qs
else:
return qs.filter(agency=get_agency())
else:
return qs.filter(agency=get_agency())
def get_queryset(self):
lead_pk = self.kwargs.get('lead_pk', None)
if lead_pk is not None:
user = CuserMiddleware.get_user()
if user:
if user.is_superuser:
return LeadProperty.objects.filter(lead__pk=lead_pk)
else:
return LeadProperty.objects.filter(lead__pk=lead_pk, agency=get_agency())
else:
return LeadProperty.objects.filter(lead__pk=lead_pk, agency=get_agency())
return []
def get_queryset(self):
qs = super(MessageViewSet, self).get_queryset()
user = CuserMiddleware.get_user()
if user:
if user.is_superuser:
return qs.order_by('-processed')
else:
agency = get_agency()
return qs.filter(mailbox=agency.mailbox).order_by('-processed')
else:
agency = get_agency()
return qs.filter(mailbox=agency.mailbox).order_by('-processed')
def __init__(self, *args, **kwargs):
super(ClienteForm, self).__init__(*args, **kwargs)
self.fields['fecha'].widget = CalendarWidget(
attrs={'class': 'date'}, format="%d/%m/%Y")
self.fields['fecha'].input_formats = ('%Y/%m/%d', '%d/%m/%Y')
if self.instance.pk == None:
user = CuserMiddleware.get_user()
cuenta = inv.Cuenta.objects.filter(pk=user.pk).first()
if cuenta:
self.fields['piscina'].queryset = inv.Activo.objects.filter(
vendido=False, bodega=cuenta.bodega)
else:
self.fields['piscina'].queryset = inv.Activo.objects.filter(
vendido=False)
def get_queryset(self):
global db_start
db_start = time.time()
qs = Lead.objects.select_related('customer').all()
source = self.request.QUERY_PARAMS.get('source', None)
if source is not None:
qs = qs.filter(source__icontains=source)
user = CuserMiddleware.get_user()
if user:
if not user.is_superuser:
qs = qs.filter(agency=get_agency())
else:
qs = qs.filter(agency=get_agency())
return qs.distinct()
def __init__(self, *args, **kwargs):
super(ActaEntradaForm, self).__init__(*args, **kwargs)
user = CuserMiddleware.get_user()
cuenta = inventario.Cuenta.objects.filter(pk=user.pk).first()
if cuenta:
if self.fields.has_key('activos'):
if self.instance.pk:
self.fields['activos'].queryset = Activo.objects.filter(vendido=False).exclude(
bodega=cuenta.bodega) | Activo.objects.filter(actaentrada=self.instance)
else:
self.fields['activos'].queryset = Activo.objects.filter(vendido=False).exclude(
bodega=cuenta.bodega)
# end if
if self.fields.has_key('origen'):
self.fields['origen'].queryset = Bodega.objects.exclude(pk=cuenta.bodega.pk)
def create(self, validated_data):
user = CuserMiddleware.get_user()
service = venta.Service.objects.filter(userservice__user = user).first()
data = {}
if 'bill' in validated_data:
data['bill'] = validated_data['bill']
#end if
if 'client' in validated_data:
data['client'] = validated_data['client']
#end if
data['service'] = service
order = venta.Order.objects.create(**data)
for item in validated_data['products']:
itemorder = venta.ItemOrder.objects.create(product=item['product'], count=item['count'])
order.products.add(itemorder)
#end for
return order
