Django में फ़ाइल कैसे अपलोड करें? [बन्द है]

Question

Django के लिए नौसिखिया के रूप में, मुझे Django 1.3 में एक अपलोड ऐप बनाने में कठिनाई हो रही है। मुझे कोई अप-टू-डेट उदाहरण / स्निपेट नहीं मिला। ऐसा करने के लिए कोई व्यक्ति न्यूनतम लेकिन पूर्ण (मॉडल, दृश्य, टेम्पलेट) उदाहरण कोड पोस्ट कर सकता है?

Answer 1

पाओ, Django प्रलेखन वास्तव में इस बारे में अच्छा उदाहरण नहीं है। मैंने यह समझने के लिए कि यह कैसे काम करता है, सभी टुकड़ों को खोदने के लिए 2 घंटे से अधिक का समय बिताया। उस ज्ञान के साथ मैंने एक परियोजना लागू की जो फ़ाइलों को अपलोड करना और उन्हें सूची के रूप में दिखाना संभव बनाती है। परियोजना के लिए स्रोत डाउनलोड करने के लिए, https://github.com/axelpale/minimal-django-file-upload-example या इसे क्लोन करें:

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

अपडेट 2013-01-30: गीथहब के स्रोत में 1.3 के अलावा Django 1.4 के लिए कार्यान्वयन भी है। भले ही कुछ बदलाव हो लेकिन निम्नलिखित ट्यूटोरियल 1.4 के लिए भी उपयोगी है।

अद्यतन 2013-05-10: जीथॉब में Django 1.5 के लिए कार्यान्वयन। Urls.py में पुनर्निर्देशन में मामूली बदलाव और सूची में url टेम्पलेट टैग का उपयोग। इस प्रयास के लिए hubert3 का धन्यवाद ।

अद्यतन 2013-12-07: जिआगो में जिआगो 1.6 का समर्थन किया गया। एक आयात myapp / urls.py में बदल गया। धन्यवाद आर्थेडियन को जाता है ।

2015-03-17 अपडेट करें: Django 1.7 ने GitHub पर समर्थन किया, धन्यवाद aronysidoro ।

अद्यतन 2015-09-04: Django 1.8 ने GitHub में समर्थन किया, धन्यवाद nerogit के लिए ।

अद्यतन 2016-07-03: Django 1.9 GitHub में समर्थित है, डेववे और nerogit के लिए धन्यवाद

प्रोजेक्ट ट्री

अपलोड के लिए एकल ऐप और मीडिया / निर्देशिका के साथ एक बुनियादी Django 1.3 परियोजना।

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. सेटिंग्स: myproject / settings.py

फ़ाइलों को अपलोड करने और उनकी सेवा करने के लिए, आपको यह निर्दिष्ट करने की आवश्यकता है कि Django ने कहाँ से फ़ाइलें अपलोड की हैं और किस URL से Django उन्हें सेवा प्रदान करता है। MEDIA_ROOT और MEDIA_URL डिफ़ॉल्ट रूप से settings.py में हैं लेकिन वे खाली हैं। विवरण के लिए Django प्रबंध फ़ाइलों में पहली पंक्तियाँ देखें। याद रखें डेटाबेस भी सेट करें और INSTALLED_APPS में myapp जोड़ें

...
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. मॉडल: myproject / myapp / model.py

आगे आपको FileField वाला मॉडल चाहिए। यह विशेष क्षेत्र मीडिया / दस्तावेजों / 2011/12/24 / जैसे वर्तमान तारीख और MEDIA_ROOT पर आधारित फ़ाइलों को संग्रहीत करता है। FileField संदर्भ देखें ।

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

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

3. फॉर्म: myproject / myapp / forms.py

अपलोड को अच्छी तरह से संभालने के लिए, आपको एक फ़ॉर्म की आवश्यकता है। इस फॉर्म में केवल एक फ़ील्ड है लेकिन वह पर्याप्त है। देखें फार्म 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. देखें: myproject / myapp / views.py

एक ऐसा दृश्य जहां सारा जादू होता है। ध्यान दें कि कैसे request.FILESसंभाला जाता है। मेरे लिए, वास्तव में इस तथ्य को समझना बहुत मुश्किल था कि request.FILES['docfile']इसे मॉडल में बचाया जा सकता है। फ़िलेफ़िल्ड उसी तरह। मॉडल का सेव () फ़ाइल के भंडारण को फाइलसिस्टम में स्वचालित रूप से संभालता है।

# -*- 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. प्रोजेक्ट URL: myproject / urls.py

