def test_pre_save(self):
c = CloudinaryField('image',
width_field="image_width",
height_field="image_height")
c.set_attributes_from_name('image')
mocked_resource = cloudinary.CloudinaryResource(metadata={
"width": TEST_IMAGE_W,
"height": TEST_IMAGE_H
},
type="upload",
public_id=TEST_IMAGE,
resource_type="image")
with mock.patch('cloudinary.uploader.upload_resource',
return_value=mocked_resource) as upload_mock:
prep_value = c.pre_save(self.p, None)
self.assertTrue(upload_mock.called)
self.assertEqual(".png", os.path.splitext(prep_value)[1])
self.assertEqual(TEST_IMAGE_W, self.p.image_width)
self.assertEqual(TEST_IMAGE_H, self.p.image_height)
# check empty values handling
self.p.image = SimpleUploadedFile(TEST_IMAGE, b'')
mocked_resource_empty = cloudinary.CloudinaryResource(metadata={})
with mock.patch('cloudinary.uploader.upload_resource',
return_value=mocked_resource_empty) as upload_mock:
c.pre_save(self.p, None)
self.assertTrue(upload_mock.called)
self.assertIsNone(self.p.image_width)
self.assertIsNone(self.p.image_height)
def url(self, name, **options):
"""
Get the full cloudinary url to a resource
Parameters:
name(string): The name of the target file used as the public_id when querying Cloudinary
Returns:
string: The url to use to access the target resource on Cloudinary
"""
url = filepath_to_uri(name).lstrip('/')
cloudinary_resource = cloudinary.CloudinaryResource(
self.upload_path(url),
default_resource_type=get_resource_type(name))
if cloudinary_resource.resource_type == 'image' and 'quality' not in options:
options = dict(
{
'quality':
settings.CLOUDINARY_STORAGE.get('DEFAULT_IMAGE_QUALITY',
'auto'),
'fetch_format':
settings.CLOUDINARY_STORAGE.get('IMAGE_FETCH_FORMAT',
'auto'),
'width':
'auto',
'dpr':
'auto'
}, **options)
if 'ckeditor' in url:
print(url, cloudinary_resource.build_url(**options))
return cloudinary_resource.build_url(**options)
def test_file_field(self):
cff_no_auto_save = CloudinaryFileField(autosave=False)
res = cff_no_auto_save.to_python(None)
self.assertIsNone(res)
# without auto_save File is untouched
res = cff_no_auto_save.to_python(self.test_file)
self.assertIsInstance(res, SimpleUploadedFile)
# when auto_save is used, resource is uploaded to Cloudinary and CloudinaryResource is returned
cff_auto_save = CloudinaryFileField(autosave=True,
options={"public_id": API_TEST_ID})
mocked_resource = cloudinary.CloudinaryResource(metadata={
"width": TEST_IMAGE_W,
"height": TEST_IMAGE_H
},
type="upload",
public_id=API_TEST_ID,
resource_type="image")
with mock.patch('cloudinary.uploader.upload_image',
return_value=mocked_resource) as upload_mock:
res = cff_auto_save.to_python(self.test_file)
self.assertTrue(upload_mock.called)
self.assertIsInstance(res, CloudinaryResource)
self.assertEqual(API_TEST_ID, res.public_id)
def upload_resource(file, **options):
result = upload(file, **options)
return cloudinary.CloudinaryResource(result["public_id"],
version=str(result["version"]),
format=result.get("format"),
type=result["type"],
resource_type=result["resource_type"],
metadata=result)
def _get_url(self, name):
name = self._prepend_prefix(name)
cloudinary_resource = cloudinary.CloudinaryResource(
name,
default_resource_type=self._get_resource_type(name),
url_options={'force_version': False, 'invalidate': True}
)
return cloudinary_resource.url
def upload_resource(file, **options):
upload_func = upload
if hasattr(file, 'size') and file.size > UPLOAD_LARGE_CHUNK_SIZE:
upload_func = upload_large
result = upload_func(file, **options)
return cloudinary.CloudinaryResource(
result["public_id"], version=str(result["version"]),
format=result.get("format"), type=result["type"],
resource_type=result["resource_type"], metadata=result)
def test_upload_options_with_filename(self):
c = CloudinaryField('image', filename=UNIQUE_TEST_ID)
c.set_attributes_from_name('image')
mocked_resource = cloudinary.CloudinaryResource(type="upload",
public_id=TEST_IMAGE,
resource_type="image")
with mock.patch('cloudinary.uploader.upload_resource',
return_value=mocked_resource) as upload_mock:
c.pre_save(self.p, None)
self.assertTrue(upload_mock.called)
self.assertEqual(upload_mock.call_args[1]['filename'], UNIQUE_TEST_ID)
class ProductFactory(factory.django.DjangoModelFactory):
class Meta:
model = Product
name = factory.Sequence(lambda n: "Product %d" % n)
product_id = factory.Sequence(lambda n: n)
description = factory.fuzzy.FuzzyText(length=56)
client_id = factory.Sequence(lambda n: uuid.uuid4())
category = factory.SubFactory(CategoryFactory)
price = factory.fuzzy.FuzzyDecimal(0.5, 58.2)
currency = factory.fuzzy.FuzzyChoice(
[curr[0] for curr in CURRENCY_CHOICES])
image_link = factory.Sequence(
lambda n: cloudinary.CloudinaryResource('sample.jpg'))
online = factory.fuzzy.FuzzyChoice([True, False])
views = factory.fuzzy.FuzzyInteger(78)
def test_upload_options(self):
c = CloudinaryField('image',
width_field="image_width",
height_field="image_height",
unique_filename='true',
use_filename='true',
phash='true')
c.set_attributes_from_name('image')
mocked_resource = cloudinary.CloudinaryResource(metadata={
"width": TEST_IMAGE_W,
"height": TEST_IMAGE_H
},
type="upload",
public_id=TEST_IMAGE,
resource_type="image")
with mock.patch('cloudinary.uploader.upload_resource',
return_value=mocked_resource) as upload_mock:
c.pre_save(self.p, None)
self.assertTrue(upload_mock.called)
self.assertEqual(upload_mock.call_args[1]['unique_filename'], 'true')
self.assertEqual(upload_mock.call_args[1]['use_filename'], 'true')
self.assertEqual(upload_mock.call_args[1]['phash'], 'true')
def _get_url(self, name):
name = self._prepend_prefix(name)
cloudinary_resource = cloudinary.CloudinaryResource(
name, default_resource_type=self._get_resource_type(name))
return cloudinary_resource.url
def render(self, image, options, caller=None):
if not isinstance(image, cloudinary.CloudinaryResource):
image = cloudinary.CloudinaryResource(image)
return image.image(**options)
def render(self, source, options, caller=None):
if not isinstance(source, cloudinary.CloudinaryResource):
source = cloudinary.CloudinaryResource(source)
return source.build_url(**options)
def create_event(request, meetup_id):
if not request.user.is_superuser and not request.user.useraccount.is_event_creator:
return redirect('landing-page')
photo_url = None
if request.method == 'POST':
event_status = 'Draft' if ('Draft' in request.POST) else 'Publish'
speakers = request.POST.getlist('speakers')
sponsors = request.POST.getlist('sponsors')
volunteers = request.POST.getlist('volunteers')
member_speakers = request.POST.getlist('member_speakers')
member_sponsors = request.POST.getlist('member_sponsors')
member_volunteers = request.POST.getlist('member_volunteers')
form = EventForm(request.POST, request.FILES)
if form.is_valid():
event = form.save(commit=False)
event.author = request.user
event.status = event_status
event.save()
if speakers:
for speaker in speakers:
event.speakers.add(Speaker.objects.get(pk=speaker))
if sponsors:
for sponsor in sponsors:
event.sponsors.add(Sponsor.objects.get(pk=sponsor))
if member_speakers:
for member in member_speakers:
event.member_speaker.add(Member.objects.get(pk=member))
if member_sponsors:
for member in member_sponsors:
event.member_sponsor.add(Member.objects.get(pk=member))
if volunteers:
for volunteer in volunteers:
event.volunteers.add(Volunteer.objects.get(pk=volunteer))
if member_volunteers:
for volunteer in member_volunteers:
event.member_volunteer.add(
Member.objects.get(pk=volunteer))
if not ('overwrite'
in request.POST) and 'meetup_photo_url' in request.POST:
if request.POST['meetup_photo_url'] != 'None':
meetup_photo_url = request.POST['meetup_photo_url']
meetup_banner = cloudinary.uploader.upload(
meetup_photo_url)
result = cloudinary.CloudinaryResource(
public_id=meetup_banner['public_id'],
type=meetup_banner['type'],
resource_type=meetup_banner['resource_type'],
version=meetup_banner['version'],
format=meetup_banner['format'])
str_result = result.get_prep_value()
event.banner = str_result
event.save()
EventStatistics.objects.create(event=event)
UserLog.objects.create(
user=request.user,
description="New Event Created. (%s)" % (event.title, ),
)
if ('Yes' in request.POST) and event.status == 'Publish':
t = threading.Thread(target=send_event_notification(event))
t.setDaemon = True
t.start()
send_event_notification_to_speakers(event)
return redirect('event:event-upcoming')
else:
if Event.objects.filter(meetup_ID=meetup_id).exists():
event = Event.objects.get(meetup_ID=meetup_id)
return redirect('event:event-view', slug=event.slug)
meetup_event = settings.MEETUP_CLIENT.GetEvent({'id': meetup_id})
# Get Event Banner
photo_url = meetup_event.photo_url if 'photo_url' in meetup_event.__dict__ else None
if 'venue' in meetup_event.__dict__:
venue_name = meetup_event.venue[
'name'] if 'name' in meetup_event.venue else ''
address_1 = meetup_event.venue[
'address_1'] if 'address_1' in meetup_event.venue else ''
address_2 = meetup_event.venue[
'address_2'] if 'address_2' in meetup_event.venue else ''
city = meetup_event.venue[
'city'] if 'city' in meetup_event.venue else ''
event_lat = meetup_event.venue[
'lat'] if 'lat' in meetup_event.venue else 6.9214
event_lng = meetup_event.venue[
'lon'] if 'lon' in meetup_event.venue else 122.0790
event_location = venue_name + ', ' + address_1 + ', ' + address_2 + ', ' + city
else:
event_location = 'No event venue was set'
event_lat = 6.9214
event_lng = 122.0790
# Get Event Duration
event_duration = meetup_event.duration if 'duration' in meetup_event.__dict__ else 0
# Get Event Description
event_description = meetup_event.description if 'description' in meetup_event.__dict__ else 'No Description'
event_start = datetime.datetime.fromtimestamp(meetup_event.time /
1000.0)
event_start_date = event_start.strftime("%Y-%m-%d")
event_start_time = event_start.strftime("%H:%M:%S")
event_end = datetime.datetime.fromtimestamp(
meetup_event.time /
1000.0) + datetime.timedelta(hours=event_duration / 3600000)
event_end_date = event_end.strftime("%Y-%m-%d")
event_end_time = event_end.strftime("%H:%M:%S")
event_description = BeautifulSoup(
event_description, features='html.parser').get_text(separator='\n')
form = EventForm(
initial={
'author': request.user,
'title': meetup_event.name,
'location': event_location,
'latitude': event_lat,
'longitude': event_lng,
'date': event_start_date,
'time': event_start_time,
'date_to': event_end_date,
'time_to': event_end_time,
'description': event_description,
'meetup_ID': meetup_id,
})
speaker_form = SpeakerForm()
sponsor_form = SponsorForm()
volunteer_form = VolunteerForm()
speaker_list = Speaker.objects.all()
sponsor_list = Sponsor.objects.all()
member_list = Member.objects.all()
volunteer_list = Volunteer.objects.all()
context = {
'form': form,
'speaker_form': speaker_form,
'sponsor_form': sponsor_form,
'volunteer_form': volunteer_form,
'speaker_list': speaker_list,
'sponsor_list': sponsor_list,
'member_list': member_list,
'volunteer_list': volunteer_list,
'photo_url': photo_url,
'start_date': event_start_date,
'end_date': event_end_date
}
return render(request, 'event/event-create.html', context)
