Jako nowicjusz w Django mam trudności z tworzeniem aplikacji do przesyłania w Django 1.3. Nie mogłem znaleźć żadnego aktualnego przykładu / fragmentów. Czy ktoś może w tym celu opublikować minimalny, ale kompletny przykładowy kod (Model, Widok, Szablon)?

Uff, dokumentacja Django naprawdę nie ma dobrego przykładu na ten temat. Spędziłem ponad 2 godziny, aby wykopać wszystkie elementy, aby zrozumieć, jak to działa. Dzięki tej wiedzy zrealizowałem projekt, który umożliwia przesyłanie plików i wyświetlanie ich jako listy. Aby pobrać źródło projektu, odwiedź https://github.com/axelpale/minimal-django-file-upload-example lub sklonuj go:

> git clone https://github.com/axelpale/minimal-django-file-upload-example.git

Aktualizacja 2013-01-30: Źródło w GitHub ma również implementację dla Django 1.4 oprócz 1.3. Mimo niewielkich zmian poniższy samouczek jest również przydatny w wersji 1.4.

Aktualizacja 2013-05-10: Implementacja Django 1.5 w GitHub. Niewielkie zmiany przekierowania w urls.py i użycie tagu szablonu adresu URL w list.html. Dzięki hubert3 za wysiłek.

Aktualizacja 2013-12-07: Django 1.6 obsługiwany w GitHub. Zmieniono jeden import w myapp / urls.py. Podziękowania należą się Arthedianowi .

Aktualizacja 2015-03-17: Django 1.7 obsługiwany w GitHub, dzięki aronysidoro .

Aktualizacja 2015-09-04: Django 1.8 obsługiwane w GitHub, dzięki nerogit .

Aktualizacja 2016-07-03: Django 1.9 obsługiwany w GitHub, dzięki daavve i nerogit

Drzewo projektu

Podstawowy projekt Django 1.3 z pojedynczą aplikacją i katalogiem media / do przesyłania.

minimal-django-file-upload-example/
    src/
        myproject/
            database/
                sqlite.db
            media/
            myapp/
                templates/
                    myapp/
                        list.html
                forms.py
                models.py
                urls.py
                views.py
            __init__.py
            manage.py
            settings.py
            urls.py

1. Ustawienia: myproject / settings.py

Aby przesyłać i udostępniać pliki, musisz określić, gdzie Django przechowuje przesłane pliki i pod jakim adresem URL Django je obsługuje. MEDIA_ROOT i MEDIA_URL są domyślnie w settings.py, ale są puste. Zobacz pierwsze wiersze w Django Managing Files, aby uzyskać szczegółowe informacje. Pamiętaj również o ustawieniu bazy danych i dodaniu myapp do INSTALLED_APPS

...
import os

BASE_DIR = os.path.dirname(os.path.dirname(__file__))
...
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'database.sqlite3'),
        'USER': '',
        'PASSWORD': '',
        'HOST': '',
        'PORT': '',
    }
}
...
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'
...
INSTALLED_APPS = (
    ...
    'myapp',
)

2. Model: myproject / myapp / models.py

Następnie potrzebujesz modelu z FileField. To konkretne pole przechowuje pliki np. Do mediów / dokumentów / 2011/12/24 / na podstawie bieżącej daty i MEDIA_ROOT. Zobacz odniesienie do FileField .

# -*- coding: utf-8 -*-
from django.db import models

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

3. Formularz: myproject / myapp / forms.py

Aby ładnie obsłużyć przesyłanie, potrzebujesz formularza. Ten formularz ma tylko jedno pole, ale to wystarczy. Szczegółowe informacje można znaleźć w dokumentacji Form FileField .

# -*- coding: utf-8 -*-
from django import forms

class DocumentForm(forms.Form):
    docfile = forms.FileField(
        label='Select a file',
        help_text='max. 42 megabytes'
    )

4. Widok: myproject / myapp / views.py

Widok, w którym dzieje się cała magia. Zwróć uwagę, jak request.FILESsą obsługiwane. Dla mnie naprawdę trudno było dostrzec fakt, że request.FILES['docfile']można zapisać go w modelach. Model save () modelu automatycznie przechowuje plik w systemie plików.

# -*- coding: utf-8 -*-
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse

from myproject.myapp.models import Document
from myproject.myapp.forms import DocumentForm

