The image is not displayed in the template, in the img tag. The django documentation is very poor on this topic. I have also followed some tutorials but it doesn't work either. The rest of the application works perfectly, I only have to fix this. This is my project: Structure of the static and media folders:

├───.settings
├───catalogo
│   ├───migrations
│   │   └───__pycache__
│   └───__pycache__
├───media
│   └───fotos
│       ├───articulos
│       └───libros
├───plantillas
│   ├───catalogo
│   └───registration
├───static
│   ├───admin
│   │   ├───css
│   │   │   └───vendor
│   │   │       └───select2
│   │   ├───fonts
│   │   ├───img
│   │   │   └───gis
│   │   └───js
│   │       ├───admin
│   │       └───vendor
│   │           ├───jquery
│   │           ├───select2
│   │           │   └───i18n
│   │           └───xregexp
│   ├───css
│   ├───js
│   └───media

Project Settings:

STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static')
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'

MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

Models:

    class FotoArt(models.Model):
        nombre = models.CharField(max_length=50)
        foto = models.ImageField(upload_to='fotos/articulos/', 
        null=True, blank=True)

        class Meta:
            ordering = ['nombre']
            verbose_name = _('Foto Artículo')
            verbose_name_plural = _('Fotos Artículos')

        def __str__(self):
            return self.nombre

        def get_absolute_url(self):
            return reverse('detalle-fotoArt', args= 
            [str(self.id)])

    class ArtMixin(models.Model):
        class Meta:
            abstract = True
            ordering = ["titulo"]

        AÑO_CHOICES = []
        for r in range(1975, (datetime.datetime.now().year+1)):
            AÑO_CHOICES.append((r,r))

        NORMAL = 'NR'
        BUENO = 'BN'
        NUEVO = 'NV'
        ESTADO_CHOICES = [
            (NORMAL, 'Normal, con señales de uso'),
            (BUENO, 'Buen estado, como nuevo'),
            (NUEVO, 'Nuevo'),
        ]

        titulo = models.CharField(max_length=200)
        precio = models.PositiveSmallIntegerField()
        estado = models.CharField(
            max_length = 2,
            choices = ESTADO_CHOICES,
            default = BUENO,
        )
        publicado_URLs = models.ManyToManyField(Publicacion, 
        blank=True)
        descripcion = models.TextField(null=True, blank=True)


        def __str__(self):
            return self.titulo

    class Articulo(ArtMixin):
        año_compra = models.PositiveSmallIntegerField(choices = 
        ArtMixin.AÑO_CHOICES)
        fotos = models.ManyToManyField(FotoArt, blank=True)

        class Meta:
            verbose_name = _('Artículo')
            verbose_name_plural = _('Artículos')

        def get_absolute_url(self):
            return reverse('detalle-art', args=[str(self.id)])

The views:

class DetalleFotoArt(generic.DetailView):
    model = FotoArt
    context_object_name = "fotoArt"
    template_name = 'catalogo/detalle_fotoArt.html'

class FotoArtCrear(LoginRequiredMixin, CreateView):
    model = FotoArt
    fields = '__all__'

Templates:

detalle_fotoArt.html
{% extends 'catalogo/base.html' %}

{% block content %}
    <h1>Foto Artículo: {{ fotoArt.nombre }}</h1>
    <hr/>
    <img src="{{ fotoArt.foto.url}}" alt="{{ fotoArt.nombre }}" height="200" width="200">
    <hr/>
    <div class="row">
        <a class="nav-link btn-style" href = "{% url 'actualizar-fotoArt' fotoArt.pk %}">Actualizar</a>
        <a class="nav-link btn-style" href = "{% url 'borrar-fotoArt' fotoArt.pk %}">Borrar</a>
    </div>
{% endblock %}

fotoArt_form.html
{% extends 'catalogo/base.html' %}

{% block content %}
    <h2>Crear/Actualizar Fotos Artículos</h2>
    <form action="" method="post">
        {% csrf_token %}
        <table>
            {{ form.as_table }}
        </table>
        <input type="submit" value="Enviar" />
    </form>
{% endblock %}

When introducing new photos (fotoArt_form.html) it throws the error "The attribute 'photo' has no associated file.", although it actually creates the record in the database, but with the photo field empty, consulted from PgAdmin:

And in the consultation of the photo through detail_photoArt.html, it throws me the same error. I haven't entered any url to control the photos because I don't need it, but I've also tried inserting one just in case:

re_path(r'^media/(?P<path>.*)$', 'django.views.static.serve', {'document_root': settings.MEDIA_ROOT}),

and in the runserver it already throws this error:

File "E:\Trastero\Trastero\urls.py", line 33, in <module>
    re_path(r'^media/(?P<path>.*)$', 'django.views.static.serve', {'document_root': settings.MEDIA_ROOT}),
  File "C:\Users\Administrador\Envs\gelaDjango22\lib\site-packages\django\urls\conf.py", line 73, in _path
    raise TypeError('view must be a callable or a list/tuple in the case of include().')
