class AutoCreatedUpdatedMixin(models.Model):
created_at = models.DateTimeField(
verbose_name=translate('created at'),
unique=False,
null=True,
blank=True,
db_index=True,
)
updated_at = models.DateTimeField(
verbose_name=translate('updated at'),
unique=False,
null=True,
blank=True,
db_index=True,
)
class Meta:
abstract = True
def save(self, *args, **kwargs):
if not self.created_at:
# if not self.id or not self.created_at:
self.created_at = now()
self.updated_at = self.created_at
else:
auto_updated_at_is_disabled = kwargs.pop('disable_auto_updated_at',
False)
if not auto_updated_at_is_disabled:
self.updated_at = now()
super(AutoCreatedUpdatedMixin, self).save(*args, **kwargs)
class SearchProductForm(forms.Form):
class Meta:
model = Product
fields = "name"
name = forms.CharField(label=translate("Nome"), max_length=100)
description = forms.CharField(label=translate("Descrição"), max_length=100)
def format_time(seconds):
if seconds is None:
return None
days = math.trunc(seconds / 60 / 60 / 24)
seconds = seconds - days * 60 * 60 * 24
hours = math.trunc(seconds / 60 / 60)
seconds = seconds - hours * 60 * 60
minutes = math.trunc(seconds / 60)
seconds = seconds - minutes * 60
text = ""
if days:
text = "{} {}".format(text, days,
translate("day" if days == 1 else "days"))
if hours:
text = "{}{} {}".format(
"{}, ".format(text) if text else "",
hours,
translate("hour" if hours == 1 else "hours"),
)
if minutes:
text = "{}{} {}".format(
"{}, ".format(text) if text else "",
minutes,
translate("minute" if minutes == 1 else "minutes"),
)
if seconds:
text = "{}{} {}".format(
"{}, ".format(text) if text else "",
seconds,
translate("second" if seconds == 1 else "seconds"),
)
return text.strip()
class CompanyUser(TimeStampFields):
""" Modelo de usuario miembro de una empresa"""
# Referencias
user = models.OneToOneField( # Autenticacion de usuario
AppUser,
verbose_name=translate('User'),
on_delete=models.CASCADE,
parent_link=False
)
company = models.ForeignKey( # Compañia a la que pertenece
Company,
verbose_name=translate('Company'),
on_delete=models.CASCADE,
parent_link=False,
blank=False,
null=False,
)
def __str__(self):
# Retornar el nombre de la compañia y nombre del usuario
return '%s' % (self.user.full_name)
class Meta:
verbose_name = translate("Company User")
verbose_name_plural = translate("Company Users")
class Booking(models.Model):
objects = BookingSoftDeletionManager.from_queryset(
BookingSoftDeletionQuerySet)()
all_objects = BookingSoftDeletionManager.from_queryset(
BookingSoftDeletionQuerySet)(active_only=False)
event_type_id = models.CharField(max_length=32, default='', db_index=True)
email = models.EmailField(null=False, blank=True)
spot_start = models.DateTimeField()
spot_end = models.DateTimeField()
booked_at = models.DateTimeField(default=timezone.now)
APPROVAL_STATUS_NEW = 'NEW'
APPROVAL_STATUS_APPROVED = 'APPROVED'
APPROVAL_STATUS_DECLINED = 'DECLINED'
APPROVAL_STATUS_CHOICES = (
(APPROVAL_STATUS_NEW, 'New'),
(APPROVAL_STATUS_APPROVED, 'Approved'),
(APPROVAL_STATUS_DECLINED, 'Declined'),
)
approval_status = models.CharField(
default=APPROVAL_STATUS_NEW,
max_length=16,
choices=APPROVAL_STATUS_CHOICES,
)
approval_protected = models.BooleanField(default=False)
cancelled_at = models.DateTimeField(blank=True, null=True)
created_at = models.DateTimeField(
verbose_name=translate('Created at'),
unique=False,
null=True,
blank=True,
db_index=True,
auto_now_add=True,
)
updated_at = models.DateTimeField(
verbose_name=translate('Updated at'),
unique=False,
null=True,
blank=True,
db_index=True,
auto_now=True,
)
class Meta:
ordering = ["-created_at"]
def delete(self):
self.cancelled_at = timezone.now()
self.save()
def hard_delete(self):
super(Booking, self).delete()
def __str__(self):
return 'Booking #' + str(self.id)
def validate_birthdate(birthdate):
today = datetime.today()
minimumAccept = (today - timedelta(days=365 * 18)).date()
try:
if birthdate > minimumAccept:
raise ValidationError(
translate("Usuário deve ser maior de idade!"))
except Exception as error:
logger.warning("Erro ao validar data de nascimento, {}".format(error))
raise ValidationError(translate("Data de nascimento inválida!"))
class MaterialProvider(models.Model):
""" Tabla auxiliar de union de mucho a muchos
de proveedores(provider) con materia prima(raw material)"""
provider = models.ForeignKey(Provider,
verbose_name=translate("Provider"),
on_delete=models.CASCADE,
related_name="providers")
raw_material = models.ForeignKey(RawMaterial,
verbose_name=translate("Raw Material"),
on_delete=models.CASCADE,
related_name="raw_materials")
def create_superuser(self, email, password, **extra_fields):
"""
Create and save a SuperUser with the given email and password.
"""
extra_fields.setdefault('is_staff', True)
extra_fields.setdefault('is_superuser', True)
extra_fields.setdefault('is_active', True)
if extra_fields.get('is_staff') is not True:
raise ValueError(translate('Superuser must have is_staff=True.'))
if extra_fields.get('is_superuser') is not True:
raise ValueError(
translate('Superuser must have is_superuser=True.'))
return self.create_user(email, password, **extra_fields)
def validate_cpf(cpf):
cpf_expression = r"[0-9]{3}\.?[0-9]{3}\.?[0-9]{3}\-?[0-9]{2}"
if not match(cpf_expression, cpf):
raise ValidationError(
translate("CPF inválido!"),
params={'cpf': cpf},
)
def get_teacher_information(req):
args = get_query_string_params(req, args=["id"])
if isinstance(args, HttpResponse):
return args
(id_, ), _ = args
try:
teacher = Teacher.objects.get(pk=id_)
except Teacher.DoesNotExist:
return response_400(
req,
msg=translate("There is no teacher with that id"),
logger_msg=("Teacher with pk {} couldn't be found.".format(id_)),
log=logger.warning,
)
if teacher.reputation is None:
teacher.reputation = Reputation.create(teacher)
_, reputations = teacher.reputation.evaluate()
data = {
"username":
teacher.user.username,
"last_login":
teacher.user.last_login.strftime("%Y-%m-%d %H:%M:%S")
if teacher.user.last_login is not None else None,
"reputations": [{
"name": reputation["name"],
"reputation": reputation["reputation"],
} for reputation in reputations],
}
return JsonResponse(data)
class AppUser(AbstractUser, TimeStampFields):
"""Basic User model."""
username = None # removiendo campo username
# campo unico email de registro
email = models.EmailField(translate('Email address'), unique=True)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = []
objects = UserManager()
class Meta:
pass
@property
def full_name(self):
"""Retorna el nombre completo del usuario"""
return '%s %s' % (self.first_name, self.last_name)
@property
def safe_company(self):
"""Retorna la compañia sin importar el contexto o tipo de usuario"""
try:
company = self.company
except Exception:
company = self.companyuser.company
return company
def __str__(self):
# Retorna el nombre completo del usuario
return self.full_name
class CartAddProductForm(forms.Form):
quantity = forms.TypedChoiceField(label=translate("Quantidade"),
choices=PRODUCT_QUANTITY_CHOICES,
coerce=int)
update = forms.BooleanField(required=False,
initial=False,
widget=forms.HiddenInput)
class CreateCompanyForm(forms.ModelForm):
password_confirmation = forms.CharField(
label=translate('Password confirmation'),
max_length=70,
widget=forms.PasswordInput(),
required=True,
)
company_name = forms.CharField(
label="Nombre de la Compañía",
max_length=90,
widget=forms.TextInput(),
required=True,
)
class Meta:
model = AppUser
fields = (
"email",
"first_name",
"last_name",
"password",
)
def __init__(self, *args, **kwargs):
super(CreateCompanyForm, self).__init__(*args, **kwargs)
self.fields['first_name'].required = True
self.fields['last_name'].required = True
self.fields['password'].widget = forms.PasswordInput()
# Logica de limpieza de datos
def clean(self):
"""Verificando que las contraseñas coinciden"""
data = super().clean()
# Debido a que se necesita acceder a dos datos
password = data['password']
password_confirmation = data['password_confirmation']
if password != password_confirmation:
raise forms.ValidationError('Contraseñas no coinciden')
return data
# Logica de guardado
def save(self):
"""Crear usuario y compañia"""
data = self.cleaned_data
company_name = data.pop('company_name')
data.pop('password_confirmation')
data['is_superuser'] = True
user = AppUser.objects.create_user(**data)
user.save()
company = Company(user=user, company_name=company_name)
company.save()
class Company(TimeStampFields):
""" Company user model """
USD = 'USD'
VEF = 'VEF'
# measurement unit
CURRENCY_TYPES = [
(USD, 'Dolares'),
(VEF, 'Bolivares'),
]
currency = models.CharField(
translate("Denominación de la moneda"),
max_length=6,
choices=CURRENCY_TYPES,
default=VEF,
null=True,
blank=True,
)
# Referencias
user = models.OneToOneField(
AppUser,
verbose_name=translate('User'),
on_delete=models.CASCADE,
parent_link=False
)
# Campos propios
company_name = models.CharField(
translate('Name of the company'),
max_length=50,
blank=False
)
@property
def currency_name(self):
currency = dict(self.CURRENCY_TYPES)
return currency[self.currency]
def __str__(self):
# Retornar el nombre de la compañia
return self.company_name
class Meta:
verbose_name = translate("Company")
verbose_name_plural = translate("Companies")
class TimeStampModel(models.Model):
created_at = models.DateTimeField(
verbose_name=translate('created at'),
unique=False,
null=True,
blank=True,
db_index=True,
)
updated_at = models.DateTimeField(
verbose_name=translate('updated at'),
unique=False,
null=True,
blank=True,
db_index=True,
)
deleted_at = models.DateTimeField(
verbose_name=translate('deleted at'),
unique=False,
null=True,
blank=True,
db_index=True,
)
class Meta:
abstract = True
def save(self, *args, **kwargs):
if not self.id or not self.created_at:
self.created_at = now()
self.updated_at = self.created_at
else:
auto_updated_at_is_disabled = kwargs.pop('disable_auto_updated_at',
False)
if not auto_updated_at_is_disabled:
self.updated_at = now()
super(TimeStampModel, self).save(*args, **kwargs)
def delete(self):
self.deleted_at = now()
self.save()
def destroy(self):
super(TimeStampModel, self).delete()
def verify_user(
req: HttpRequest, username: str, approve: bool
) -> HttpResponse:
request = NewUserRequest.objects.get(user__username=username)
if approve:
if request.type.type == "teacher":
Teacher.objects.create(user=request.user)
else:
raise NotImplementedError(
"The verification for user type {request.type.type} hasn't "
"been implemented"
)
request.user.is_active = True
request.user.save()
link = "{}://{}{}".format(
req.scheme,
req.get_host(),
reverse(
"password_reset_confirm",
kwargs={
"uidb64": base64.urlsafe_b64encode(
force_bytes(request.user.pk)
).decode(),
"token": default_token_generator.make_token(request.user),
},
),
)
send_mail_async(
translate("Please verify your myDalite account"),
"Dear {},".format(request.user.username)
+ "\n\nYour account has been recently activated. Please visit "
"the following link to verify your email address and "
"to set your password:\n\n"
+ link
+ "\n\nCheers,\nThe myDalite Team",
"*****@*****.**",
[request.user.email],
fail_silently=True,
html_message=loader.render_to_string(
"registration/verification_email.html",
context={"username": request.user.username, "link": link},
request=req,
),
)
request.delete()
logger.info(f"New user {username} approved")
else:
request.user.delete()
logger.info(f"New user {username} refused")
return HttpResponse("")
class Address(models.Model):
name = models.CharField("Nome completo", max_length=99, null=False)
addressLine1 = models.CharField("Endereço", max_length=256, null=False)
addressLine2 = models.CharField("Complemento", max_length=128)
postal_code = models.CharField("CEP", max_length=30, null=False)
city = models.CharField(translate("Cidade"), max_length=100, null=False)
state = models.CharField(translate("Estado"), max_length=100, null=False)
cpf = models.CharField(max_length=30,
null=False,
db_index=True,
validators=[validate_cpf])
created_at = models.DateTimeField(auto_now_add=True)
class Meta:
ordering = ('city', "state")
def __str__(self):
return self.addressLine1
class CurrentUserFormPassword(forms.ModelForm):
"""Formulario de creacion de usuario miembro de una empresa"""
password_confirmation = forms.CharField(
label=translate('Password confirmation'),
max_length=70,
widget=forms.PasswordInput(),
required=True,
)
# company = forms.IntegerField(required=True)
class Meta:
model = AppUser
fields = ("password", )
def __init__(self, *args, **kwargs):
self.creator_company = kwargs.pop('creator_company')
super(CurrentUserFormPassword, self).__init__(*args, **kwargs)
# print(self.creator_company)
self.fields['password'].widget = forms.PasswordInput()
# import pdb; pdb.set_trace()
def clean(self):
"""Logica de limpieza de datos Verificando que las contraseñas coinciden"""
data = super().clean()
# Debido a que se necesita acceder a dos datos
password = data['password']
password_confirmation = data['password_confirmation']
if password != password_confirmation:
raise forms.ValidationError('Contraseñas no coinciden')
return data
def save(self, commit=True):
"""Logica de guardado guardando usuario"""
instance = super(CurrentUserFormPassword, self).save(commit=False)
data = self.cleaned_data
data.pop('password_confirmation')
# company_pk = data.pop('company')
data['is_superuser'] = False
if commit:
user = instance.user
user.set_password(data['password'])
user.save()
# company_user = instance
instance.user = user
instance.save()
return instance
def create_user(self, email, password, **extra_fields):
"""
Create and save a User with the given email and password.
"""
if not email:
raise ValueError(translate('The Email must be set'))
email = self.normalize_email(email)
user = self.model(email=email, **extra_fields)
user.set_password(password)
user.save()
return user
def register_user(request):
if request.method and request.method == "POST":
form = UserRegisterForm(request.POST)
if form.is_valid():
user = form.save()
user.objects.create(user=user)
messages.success(request, translate("Conta criada com sucesso!"))
return render(request, "register/registered.html", {"user": user})
else:
form = UserRegisterForm()
return render(request, "register/signup.html", {"form": form})
def flag_question(req, teacher):
args = get_json_params(req, args=["id", "reason"])
if isinstance(args, HttpResponse):
return args
(question_id, reason), _ = args
try:
question = Question.objects.get(id=question_id)
except Question.DoesNotExist:
return response_400(
req,
msg=translate("The question couldn't be found."),
logger_msg=("The question with pk {} couldn't be found.".format(
question_id)),
log=logger.warning,
)
try:
flag_reason = QuestionFlagReason.objects.get(title=reason)
except Question.DoesNotExist:
return response_400(
req,
msg=translate("The flag reason couldn't be found."),
logger_msg=(
"The question flag reason with title {} ".format(reason) +
"couldn't be found."),
log=logger.warning,
)
flag = QuestionFlag.objects.create(question=question,
user=teacher.user,
flag=True)
flag.flag_reason.add(flag_reason)
logger.info("Question flagged!")
return HttpResponse("")
class Category(models.Model):
name = models.CharField(translate("Nome"), max_length=150, db_index=True)
slug = models.SlugField(max_length=150, unique=True, db_index=True)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
class Meta:
ordering = ("name", )
verbose_name = "category"
verbose_name_plural = "categories"
def __str__(self):
return self.name
def get_absolute_url(self):
return reverse("shop:product_list_by_category", args=[self.slug])
def save(self, *args, **kwargs):
"""
Saves the new criterion making sure the `name` field exists.
"""
if not hasattr(self, "name"):
raise NotImplementedError(
"Your criterion needs to have a `name` field. Make sure it's "
"different from the others or it may lead to some trouble "
"down the line.")
if len(self.points_per_threshold) != len(self.thresholds) and len(
self.points_per_threshold) - 1 != len(self.thresholds):
raise ValidationError(
translate(
"The length of `Points per threshold` must be the same "
"as `Thresholds` or one more."))
super(Criterion, self).save(*args, **kwargs)
class SoftDeleteMixin(models.Model):
deleted_at = models.DateTimeField(verbose_name=translate('deleted at'),
unique=False,
null=True,
blank=True,
db_index=True)
class Meta:
abstract = True
def delete(self, using=None, keep_parents=False):
self.deleted_at = now()
kwargs = {'using': using}
if hasattr(self, 'updated_at'):
kwargs['disable_auto_updated_at'] = True
self.save(**kwargs)
class AddressRegisterForm(forms.ModelForm):
class Meta:
model = Address
fields = [
"addressLine1", "addressLine2", "postal_code", "city", "state",
"cpf"
]
addressLine1 = forms.CharField(label=translate("Endereço"))
addressLine2 = forms.CharField(label=translate("Complemento"))
postal_code = forms.CharField(label=translate("CEP"),
validators=[validate_cep])
name = forms.CharField(label=translate("Nome"))
city = forms.CharField(label=translate("Cidade"))
state = forms.CharField(label=translate("Estado"))
cpf = forms.CharField(label="CPF", validators=[validate_cpf])
def unsubscribe_from_thread(req, teacher):
"""
Unsubscribes the `teacher` from a thread (won't appear in the messages).
Parameters
----------
req : HttpRequest
Request with:
parameters:
id: int
Thread primary key
teacher : Teacher
Teacher instance returned by `teacher_required`
Returns
-------
HttpResponse
Error response or empty 200 response
"""
args = get_json_params(req, args=["id"])
if isinstance(args, HttpResponse):
return args
(id_, ), _ = args
try:
thread = ForumThread.objects.get(pk=id_)
except ForumThread.DoesNotExist:
return response_400(
req,
msg=translate("The thread couldn't be found."),
logger_msg=(
"The thread with pk {} couldn't be found.".format(id_)),
log=logger.warning,
)
thread.subscriptions.filter(user=teacher.user).delete()
return HttpResponse("")
class UserRegisterForm(forms.ModelForm):
class Meta:
model = Users
fields = [
"name", "last_name", "gender", "login", "password", "email",
"phone_number", "cpf", "birthdate"
]
field_order = [
"login", "password", "name", "last_name", "email", "phone_number",
"cpf", "birthdate"
]
name = forms.CharField(label=translate("Nome"))
last_name = forms.CharField(label=translate("Sobrenome"))
gender = forms.ChoiceField(choices=GENDER_CHOICES,
label=translate("Gênero"),
initial="M",
widget=forms.Select(),
required=True)
login = forms.CharField(label=translate("Usuário"))
password = forms.CharField(max_length=20,
required=True,
label=translate("Senha"),
widget=forms.PasswordInput)
email = forms.CharField(label="E-mail")
phone_number = forms.CharField(label=translate("Celular"),
validators=[validate_phone_number])
cpf = forms.CharField(label="CPF", validators=[validate_cpf])
birthdate = forms.DateField(
label=translate("Nascimento"),
input_formats="%d/%m/%Y",
error_messages={
"invalid": "Insira data de nascimento formatada, ex: 01/01/2002"
},
widget=DateInput(
attrs={
'class': 'form-control datetimepicker-input',
'data-target': '#datetimepicker1'
}))
class Product(models.Model):
category = models.ForeignKey(Category,
related_name="products",
on_delete=models.CASCADE)
name = models.CharField(translate("Nome"), max_length=100, db_index=True)
slug = models.SlugField(max_length=100, db_index=True)
cart_added = models.PositiveIntegerField(editable=False, null=True)
description = models.TextField(translate("Descrição"), blank=True)
last_price = models.DecimalField(translate("Valor anterior"),
max_digits=10,
decimal_places=2,
blank=True,
null=True)
price = models.DecimalField(translate("Valor atual"),
max_digits=10,
decimal_places=2,
null=False)
available = models.BooleanField(translate("Disponível"), default=True)
stock = models.PositiveIntegerField(translate("Quantidade em estoque"),
default=1)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
image = models.ImageField(translate("Imagem"),
upload_to="products/%Y/%m/%d",
blank=True)
class Meta:
ordering = ("name", "available", "price")
index_together = (("id", "slug"), )
def __str__(self):
return self.name
def show_desc(self):
return self.description[:75]
def get_absolute_url(self):
return reverse("shop:product_detail", args=[self.id, self.slug])
class CompanyUserForm(forms.ModelForm):
"""Formulario de creacion de usuario miembro de una empresa"""
password_confirmation = forms.CharField(
label=translate('Password confirmation'),
max_length=70,
widget=forms.PasswordInput(),
required=True,
)
# company = forms.IntegerField(required=True)
class Meta:
model = AppUser
fields = (
"email",
"first_name",
"last_name",
"password",
"is_staff",
)
def __init__(self, *args, **kwargs):
self.creator_company = kwargs.pop('creator_company')
super(CompanyUserForm, self).__init__(*args, **kwargs)
# print(self.creator_company)
self.fields['first_name'].required = True
self.fields['last_name'].required = True
self.fields['password'].widget = forms.PasswordInput()
try:
self.fields['first_name'].initial = kwargs[
'instance'].user.first_name
self.fields['last_name'].initial = kwargs[
'instance'].user.last_name
self.fields['email'].initial = kwargs['instance'].user.email
self.fields['is_staff'].initial = kwargs['instance'].user.is_staff
pass
except Exception:
pass
# import pdb; pdb.set_trace()
def clean(self):
"""Logica de limpieza de datos Verificando que las contraseñas coinciden"""
data = super().clean()
# Debido a que se necesita acceder a dos datos
password = data['password']
password_confirmation = data['password_confirmation']
if password != password_confirmation:
raise forms.ValidationError('Contraseñas no coinciden')
return data
def save(self, commit=True):
"""Logica de guardado guardando usuario"""
instance = super(CompanyUserForm, self).save(commit=False)
data = self.cleaned_data
data.pop('password_confirmation')
# company_pk = data.pop('company')
data['is_superuser'] = False
if commit:
user = AppUser.objects.create_user(**data)
user.save()
company_user = CompanyUser(user=user, company=self.creator_company)
company_user.save()
return instance
def request_gradebook(req, teacher):
"""
Request the generation of a gradebook. An response containing the task id
is returned so the client can poll the server for the result until it's
ready.
Parameters
----------
req : HttpRequest
Request with:
parameters
group_id: int
Primary key of the group for which the gradebook is wanted
optional parameters:
assignment_id: int (default : None)
Primary key of the assignment for which the gradebook is
wanted
teacher : Teacher
Teacher instance returned by `teacher_required`
Returns
-------
Either
JsonResponse with json data
Response 201 (created) with json data if computation run
asynchronously
{
task_id: str
Id corresponding to the celery task for use in polling
}
Response 200 with json data if computation run synchronously
Either
If group gradebook wanted
{
assignments: List[str]
Assignment identifier
school_id_needed: bool
If a school id is needed
results: [{
school_id: Optional[str]
School id if needed
email: str
Student email
assignments: [{
n_completed: int
Number of completed questions
n_correct: int
Number of correct questions
}]
}]
}
If assignment gradebook wanted
{
questions: List[str]
Question title
school_id_needed: bool
If a school id is needed
results: [{
school_id: Optional[str]
School id if needed
email: str
Student email
questions: List[float]
Grade for each question
}]
}
HttpResponse
Error response
"""
args = get_json_params(req, args=["group_id"], opt_args=["assignment_id"])
if isinstance(args, HttpResponse):
return args
(group_pk, ), (assignment_pk, ) = args
try:
group = StudentGroup.objects.get(pk=group_pk)
except StudentGroup.DoesNotExist:
return response_400(
req,
msg=translate("The group doesn't exist."),
logger_msg=("Access to {} with an invalid group {}.".format(
req.path, group_pk)),
log=logger.warning,
)
if teacher not in group.teacher.all():
return response_403(
req,
msg=translate(
"You don't have access to this resource. You must be "
"registered as a teacher for the group."),
logger_msg=(
"Unauthorized access to group {} from teacher {}.".format(
group.pk, teacher.pk)),
log=logger.warning,
)
if assignment_pk is not None:
try:
assignment = StudentGroupAssignment.objects.get(pk=assignment_pk)
except StudentGroupAssignment.DoesNotExist:
return response_400(
req,
msg=translate("The group or assignment don't exist."),
logger_msg=(
"Access to {} with an invalid assignment {}.".format(
req.path, assignment_pk)),
log=logger.warning,
)
result = compute_gradebook_async(group_pk, assignment_pk)
if assignment_pk is None:
description = format_html("gradebook for group <strong>{}</strong>",
group.name)
else:
description = "gradebook for assignment {} and group {}".format(
assignment.assignment.identifier, group.name)
if isinstance(result, AsyncResult):
task = RunningTask.objects.create(id=result.id,
description=description,
teacher=teacher)
data = {
"id": task.id,
"description": task.description,
"completed": False,
"datetime": task.datetime.strftime("%Y-%m-%d %H:%M:%S.%f"),
}
return JsonResponse(data, status=201)
else:
return download_gradebook(req, results=result)