def list(request):
    # Handle file upload
    if request.method == 'POST':
        form = DocumentForm(request.POST, request.FILES)
        if form.is_valid():
            newdoc = Document(docfile = request.FILES['docfile'])
            newdoc.save()

            # Redirect to the document list after POST
            return HttpResponseRedirect(reverse('myapp.views.list'))
    else:
        form = DocumentForm() # A empty, unbound form

    # Load documents for the list page
    documents = Document.objects.all()

    # Render list page with the documents and the form
    return render_to_response(
        'myapp/list.html',
        {'documents': documents, 'form': form},
        context_instance=RequestContext(request)
    )

5. Adresy URL projektu: myproject / urls.py

Django domyślnie nie obsługuje MEDIA_ROOT. To byłoby niebezpieczne w środowisku produkcyjnym. Ale na etapie rozwoju moglibyśmy skrócić. Zwróć uwagę na ostatnią linię. Ta linia umożliwia Django wyświetlanie plików z MEDIA_URL. Działa to tylko na etapie opracowywania.

Szczegółowe informacje można znaleźć w dokumentacji django.conf.urls.static.static . Zobacz także tę dyskusję na temat udostępniania plików multimedialnych .

# -*- coding: utf-8 -*-
from django.conf.urls import patterns, include, url
from django.conf import settings
from django.conf.urls.static import static

urlpatterns = patterns('',
    (r'^', include('myapp.urls')),
) + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

6. Adresy URL aplikacji: myproject / myapp / urls.py

Aby widok był dostępny, musisz podać jego adresy URL. Nic specjalnego.

# -*- coding: utf-8 -*-
from django.conf.urls import patterns, url

urlpatterns = patterns('myapp.views',
    url(r'^list/$', 'list', name='list'),
)

7. Szablon: myproject / myapp / templates / myapp / list.html

Ostatnia część: szablon listy i poniższy formularz przesyłania. Formularz musi mieć atrybut enctype ustawiony na „multipart / form-data” i metodę ustawioną na „post”, aby umożliwić przesyłanie do Django. Szczegółowe informacje można znaleźć w dokumentacji przesyłania plików .

FileField ma wiele atrybutów, których można używać w szablonach. Np. {{Document.docfile.url}} i {{document.docfile.name}} jak w szablonie. Zobacz więcej na ten temat w artykule Korzystanie z plików w modelach i dokumentacji obiektu Plik .

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title>Minimal Django File Upload Example</title>   
    </head>
    <body>
    <!-- List of uploaded documents -->
    {% if documents %}
        <ul>
        {% for document in documents %}
            <li><a href="{{ document.docfile.url }}">{{ document.docfile.name }}</a></li>
        {% endfor %}
        </ul>
    {% else %}
        <p>No documents.</p>
    {% endif %}

        <!-- Upload form. Note enctype attribute! -->
        <form action="{% url 'list' %}" method="post" enctype="multipart/form-data">
            {% csrf_token %}
            <p>{{ form.non_field_errors }}</p>
            <p>{{ form.docfile.label_tag }} {{ form.docfile.help_text }}</p>
            <p>
                {{ form.docfile.errors }}
                {{ form.docfile }}
            </p>
            <p><input type="submit" value="Upload" /></p>
        </form>
    </body>
</html> 

8. Zainicjuj

Wystarczy uruchomić syncdb i runserver.

> cd myproject
> python manage.py syncdb
> python manage.py runserver

Wyniki

Wreszcie wszystko jest gotowe. W domyślnym środowisku programistycznym Django listę przesłanych dokumentów można zobaczyć pod adresem localhost:8000/list/. Dzisiaj pliki są przesyłane do / path / to / myproject / media / documents / 2011/12/17 / i można je otworzyć z listy.

Mam nadzieję, że ta odpowiedź pomoże komuś tak bardzo, jak by mi pomogła.

Mówiąc ogólnie, gdy próbujesz „po prostu uzyskać działający przykład”, najlepiej „po prostu zacząć pisać kod”. Nie ma tutaj kodu, który mógłby ci w tym pomóc, więc sprawia, że ​​udzielenie odpowiedzi na pytanie jest dla nas o wiele więcej pracy.

Jeśli chcesz pobrać plik, potrzebujesz czegoś takiego w pliku HTML gdzieś:

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

To da ci przycisk przeglądania, przycisk przesyłania, aby rozpocząć akcję (prześlij formularz) i zanotuj kod, aby Django wiedział, że ci da request.FILES

W widoku gdzieś możesz uzyskać dostęp do pliku za pomocą

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

Dokumenty do przesyłania plików zawierają ogromną ilość informacji

Zalecam dokładne przeczytanie strony i po prostu zacznij pisać kod - a potem wróć z przykładami i stosami śladów, gdy nie działa.

Próbny

Zobacz repozytorium github , działa z Django 3

