Precisa de um exemplo mínimo de envio de ficheiros Django [fechado]

Geralmente falando quando você está tentando ' apenas obter um exemplo de trabalho 'é melhor'apenas começar a escrever código'. Não há nenhum código aqui para ajudá-lo, por isso faz com que responder à pergunta funcione muito mais para nós.

Se quiser obter um ficheiro, precisa de algo como isto num ficheiro html algures:

<form method="post" enctype="multipart/form-data">
    <input type="file" name="myfile" />
    <input type="submit" name="submit" value="Upload" />
</form>

Isso dar-lhe-á o botão de navegação, Um botão de envio para iniciar a acção (enviar o formulário) e anotar o enctype para que o Django saiba que lhe dá request.FILES

Em uma vista em algum lugar onde você pode acessar o arquivo com

def myview(request):
    request.FILES['myfile'] # this is my file

Há uma enorme quantidade de informação no ficheiro enviar documentos

Recomendo que leia a página cuidadosamente e comece a escrever o código - depois volte com exemplos e empilhe vestígios quando não funcionar.

Demonstração

Actualização da resposta de Akseli Palén. ver o relatório do github , trabalha com o Django 2

1. Criar um projecto django

Executar projecto inicial::

$ django-admin.py startproject sample

Agora é criada uma pasta (amostra ):

sample/
  manage.py
  sample/
    __init__.py
    settings.py
    urls.py
    wsgi.py 

2. criar uma aplicação

Crie uma aplicação::

$ cd sample
$ python manage.py startapp uploader

Agora uma pasta(uploader) com estes ficheiros são criado por:

uploader/
  __init__.py
  admin.py
  app.py
  models.py
  tests.py
  views.py
  migrations/
    __init__.py

3. Actualizar settings.py

Em sample/settings.py adicionar 'uploader.apps.UploaderConfig' a INSTALLED_APPS e adicionar MEDIA_ROOT e MEDIA_URL, ou seja:

INSTALLED_APPS = [
    ...<other apps>...
    'uploader.apps.UploaderConfig',
]

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

4. Actualizar urls.py

Em sample/urls.py adicionar:

...<other imports>...
from django.conf import settings
from django.conf.urls.static import static
from uploader import views as uploader_views

urlpatterns = [
    ...<other url patterns>...
    path('', uploader_views.home, name='imageupload'),
]+ static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

5. Actualizar models.py

Actualizar uploader/models.py::

from django.db import models
from django.forms import ModelForm

class Upload(models.Model):
    pic = models.FileField(upload_to="images/")    
    upload_date=models.DateTimeField(auto_now_add =True)

# FileUpload form class.
class UploadForm(ModelForm):
    class Meta:
        model = Upload
        fields = ('pic',)

6. Actualizar views.py

Actualizar uploader/views.py::

from django.shortcuts import render
from uploader.models import UploadForm,Upload
from django.http import HttpResponseRedirect
from django.urls import reverse
# Create your views here.
def home(request):
    if request.method=="POST":
        img = UploadForm(request.POST, request.FILES)       
        if img.is_valid():
            img.save()  
            return HttpResponseRedirect(reverse('imageupload'))
    else:
        img=UploadForm()
    images=Upload.objects.all().order_by('-upload_date')
    return render(request,'home.html',{'form':img,'images':images})

7. criar modelos

Crie uma pasta modelos na pasta uploader , depois crie um ficheiro em casa.html , ie sample/uploader/templates/home.html::

<div style="padding:40px;margin:40px;border:1px solid #ccc">
    <h1>picture</h1>
    <form action="#" method="post" enctype="multipart/form-data">
        {% csrf_token %} {{form}} 
        <input type="submit" value="Upload" />
    </form>
    {% for img in images %}
        {{forloop.counter}}.<a href="{{ img.pic.url }}">{{ img.pic.name }}</a>
        ({{img.upload_date}})<hr />
    {% endfor %}
</div>

8. Syncronize base de Dados

Syncronize a base de dados e o servidor::

$ python manage.py makemigrations
$ python manage.py migrate
$ python manage.py runserver

Visita http://localhost.com:8000

for key, file in request.FILES.items():
    path = file.name
    dest = open(path, 'w')
    if file.multiple_chunks:
        for c in file.chunks():
            dest.write(c)
    else:
        dest.write(file.read())
    dest.close()

O ficheiro html parece-se com o código abaixo, embora este exemplo apenas envie um ficheiro e o código para salvar os ficheiros lida com muitos: -

<form action="/upload_file/" method="post" enctype="multipart/form-data">{% csrf_token %}
<label for="file">Filename:</label>
<input type="file" name="file" id="file" />
<br />
<input type="submit" name="submit" value="Submit" />
</form>

Estes exemplos não são o meu código, foram retirados de outros dois exemplos que encontrei. Sou um principiante relativamente a django, por isso é muito provável que seja eu. falta um ponto-chave.

Continuando no exemplo do Henry :

import tempfile
import shutil

FILE_UPLOAD_DIR = '/home/imran/uploads'