Django डिफ़ॉल्ट रूप से MEDIA_ROOT की सेवा नहीं करता है। यह उत्पादन के माहौल में खतरनाक होगा। लेकिन विकास के चरण में, हम कम कटौती कर सकते हैं। अंतिम पंक्ति पर ध्यान दें। वह लाइन Django को MEDIA_URL की फ़ाइलों की सेवा करने में सक्षम बनाती है। यह केवल डेवलपमेंट स्टेज में काम करता है।

देखें django.conf.urls.static.static संदर्भ जानकारी के लिए। मीडिया फ़ाइलों की सेवा के बारे में यह चर्चा भी देखें ।

# -*- 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. ऐप यूआरएल: myproject / myapp / urls.py

दृश्य को सुलभ बनाने के लिए, आपको इसके लिए यूआरएल निर्दिष्ट करना होगा। यहां कुछ खास नहीं।

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

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

7. टेम्पलेट: myproject / myapp / टेम्पलेट्स / myapp / list.html

अंतिम भाग: सूची के लिए टेम्प्लेट और उसके नीचे अपलोड फॉर्म। फॉर्म में DjNO को अपलोड करने के लिए "मल्टीपार्ट / फॉर्म-डेटा" और "पोस्ट" करने के लिए सेट विधि के लिए एनक्टाइप-विशेषता सेट होना चाहिए। देखें फ़ाइल अपलोड प्रलेखन जानकारी के लिए।

FileField में कई विशेषताएं हैं जिनका उपयोग टेम्प्लेट में किया जा सकता है। जैसे {{document.docfile.url}} और {{document.docfile.name}} टेम्पलेट में। मॉडल लेख और फ़ाइल ऑब्जेक्ट प्रलेखन में फ़ाइलों का उपयोग करने में इनके बारे में अधिक देखें ।

<!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. प्रारंभिक

बस सिंकडब और रनरसवर चला।

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

परिणाम

अंत में, सब कुछ तैयार है। डिफ़ॉल्ट Django विकास पर्यावरण पर अपलोड किए गए दस्तावेज़ों की सूची को देखा जा सकता हैlocalhost:8000/list/ । आज फाइलें / पथ / / / myproject / मीडिया / दस्तावेजों / 2011/12/17 / पर अपलोड की जाती हैं और सूची से खोला जा सकता है।

मुझे उम्मीद है कि यह जवाब किसी की मदद करेगा जितना उसने मेरी मदद की होगी।

Comments

Django डॉक्स में स्थान मिला जो फ़ाइल अपलोड दिखाता है। इस उत्तर में उदाहरण उत्कृष्ट है, लेकिन django डॉक्स में जानकारी नए रिलीज के साथ तारीख तक रखी जाएगी। docs.djangoproject.com/en/dev/topics/http/file-uploads

— TaiwanGrapefruitTea

उदाहरण Django "1.5" के लिए काम नहीं करता है। में HTML {% url list %}बन जाता है {% url "list" %}।

— मैथ्यू रीगलर

आपका बहुत बहुत धन्यवाद । यह वास्तव में मेरे लिए काम करता है। हालांकि, आगामी दर्शकों के लिए, आपको पायथन और Django के नए संस्करणों के साथ सर्वोत्तम संगतता के लिए gitHub में कोड की जांच करनी चाहिए। उदाहरण के लिए, CSRF त्रुटि से बचने के लिए view.py, render_to_response () को रेंडर (अनुरोध, ...) से बदला जाना चाहिए। चीयर्स।

— हू थान

यह बिना FORMS के संभव है?

— रोएल

क्या फ़ाइल .zip, या अन्य संपीड़ित फ़ाइलें हो सकती हैं?

— qg_java_17137

Answer 2

आम तौर पर बोलते हुए जब आप 'बस एक कामकाजी उदाहरण प्राप्त करने की कोशिश कर रहे होते हैं' तो 'बस लिखना शुरू कर देना' के लिए सबसे अच्छा है। आपकी सहायता करने के लिए यहां कोई कोड नहीं है, इसलिए यह हमारे लिए बहुत अधिक काम के सवाल का जवाब देता है।

यदि आप किसी फ़ाइल को हड़पना चाहते हैं, तो आपको html फाइल में कुछ इस तरह की आवश्यकता है:

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

वह आपको ब्राउज बटन देगा, एक्शन शुरू करने के लिए एक अपलोड बटन (फॉर्म जमा करें) और नोट करें ताकि Django आपसे पूछ सके request.FILES

एक दृश्य में कहीं आप के साथ फ़ाइल का उपयोग कर सकते हैं

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

फ़ाइल अपलोड डॉक्स में भारी मात्रा में जानकारी है