Przykład przesyłania minimalnego pliku Django

1. Utwórz projekt django

Uruchom startproject ::

$ django-admin.py startproject sample

teraz tworzony jest folder ( próbka ).

2. utwórz aplikację

Utwórz aplikację ::

$ cd sample
$ python manage.py startapp uploader

Teraz uploadertworzony jest folder ( ) z tymi plikami:

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

3. Zaktualizuj settings.py

Po sample/settings.pydodaniu 'uploader'do INSTALLED_APPSi dodaniu MEDIA_ROOToraz MEDIA_URL, tj .:

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

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

4. Zaktualizuj urls.py

w sample/urls.pyadd ::

...<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.UploadView.as_view(), name='fileupload'),
]+ static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

5. Zaktualizuj models.py

aktualizacja uploader/models.py::

from django.db import models
class Upload(models.Model):
    upload_file = models.FileField()    
    upload_date = models.DateTimeField(auto_now_add =True)

6. Zaktualizuj views.py

aktualizacja uploader/views.py::

from django.views.generic.edit import CreateView
from django.urls import reverse_lazy
from .models import Upload
class UploadView(CreateView):
    model = Upload
    fields = ['upload_file', ]
    success_url = reverse_lazy('fileupload')
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['documents'] = Upload.objects.all()
        return context

7. tworzyć szablony

Utwórz przykładowy folder / program do przesyłania / szablony / program do przesyłania

Utwórz plik upload_form.html tj . sample/uploader/templates/uploader/upload_form.html:

<div style="padding:40px;margin:40px;border:1px solid #ccc">
    <h1>Django File Upload</h1>
    <form method="post" enctype="multipart/form-data">
      {% csrf_token %}
      {{ form.as_p }}
      <button type="submit">Submit</button>
    </form><hr>
    <ul>
    {% for document in documents %}
        <li>
            <a href="{{ document.upload_file.url }}">{{ document.upload_file.name }}</a>
            <small>({{ document.upload_file.size|filesizeformat }}) - {{document.upload_date}}</small>
        </li>
    {% endfor %}
    </ul>
</div>

8. Synchronizuj bazę danych

Synchronizuj bazę danych i serwer Run ::

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

odwiedź http: // localhost: 8000 /

Muszę powiedzieć, że uważam, że dokumentacja w django jest myląca. Również dla najprostszego przykładu, dlaczego wymienione są formularze? Przykładem pracy w views.py jest: -

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()

Plik HTML wygląda jak poniższy kod, chociaż ten przykład przesyła tylko jeden plik, a kod do zapisywania plików obsługuje wiele: -

<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>

Te przykłady nie są moim kodem, zostały odrzucone z dwóch innych przykładów, które znalazłem. Jestem względnym początkującym w stosunku do django, więc bardzo prawdopodobne jest, że brakuje mi jakiegoś kluczowego punktu.

Miałem również podobny wymóg. Większość przykładów w sieci wymaga tworzenia modeli i formularzy, których nie chciałem używać. Oto mój ostatni kod.

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

I w HTML do przesłania napisałem:

{% 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 %}

Poniżej znajduje się HTML, który wyświetla zawartość pliku:

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

Rozszerzając przykład Henry'ego :

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

Możesz wywołać tę handle_uploaded_filefunkcję z twojego widoku za pomocą przesłanego obiektu pliku. Spowoduje to zapisanie pliku z unikalną nazwą (poprzedzoną nazwą oryginalnego przesłanego pliku) w systemie plików i zwróci pełną ścieżkę zapisanego pliku. Możesz zapisać ścieżkę w bazie danych i zrobić coś z plikiem później.

Tutaj może ci pomóc: utworzyć pole pliku w pliku models.py

Aby przesłać plik (w pliku 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)

i użyj tego pola w swoim szablonie.

Możesz odwoływać się do przykładów serwerów w programie Fine Uploader, który ma wersję django. https://github.com/FineUploader/server-examples/tree/master/python/django-fine-uploader

Jest bardzo elegancki i co najważniejsze, zapewnia polecaną bibliotekę js lib. Szablon nie jest zawarty w przykładach serwerów, ale można znaleźć wersję demonstracyjną na jego stronie internetowej. Fine Uploader: http://fineuploader.com/demos.html

django-fine-uploader

views.py

UploadView wysyła żądanie wysłania i usunięcia do odpowiednich handlerów.

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)

Nie jestem pewien, czy takie podejście ma wady, ale jeszcze bardziej minimalne, w views.py:

entry = form.save()

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

Napotkałem podobny problem i rozwiązany przez stronę administratora django.

# 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)