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)