मैं आपको सलाह देता हूं कि आप पृष्ठ को अच्छी तरह से पढ़ें और कोड लिखना शुरू करें - फिर उदाहरण और स्टैक के निशान के साथ वापस आएं जब यह काम न करे।

Comments

धन्यवाद हेनरी। वास्तव में मैंने डॉक्स पढ़े हैं और कुछ कोड भी लिखे हैं, लेकिन चूंकि डॉक्स में कुछ अंतराल हैं (उदाहरण के लिए "कहीं आयात हैंडल_अपलोडेड_फाइल" से) और मेरा कोड त्रुटिपूर्ण था, तो सोचा कि अगर मैं एक कामकाजी उदाहरण से शुरू कर सकता हूं तो यह बहुत बेहतर होगा। ।

— qliq

Qliq से सहमत हैं। एक सरल काम करने वाला उदाहरण है,

— न्युक्विज

enctype="multipart/form-data"क्या मैं इस काम बनाने के लिए आवश्यक धन्यवाद!

— जॉन-चार्ल्स

फॉर्म टैग के भीतर बस {% csrf_token%} को याद न करें।

— जोंकिनानाडा

यह संभव है कि FORMS.PY से FORMS के बिना यह करना संभव है?

— Roel

Answer 3

डेमो

जीथुबो रेपो देखें , Django 3 के साथ काम करता है

एक न्यूनतम Django फ़ाइल अपलोड उदाहरण

1. एक django प्रोजेक्ट बनाएं

स्टार्टप्रोजेक्ट चलाएं ::

$ django-admin.py startproject sample

अब एक फ़ोल्डर ( नमूना ) बनाया गया है।

2. एक ऐप बनाएं

एप्लिकेशन बनाएं ::

$ cd sample
$ python manage.py startapp uploader

अब uploaderइन फ़ाइलों के साथ एक फ़ोल्डर ( ) बनाया जाता है ::

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

3. सेटिंग्स को अपडेट करें

पर sample/settings.pyजोड़ने 'uploader'के लिए INSTALLED_APPSऔर जोड़ने MEDIA_ROOTऔर MEDIA_URL, यानी ::

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

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

4. urls.py अपडेट करें

में sample/urls.pyजोड़ने ::

...<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. अपडेट करें प्रतिमा

अद्यतन 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. अपडेट देखें

अद्यतन 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. टेम्पलेट बनाएँ

एक फ़ोल्डर नमूना / अपलोडर / टेम्प्लेट / अपलोडर बनाएँ

एक फ़ाइल बनाएँ upload_form.html यानी 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. डेटाबेस को सिंक करें

डेटाबेस और रनर को समन्वित करें ::

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

यात्रा http: // localhost: 8000 /

Comments

अंतिम पंक्ति को छोड़कर - परिपूर्ण होना चाहिए localhost.com:8000/upload > यह django 1.6 और पायथन 3.3 के लिए काम करता है।

— स्टीव

पुन: प्रयोज्य django ऐप डिज़ाइन पैटर्न के लिए +1

— मार्सेल

अक्सली ने सुहैल का इस्तेमाल FileFieldकरते समय ए ImageField, किसी ने विकल्पों की व्याख्या कर सकता है?

— नवतन

@dtgq I ने उपयोग करने के लिए उत्तर अपडेट किया FileField। ImageFieldकेवल छवि अपलोड के लिए चाहिए अद्यतन Django 1.11 के साथ काम करेगा।

— suhailvs

Django 2.0 पर परीक्षण किया और पूरी तरह से काम किया

— 21

Answer 4

मुझे कहना होगा कि मैं django भ्रामक पर प्रलेखन मिल। सरल उदाहरण के लिए भी रूपों का उल्लेख क्यों किया जा रहा है? उदाहरण मुझे देखने के लिए काम करने के लिए मिला है:

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

HTML फ़ाइल नीचे दिए गए कोड की तरह दिखती है, हालांकि यह उदाहरण केवल एक फ़ाइल अपलोड करता है और फ़ाइलों को सहेजने के लिए कोड कई को हैंडल करता है: -

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

ये उदाहरण मेरे कोड नहीं हैं, वे मेरे द्वारा पाए गए दो अन्य उदाहरणों से प्राप्त हुए हैं। मैं django के लिए एक रिश्तेदार शुरुआत कर रहा हूं, इसलिए यह संभव है कि मुझे कुछ महत्वपूर्ण बिंदु याद आ रहे हैं।

Comments

A FileFieldऔर a का उपयोग नहीं करने के लिए +1 model.Form। शुरुआती (और तुच्छ कार्यों के लिए), ऊपर दिखाए गए जैसे अपलोड की गई फ़ाइलों का मैन्युअल प्रसंस्करण कम भ्रामक है।

