Respostas:
Ufa, a documentação do Django realmente não tem um bom exemplo disso. Passei mais de 2 horas para desenterrar todas as peças para entender como isso funciona. Com esse conhecimento, implementei um projeto que possibilita o upload de arquivos e os mostra como lista. Para baixar a fonte do projeto, visite https://github.com/axelpale/minimal-django-file-upload-example ou clone-o:
> git clone https://github.com/axelpale/minimal-django-file-upload-example.git
Atualização 2013-01-30: A fonte no GitHub também tem implementação para o Django 1.4, além da 1.3. Embora haja poucas alterações, o tutorial a seguir também é útil para o 1.4.
Atualização 2013-05-10: Implementação para o Django 1.5 no GitHub. Pequenas alterações no redirecionamento em urls.py e uso da tag de modelo de URL em list.html. Obrigado a hubert3 pelo esforço.
Atualização 07/12/2013: Django 1.6 suportado no GitHub. Uma importação foi alterada em myapp / urls.py. Agradecimentos vão para Arthedian .
Atualização 17-03-2015: Django 1.7 suportado no GitHub, graças a aronysidoro .
Atualização 2015-09-04: Django 1.8 suportado no GitHub, graças ao nerogit .
Atualização 2016-07-03: Django 1.9 suportado no GitHub, graças a daavve e nerogit
Um projeto básico do Django 1.3 com aplicativo único e mídia / diretório para uploads.
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
Para fazer upload e servir arquivos, você precisa especificar onde o Django armazena os arquivos enviados e de qual URL o Django os serve. MEDIA_ROOT e MEDIA_URL estão em settings.py por padrão, mas estão vazios. Veja as primeiras linhas no Django Managing Files para detalhes. Lembre-se também de definir o banco de dados e adicionar myapp para 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',
)
Em seguida, você precisa de um modelo com um FileField. Este campo específico armazena arquivos, por exemplo, em mídia / documentos / 2011/12/24 / com base na data atual e MEDIA_ROOT. Consulte a referência FileField .
# -*- coding: utf-8 -*-
from django.db import models
class Document(models.Model):
docfile = models.FileField(upload_to='documents/%Y/%m/%d')
Para lidar bem com o upload, você precisa de um formulário. Este formulário possui apenas um campo, mas isso é suficiente. Consulte Referência do Form FileField para obter detalhes.
# -*- coding: utf-8 -*-
from django import forms
class DocumentForm(forms.Form):
docfile = forms.FileField(
label='Select a file',
help_text='max. 42 megabytes'
)
Uma visão em que toda a mágica acontece. Preste atenção em como request.FILES
são tratados. Para mim, foi realmente difícil identificar o fato de que request.FILES['docfile']
pode ser salvo nos modelos. O save () do modelo lida com o armazenamento do arquivo no sistema de arquivos automaticamente.
# -*- 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)
)
O Django não serve MEDIA_ROOT por padrão. Isso seria perigoso no ambiente de produção. Mas no estágio de desenvolvimento, poderíamos interromper. Preste atenção na última linha. Essa linha permite que o Django sirva arquivos de MEDIA_URL. Isso funciona apenas no estágio de desenvolvimento.
Consulte a referência django.conf.urls.static.static para obter detalhes. Consulte também esta discussão sobre a veiculação de arquivos de mídia .
# -*- 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)
Para tornar a visualização acessível, você deve especificar URLs para ela. Nada de especial aqui.
# -*- coding: utf-8 -*-
from django.conf.urls import patterns, url
urlpatterns = patterns('myapp.views',
url(r'^list/$', 'list', name='list'),
)
A última parte: modelo para a lista e o formulário de upload abaixo dela. O formulário deve ter o atributo enctype definido como "multipart / form-data" e o método definido como "post" para tornar possível o upload no Django. Consulte a documentação Upload de arquivos para obter detalhes.
O FileField possui muitos atributos que podem ser usados em modelos. Por exemplo, {{document.docfile.url}} e {{document.docfile.name}} como no modelo. Veja mais sobre isso no artigo Usando arquivos nos modelos e na documentação do objeto Arquivo .
<!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>
Basta executar syncdb e runserver.
> cd myproject
> python manage.py syncdb
> python manage.py runserver
Finalmente, está tudo pronto. No ambiente de desenvolvimento padrão do Django, a lista de documentos enviados pode ser vista emlocalhost:8000/list/
. Hoje, os arquivos são enviados para / path / to / myproject / media / documents / 2011/12/17 / e podem ser abertos a partir da lista.
Espero que esta resposta ajude alguém tanto quanto teria me ajudado.
{% url list %}
se torna {% url "list" %}
.
De um modo geral, quando você está tentando "apenas obter um exemplo prático", é melhor "apenas começar a escrever o código". Não existe um código aqui para ajudá-lo, portanto, responder à pergunta é muito mais útil para nós.
Se você deseja pegar um arquivo, precisa de algo assim em um arquivo html em algum lugar:
<form method="post" enctype="multipart/form-data">
<input type="file" name="myfile" />
<input type="submit" name="submit" value="Upload" />
</form>
Isso fornecerá o botão de navegação, um botão de upload para iniciar a ação (envie o formulário) e observe o enctype para que o Django saiba dar a você request.FILES
Em uma exibição em algum lugar, você pode acessar o arquivo com
def myview(request):
request.FILES['myfile'] # this is my file
Há uma enorme quantidade de informações nos documentos de upload de arquivos
Eu recomendo que você leia a página completamente e apenas comece a escrever o código - depois volte com exemplos e empilhe rastreamentos quando não funcionar.
enctype="multipart/form-data"
que eu precisava para fazer isso funcionar, obrigado!
Veja o repositório do github , trabalha com o Django 3
Execute o startproject ::
$ django-admin.py startproject sample
agora uma pasta ( amostra ) é criada.
Crie um aplicativo ::
$ cd sample
$ python manage.py startapp uploader
Agora uma pasta ( uploader
) com esses arquivos é criada:
uploader/
__init__.py
admin.py
app.py
models.py
tests.py
views.py
migrations/
__init__.py
Em sample/settings.py
adicionar 'uploader'
a INSTALLED_APPS
e adicionar MEDIA_ROOT
e MEDIA_URL
, ou seja:
INSTALLED_APPS = [
'uploader',
...<other apps>...
]
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'
em sample/urls.py
add ::
...<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)
update uploader/models.py
::
from django.db import models
class Upload(models.Model):
upload_file = models.FileField()
upload_date = models.DateTimeField(auto_now_add =True)
update 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
Crie uma pasta sample / uploader / templates / uploader
Crie um arquivo upload_form.html ie 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>
Sincronizar banco de dados e servidor de execução ::
$ python manage.py makemigrations
$ python manage.py migrate
$ python manage.py runserver
visite http: // localhost: 8000 /
FileField
tempo suhail usou um ImageField
, alguém poderia por favor explicar as escolhas?
FileField
. ImageField
deve apenas para upload de imagem. a atualização funcionará com o Django 1.11.
Devo dizer que acho a documentação no django confusa. Também para o exemplo mais simples, por que os formulários estão sendo mencionados? O exemplo que eu trabalhei no views.py é: -
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 arquivo html se parece com o código abaixo, embora este exemplo faça upload apenas de um arquivo e o código para salvar os arquivos lide 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>
Esses exemplos não são meu código, eles foram obtidos de outros dois exemplos que encontrei. Eu sou um iniciante em relação ao django, por isso é muito provável que esteja perdendo algum ponto-chave.
FileField
a model.Form
. Para iniciantes (e para tarefas triviais), o processamento manual dos arquivos enviados, como mostrado acima, é menos confuso.
Eu também tive o requisito semelhante. A maioria dos exemplos na net está pedindo para criar modelos e criar formulários 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 em 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 exibe o conteúdo do arquivo:
{% block content %}
<h3>File uploaded successfully</h3>
{{file.name}}
</br>content = {{contentOfFile}}
{% endblock %}
Estendendo o exemplo de 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
Você pode chamar essa handle_uploaded_file
função da sua visualização com o objeto de arquivo carregado. Isso salvará o arquivo com um nome exclusivo (prefixado com o nome do arquivo do arquivo original carregado) no sistema de arquivos e retornará o caminho completo do arquivo salvo. Você pode salvar o caminho no banco de dados e fazer algo com o arquivo posteriormente.
request.FILES['myfile']
) para handle_uploaded_file
, não o request
próprio.
prefix=source.name
lo, adicionou caracteres extras no final do arquivo, atrapalhando a extensão do arquivo. Por exemplo, upload.csv
foi alterado para upload.csv5334
. Alterá-lo para suffix=source.name
corrigi-lo para mim.
Aqui pode ajudar você a: criar um campo de arquivo em seus models.py
Para fazer upload do arquivo (em seu 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 consultar exemplos de servidor no Fine Uploader, que possui a versão do django. https://github.com/FineUploader/server-examples/tree/master/python/django-fine-uploader
É muito elegante e o mais importante de tudo, fornece o js lib em destaque. O modelo não está incluído nos exemplos de servidor, mas você pode encontrar uma demonstração em seu site. Fine Uploader: http://fineuploader.com/demos.html
views.py
O UploadView envia a solicitação de postagem e exclusão para os 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)
Eu enfrentei o problema semelhante e resolvi pelo site de administração do 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)