def handle_uploaded_file(source):
    fd, filepath = tempfile.mkstemp(prefix=source.name, dir=FILE_UPLOAD_DIR)
    with open(filepath, 'wb') as dest:
        shutil.copyfileobj(source, dest)
    return filepath

Pode chamar a esta função handle_uploaded_file da sua vista com o objecto de ficheiro carregado. Isto irá gravar o ficheiro com um nome único (prefixado com o nome do ficheiro original carregado) no sistema de ficheiros e devolver a localização completa do ficheiro gravado. Você pode salvar o caminho no banco de dados, e fazer algo com o arquivo mais tarde.

Eu também tinha a mesma exigência. A maioria dos exemplos na net estão pedindo para criar modelos e criar formas que eu não queria usar. Aqui está o meu código final.

if request.method == 'POST':
    file1 = request.FILES['file']
    contentOfFile = file1.read()
    if file1:
        return render(request, 'blogapp/Statistics.html', {'file': file1, 'contentOfFile': contentOfFile})

E no HTML para enviar escrevi:

{% block content %}
    <h1>File content</h1>
    <form action="{% url 'blogapp:uploadComplete'%}" method="post" enctype="multipart/form-data">
         {% csrf_token %}
        <input id="uploadbutton" type="file" value="Browse" name="file" accept="text/csv" />
        <input type="submit" value="Upload" />
    </form>
    {% endblock %}

A seguir está o HTML que mostra o conteúdo do ficheiro:

{% block content %}
    <h3>File uploaded successfully</h3>
    {{file.name}}
    </br>content = {{contentOfFile}}
{% endblock %}

Para enviar o ficheiro admin.py):

def save_model(self, request, obj, form, change):
    url = "http://img.youtube.com/vi/%s/hqdefault.jpg" %(obj.video)
    url = str(url)

    if url:
        temp_img = NamedTemporaryFile(delete=True)
        temp_img.write(urllib2.urlopen(url).read())
        temp_img.flush()
        filename_img = urlparse(url).path.split('/')[-1]
        obj.image.save(filename_img,File(temp_img)

E use esse campo no seu modelo também.

Você pode se referir a exemplos de Servidores no Fine Uploader, que tem a versão django. https://github.com/FineUploader/server-examples/tree/master/python/django-fine-uploader

Django-fine-uploader

Views.py

UploadView envia o correio e apaga o pedido aos respectivos manipuladores.

class UploadView(View):

    @csrf_exempt
    def dispatch(self, *args, **kwargs):
        return super(UploadView, self).dispatch(*args, **kwargs)

    def post(self, request, *args, **kwargs):
        """A POST request. Validate the form and then handle the upload
        based ont the POSTed data. Does not handle extra parameters yet.
        """
        form = UploadFileForm(request.POST, request.FILES)
        if form.is_valid():
            handle_upload(request.FILES['qqfile'], form.cleaned_data)
            return make_response(content=json.dumps({ 'success': True }))
        else:
            return make_response(status=400,
                content=json.dumps({
                    'success': False,
                    'error': '%s' % repr(form.errors)
                }))

    def delete(self, request, *args, **kwargs):
        """A DELETE request. If found, deletes a file with the corresponding
        UUID from the server's filesystem.
        """
        qquuid = kwargs.get('qquuid', '')
        if qquuid:
            try:
                handle_deleted_file(qquuid)
                return make_response(content=json.dumps({ 'success': True }))
            except Exception, e:
                return make_response(status=400,
                    content=json.dumps({
                        'success': False,
                        'error': '%s' % repr(e)
                    }))
        return make_response(status=404,
            content=json.dumps({
                'success': False,
                'error': 'File not present'
            }))

Forms.py

class UploadFileForm(forms.Form):

    """ This form represents a basic request from Fine Uploader.
    The required fields will **always** be sent, the other fields are optional
    based on your setup.
    Edit this if you want to add custom parameters in the body of the POST
    request.
    """
    qqfile = forms.FileField()
    qquuid = forms.CharField()
    qqfilename = forms.CharField()
    qqpartindex = forms.IntegerField(required=False)
    qqchunksize = forms.IntegerField(required=False)
    qqpartbyteoffset = forms.IntegerField(required=False)
    qqtotalfilesize = forms.IntegerField(required=False)
    qqtotalparts = forms.IntegerField(required=False)

Não tenho a certeza se há alguma desvantagem para esta abordagem, mas ainda mais mínima, em views.py:

entry = form.save()

# save uploaded file
if request.FILES['myfile']:
    entry.myfile.save(request.FILES['myfile']._name, request.FILES['myfile'], True)

# models
class Document(models.Model):
    docfile = models.FileField(upload_to='documents/Temp/%Y/%m/%d')

    def doc_name(self):
        return self.docfile.name.split('/')[-1] # only the name, not full path

# admin
from myapp.models import Document
class DocumentAdmin(admin.ModelAdmin):
    list_display = ('doc_name',)
admin.site.register(Document, DocumentAdmin)