— अनीश अहमद 7

भाग्य = खुला (पथ, 'wb') जब फ़ाइल बाइट्स के साथ लिखती है

— बिपुल रॉय

Answer 5

मेरी भी ऐसी ही आवश्यकता थी। नेट पर अधिकांश उदाहरण मॉडल बनाने और उन रूपों को बनाने के लिए कह रहे हैं, जिनका मैं उपयोग नहीं करना चाहता था। यहाँ मेरा अंतिम कोड है

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

और HTML में मैंने अपलोड करने के लिए लिखा है:

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

निम्नलिखित HTML है जो फ़ाइल की सामग्री प्रदर्शित करता है:

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

Comments

अच्छा इसलिए क्योंकि कभी-कभी कोई फ़ाइल को अपलोड न करने की सामग्री का उपयोग करना चाहता है ...

— nemesisfixx

Answer 6

हेनरी के उदाहरण पर विस्तार :

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

आप handle_uploaded_fileअपलोड किए गए फ़ाइल ऑब्जेक्ट के साथ अपने दृश्य से इस फ़ंक्शन को कॉल कर सकते हैं । यह फ़ाइल को सिस्टम में एक अद्वितीय नाम (मूल अपलोड की गई फ़ाइल के नाम के साथ उपसर्ग) से बचाएगा और सहेजे गए फ़ाइल का पूरा पथ लौटाएगा। आप डेटाबेस में पथ को सहेज सकते हैं, और बाद में फ़ाइल के साथ कुछ कर सकते हैं।

Comments

इमरान, मैंने आपके कोड को मेरे विचार पर आज़माया लेकिन मुझे यह त्रुटि मिली: 'WSGIRequest' ऑब्जेक्ट में कोई विशेषता 'नाम' नहीं है।

— शाम

अपलोड की गई फ़ाइल ऑब्जेक्ट ( request.FILES['myfile']) पास करें handle_uploaded_file, requestस्वयं नहीं ।

— इमरान

क्या मैं इसे सीधे डेटाबेस में सहेज सकता हूं? stackoverflow.com/questions/24705246/…

— एलेक्जेंड्रुक

prefix=source.nameइसका उपयोग करके फ़ाइल के अंत में अतिरिक्त वर्ण जोड़े, फ़ाइल एक्सटेंशन के साथ गड़बड़ कर रहा है। जैसे upload.csvबदल गया upload.csv5334। इसे बदलना suffix=source.nameमेरे लिए तय है।

— तहरीम इकबाल

Answer 7

यहाँ यह आपकी मदद कर सकता है: अपने मॉडल के लिए एक फ़ाइल क्षेत्र बनाएँ

फ़ाइल अपलोड करने के लिए (आपके व्यवस्थापक में):

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)

और अपने टेम्पलेट में उस फ़ील्ड का उपयोग करें।

Comments

यह उपयोगी है, जब आपको उन फ़ाइलों के साथ मैन्युअल रूप से गुस्सा करना पड़ता है जिन्हें आप सहेजना चाहते हैं। यदि हां, तो आपको इस अनुभाग की भी आवश्यकता हो सकती है: docs.djangoproject.com/en/dev/topics/files/#the-file-object

— kecske

Answer 8

आप सर्वर के उदाहरणों को ललित अपलोडर में संदर्भित कर सकते हैं, जिसमें django संस्करण है। https://github.com/FineUploader/server-examples/tree/master/python/django-fine-uploader

यह बहुत ही सुंदर और सबसे महत्वपूर्ण है, यह विशेष रुप से प्रदर्शित जेएस लिबास प्रदान करता है। टेम्पलेट सर्वर-उदाहरणों में शामिल नहीं है, लेकिन आप इसकी वेबसाइट पर डेमो पा सकते हैं। ठीक अपलोडर: http://fineuploader.com/demos.html

Django ठीक-अपलोड करने वाले

views.py

UploadView पोस्ट प्रेषित करता है और संबंधित हैंडलर को अनुरोध हटाता है।

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)

Answer 9

सुनिश्चित नहीं हैं कि इस दृष्टिकोण में कोई नुकसान है लेकिन और भी कम से कम, view.py:

entry = form.save()

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

Answer 10

मैंने इसी तरह की समस्या का सामना किया, और django admin साइट द्वारा हल किया गया।

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

Comments

[यहां लिंक विवरण दर्ज करें] [1] [यहां लिंक विवरण दर्ज करें] [२] [१]: youtu.be/0tNZB3dyopY [२]: youtu.be/klhMYMc3PlY

— uda123