TypeError: view must be a callable or a list/tuple in the case of include().

What is wrong? I've tried a thousand things, and that they say that Django is a framework to create applications "quickly", hahaha it makes me laugh, surely it refers to the experts. I have also tried with src= "{{ fotoArt.foto.path}}" and with the same error.

I have a huge MongoDB database and I want to generate the Django models dynamically so I don't do it by hand (it would save me a lot of work).

I have used inspectdb before to generate the models, but according to the official Django documentation, it is only available for relational databases ( PostgreSQL, MySQL and SQLite ).

Any alternative to generate models with MongoDB and import them into my models.py?

I have a user role schema (medical, patient, physiotherapist) that derives from the AbstractUser class to use it in requests as seen in the following models:

#models.py

from __future__ import unicode_literals
from django.conf import settings
from django.contrib.auth.models import AbstractUser
from django.db import models
from django.contrib.auth import get_user_model
from django.dispatch import receiver
from django.db.models.signals import post_save

class User(AbstractUser):
    is_medical = models.BooleanField(default=False)
    is_physiotherapist = models.BooleanField(default=False)
    is_patient = models.BooleanField(default=False)
    slug = models.SlugField(max_length=100, blank=True)
    photo = models.ImageField(upload_to='avatars', null = True, blank = True)

    def get_medical_profile(self):
        medical_profile = None
        if hasattr(self, 'medicalprofile'):
            medical_profile=self.medicalprofile
        return medical_profile

    def get_patient_profile(self):
        patient_profile = None
        if hasattr(self, 'patientprofile'):
            patient_profile = self.patientprofile
        return patient_profile

    def get_physiotherapist_profile(self):
        physiotherapist_profile = None
        if hasattr(self, 'physiotherapistprofile'):
            physiotherapist_profile = self.physiotherapistprofile
        return physiotherapist_profile

    class Meta:
        db_table = 'auth_user'

class MedicalProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    name = models.CharField(max_length=64)

class PatientProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    name = models.CharField(max_length=64)

class PhysiotherapistProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    name = models.CharField(max_length=64)

What I want is that when a new user is created, automatically, his profile is created depending on his field if he is a doctor, patient, or physiotherapist ( is_medical, is_patient, is_physiotherapist)

For that I am using the signal in post_save()the following way in the same models.py file where my models are:

In the signal I am sending three parameters plus the **kwargs:

• sender, which is my users model
• created, a boolean parameter that tells me that an instance of my user model AUTH_USER_MODELhas been created
• instance, the user instance being created

To know that a user is about to be created, somehow I must find out if in that request that I make (create the user), that user or that instance that is about to be created goes, for which I douser = self.request.user

    @receiver(post_save, sender=settings.AUTH_USER_MODEL)
    def create_profile_for_new_user(sender, created, instance, **kwargs):
        # Pregunto si en el request va el user, aqui va mi inquietud
        user = self.request.user
        #user = get_user_model()
        if created:
            if user.is_medical:
                profile=MedicalProfile(user=instance)
                profile.save()

It's good logic, but it turns out that I haven't defined self and I (obviously) get this error

In the method in create_profile_for_new_user(...)which I am applying the signal of post_save()I only have four attributes, so if I add self as an attribute at the beginning

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def create_profile_for_new_user(self,sender, created, instance, **kwargs):

would get this error:

TypeError: create_profile_for_new_user() missing 1 required positional argument: 'self'
127.0.0.1 - - [28/Dec/2015 22:57:04] "GET /admin/userprofile/user/add/?__debugger__=yes&cmd=resource&f=style.css HTTP/1.1" 200 -

Another option that I was contemplating is to obtain the user that is being created with the function get_user_model()as I do here (previously importing the function of course from django.contrib.auth import get_user_model):

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
    def create_profile_for_new_user(sender, created, instance, **kwargs):
        # Pregunto si en el request va el user, aqui va mi inquietud
        #user = self.request.user
        user = get_user_model()
        if created:
            if user.is_medical:
                profile=MedicalProfile(user=instance)
                profile.save()

But when I do, I get this message, and it's logical, because my User object (I'm getting an instance of the original Django User model) doesn't have the attribute I'm asking for, in this caseis_medical

According to the above, I don't know how to ask or inquire about the user to examine their boolean attributes ( is_patient, is_medical, is_physiotherapist) and create their respective profile accordingly.

By the way, I take advantage and another concern arises: Is it possible to use the signal post_savefor more than one purpose?

In this case, I want to use it both to create a profile of the user instance that is created and to give a value to a named field slugbased on its attribute first_name. That is, could you apply it to the methods you need?

I have a disease table that has only 3 columns:

• The automatic id.
• A code varchar(10).
• the name string.

But, it has 14197 records.

The problem is that your Primary Key is a foreign key for other models, but it is taking a long time to load it.

Use djangoand PostgreSql, what is the most recommended so that it does not take so long to load it Foreign Keyin the template?

