def uploadfile(request):
"""
Initialize Ajax File Uploader
"""
from ajaxuploader.views import AjaxFileUploader
from pages.ajaxupload import CustomStorageUploadBackend
from django.http import HttpResponseBadRequest
directory = request.GET["directory"]
directory_allowed = {"background": 0, "photo": 0, "pdf": 0, "logo": 0}
try:
directory_allowed[directory]
except:
return HttpResponseBadRequest()
uploaderresponse = AjaxFileUploader(backend=CustomStorageUploadBackend, uploaddir="uploads/" + directory + "/")
return uploaderresponse._ajax_upload(request)
class UploadFileView(IssueSignalsMixin, UpdateView):
"""
Override the uploader and cater to the multiple file associations
@TODO turn this into a service
"""
model = EightyThreeB
uploader = None
def __init__(self, *args, **kwargs):
super(UploadFileView, self).__init__(*args, **kwargs)
self.uploader = AjaxFileUploader()
def post(self, request, *args, **kwargs):
self.object = self.get_object()
# Upload the File using the ajax_uploader object
response = self.uploader._ajax_upload(request, *args, **kwargs)
if response.status_code in [200]:
# success
data = json.loads(response.content)
base_path, filename = os.path.split(data.get('path'))
# create and upload to s3
with open(os.path.join(settings.MEDIA_ROOT, 'uploads', filename)) as file_path:
uploaded_file = File(file_path)
attachment = self.object.attachment_set.create(eightythreeb=self.object)
attachment.attachment = uploaded_file
attachment.save()
os.remove(uploaded_file.name)
data['path'] = attachment.attachment.url
response.content = json.dumps(data)
# send signal
self.issue_signals(request=request, instance=self.object, name='copy_uploaded')
return response
from mimes import get_mime
# Create your views here.
class JUploaderbackend(LocalUploadBackend):
def __init__(self,*args,**kwargs):
if('target_dir' not in kwargs):
self.target_dir = getattr(settings, "DEFAULT_JUPLOAD_DIR", "unsorted_files")
else:
self.target_dir = kwargs.pop('target_dir')
super(JUploaderbackend,self).__init__()
self.UPLOAD_DIR = os.path.join(self.UPLOAD_DIR,self.target_dir)
def update_filename(self,request,filename):
'''filename gets put into the users avatar directory'''
#TODO detect duplicate files
filename = filename.replace(',','') #Pesky comas, hate them
return filename
def upload_complete(self,request,filename):
'''resizes the image and converts to PNG'''
fpath = os.path.join(self.UPLOAD_DIR,filename)
mimetype = get_mime(fpath)
return {'mimetype':mimetype,
'path':fpath,}
uploader_conf = AjaxFileUploader(backend=JUploaderbackend)
next_song = client.playlistinfo(status['nextsong'])
except:
pass
client.close()
client.disconnect()
if request.user.is_authenticated():
carma = profile.carma
else:
carma = "0"
login_form = AuthenticationForm(request=request)
registration_form = RegistrationForm()
upload_form = TrackForm(user=request.user)
csrf_token = get_token(request)
return {
"playlist": playlist,
"current_song": current_song,
"next_song": next_song[0],
"status": status,
"carma": carma,
"login_form": login_form,
"registration_form": registration_form,
"upload_form": upload_form,
'csrf_token': csrf_token
}
import_uploader = AjaxFileUploader(backend=TrackUploadBackend)
# -*- coding: UTF-8 -*-
from django.conf.urls import patterns, include, url
from django.conf import settings
from django.contrib.staticfiles.urls import staticfiles_urlpatterns
from ajaxuploader.views import AjaxFileUploader
uploader = AjaxFileUploader()
# Uncomment the next two lines to enable the admin:
# from django.contrib import admin
# admin.autodiscover()
urlpatterns = patterns(
'',
url(r'^helper/ajax-upload/$', uploader, name="ajax_uploader"),
url(r'^$', 'images.views.image_list', name='image_list'),
url(r'^images/(?P<image_id>\d*)/$',
'images.views.image_upload',
name='change_image'),
url(r'^images/add/$', 'images.views.image_upload', name='add_image'),
# Uncomment the next line to enable the admin:
# url(r'^admin/', include(admin.site.urls)),
)
urlpatterns += staticfiles_urlpatterns()
urlpatterns = patterns(
'',
url(r'^media/(?P<path>.*)$',
'django.views.static.serve', {'document_root': settings.MEDIA_ROOT},
post.save()
except:
pass
os.unlink(media_root + path)
return {
'id': linked_document.id,
'url': linked_document.document.url
}
except IOError as e:
if getattr(settings, 'DEBUG', False):
raise e
return {'error': 'File failed to upload. May be invalid or corrupted image file'}
post_photo_uploader = AjaxFileUploader(PostPhotoUploadBackend)
Post_document_uploader = AjaxFileUploader(PostDocumentUploadBackend)
def delete_photo(request, *args, **kwargs):
post_id = request.GET.get('post_id')
photo_id = request.GET['photo_id']
photo = Photo(id=photo_id)
if post_id:
post = Post.objects.get(pk=post_id)
if photo in post.image:
post.image.remove(photo)
post.save()
try:
Photo.objects.get(pk=photo_id).delete()
except:
url(r'^admin/museo/(?P<slug>[\w-]+)/$',
views.MuseoUpdate.as_view(),
name='museo_actualizar'),
# admin urls:
url(r'^admin/museo$',
views.ExposicionAdmin.as_view(),
name='exposicion_admin'),
url(r'^admin/exposicion/nueva$',
views.ExposicionCreate.as_view(),
name='exposicion_nueva'),
url(r'^admin/exposicion/(?P<slug>[\w-]+)/$',
views.ExposicionUpdate.as_view(),
name='exposicion_actualizar'),
url(r'^admin/exposicion/(?P<slug>[\w-]+)/media/img$',
AjaxFileUploader(),
name='img_agregar'),
url(r'^admin/exposicion/(?P<slug>[\w-]+)/media/agregar$',
views.MediaCreate.as_view(),
name='media_agregar'),
url(r'^admin/exposicion/(?P<slug>[\w-]+)/media$',
views.MediaList.as_view(),
name='media_list'),
url(r'^admin/catalogo/(?P<slug>[\w-]+)/$',
views.CatalogoCreate.as_view(),
name='catalogo_create'),
url(r'^admin/catalogo/(?P<slug>[\w-]+)/save/$',
views.CatalogoSave.as_view(),
name='catalogo_save'),
url(r'^admin/catalogo/(?P<slug>[\w-]+)/export/$',
views.CatalogoExport.as_view(),
raise e
return {'path': url}
except IOError as e:
if settings.DEBUG:
raise e
return {
'error':
'File failed to upload. May be invalid or corrupted image file'
}
else:
return super(CouponUploadBackend,
self).upload_complete(request, filename, *args,
**kwargs)
upload_coupon_image = AjaxFileUploader(CouponUploadBackend)
def render_reward_offered_event(event, request):
event_type = event.event_type
if event_type.codename == WELCOME_REWARD_OFFERED:
reward_list = Reward.objects.using(UMBRELLA).filter(
type=Reward.JOIN, member=event.member)
elif event_type.codename == FREE_REWARD_OFFERED:
reward_list = Reward.objects.using(UMBRELLA).filter(
type=Reward.FREE, member=event.member)
elif event_type.codename == REFERRAL_REWARD_OFFERED:
reward_list = Reward.objects.using(UMBRELLA).filter(
type=Reward.REFERRAL, member=event.member)
else:
reward_list = Reward.objects.using(UMBRELLA).filter(
post.save()
except:
pass
os.unlink(media_root + path)
return {'id': photo.id, 'url': photo.image.small_url}
except IOError as e:
if getattr(settings, 'DEBUG', False):
raise e
return {
'error':
'File failed to upload. May be invalid or corrupted image file'
}
post_photo_uploader = AjaxFileUploader(PostPhotoUploadBackend)
class Receipt(TemplateView):
template_name = 'enfinchezmoi/receipt.html'
def get_context_data(self, **kwargs):
context = super(Receipt, self).get_context_data(**kwargs)
config = get_service_instance().config
receipt_id = self.kwargs.get('receipt_id')
try:
reservation = Reservation.objects.select_related('member').get(
pk=receipt_id)
except Reservation.DoesNotExist:
raise Http404("Reservation not found")
context['currency_symbol'] = config.currency_symbol
result = item_resource.import_data(dataset, dry_run=True)
result.has_errors()
except Exception as e:
return {'exception': e.message}
os.unlink(media_root + path)
return {'id': batch_upload.id, 'url': batch_upload.image.thumb_url}
except IOError as e:
if settings.DEBUG:
raise e
return {
'error':
'File failed to upload. May be invalid or corrupted image file'
}
item_batch_uploader = AjaxFileUploader(ItemSpreadsheetUploadBackend)
@permission_required('items.manage_item')
def do_import_items_from_spreadsheet(request, *args, **kwargs):
upload_id = request.GET['upload_id']
upload = BatchUpload.objects.get(pk=upload_id)
service = get_service_instance()
item_resource = ItemResource()
item_resource.provider = service
item_resource.batch_upload = upload
item_resource.retail_price_is_modifiable = True if request.GET.get(
'retail_price_is_modifiable') else False
dataset = tablib.Dataset()
dataset.xls = open(upload.spreadsheet.path).read()
add_database, calculate_watch_info, set_counters, get_mail_content
from ikwen.rewarding.models import CROperatorProfile
try:
ikwen_service = Service.objects.using(UMBRELLA).get(
pk=ikwen.conf.settings.IKWEN_SERVICE_ID)
IKWEN_BASE_URL = ikwen_service.url
except Service.DoesNotExist:
IKWEN_BASE_URL = getattr(settings, 'IKWEN_BASE_URL') if getattr(
settings, 'DEBUG', False) else ikwen.conf.settings.PROJECT_URL
logger = logging.getLogger('ikwen')
HybridListView = HybridListView # Proxy import to make ikwen.core.views.HybridListView valid
ChangeObjectBase = ChangeObjectBase # Proxy import to make ikwen.core.views.ChangeObjectBase valid
upload_image = AjaxFileUploader(DefaultUploadBackend)
upload_customization_image = AjaxFileUploader(CustomizationImageUploadBackend)
class DefaultHome(TemplateView):
"""
Can be used to set at default Home page for applications that do
not have a public part. This merely shows the company name, logo
and slogan. This view can be used to create the url with the
name 'home' that MUST ABSOLUTELY EXIST in all ikwen applications.
"""
template_name = 'core/default_home.html'
class ServiceDetail(TemplateView):
template_name = 'core/service_detail.html'
from django.conf.urls import *
from ajaxuploader.views import AjaxFileUploader
from ajaxuploader.backends.default_storage import DefaultStorageUploadBackend
default_storage_uploader = AjaxFileUploader(
backend=DefaultStorageUploadBackend)
urlpatterns = patterns(
'',
url(r'^upload$',
default_storage_uploader,
name="ajax-upload-default-storage"),
)
uploads = IMGSource.objects.filter(object_pk=obj_pk)
ctypemod = ContentType.objects.get(pk=ctype_pk)
m = ctypemod.model_class()
obj = m.objects.get(pk=obj_pk)
return direct_to_template(
request, 'upload.html', {
'form': form,
'upload_url': upload_url,
'upload_data': upload_data,
'object': obj,
'uploads': uploads,
'obj_pk': obj_pk,
'ctype_pk': ctype_pk,
'error': request.GET.get('error')
})
def download_handler(request, pk):
upload = get_object_or_404(IMGSource, pk=pk)
return serve_file(request, upload.file, save_as=True)
def delete_handler(request, pk, ctype_pk):
get_object_or_404(IMGSource, pk=pk).delete()
return HttpResponseRedirect(reverse('pirate_sources.views.upload_handler'),
args=[pk, ctype_pk])
import_uploader = AjaxFileUploader(backend=S3CustomBackend,
NUM_PARALLEL_PROCESSES=8)
return HttpResponseRedirect(
reverse('profile_newhome_workflow', args=[newhome_id]))
else:
if progress_id is None:
form = ProgressForm()
else:
form = ProgressForm(
initial={'date': progress.date.strftime('%d-%m-%Y')})
return render(request, 'newhome/cabinet/workflow-add.jinja.html', locals())
object_uploader = login_required(
AjaxFileUploader(backend=ajax_upload.NewhomeStorageBackend,
UPLOAD_DIR=settings.AJAX_UPLOAD_DIR))
@login_required
@accept_newhome_user
def object_change(request, newhome_id=None):
"""
Профиль застройщика: добавление/редактирование объекта
todo: упростить работу с формой или разделить на два разных метода
todo: создание Ad + присвоение региона
"""
if newhome_id is None:
del newhome_id
from ajaxuploader.views import AjaxFileUploader
from django.conf import settings
from ui.storage.upload_backend import CustomUploadBackend
# uploading temporary images for Creative
upload_creative_image = AjaxFileUploader(
backend=CustomUploadBackend,
UPLOAD_DIR=settings.CREATIVES_UPLOAD_DIR,
)
from django.shortcuts import render, redirect, get_object_or_404
from django.middleware.csrf import get_token
from django.shortcuts import render_to_response
from django.template import RequestContext
from ajaxuploader.views import AjaxFileUploader
from upload import StringUploadBackend
from replay_persister import *
from s2gs_persister import *
from django.http import HttpResponse, HttpResponseBadRequest, HttpResponseServerError
from buildnodes import *
replayPersister = ReplayPersister()
s2gsPersister = S2GSPersister()
buildNodes = BuildNodes()
uploader = AjaxFileUploader(backend=StringUploadBackend,
completeListener=replayPersister)
def json_uploader(request):
if request.method != "GET":
return HttpResponseBadRequest("AJAX request not valid")
id = request.GET['id']
sender_subdomain = request.GET['sender_subdomain']
try:
if replayPersister.upload_from_ruby(id, sender_subdomain):
return HttpResponse("no problem")
else:
return HttpResponseServerError("problem")
except Exception, e:
print "Exception! ", e
traceback.print_exc()
from django.contrib.auth.decorators import login_required
from django.contrib.auth import REDIRECT_FIELD_NAME
from django.contrib.contenttypes.models import ContentType
from django.contrib.auth.models import User, Group
from django.middleware.csrf import get_token
from django.template.loader import render_to_string
from django.template import RequestContext, loader, Context
from django.core.servers.basehttp import FileWrapper
from django.core.serializers.json import DjangoJSONEncoder
from django.core.urlresolvers import reverse
from django.core.files import File
from django.db.models.loading import get_model
from shapesengine.utils import instance_dict
from shapesengine.models import *
from ajaxuploader.backends.local import LocalUploadBackend
class AjaxUploadBackend(LocalUploadBackend):
UPLOAD_DIR = 'ajax_uploads'
from ajaxuploader.views import AjaxFileUploader
import_uploader = AjaxFileUploader(AjaxUploadBackend)
def __init__(self, *args, **kwargs):
super(UploadFileView, self).__init__(*args, **kwargs)
self.uploader = AjaxFileUploader()
product.save()
except:
pass
os.unlink(media_root + path)
return {
'id': photo.id,
'url': photo.image.small_url
}
except IOError as e:
if getattr(settings, 'DEBUG', False):
raise e
return {'error': 'File failed to upload. May be invalid or corrupted image file'}
product_photo_uploader = AjaxFileUploader(ProductPhotoUploadBackend)
class ChangeProduct(ChangeObjectBase):
template_name = 'kako/change_product.html'
model_admin = ProductAdmin
model = Product
context_object_name = 'product'
def get_object(self, **kwargs):
object_id = kwargs.get('object_id', self.request.GET.get('product_id'))
if object_id:
return get_object_or_404(Product, pk=object_id)
def get_context_data(self, **kwargs):
context = super(ChangeProduct, self).get_context_data(**kwargs)
from django.views.decorators.http import require_POST
from django.views.decorators.http import require_http_methods
from django.contrib import messages
from django.core.exceptions import PermissionDenied
from django.http import HttpResponse
from ajaxuploader.views import AjaxFileUploader
from ajaxuploader.backends.thumbnail import ThumbnailUploadBackend
from .forms import *
from .models import *
from .decorators import require_auth
from subpages.views import DIVISIONS, PROJECTS
import_uploader = AjaxFileUploader(backend=ThumbnailUploadBackend,
DIMENSIONS="188",
KEEP_ORIGINAL=False,
UPLOAD_DIR='members/avatars/')
def _display_member(request,
template,
member,
address_form=None,
contact_form=None):
return render(
request, template, {
'member':
member,
'is_owner':
member.id == request.session['members_user_id'],
from django.core.urlresolvers import reverse
from food.models import Food, FoodCategory
from django.core import serializers
from actstream import action
from django.contrib.auth.models import User
from django.forms.formsets import formset_factory
from django.conf import settings
from accounts.models import MyProfile
from ajaxuploader.views import AjaxFileUploader
from ajaxuploader.backends.easythumbnails import EasyThumbnailUploadBackend
from recipe.search import autonav, normal_search
from django.db.models import Q
did_image_upload = AjaxFileUploader(backend=EasyThumbnailUploadBackend,
DIMENSIONS=(540, 000),
QUALITY=90,
DETAIL=False,
SHARPEN=False,
UPLOAD_DIR='Recipe_Images/Did_Images')
cover_image_upload = AjaxFileUploader(backend=EasyThumbnailUploadBackend,
DIMENSIONS=(540, 000),
QUALITY=90,
DETAIL=False,
SHARPEN=False,
UPLOAD_DIR='Recipe_Images/Cover_Images')
step_image_upload = AjaxFileUploader(backend=EasyThumbnailUploadBackend,
DIMENSIONS=(540, 000),
QUALITY=80,
DETAIL=False,
SHARPEN=False,
kw_fields = {field: request.REQUEST.get(field, '')
for field in ['source_program', 'source_program_version']}
f = ImportFile.objects.create(import_record=record,
file=self.path,
source_type=source_type,
**kw_fields)
_log.info("Created ImportFile. kw_fields={} from-PM={}"
.format(kw_fields, f.from_portfolio_manager))
return {'success': True, "import_file_id": f.pk}
#this actually creates the django view for handling local file uploads.
#thus the use of decorators as functions instead of decorators.
local_uploader = AjaxFileUploader(backend=DataImportBackend)
local_uploader = login_required(local_uploader)
local_uploader = api_endpoint(local_uploader)
#API documentation and method name fix
local_uploader.__doc__ = \
"""
Endpoint to upload data files to, if uploading to local file storage.
Valid source_type values are found in ``seed.models.SEED_DATA_SOURCES``
:GET:
The following parameters are expected to be in the query string:
import_record: the ID of the ImportRecord to associate this file with.
Send a file through Django without loading the whole file into
memory at once. The FileWrapper will turn the file object into an
iterator for chunks of 8KB.
"""
requested_file = get_object_or_404(UploadedFile, id=id)
filename = str(requested_file.supporting_document.name)
wrapper = FileWrapper(open(filename, 'rb'))
content_type = mimetypes.MimeTypes().guess_type(filename)[0]
response = HttpResponse(wrapper, content_type=content_type)
response['Content-Length'] = os.path.getsize(filename)
response['Content-Disposition'] = 'attachment; filename="{}"'.format(
os.path.basename(filename))
return response
import_uploader = AjaxFileUploader()
@login_required
def delete_uploaded_file(request):
if request.method != 'POST':
return HttpResponseNotAllowed('Error - POST required to delete')
file_id = request.POST.get('file_id', None)
selected_file = get_object_or_404(UploadedFile,
id=file_id,
user=request.user)
protected = False
message = 'File deleted.'
if selected_file.application is not None:
if selected_file.application.frozen == True:
def post_ajax(self, request, slug):
exhibition = _get_exhibition(request.user, slug)
folder = exhibition.museum.slug + "/" + exhibition.slug
uploader = AjaxFileUploader(backend=DefaultStorageUploadBackend,
UPLOAD_DIR=folder)
return uploader(request)
except Exception as e:
return {
'exception': e.message
}
os.unlink(media_root + path)
return {
'id': batch_upload.id,
'url': batch_upload.image.thumb_url
}
except IOError as e:
if settings.DEBUG:
raise e
return {'error': 'File failed to upload. May be invalid or corrupted image file'}
product_batch_uploader = AjaxFileUploader(ProductSpreadsheetUploadBackend)
@permission_required('kako.manage_product')
def do_import_products_from_spreadsheet(request, *args, **kwargs):
upload_id = request.GET['upload_id']
upload = BatchUpload.objects.get(pk=upload_id)
service = get_service_instance()
product_resource = ProductResource()
product_resource.provider = service
product_resource.batch_upload = upload
product_resource.retail_price_is_modifiable = True if request.GET.get('retail_price_is_modifiable') else False
dataset = tablib.Dataset()
dataset.xls = open(upload.spreadsheet.path).read()
col_id = ['' for i in range(dataset.height)]
return {
'success': False,
'message': "Import Record %s not found" % import_record_pk
}
source_type = request.REQUEST['source_type']
f = ImportFile.objects.create(import_record=record,
file=self.path,
source_type=source_type)
return {'success': True, "import_file_id": f.pk}
#this actually creates the django view for handling local file uploads.
#thus the use of decorators as functions instead of decorators.
local_uploader = AjaxFileUploader(backend=DataImportBackend)
local_uploader = login_required(local_uploader)
local_uploader = api_endpoint(local_uploader)
#API documentation and method name fix
local_uploader.__doc__ = \
"""
Endpoint to upload data files to, if uploading to local file storage.
Valid source_type values are found in ``seed.models.SEED_DATA_SOURCES``
:GET:
The following parameters are expected to be in the query string:
import_record: the ID of the ImportRecord to associate this file with.
is_ghost=True)
Subscription.objects.create(member=member,
product=product,
reference_id=reference_id,
monthly_cost=cost,
billing_cycle=billing_cycle,
invoice_tolerance=tolerance,
since=since,
expiry=expiry,
status=status.capitalize())
except:
continue
return error
class SubscriptionUploadBackend(DefaultUploadBackend):
def upload_complete(self, request, filename, *args, **kwargs):
path = self.UPLOAD_DIR + "/" + filename
self._dest.close()
try:
error = import_subscriptions(path)
except Exception as e:
error = e.message
return {
'path': getattr(settings, 'MEDIA_URL') + path,
'error_message': error
}
upload_subscription_file = AjaxFileUploader(SubscriptionUploadBackend)
item.save()
except:
pass
os.unlink(media_root + path)
return {
'id': photo.id,
'url': photo.image.small_url
}
except IOError as e:
if getattr(settings, 'DEBUG', False):
raise e
return {'error': 'File failed to upload. May be invalid or corrupted image file'}
item_photo_uploader = AjaxFileUploader(ItemPhotoUploadBackend)
class ChangeItem(TemplateView):
template_name = 'items/change_item.html'
def get_item_admin(self):
default_site = AdminSite()
item_admin = ItemAdmin(Item, default_site)
return item_admin
def get_context_data(self, **kwargs):
context = super(ChangeItem, self).get_context_data(**kwargs)
collection_id = self.request.GET.get('collection_id')
if collection_id:
try:
