def verify_file(self, path):
return ImageService.verify_file(path)
def test_get_revision(self):
image = Generators.image(is_wip=True)
revision = Generators.imageRevision(image=image)
self.assertEqual(ImageService(image).get_revision(revision.label), revision)
def test_get_final_revision(self):
image = Generators.image(is_wip=True)
final = Generators.imageRevision(image=image, is_final=True)
Generators.imageRevision(image=image, is_final=False, label='C')
self.assertEqual(ImageService(image).get_final_revision(), final)
def test_display_download_menu_everybody(self):
image = Generators.image(download_limitations=DownloadLimitation.EVERYBODY)
self.assertTrue(ImageService(image).display_download_menu(image.user))
self.assertTrue(ImageService(image).display_download_menu(Generators.user()))
self.assertTrue(ImageService(image).display_download_menu(AnonymousUser))
def test_get_next_available_revision_label_after_z(self):
image = Generators.image(is_wip=True)
Generators.imageRevision(image=image, label='Z')
self.assertEqual(ImageService(image).get_next_available_revision_label(), 'BA')
def test_needs_premium_subscription_to_platesolve_solar_system(self, is_platesolvable):
image = Generators.image()
is_platesolvable.return_value = False
self.assertFalse(ImageService(image).needs_premium_subscription_to_platesolve())
def test_display_download_menu_me_only(self):
image = Generators.image(download_limitations=DownloadLimitation.ME_ONLY)
self.assertTrue(ImageService(image).display_download_menu(image.user))
self.assertFalse(ImageService(image).display_download_menu(Generators.user()))
self.assertFalse(ImageService(image).display_download_menu(AnonymousUser))
def test_get_crop_box_collection(self):
image = Generators.image(is_wip=True)
image.w = image.h = 1000
image.square_cropping = '100,100,200,200'
self.assertEqual(ImageService(image).get_crop_box('collection'), '100,100,200,200')
def test_get_crop_box_iotd_top_left(self):
image = Generators.image(is_wip=True)
image.w = image.h = 1000
image.square_cropping = '100,100,200,200'
self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,0,1000,380')
def test_get_default_cropping_rectangular(self):
image = Generators.image(is_wip=True)
image.w = 1000
image.h = 600
self.assertEqual(ImageService(image).get_default_cropping(), '200,0,800,600')
def test_get_crop_box_gallery_inverted(self):
image = Generators.image(is_wip=True)
image.w = image.h = 1000
image.square_cropping = '100,100,200,200'
self.assertEqual(ImageService(image).get_crop_box('gallery_inverted'), '100,100,200,200')
def test_get_default_cropping_revision(self, get_revision):
image = Generators.image(is_wip=True)
revision = Generators.imageRevision(image=image)
revision.w = revision.h = 1000
get_revision.return_value = revision
self.assertEqual(ImageService(image).get_default_cropping(revision_label=revision.label), '0,0,1000,1000')
def common_variables(request):
from django_user_agents.utils import get_and_set_user_agent
from django_bouncy.models import Bounce, Complaint
get_and_set_user_agent(request)
hard_bounces = None
soft_bounces = None
complained = False
if request.user.is_authenticated():
cache_key = 'hard_bounces_%d' % request.user.pk
hard_bounces = cache.get(cache_key)
if hard_bounces is None:
hard_bounces = Bounce.objects.filter(
hard=True,
address=request.user.email,
bounce_type="Permanent")
cache.set(cache_key, hard_bounces, 3600)
cache_key = 'soft_bounces_%d' % request.user.pk
soft_bounces = cache.get(cache_key)
if soft_bounces is None:
soft_bounces = Bounce.objects.filter(
hard=False,
address=request.user.email,
bounce_type="Transient",
created_at__gte=datetime.now() - timedelta(days=7))[:3]
cache.set(cache_key, soft_bounces, 3600)
cache_key = 'complained_%d' % request.user.pk
complained = cache.get(cache_key)
if complained is None:
complained = Complaint.objects.filter(address=request.user.email).exists()
cache.set(cache_key, complained, 3600)
d = {
'True': True,
'False': False,
'STATIC_URL': settings.STATIC_URL,
'LANGUAGE_CODE': request.LANGUAGE_CODE if hasattr(request, "LANGUAGE_CODE") else "en",
'DEBUG_MODE': settings.DEBUG,
'REQUEST_COUNTRY': get_client_country_code(request),
'IMAGES_URL': settings.IMAGES_URL,
'MEDIA_URL': settings.MEDIA_URL,
'ADS_ENABLED': settings.ADS_ENABLED,
'ADSENSE_ENABLED': settings.ADSENSE_ENABLED,
'ADMANAGER_PUBLISHER_ID': settings.ADMANAGER_PUBLISHER_ID,
'NATIVE_RESPONSIVE_WIDE_SLOT': settings.NATIVE_RESPONSIVE_WIDE_SLOT,
'NATIVE_RESPONSIVE_RECTANGULAR_SLOT': settings.NATIVE_RESPONSIVE_RECTANGULAR_SLOT,
'NATIVE_RESPONSIVE_RECTANGULAR_SLOT_2': settings.NATIVE_RESPONSIVE_RECTANGULAR_SLOT_2,
'DONATIONS_ENABLED': settings.DONATIONS_ENABLED,
'PREMIUM_ENABLED': settings.PREMIUM_ENABLED,
'PREMIUM_MAX_IMAGES_FREE': settings.PREMIUM_MAX_IMAGES_FREE,
'PREMIUM_MAX_IMAGES_LITE': settings.PREMIUM_MAX_IMAGES_LITE,
'PREMIUM_MAX_IMAGES_FREE_2020': settings.PREMIUM_MAX_IMAGES_FREE_2020,
'PREMIUM_MAX_IMAGES_LITE_2020': settings.PREMIUM_MAX_IMAGES_LITE_2020,
'PREMIUM_MAX_IMAGES_PREMIUM_2020': settings.PREMIUM_MAX_IMAGES_PREMIUM_2020,
'PREMIUM_MAX_IMAGE_SIZE_FREE_2020': settings.PREMIUM_MAX_IMAGE_SIZE_FREE_2020,
'PREMIUM_MAX_IMAGE_SIZE_LITE_2020': settings.PREMIUM_MAX_IMAGE_SIZE_LITE_2020,
'PREMIUM_MAX_IMAGE_SIZE_PREMIUM_2020': settings.PREMIUM_MAX_IMAGE_SIZE_PREMIUM_2020,
'PREMIUM_MAX_REVISIONS_FREE_2020': settings.PREMIUM_MAX_REVISIONS_FREE_2020,
'PREMIUM_MAX_REVISIONS_LITE_2020': settings.PREMIUM_MAX_REVISIONS_LITE_2020,
'PREMIUM_MAX_REVISIONS_PREMIUM_2020': settings.PREMIUM_MAX_REVISIONS_PREMIUM_2020,
'PREMIUM_PRICE_FREE_2020': settings.PREMIUM_PRICE_FREE_2020,
'PREMIUM_PRICE_LITE_2020': settings.PREMIUM_PRICE_LITE_2020,
'PREMIUM_PRICE_PREMIUM_2020': settings.PREMIUM_PRICE_PREMIUM_2020,
'PREMIUM_PRICE_ULTIMATE_2020': settings.PREMIUM_PRICE_ULTIMATE_2020,
'PAYPAL_TEST': settings.PAYPAL_TEST,
'IOTD_SHOW_CHOOSING_JUDGE': settings.IOTD_SHOW_CHOOSING_JUDGE,
'ENABLE_SOLVING': settings.ENABLE_SOLVING,
'GOOGLE_ANALYTICS_ID': settings.GOOGLE_ANALYTICS_ID,
'GOOGLE_ADS_ID': settings.GOOGLE_ADS_ID,
'READONLY_MODE': settings.READONLY_MODE,
'HARD_BOUNCES': hard_bounces,
'SOFT_BOUNCES': soft_bounces,
'HAS_COMPLAINT': complained,
'COUNTRIES': COUNTRIES,
'COOKIELAW_ACCEPTED': request.COOKIES.get('cookielaw_accepted', False),
'AUTOMATIC_RECOVERY_CONFIRMATION_BEGINS': Image.all_objects.filter(
user=request.user,
corrupted=True,
recovered__isnull=False).order_by('recovered').first().recovered + timedelta(days=14) \
if request.user.is_authenticated() and \
Image.all_objects.filter(
user=request.user,
corrupted=True,
recovered__isnull=False).exists() \
else None,
'min_index_to_like': settings.MIN_INDEX_TO_LIKE,
'enums': {
'SubjectType': SubjectType,
},
}
if request.user.is_authenticated() and request.user.userprofile.is_image_moderator():
d['images_pending_moderation_no'] = ImageService().get_images_pending_moderation().count()
return d
def get_context_data(self, **kwargs):
context = super(ImageDetailView, self).get_context_data(**kwargs)
image = context['object']
r = self.kwargs.get('r')
if r is None:
r = '0'
revision_image = None
instance_to_platesolve = image
is_revision = False
if r != '0':
try:
revision_image = ImageRevision.objects.filter(image=image,
label=r)[0]
instance_to_platesolve = revision_image
is_revision = True
except:
pass
#############################
# GENERATE ACQUISITION DATA #
#############################
from astrobin.moon import MoonPhase
gear_list = (
(_('Imaging telescopes or lenses'), image.imaging_telescopes.all(),
'imaging_telescopes'),
(_('Imaging cameras'), image.imaging_cameras.all(),
'imaging_cameras'),
(_('Mounts'), image.mounts.all(), 'mounts'),
(_('Guiding telescopes or lenses'), image.guiding_telescopes.all(),
'guiding_telescopes'),
(_('Guiding cameras'), image.guiding_cameras.all(),
'guiding_cameras'),
(_('Focal reducers'), image.focal_reducers.all(),
'focal_reducers'),
(_('Software'), image.software.all(), 'software'),
(_('Filters'), image.filters.all(), 'filters'),
(_('Accessory'), image.accessories.all(), 'accessories'),
)
makes_list = ','.join(
filter(
None,
reduce(lambda x, y: x + y, [
list(x.values_list('make', flat=True))
for x in [y[1] for y in gear_list]
])))
deep_sky_acquisitions = DeepSky_Acquisition.objects.filter(image=image)
ssa = None
image_type = None
deep_sky_data = {}
if is_revision:
w, h = get_image_resolution(revision_image)
else:
w, h = get_image_resolution(image)
try:
ssa = SolarSystem_Acquisition.objects.get(image=image)
except SolarSystem_Acquisition.DoesNotExist:
pass
if deep_sky_acquisitions:
image_type = 'deep_sky'
moon_age_list = []
moon_illuminated_list = []
dsa_data = {
'dates': [],
'frames': {},
'integration': 0,
'darks': [],
'flats': [],
'flat_darks': [],
'bias': [],
'bortle': [],
'mean_sqm': [],
'mean_fwhm': [],
'temperature': [],
}
for a in deep_sky_acquisitions:
if a.date is not None and a.date not in dsa_data['dates']:
dsa_data['dates'].append(a.date)
m = MoonPhase(a.date)
moon_age_list.append(m.age)
moon_illuminated_list.append(m.illuminated * 100.0)
if a.number and a.duration:
key = ""
if a.filter is not None:
key = "filter(%s)" % a.filter.get_name()
if a.iso is not None:
key += '-ISO(%d)' % a.iso
if a.gain is not None:
key += '-gain(%.2f)' % a.gain
if a.sensor_cooling is not None:
key += '-temp(%d)' % a.sensor_cooling
if a.binning is not None:
key += '-bin(%d)' % a.binning
key += '-duration(%d)' % a.duration
try:
current_frames = dsa_data['frames'][key]['integration']
except KeyError:
current_frames = '0x0"'
integration_re = re.match(r'^(\d+)x(\d+)"$',
current_frames)
current_number = int(integration_re.group(1))
dsa_data['frames'][key] = {}
dsa_data['frames'][key][
'filter_url'] = a.filter.get_absolute_url(
) if a.filter is not None else '#'
dsa_data['frames'][key][
'filter'] = a.filter if a.filter is not None else ''
dsa_data['frames'][key][
'iso'] = 'ISO%d' % a.iso if a.iso is not None else ''
dsa_data['frames'][key][
'gain'] = '(gain: %.2f)' % a.gain if a.gain is not None else ''
dsa_data['frames'][key][
'sensor_cooling'] = '%dC' % a.sensor_cooling if a.sensor_cooling is not None else ''
dsa_data['frames'][key]['binning'] = 'bin %sx%s' % (
a.binning, a.binning) if a.binning else ''
dsa_data['frames'][key]['integration'] = '%sx%s"' % (
current_number + a.number, a.duration)
dsa_data['integration'] += (a.duration * a.number / 3600.0)
for i in ['darks', 'flats', 'flat_darks', 'bias']:
if a.filter and getattr(a, i):
dsa_data[i].append("%d" % getattr(a, i))
elif getattr(a, i):
dsa_data[i].append(getattr(a, i))
if a.bortle:
dsa_data['bortle'].append(a.bortle)
if a.mean_sqm:
dsa_data['mean_sqm'].append(a.mean_sqm)
if a.mean_fwhm:
dsa_data['mean_fwhm'].append(a.mean_fwhm)
if a.temperature:
dsa_data['temperature'].append(a.temperature)
def average(values):
if not len(values):
return 0
return float(sum(values)) / len(values)
frames_list = sorted(dsa_data['frames'].items())
deep_sky_data = (
(_('Dates'), sorted(dsa_data['dates'])),
(_('Frames'), ('\n' if len(frames_list) > 1 else '') +
u'\n'.join("%s %s" % (
"<a href=\"%s\">%s</a>:" %
(f[1]['filter_url'],
f[1]['filter']) if f[1]['filter'] else '',
"%s %s %s %s %s" %
(f[1]['integration'], f[1]['iso'], f[1]['gain'],
f[1]['sensor_cooling'], f[1]['binning']),
) for f in frames_list)),
(_('Integration'),
"%.1f %s" % (dsa_data['integration'], _("hours"))),
(_('Darks'), '~%d' %
(int(reduce(lambda x, y: int(x) + int(y), dsa_data['darks']))
/ len(dsa_data['darks'])) if dsa_data['darks'] else 0),
(_('Flats'), '~%d' %
(int(reduce(lambda x, y: int(x) + int(y), dsa_data['flats']))
/ len(dsa_data['flats'])) if dsa_data['flats'] else 0),
(_('Flat darks'), '~%d' % (int(
reduce(lambda x, y: int(x) + int(y),
dsa_data['flat_darks'])) /
len(dsa_data['flat_darks']))
if dsa_data['flat_darks'] else 0),
(_('Bias'), '~%d' %
(int(reduce(lambda x, y: int(x) + int(y), dsa_data['bias'])) /
len(dsa_data['bias'])) if dsa_data['bias'] else 0),
(_('Avg. Moon age'), ("%.2f " % (average(moon_age_list), ) +
_("days")) if moon_age_list else None),
(_('Avg. Moon phase'),
"%.2f%%" % (average(moon_illuminated_list), )
if moon_illuminated_list else None),
(_('Bortle Dark-Sky Scale'),
"%.2f" % (average([float(x) for x in dsa_data['bortle']]))
if dsa_data['bortle'] else None),
(_('Mean SQM'),
"%.2f" % (average([float(x) for x in dsa_data['mean_sqm']]))
if dsa_data['mean_sqm'] else None),
(_('Mean FWHM'),
"%.2f" % (average([float(x) for x in dsa_data['mean_fwhm']]))
if dsa_data['mean_fwhm'] else None),
(_('Temperature'),
"%.2f" % (average([float(x)
for x in dsa_data['temperature']]))
if dsa_data['temperature'] else None),
)
elif ssa:
image_type = 'solar_system'
profile = None
if self.request.user.is_authenticated():
profile = self.request.user.userprofile
##############
# BASIC DATA #
##############
published_on = \
to_user_timezone(image.uploaded, profile) \
if profile else image.uploaded
if image.published:
published_on = \
to_user_timezone(image.published, profile) \
if profile else image.published
alias = 'regular' if not image.sharpen_thumbnails else 'regular_sharpened'
mod = self.request.GET.get('mod')
if mod == 'inverted':
alias = 'regular_inverted'
subjects = []
skyplot_zoom1 = None
if image.solution:
subjects = SolutionService(image.solution).get_objects_in_field()
skyplot_zoom1 = image.solution.skyplot_zoom1
if is_revision and revision_image.solution:
subjects = SolutionService(
revision_image.solution).get_objects_in_field()
if revision_image.solution.skyplot_zoom1:
skyplot_zoom1 = revision_image.solution.skyplot_zoom1
licenses = (
(0, 'cc/c.png', LICENSE_CHOICES[0][1]),
(1, 'cc/cc-by-nc-sa.png', LICENSE_CHOICES[1][1]),
(2, 'cc/cc-by-nc.png', LICENSE_CHOICES[2][1]),
(3, 'cc/cc-by-nc-nd.png', LICENSE_CHOICES[3][1]),
(4, 'cc/cc-by.png', LICENSE_CHOICES[4][1]),
(5, 'cc/cc-by-sa.png', LICENSE_CHOICES[5][1]),
(6, 'cc/cc-by-nd.png', LICENSE_CHOICES[6][1]),
)
locations = '; '.join([u'%s' % (x) for x in image.locations.all()])
######################
# PREFERRED LANGUAGE #
######################
preferred_language = image.user.userprofile.language
if preferred_language:
try:
preferred_language = LANGUAGES[preferred_language]
except KeyError:
preferred_language = _("English")
else:
preferred_language = _("English")
##########################
# LIKE / BOOKMARKED THIS #
##########################
like_this = image.toggleproperties.filter(property_type="like")
bookmarked_this = image.toggleproperties.filter(
property_type="bookmark")
##############
# NAVIGATION #
##############
image_next = None
image_prev = None
try:
nav_ctx = self.request.GET.get('nc')
if nav_ctx is None:
nav_ctx = self.request.session.get('nav_ctx')
if nav_ctx is None:
nav_ctx = 'user'
nav_ctx_extra = self.request.GET.get('nce')
if nav_ctx_extra is None:
nav_ctx_extra = self.request.session.get('nav_ctx_extra')
# Always only lookup public, non corrupted images!
if nav_ctx == 'user':
image_next = Image.objects \
.exclude(corrupted=True) \
.filter(user=image.user, pk__gt=image.pk).order_by('pk')[0:1]
image_prev = Image.objects \
.exclude(corrupted=True) \
.filter(user=image.user, pk__lt=image.pk).order_by('-pk')[0:1]
elif nav_ctx == 'collection':
try:
try:
collection = image.collections.get(pk=nav_ctx_extra)
except ValueError:
# Maybe this image is in a single collection
collection = image.collections.all()[0]
if collection.order_by_tag:
collection_images = Image.objects \
.exclude(corrupted=True) \
.filter(user=image.user, collections=collection, keyvaluetags__key=collection.order_by_tag) \
.order_by('keyvaluetags__value')
current_index = 0
for iter_image in collection_images.all():
if iter_image.pk == image.pk:
break
current_index += 1
image_next = collection_images.all()[current_index + 1] \
if current_index < collection_images.count() - 1 \
else None
image_prev = collection_images.all()[current_index - 1] \
if current_index > 0 \
else None
else:
image_next = Image.objects \
.exclude(corrupted=True) \
.filter(user=image.user, collections=collection,
pk__gt=image.pk).order_by('pk')[0:1]
image_prev = Image.objects \
.exclude(corrupted=True) \
.filter(user=image.user, collections=collection,
pk__lt=image.pk).order_by('-pk')[0:1]
except Collection.DoesNotExist:
# image_prev and image_next will remain None
pass
elif nav_ctx == 'group':
try:
group = image.part_of_group_set.get(pk=nav_ctx_extra)
if group.public:
image_next = Image.objects \
.exclude(corrupted=True) \
.filter(part_of_group_set=group, pk__gt=image.pk).order_by('pk')[0:1]
image_prev = Image.objects \
.exclude(corrupted=True) \
.filter(part_of_group_set=group, pk__lt=image.pk).order_by('-pk')[0:1]
except (Group.DoesNotExist, ValueError):
# image_prev and image_next will remain None
pass
elif nav_ctx == 'all':
image_next = Image.objects.exclude(corrupted=True).filter(
pk__gt=image.pk).order_by('pk')[0:1]
image_prev = Image.objects.exclude(corrupted=True).filter(
pk__lt=image.pk).order_by('-pk')[0:1]
except Image.DoesNotExist:
image_next = None
image_prev = None
if image_next and isinstance(image_next, QuerySet):
image_next = image_next[0]
if image_prev and isinstance(image_prev, QuerySet):
image_prev = image_prev[0]
#################
# RESPONSE DICT #
#################
from astrobin_apps_platesolving.solver import Solver
if skyplot_zoom1 and not skyplot_zoom1.name.startswith('images/'):
skyplot_zoom1.name = 'images/' + skyplot_zoom1.name
response_dict = context.copy()
response_dict.update({
'SHARE_PATH': settings.SHORT_BASE_URL,
'alias': alias,
'mod': mod,
'revisions': ImageService(image) \
.get_revisions(include_corrupted=self.request.user == image.user) \
.select_related('image__user__userprofile'),
'revisions_with_description': ImageService(image) \
.get_revisions_with_description(include_corrupted=self.request.user == image.user) \
.select_related('image__user__userprofile'),
'is_revision': is_revision,
'revision_image': revision_image,
'revision_label': r,
'instance_to_platesolve': instance_to_platesolve,
'show_solution': instance_to_platesolve.mouse_hover_image == "SOLUTION"
and instance_to_platesolve.solution
and instance_to_platesolve.solution.status >= Solver.SUCCESS,
'show_advanced_solution': instance_to_platesolve.mouse_hover_image == "SOLUTION"
and instance_to_platesolve.solution
and instance_to_platesolve.solution.status == Solver.ADVANCED_SUCCESS,
'skyplot_zoom1': skyplot_zoom1,
'image_ct': ContentType.objects.get_for_model(Image),
'like_this': like_this,
'user_can_like': can_like(self.request.user, image),
'bookmarked_this': bookmarked_this,
'comments_number': NestedComment.objects.filter(
deleted=False,
content_type__app_label='astrobin',
content_type__model='image',
object_id=image.id).count(),
'gear_list': gear_list,
'makes_list': makes_list,
'image_type': image_type,
'ssa': ssa,
'deep_sky_data': deep_sky_data,
'private_message_form': PrivateMessageForm(),
'promote_form': ImagePromoteForm(instance=image),
'upload_revision_form': ImageRevisionUploadForm(),
'upload_uncompressed_source_form': UncompressedSourceUploadForm(instance=image),
'dates_label': _("Dates"),
'published_on': published_on,
'show_contains': (image.subject_type == SubjectType.DEEP_SKY and subjects) or
(image.subject_type != SubjectType.DEEP_SKY),
'subjects': subjects,
'subject_type': ImageService(image).get_subject_type_label(),
'hemisphere': ImageService(image).get_hemisphere(r),
'license_icon': static('astrobin/icons/%s' % licenses[image.license][1]),
'license_title': licenses[image.license][2],
'resolution': '%dx%d' % (w, h) if (w and h) else None,
'locations': locations,
'solar_system_main_subject': ImageService(image).get_solar_system_main_subject_label(),
'content_type': ContentType.objects.get(app_label='astrobin', model='image'),
'preferred_language': preferred_language,
'select_group_form': GroupSelectForm(
user=self.request.user) if self.request.user.is_authenticated() else None,
'in_public_groups': Group.objects.filter(Q(public=True, images=image)),
'image_next': image_next,
'image_prev': image_prev,
'nav_ctx': nav_ctx,
'nav_ctx_extra': nav_ctx_extra,
})
return response_dict
def test_get_revisions_includes_corrupted(self):
image = Generators.image(is_wip=True)
Generators.imageRevision(image=image)
Generators.imageRevision(image=image, corrupted=True, label='C')
self.assertEqual(ImageService(image).get_revisions(include_corrupted=True).count(), 2)
def test_get_crop_box_iotd_bottom_right(self):
image = Generators.image(is_wip=True)
image.w = image.h = 1000
image.square_cropping = '800,800,900,900'
self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,620,1000,1000')
def test_get_hemisphere_no_solution(self):
image = Generators.image()
PlateSolvingGenerators.solution(image)
self.assertEqual(Image.HEMISPHERE_TYPE_UNKNOWN, ImageService(image).get_hemisphere())
def test_get_crop_box_iotd_center_large_crop(self):
image = Generators.image(is_wip=True)
image.w = image.h = 1000
image.square_cropping = '10,10,990,990'
self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,310,1000,690')
def test_get_revisions_with_title_or_description_only_title_but_empty(self):
image = Generators.image(is_wip=True)
Generators.imageRevision(image=image)
Generators.imageRevision(image=image, label='C', title='')
self.assertEqual(ImageService(image).get_revisions_with_title_or_description().count(), 0)
def test_get_crop_box_iotd_center_example_1(self):
image = Generators.image(is_wip=True)
image.w = 400
image.h = 800
image.square_cropping = '50,50,350,350'
self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,124,400,276')
def test_display_download_menu_null(self):
image = Generators.image(download_limitations=None)
self.assertTrue(ImageService(image).display_download_menu(image.user))
self.assertFalse(ImageService(image).display_download_menu(Generators.user()))
self.assertFalse(ImageService(image).display_download_menu(AnonymousUser))
def test_get_crop_box_iotd_center_example_2(self):
image = Generators.image(is_wip=True)
image.w = 2100
image.h = 2500
image.square_cropping = '100,400,100,2200'
self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,901,2100,1699')
def test_get_revisions_with_title_or_description(self):
image = Generators.image(is_wip=True)
Generators.imageRevision(image=image)
Generators.imageRevision(image=image, label='C', title='Foo', description='Bar')
self.assertEqual(ImageService(image).get_revisions_with_title_or_description().count(), 1)
def test_get_crop_box_iotd_edge(self):
image = Generators.image(is_wip=True)
image.w = 1200
image.h = 500
image.square_cropping = '0,20,0,20'
self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,0,1200,455')
def test_get_next_available_revision_label_with_deleted_revision(self):
image = Generators.image(is_wip=True)
Generators.imageRevision(image=image)
to_delete = Generators.imageRevision(image=image, corrupted=True, label='C')
to_delete.delete()
self.assertEqual(ImageService(image).get_next_available_revision_label(), 'D')
def test_get_crop_box_iotd_tiny_image(self):
image = Generators.image(is_wip=True)
image.w = 100
image.h = 100
image.square_cropping = '0,0,50,50'
self.assertEqual(ImageService(image).get_crop_box('iotd'), '0,6,100,44')
def test_get_final_revision_label(self):
image = Generators.image(is_wip=True)
revision = Generators.imageRevision(image=image, is_final=True)
self.assertEqual(ImageService(image).get_final_revision_label(), revision.label)
another = Generators.imageRevision(image=image, is_final=True, label='C')
self.assertEqual(ImageService(image).get_final_revision_label(), another.label)
def test_get_crop_box_regular(self):
image = Generators.image(is_wip=True)
image.w = image.h = 1000
image.square_cropping = '450,450,550,550'
self.assertEqual(ImageService(image).get_crop_box('regular'), None)
def test_get_default_cropping(self):
image = Generators.image(is_wip=True)
image.w = image.h = 1000
self.assertEqual(ImageService(image).get_default_cropping(), '0,0,1000,1000')
def test_get_next_available_revision_label(self):
image = Generators.image(is_wip=True)
Generators.imageRevision(image=image)
self.assertEquals(
ImageService(image).get_next_available_revision_label(), 'C')