Models

class Cie10(models.Model):
    codigo = models.CharField(max_length=10)
    nombre = models.TextField()
    def __unicode__(self):
        return (u"%s (%s)"%(self.nombre, self.codigo)).strip() or "-"

class EnfermedadGeneral(Enfermedad):
    dias = models.IntegerField(validators=[no_negativo])
    cie10 = models.ForeignKey(Cie10, verbose_name="diagnóstico Cie10")
    soportes = models.FileField(upload_to=crear_ruta_archivo_enfermedad_general, blank=True, null=True)

class Enfermedad(models.Model):
    persona = models.ForeignKey(Persona, related_name="enfermo")
    responsable = models.ForeignKey(Persona, related_name="responsable")
    municipio = models.ForeignKey(Municipio)
    zona = models.IntegerField(choices=ZONAS)
    sucursal = models.ForeignKey(Sucursal)
    area = models.ForeignKey(Area)
    cargo = models.ForeignKey(Cargo)
    tipo_empleado = models.CharField(max_length=1, choices=TIPO_EMPLEADO)
    fecha_ingreso = models.DateField()
    fecha_diligenciamiento = models.DateTimeField(auto_now_add=True, blank=True)

    fecha = models.DateField(verbose_name="fecha del diagnóstico")

    def __unicode__(self):
        return (u"%s (%s)"%(self.persona, self.fecha)).strip() or "-"

    class Meta:
        unique_together = (("persona", "fecha"),)

Form Example

class EnfermedadGeneralForm(forms.ModelForm):
    class Meta: model = EnfermedadGeneral
    exclude = ('responsable', 'persona', 'sucursal', 'area', 'cargo', 'tipo_empleado', 'fecha_ingreso', 'fecha_diligenciamiento',)
    widgets = {
        'fecha' : MyDateWidget(),
        'municipio': Select2Widget(),
        'cie10': Select2Widget(),
        'soportes' : MyFileInput(), } 

Form in the template

<form class="form-vertical" enctype="multipart/form-data" method="post">{% csrf_token %}
    {% bootstrap_form form layout="horizontal" %}
    <button class="btn btn-lg btn-primary pull-right" type="submit" onclick="$('#id_dia_semana').attr('disabled', false);">
        Registrar <i class="fa fa-check"></i>
    </button>
</form>

view example

@login_required
@all_permission_required('novedades.add_enfermedadgeneral')
def crear_enfermedad_general(request, idPersona=None):
    persona = None
    hoy = datetime.now()
    usuario = Persona.objects.get(usuario=request.user)

    enfermedadGeneralCreada = request.session.get('nueva_enfermedad_general')

    if enfermedadGeneralCreada == True:
        del request.session['nueva_enfermedad_general']

    if idPersona:
        try:
            persona = Persona.objects.get(id=idPersona)
        except Exception:
            return redirect('crear_enfermedad_general')


    if request.method == 'POST':
        form = EnfermedadGeneralForm(request.POST, request.FILES)
        if form.is_valid():
            objeto = form.save(commit=False)
            objeto.responsable = Persona.objects.get(usuario=request.user)
            objeto.persona = persona
            objeto.sucursal = persona.sucursal
            objeto.area = persona.cargo.area
            objeto.cargo = persona.cargo
            objeto.tipo_empleado = persona.tipo_empleado
            objeto.fecha_ingreso = persona.fecha_ingreso

            objeto.soportes = None
            objeto.save()

            try:
                objeto.soportes = request.FILES['soportes']
            except Exception:
                1

            objeto.save()

            request.session['nueva_enfermedad_general'] = True
            return redirect('crear_enfermedad_general')

        form2 = CedulaForm(request.POST)
        if form2.is_valid():
            persona = form2.cleaned_data['persona']
            return redirect('crear_enfermedad_general', persona.id)
    else:
        form = EnfermedadGeneralForm()
        try:
            form2 = CedulaForm({'persona': persona.id})
        except Exception:
            form2 = CedulaForm()

    return render(request, 'enfermedad_general.html', {
        'enfermedadGeneralCreada': enfermedadGeneralCreada,
        'persona': persona,
        'form': form,
        'form2': form2,
        'hoy': hoy,
        'usuario': usuario,
    })

My problem or question is how to use the permissions assigned to users, whether they are group or individual permissions, so that when a user logs in using the Django Rest Framework, they only have access to the tables to which they have assigned permissions.

Currently if I log in I have access to all the tables, be it the admin user or any other. If you can give me an example, or show me a link where it is exemplified, it would be very helpful.

I leave the repository link on github https://github.com/Weed-Nim/BillAPI.git

For programming use the serializer and viewsets in each of the apps

Here I put pictures of the code:

PD: above is the repository, I only put a quick view of how I work it, although I repeat my doubt is how can I do it so that when a user logs in he only has access to the tables which he has permissions (individual or group) and it does not happen the image thing. Thanks in advance.