108 |
109 |
136 |
177 |
178 |
179 |
180 |
181 |
182 |
183 |
--------------------------------------------------------------------------------
/upload/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/miki725/Django-jQuery-File-Uploader-Integration-demo/98ebf63caebeeb9c78c0207eb553dd3c8320087f/upload/__init__.py
--------------------------------------------------------------------------------
/upload/models.py:
--------------------------------------------------------------------------------
1 | from django.db import models
2 |
3 | # Create your models here.
4 |
--------------------------------------------------------------------------------
/upload/tests.py:
--------------------------------------------------------------------------------
1 | """
2 | This file demonstrates writing tests using the unittest module. These will pass
3 | when you run "manage.py test".
4 |
5 | Replace this with more appropriate tests for your application.
6 | """
7 |
8 | from django.test import TestCase
9 |
10 |
11 | class SimpleTest(TestCase):
12 | def test_basic_addition(self):
13 | """
14 | Tests that 1 + 1 always equals 2.
15 | """
16 | self.assertEqual(1 + 1, 2)
17 |
--------------------------------------------------------------------------------
/upload/urls.py:
--------------------------------------------------------------------------------
1 | from django.conf.urls.defaults import *
2 |
3 | urlpatterns = patterns('upload.views',
4 |
5 | # ================================== #
6 | # Upload URLS #
7 | # ================================== #
8 |
9 | # Main template with the gui to upload
10 | # If you want you can expand this so each action of the uploader
11 | # will have it's own url. Now a single view is responsible for
12 | # distinguishing what it is suppose to do.
13 | (r'^', 'Upload'),
14 |
15 | )
16 |
--------------------------------------------------------------------------------
/upload/views.py:
--------------------------------------------------------------------------------
1 | # imports
2 |
3 | # import the django settings
4 | from django.conf import settings
5 | # for generating json
6 | from django.utils import simplejson
7 | # for loading template
8 | from django.template import Context, loader
9 | # for csrf
10 | from django.core.context_processors import csrf
11 | # for HTTP response
12 | from django.http import HttpResponse, HttpResponseBadRequest, HttpResponseRedirect
13 | # for os manipulations
14 | import os
15 |
16 |
17 | def Upload(request):
18 | """
19 |
20 | ## View for file uploads ##
21 |
22 | It does the following actions:
23 | - displays a template if no action have been specified
24 | - upload a file into unique temporary directory
25 | unique directory for an upload session
26 | meaning when user opens up an upload page, all upload actions
27 | while being on that page will be uploaded to unique directory.
28 | as soon as user will reload, files will be uploaded to a different
29 | unique directory
30 | - delete an uploaded file
31 |
32 | ## How Single View Multi-functions ##
33 |
34 | If the user just goes to a the upload url (e.g. '/upload/'), the request.method will be "GET"
35 | Or you can think of it as request.method will NOT be "POST"
36 | Therefore the view will always return the upload template
37 |
38 | If on the other side the method is POST, that means some sort of upload action
39 | has to be done. That could be either uploading a file or deleting a file
40 |
41 | For deleting files, there is the same url (e.g. '/upload/'), except it has an
42 | extra query parameter. Meaning the url will have '?' in it.
43 | In this implementation the query will simply be '?f=filename_of_the_file_to_be_removed'
44 |
45 | If the request has no query parameters, file is being uploaded.
46 |
47 | """
48 |
49 | # used to generate random unique id
50 | import uuid
51 |
52 | # settings for the file upload
53 | # you can define other parameters here
54 | # and check validity late in the code
55 | options = {
56 | # the maximum file size (must be in bytes)
57 | "maxfilesize": 2 * 2 ** 20, # 2 Mb
58 | # the minimum file size (must be in bytes)
59 | "minfilesize": 1 * 2 ** 10, # 1 Kb
60 | # the file types which are going to be allowed for upload
61 | # must be a mimetype
62 | "acceptedformats": (
63 | "image/jpeg",
64 | "image/png",
65 | )
66 | }
67 |
68 |
69 | # POST request
70 | # meaning user has triggered an upload action
71 | if request.method == 'POST':
72 | # figure out the path where files will be uploaded to
73 | # PROJECT_ROOT is from the settings file
74 | temp_path = os.path.join(settings.PROJECT_ROOT, "tmp")
75 |
76 | # if 'f' query parameter is not specified
77 | # file is being uploaded
78 | if not ("f" in request.GET.keys()): # upload file
79 |
80 | # make sure some files have been uploaded
81 | if not request.FILES:
82 | return HttpResponseBadRequest('Must upload a file')
83 |
84 | # make sure unique id is specified - VERY IMPORTANT
85 | # this is necessary because of the following:
86 | # we want users to upload to a unique directory
87 | # however the uploader will make independent requests to the server
88 | # to upload each file, so there has to be a method for all these files
89 | # to be recognized as a single batch of files
90 | # a unique id for each session will do the job
91 | if not request.POST[u"uid"]:
92 | return HttpResponseBadRequest("UID not specified.")
93 | # if here, uid has been specified, so record it
94 | uid = request.POST[u"uid"]
95 |
96 | # update the temporary path by creating a sub-folder within
97 | # the upload folder with the uid name
98 | temp_path = os.path.join(temp_path, uid)
99 |
100 | # get the uploaded file
101 | file = request.FILES[u'files[]']
102 |
103 | # initialize the error
104 | # If error occurs, this will have the string error message so
105 | # uploader can display the appropriate message
106 | error = False
107 |
108 | # check against options for errors
109 |
110 | # file size
111 | if file.size > options["maxfilesize"]:
112 | error = "maxFileSize"
113 | if file.size < options["minfilesize"]:
114 | error = "minFileSize"
115 | # allowed file type
116 | if file.content_type not in options["acceptedformats"]:
117 | error = "acceptFileTypes"
118 |
119 |
120 | # the response data which will be returned to the uploader as json
121 | response_data = {
122 | "name": file.name,
123 | "size": file.size,
124 | "type": file.content_type
125 | }
126 |
127 | # if there was an error, add error message to response_data and return
128 | if error:
129 | # append error message
130 | response_data["error"] = error
131 | # generate json
132 | response_data = simplejson.dumps([response_data])
133 | # return response to uploader with error
134 | # so it can display error message
135 | return HttpResponse(response_data, mimetype='application/json')
136 |
137 |
138 | # make temporary dir if not exists already
139 | if not os.path.exists(temp_path):
140 | os.makedirs(temp_path)
141 |
142 | # get the absolute path of where the uploaded file will be saved
143 | # all add some random data to the filename in order to avoid conflicts
144 | # when user tries to upload two files with same filename
145 | filename = os.path.join(temp_path, str(uuid.uuid4()) + file.name)
146 | # open the file handler with write binary mode
147 | destination = open(filename, "wb+")
148 | # save file data into the disk
149 | # use the chunk method in case the file is too big
150 | # in order not to clutter the system memory
151 | for chunk in file.chunks():
152 | destination.write(chunk)
153 | # close the file
154 | destination.close()
155 |
156 | # here you can add the file to a database,
157 | # move it around,
158 | # do anything,
159 | # or do nothing and enjoy the demo
160 | # just make sure if you do move the file around,
161 | # then make sure to update the delete_url which will be send to the server
162 | # or not include that information at all in the response...
163 |
164 | # allows to generate properly formatted and escaped url queries
165 | import urllib
166 |
167 | # url for deleting the file in case user decides to delete it
168 | response_data["delete_url"] = request.path + "?" + urllib.urlencode(
169 | {"f": uid + "/" + os.path.split(filename)[1]})
170 | # specify the delete type - must be POST for csrf
171 | response_data["delete_type"] = "POST"
172 |
173 | # generate the json data
174 | response_data = simplejson.dumps([response_data])
175 | # response type
176 | response_type = "application/json"
177 |
178 | # QUIRK HERE
179 | # in jQuey uploader, when it falls back to uploading using iFrames
180 | # the response content type has to be text/html
181 | # if json will be send, error will occur
182 | # if iframe is sending the request, it's headers are a little different compared
183 | # to the jQuery ajax request
184 | # they have different set of HTTP_ACCEPT values
185 | # so if the text/html is present, file was uploaded using jFrame because
186 | # that value is not in the set when uploaded by XHR
187 | if "text/html" in request.META["HTTP_ACCEPT"]:
188 | response_type = "text/html"
189 |
190 | # return the data to the uploading plugin
191 | return HttpResponse(response_data, mimetype=response_type)
192 |
193 | else: # file has to be deleted
194 |
195 | # get the file path by getting it from the query (e.g. '?f=filename.here')
196 | filepath = os.path.join(temp_path, request.GET["f"])
197 |
198 | # make sure file exists
199 | # if not return error
200 | if not os.path.isfile(filepath):
201 | return HttpResponseBadRequest("File does not exist")
202 |
203 | # delete the file
204 | # this step might not be a secure method so extra
205 | # security precautions might have to be taken
206 | os.remove(filepath)
207 |
208 | # generate true json result
209 | # in this case is it a json True value
210 | # if true is not returned, the file will not be removed from the upload queue
211 | response_data = simplejson.dumps(True)
212 |
213 | # return the result data
214 | # here it always has to be json
215 | return HttpResponse(response_data, mimetype="application/json")
216 |
217 | else: #GET
218 | # load the template
219 | t = loader.get_template("upload.html")
220 | c = Context({
221 | # the unique id which will be used to get the folder path
222 | "uid": uuid.uuid4(),
223 | # these two are necessary to generate the jQuery templates
224 | # they have to be included here since they conflict with django template system
225 | "open_tv": u'{{',
226 | "close_tv": u'}}',
227 | # some of the parameters to be checked by javascript
228 | "maxfilesize": options["maxfilesize"],
229 | "minfilesize": options["minfilesize"],
230 | })
231 | # add csrf token value to the dictionary
232 | c.update(csrf(request))
233 | # return
234 | return HttpResponse(t.render(c))
235 |
236 |
--------------------------------------------------------------------------------
/urls.py:
--------------------------------------------------------------------------------
1 | from django.conf.urls.defaults import patterns, include, url
2 | from django.contrib.staticfiles.urls import staticfiles_urlpatterns
3 |
4 | # Uncomment the next two lines to enable the admin:
5 | # from django.contrib import admin
6 | # admin.autodiscover()
7 |
8 | urlpatterns = patterns('',
9 | # Examples:
10 | # url(r'^$', 'djangoUpload.views.home', name='home'),
11 | # url(r'^djangoUpload/', include('djangoUpload.foo.urls')),
12 |
13 | # Uncomment the admin/doc line below to enable admin documentation:
14 | # url(r'^admin/doc/', include('django.contrib.admindocs.urls')),
15 |
16 | # Uncomment the next line to enable the admin:
17 | # url(r'^admin/', include(admin.site.urls)),
18 |
19 | # For the Django Jquery Upload
20 | (r'^upload/', include('upload.urls')),
21 | #(r'^upload/', 'upload.views.Upload')),
22 |
23 | #(r'^studyview/', include('studyview.urls')),
24 |
25 | )
26 |
27 | urlpatterns += staticfiles_urlpatterns()
28 |
--------------------------------------------------------------------------------