def clean(self):
cleaned_data = super().clean()
config = cleaned_data.get("config")
media = cleaned_data.get("media")
kind = cleaned_data.get("kind")
address = cleaned_data.get("address")
if kind == Media.PHYSICAL and (not address
or not address.physical_compatible):
self.add_error(
"address",
_("This address can't be used as it misses postal details"))
if config is not None:
# save config if its size changed
if config.size_value_changed():
config.save()
if config is not None and media is not None and not config.can_fit_on(
media):
min_media = Media.get_min_for(config.size)
if min_media is None:
msg = _("There is no large enough Media for this config.")
field = "config"
else:
msg = _(
"Media not large enough for config (use at least %(media)s)"
) % {
"media": min_media.name
}
field = "media"
self.add_error(field, msg)
def required_size_for_config(request):
try:
payload = request.body
if type(payload) is bytes:
payload = payload.decode("UTF-8")
data = json.loads(payload)
except Exception:
return JsonResponse({"error": str(request.body)})
# check disk space
collection = get_collection(
edupi=data.get("edupi", False),
edupi_resources=data.get("edupi_resources", None),
nomad=data.get("nomad", False),
mathews=data.get("mathews", False),
africatik=data.get("africatik", False),
packages=data.get("packages", []),
kalite_languages=data.get("kalite", []),
wikifundi_languages=data.get("wikifundi", []),
aflatoun_languages=["fr", "en"] if data.get("aflatoun", False) else [],
)
required_image_size = get_required_image_size(collection)
media = Media.get_min_for(required_image_size)
return JsonResponse({
"size":
required_image_size,
"hsize":
human_readable_size(required_image_size, False),
"media_size":
human_readable_size(media.size * ONE_GB, False) if media else None,
"hfree":
human_readable_size(media.bytes -
required_image_size) if media else None,
})
def clean_media(self):
media = Media.get_or_none(self.cleaned_data.get("media"))
if media is None:
raise forms.ValidationError(_("Incorrect Media"), code="invalid")
if media.kind == Media.PHYSICAL and not self.client.can_order_physical:
raise forms.ValidationError(_("Not allowed to order physical"),
code="invalid")
return media
def __init__(self, *args, **kwargs):
client = kwargs.pop("client")
super().__init__(*args, **kwargs)
self.client = client
self.organization = client.organization
self.fields["config"].choices = Configuration.get_choices(
self.organization)
self.fields["address"].choices = Address.get_choices(self.organization)
self.fields["media"].choices = Media.get_choices()
def media_choices_for_configuration(request, config_id):
all_medias = Media.objects.all()
config = Configuration.get_or_none(config_id)
if config is not None and config.organization == request.user.profile.organization:
medias = [m for m in all_medias if m.bytes >= config.size]
if not medias:
medias = all_medias.filter(size=all_medias.aggregate(Max("size"))["size__max"])
return JsonResponse(Media.choices_for(medias), safe=False)
def __init__(self, *args, **kwargs):
request = kwargs.pop("request")
super().__init__(*args, **kwargs)
self.client = request.user.profile
self.request_lang = get_language_from_request(request)
self.organization = self.client.organization
self.fields["config"].choices = Configuration.get_choices(
self.organization)
self.fields["address"].choices = [
("none", "Myself")
] + Address.get_choices(self.organization)
self.fields["media"].choices = Media.get_choices(
kind=None if self.client.can_order_physical else Media.VIRTUAL,
display_units=self.client.is_limited,
)
self.fields["kind"].choices = filter(
lambda item: self.client.can_order_physical or item[0] != Media.
PHYSICAL,
self.KIND_CHOICES.items(),
)
def __init__(self, *args, **kwargs):
client = kwargs.pop("client")
print(client, client.is_limited)
super().__init__(*args, **kwargs)
self.client = client
self.organization = client.organization
self.fields["config"].choices = Configuration.get_choices(
self.organization)
self.fields["address"].choices = [
("none", "Myself")
] + Address.get_choices(self.organization)
self.fields["media"].choices = Media.get_choices(
kind=None if client.can_order_physical else Media.VIRTUAL,
display_units=client.is_limited,
)
self.fields["kind"].choices = filter(
lambda item: client.can_order_physical or item[0] != Media.
PHYSICAL,
self.KIND_CHOICES.items(),
)
def clean(self):
cleaned_data = super().clean()
config = cleaned_data.get("config")
media = cleaned_data.get("media")
kind = cleaned_data.get("kind")
address = cleaned_data.get("address")
if kind == media.PHYSICAL and not address.physical_compatible:
self.add_error(
"address",
"This address can't be used as it misses postal details")
if config is not None and media is not None and not config.can_fit_on(
media):
min_media = Media.get_min_for(config.size)
if min_media is None:
msg = "There is no large enough Media for this config."
field = "config"
else:
msg = "Media not large enough for config (use at least {})".format(
min_media.name)
field = "media"
self.add_error(field, msg)
def PHYSICAL_CHOICES(self):
return Media.get_choices(kind=Media.PHYSICAL)
def VIRTUAL_CHOICES(self):
return Media.get_choices(kind=Media.VIRTUAL)
def clean_media(self):
media = Media.get_or_none(self.cleaned_data.get("media"))
if media is None:
raise forms.ValidationError("Incorrect Media", code="invalid")
return media
