def with_author(cls): """ Decorator to add added_by/modified_by field to particular model """ cls_name = cls.__name__ created_by = models.ForeignKey('auth.User', related_name=u'%s_created' % cls_name, verbose_name=_('author'), null=True, blank=True, editable=False) modified_by = models.ForeignKey('auth.User', related_name=u'%s_modified' % cls_name, verbose_name=_('last modified by'), null=True, blank=True, editable=False) if not hasattr(cls, settings.AUTHOR_CREATED_BY_FIELD_NAME): cls.add_to_class(settings.AUTHOR_CREATED_BY_FIELD_NAME, created_by) if not hasattr(cls, settings.AUTHOR_UPDATED_BY_FIELD_NAME): cls.add_to_class(settings.AUTHOR_UPDATED_BY_FIELD_NAME, modified_by) return cls
def clean(self): cleaned_data = super().clean() # for transfers, check the transfer_account field if (int(cleaned_data.get('type', -1)) == Transaction.TYPE_TRANSFER and not cleaned_data.get('transfer', None)): raise forms.ValidationError({'transfer': _('This field is required.')}) # can't select Transferência category when not creating a transfer if int(self.cleaned_data['type']) == Transaction.TYPE_TRANSFER: transfer_category = Category.transfer_category(self.user) if self.cleaned_data['category'] == transfer_category: raise forms.ValidationError({'category': _('This field is required.')}) # for debit and credit, check the category field if (int(cleaned_data.get('type', -1)) != Transaction.TYPE_TRANSFER and not cleaned_data.get('category', None)): raise forms.ValidationError({'category': _('This field is required.')}) # for transfers, accounts must be different if int(cleaned_data.get('type', -1)) == Transaction.TYPE_TRANSFER: if cleaned_data.get('transfer') == cleaned_data.get('account'): acc = cleaned_data.get('account') raise forms.ValidationError( {'transfer': _('Account must not be %s' % acc.name)}) return cleaned_data
def clean(self): cleaned_data = super().clean() btype = cleaned_data.get('type', -1) category = cleaned_data.get('category') date = self.clean_date() # category is required when type=debit or credit if int(btype) in (Budget.TYPE_CREDIT, Budget.TYPE_DEBIT) and not category: raise forms.ValidationError({'category': _('This field is required.')}) # check if budget already exists if not self.instance or not self.instance.pk: budget_count = self.user.budget_set \ .filter(category=category, date=date, type=btype) \ .count() if budget_count > 0: raise forms.ValidationError( _('A budget for this month and category already exists.')) # can't select Transferência category transfer_category = Category.transfer_category(self.user) if cleaned_data.get('category', None) == transfer_category: raise forms.ValidationError({'category': _('This field is required.')}) return cleaned_data
def get_object(self, queryset=None): """get ``RegistrationProfile`` instance by ``activation_key`` ``activation_key`` should be passed by URL """ queryset = queryset or self.get_queryset() try: obj = queryset.get(activation_key=self.kwargs["activation_key"]) if obj.activation_key_expired(): raise Http404(_("Activation key has expired")) except self.model.DoesNotExist: raise Http404(_("An invalid activation key has passed")) return obj
def clean(self): username = self.cleaned_data.get("username") password = self.cleaned_data.get("password") message = "error message" # ERROR_MESSAGE if username and password: self.user_cache = authenticate(username=username, password=password) if self.user_cache is None: if u"@" in username: # Mistakenly entered e-mail address instead of username? # Look it up. try: user = User.objects.get(email=username) except (User.DoesNotExist, User.MultipleObjectsReturned): # Nothing to do here, moving along. pass else: if user.check_password(password): message = ( _("Your e-mail address is not your " "username." " Try '%s' instead.") % user.username ) raise forms.ValidationError(message) # Removed check for is_staff here! elif not self.user_cache.is_active: raise forms.ValidationError(message) self.check_for_test_cookie() return self.cleaned_data
def with_timestamp(cls): """Decorator to add added/modified field to particular model""" added_at = models.DateTimeField(verbose_name=_('added at'), auto_now_add=True, editable=False) modified_at = models.DateTimeField(verbose_name=_('modified at'), auto_now=True, editable=False) if not hasattr(cls, 'added_at'): cls.add_to_class('added_at', added_at) if not hasattr(cls, 'modified_at'): cls.add_to_class('modified_at', modified_at) return cls
def get(self, request, *args, **kwargs): self.object_list = self.get_queryset_perm(request.user) allow_empty = self.get_allow_empty() if not allow_empty and len(self.object_list) == 0: raise Http404(_(u"Empty list and '%(class_name)s.allow_empty' is False.") % {'class_name': self.__class__.__name__}) context = self.get_context_data(object_list=self.object_list) return self.render_to_response(context)
def clean(self): """ check if the email exists """ cleaned_data = super().clean() try: User.objects.get(email=cleaned_data['email']) except User.DoesNotExist: raise forms.ValidationError(_('Email não cadastrado.')) return cleaned_data
def form_valid(self, form): package_name = form.cleaned_data['name'] messages.info( self.request, _("Retrieving package information from '%s'" % form.cleaned_data['name'])) fetch_package.delay(self.repository.pk, package_name) return redirect(self.get_success_url())
def with_author(cls): """Decorator to add created_by/updated_by field to particular model""" def _get_user_model(): from django.contrib.auth.models import User backend = get_backend() return backend._get_user_model() if hasattr(backend, '_get_user_model') else User user_model = _get_user_model() verbose_name_plural = cls._meta.object_name created_by = models.ForeignKey(user_model, verbose_name=_('author'), related_name='%s_create' % verbose_name_plural.lower(), null=True, blank=True) updated_by = models.ForeignKey(user_model, verbose_name=_('last updated by'), related_name='%s_update' % verbose_name_plural.lower(), null=True, blank=True) if not hasattr(cls, settings.AUTHOR_CREATED_BY_FIELD_NAME): cls.add_to_class(settings.AUTHOR_CREATED_BY_FIELD_NAME, created_by) if not hasattr(cls, settings.AUTHOR_UPDATED_BY_FIELD_NAME): cls.add_to_class(settings.AUTHOR_UPDATED_BY_FIELD_NAME, updated_by) return cls
def __init__(self, date, user, *args, **kwargs): super().__init__(*args, **kwargs) self.date = date self.fields['month'].initial = self.date.month self.fields['year'].initial = self.date.year self.user = user self.fields['category'].queryset = (user.category_set .exclude(name=_('Transfer')) .order_by('name'))
def timedelta_to_string(delta, form='days_hours_minutes_seconds'): days = delta.days hours = (delta.seconds // 3600) minutes = (delta.seconds // 60) % 60 seconds = delta.seconds % 60 if form == 'days_hours_minutes_seconds': template_string = _("{days} days, {hours} hours, {minutes} minutes and {seconds} seconds") elif form == 'days_hours_minutes': template_string = _("{days} days, {hours} hours and {minutes} minutes") elif form == 'days_hours': template_string = _("{days} days and {hours} hours") elif form == 'days': template_string = _("{days} days") else: return "" return template_string.format(days=days, hours=hours, minutes=minutes, seconds=seconds)
class OutletStock(RawMaterialStock): outlet = models.ForeignKey(to=Outlet, on_delete=models.PROTECT, verbose_name=_("Outlet")) def __str__(self): return self.outlet.name + " - " + self.raw_material.name class Meta: unique_together = ('outlet', 'raw_material') verbose_name = _("Outlet Stock") verbose_name_plural = _("Outlet Stocks")
def clean_fields(self, exclude=None): super(Notice, self).clean_fields() if self.screenshot and not self.screenshot.exists(): raise ValidationError({'file': [_('File Not Exists')]}) else: path = self.screenshot.site.storage.path(self.screenshot) m = hashlib.md5() a_file = open(path, 'rb') m.update(a_file.read()) self.sign = m.hexdigest()
class OutletImage(CreateUpdateModel): """ Represents Images of outlet Author: Himanshu Shankar (https://himanshus.com) """ from .utils import outlet_image_upload name = models.CharField(verbose_name=_("Image name"), max_length=154) outlet = models.ForeignKey(to=Outlet, verbose_name=_("Outlet"), on_delete=models.PROTECT) image = models.ImageField(upload_to=outlet_image_upload) def __str__(self): return self.name class Meta: verbose_name = _("Outlet Image") verbose_name_plural = _("Outlet Images")
class Country(CommonData): model_name = 'Country' code: str = models.CharField(verbose_name=_('Code'), max_length=3, unique=True, error_messages=ErrorMessages.get_char_field( model=model_name, field='code')) name: str = models.CharField(verbose_name=_('Name'), max_length=255, unique=True, error_messages=ErrorMessages.get_char_field( model=model_name, field='name')) def __str__(self): return self.code class Meta(CommonData.Meta): verbose_name_plural = _('Countries')
class RawMaterialStock(CreateUpdateModel): """ Represents stock of raw material in a warehouse Author: Himanshu Shankar (https://himanshus.com) """ raw_material = models.ForeignKey(to=RawMaterialMaster, on_delete=models.PROTECT, verbose_name=_("Raw Material")) quantity = models.DecimalField(verbose_name=_("Quantity"), decimal_places=3, max_digits=10) @property def stock(self): return "{quant} {uom}".format(quant=str(self.quantity), uom=self.raw_material.uom.name) class Meta: abstract = True
class DefaultRegistrationSupplement(RegistrationSupplementBase): """A simple registration supplement model which requires remarks""" remarks = models.TextField(_('remarks')) def __str__(self): """return a summary of this addition""" return self.remarks # it is required to specify from django 1.6 class Meta: app_label = 'registration'
class OTPValidation(models.Model): """ Represents all OTP Validation in the System. Author: Himanshu Shankar (https://himanshus.com) """ otp = models.CharField(verbose_name=_("OTP Code"), max_length=10) destination = models.CharField( verbose_name=_("Destination Address (Mobile/EMail)"), max_length=254, unique=True, ) create_date = models.DateTimeField(verbose_name=_("Create Date"), auto_now_add=True) update_date = models.DateTimeField(verbose_name=_("Date Modified"), auto_now=True) is_validated = models.BooleanField(verbose_name=_("Is Validated"), default=False) validate_attempt = models.IntegerField( verbose_name=_("Attempted Validation"), default=3 ) prop = models.CharField( verbose_name=_("Destination Property"), default=EMAIL, max_length=3, choices=DESTINATION_CHOICES, ) send_counter = models.IntegerField(verbose_name=_("OTP Sent Counter"), default=0) sms_id = models.CharField( verbose_name=_("SMS ID"), max_length=254, null=True, blank=True ) reactive_at = models.DateTimeField(verbose_name=_("ReActivate Sending OTP")) def __str__(self): """String representation of model""" return self.destination class Meta: """Passing model metadata""" verbose_name = _("OTP Validation") verbose_name_plural = _("OTP Validations")
class Account(models.Model): hashid = models.CharField(_('Hash'), max_length=255, null=True, blank=True, db_index=True) user = models.ForeignKey(User, verbose_name=_('User')) name = models.CharField(_('Name'), max_length=255) description = models.TextField(_('Description'), null=True, blank=True) is_savings = models.BooleanField(_('Investment Account?'), default=False) created_at = models.DateTimeField(auto_now_add=True) updated_at = models.DateTimeField(auto_now=True) objects = AccountManager() def __str__(self): return self.name def get_absolute_url(self): return reverse('accounts-detail', kwargs={'slug': self.hashid}) def get_credit_balance(self, start=None, end=None, payed=True): return Transaction.objects.get_credit_balance(self.user, accounts=[self], start=start, end=end, payed=payed) def get_debit_balance(self, start=None, end=None, payed=True): return Transaction.objects.get_debit_balance(self.user, accounts=[self], start=start, end=end, payed=payed) def get_balance(self, start=None, end=None, payed=True): return Transaction.objects.get_balance(self.user, accounts=[self], start=start, end=end, payed=payed)
def post(self, request, *args, **kwargs): from rest_framework.response import Response from rest_framework import status from rest_framework.exceptions import APIException from .utils import validate_otp, login_user, generate_otp, send_otp serializer = self.serializer_class(data=request.data) serializer.is_valid(raise_exception=True) destination = serializer.validated_data.get("destination") prop = serializer.validated_data.get("prop") user = serializer.validated_data.get("user") email = serializer.validated_data.get("email") is_login = serializer.validated_data.get("is_login") if "verify_otp" in request.data.keys(): if validate_otp(destination, request.data.get("verify_otp")): if is_login: return Response(login_user(user, self.request), status=status.HTTP_202_ACCEPTED) else: return Response( data={"OTP": [ _("OTP Validated successfully!"), ]}, status=status.HTTP_202_ACCEPTED, ) else: otp_obj = generate_otp(prop, destination) sentotp = send_otp(destination, otp_obj, email) if sentotp["success"]: otp_obj.send_counter += 1 otp_obj.save() return Response(sentotp, status=status.HTTP_201_CREATED) else: raise APIException(detail=_("A Server Error occurred: " + sentotp["message"]))
class WarehouseStock(RawMaterialStock): warehouse = models.ForeignKey(to=Warehouse, on_delete=models.PROTECT, verbose_name=_("Warehouse")) def __str__(self): return self.warehouse.name + " - " + self.raw_material.name class Meta: unique_together = ('warehouse', 'raw_material') verbose_name = _("Warehouse Stock") verbose_name_plural = _("Warehouse Stocks")
class Noticeship(models.Model): zone = models.ForeignKey(Zone) notice = models.ForeignKey(Notice) position = PositionField(_('Position'), collection='zone') class Meta: verbose_name = 'Noticeship' verbose_name_plural = _('Noticeships') ordering = ('position', ) def __unicode__(self): return self.notice.title
class MailLog(models.Model): user = models.ForeignKey(User) zid = models.CharField(_('Zid'), max_length=10) mail = models.TextField(blank=True) created_at = models.DateTimeField(default=datetime.datetime.now) class Meta: verbose_name = _('MailLog') verbose_name_plural = _('MailLogs') def __unicode__(self): return self.user
class OutletSubProduct(CreateUpdateModel): outlet_product = models.ForeignKey(to=OutletProduct, on_delete=models.PROTECT) size = models.CharField(verbose_name=_("Size"), max_length=4, choices=PRODUCT_CHOICES, default="24") price = models.DecimalField(verbose_name=_("Price"), max_digits=10, decimal_places=3) warehouse_stock = models.IntegerField(verbose_name=_("Warehouse Stock"), default=0) display_stock = models.IntegerField(verbose_name=_("Display Stock"), default=0) def __str__(self): return "{},{}".format(str(self.size), str(self.outlet_product)) class Meta: verbose_name = _("Outlet SubProduct") verbose_name_plural = _("Outlet SubProducts")
def jwt_decode_handler(token): from rest_framework_jwt.utils import jwt_decode_handler from django.utils.text import gettext_lazy as _ from rest_framework.exceptions import AuthenticationFailed from .models import AuthTransaction try: auth_transaction = AuthTransaction.objects.get( token=token.decode('utf-8')) except AuthTransaction.DoesNotExist: raise AuthenticationFailed( _('Unrecognized token. Kindly login again.')) else: if auth_transaction.is_active: return jwt_decode_handler(token=token) else: raise AuthenticationFailed( _('Token has been disabled. Kindly login again.'))
class Tax(CreateUpdateModel): """ Represents Taxes in a system Author: Himanshu Shankar (https://himanshus.com) """ name = models.CharField(verbose_name=_("Tax Name"), max_length=254, unique=True) display_name = models.CharField(verbose_name=_("Bill Display Name"), max_length=254) percentage = models.DecimalField(verbose_name=_("Percentage"), max_digits=5, decimal_places=2) def __str__(self): return self.name class Meta: verbose_name = _("Tax") verbose_name_plural = _("Taxes")
def post(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) try: kwargs = account_helper.email_or_mobile(serializer.initial_data["device"]) user = account_helper.user_exists(**kwargs) user.verification.generate_otp() message = _("Verification Token sent to {phone} and {email}") message = message.format(phone=user.mobile, email=user.email) except Exception as ex: return Response(helper.render(False, None, ex.args, status.HTTP_500_INTERNAL_SERVER_ERROR)) return Response(helper.render(True, None, message, status.HTTP_201_CREATED))
class RefreshTokenSerializer(serializers.Serializer): refresh = serializers.CharField() default_error_messages = { 'bad_token': _('Refresh token is invalid or expired') } def save(self, **kwargs): try: RefreshToken(self.validated_data['refresh']).blacklist() except TokenError: self.fail('bad_token')
class Product(CreateUpdateModel): name = models.CharField(verbose_name=_("Product"), max_length=254) sku = models.CharField(verbose_name=_("SKU Code"), max_length=254, unique=True) category = models.ForeignKey(to=CategoryMaster, on_delete=models.PROTECT) gender_type = models.CharField( verbose_name=_("Gender"), max_length=254, choices=GENDER_CHOICES, default=MALE ) product_type = models.CharField( verbose_name=_("Product Type"), choices=PRODUCT_TYPE_CHOICES, max_length=3, blank=True, null=True, ) def __str__(self): return self.name class Meta: verbose_name = _("Product") verbose_name_plural = _("Products")
class Profile(models.Model): gender_choice = (('M', 'male'), ('F', 'female'), ('O', 'other')) user = models.OneToOneField(User, on_delete=models.CASCADE, verbose_name=_('User')) pubg_id = models.IntegerField(unique=True, blank=True, null=True, verbose_name=_('Pubg ID')) name = models.CharField(max_length=25, verbose_name=_('Name')) age = models.PositiveIntegerField(verbose_name=_('Age'), blank=True, null=True) gender = models.CharField(choices=gender_choice, max_length=1, verbose_name=_('Gender')) image = models.ImageField(default='default.jpg', upload_to='profile_pics', verbose_name=_('User image')) def __str__(self): return self.name # def save(self, force_insert=False, force_update=False, using=None, # update_fields=None): # super(Profile, self).save() # image = Image.open(self.image.path) # if image.height > 300 and image.width > 300: # output_size = (300, 300) # image.thumbnail(output_size) # image.save(self.image.path) class Meta: verbose_name = _('Pubg Profile') verbose_name_plural = _('Pubg Profiles')
def validate(self, attrs: dict) -> dict: """ Performs custom validation to check if any user exists with provided details. Parameters ---------- attrs: dict Returns ------- attrs: dict Raises ------ NotFound: If user is not found ValidationError: Email field not provided """ validator = EmailValidator() try: validator(attrs["destination"]) except ValidationError: attrs["prop"] = MOBILE else: attrs["prop"] = EMAIL user = self.get_user(attrs.get("prop"), attrs.get("destination")) if not user: if attrs["is_login"]: raise NotFound(_("No user exists with provided details")) if "email" not in attrs.keys() and "verify_otp" not in attrs.keys( ): raise serializers.ValidationError( _("email field is compulsory while verifying a" " non-existing user's OTP.")) else: attrs["email"] = user.email attrs["user"] = user return attrs
class AuthenticationForm(forms.Form): error_messages = { 'invalid_login': _("Please enter a correct %(email)s and password. Note that both " "fields may be case-sensitive.") } email = forms.EmailField( max_length=254, widget=forms.TextInput(attrs={'autofocus': True}), ) password = forms.CharField( label=_("Password"), strip=False, widget=forms.PasswordInput, ) def __init__(self, request=None, *args, **kwargs): """ The 'request' parameter is set for custom auth use by subclasses. The form data comes in via the standard 'data' kwarg. """ self.request = request self.user_cache = None super().__init__(*args, **kwargs) def clean(self): email = self.cleaned_data.get('email') password = self.cleaned_data.get('password') if email is not None and password: self.user_cache = authenticate(self.request, username=email, password=password) if self.user_cache is None: raise forms.ValidationError( self.error_messages['invalid_login'], code='invalid_login', ) return self.cleaned_data
class User(AbstractUser): # First Name and Last Name do not cover name patterns # around the globe. name = models.CharField(_("Name of User"), blank=True, max_length=255) mobile = models.CharField(verbose_name=_('Mobile Number'), max_length=150, unique=True, blank=True, null=True) address = models.TextField(verbose_name=_("Address"),blank=True, null=True) dob = models.DateField(verbose_name=_("Date of Birth"),null=True, blank=True) city = models.CharField(verbose_name=_("City"), max_length=50, blank=True, null=True) country = models.CharField(verbose_name=_("Country"), max_length=50, blank=True, null=True) profile_picture = models.URLField(blank=True, null=True) # class Profile(models.Model): # user = models.OneToOneField(AbstractUser, on_delete=models.CASCADE, unique=True) # def __str__(self): # return self.user.username # # @property # # def user_email(self): # # return self.user. # @receiver(post_save, sender=AbstractUser) # def create_user_profile(sender, instance, created, **kwargs): # if created: # Profile.objects.create(user=instance) # @receiver(post_save, sender=AbstractUser) # def save_user_profile(sender, instance, **kwargs): # instance.profile.save()
class Author(models.Model): """Blog post Author.""" user = models.OneToOneField( User, verbose_name=_('Linked user'), on_delete=models.SET_NULL, null=True, blank=True, ) name = models.TextField(_('Name')) slug = models.SlugField(_('Url name'), default="") appointment = models.TextField(_('Position at work')) avatar = models.ImageField(_('Avatar'), upload_to="author") def avatar_tag(self): """Change output avatar field.""" return mark_safe('<img src="{}" style="max-width: 108px;" />'.format(self.avatar.url)) avatar_tag.short_description = _('Image') def __str__(self): """View for Author object.""" return "{name}, {appointment}".format( name=self.name, appointment=self.appointment ) class Meta: """Meta Class for Author class.""" verbose_name = _('Author') verbose_name_plural = _('Authors') ordering = ['name']
class OTPValidation(models.Model): """ Represents all OTP Validation in the System. Author: Himanshu Shankar (https://himanshus.com) """ from .variables import EMAIL, DESTINATION_CHOICES otp = models.CharField(verbose_name=_('OTP Code'), max_length=10) destination = models.CharField( verbose_name=_('Destination Address (Mobile/EMail)'), max_length=254, unique=True) create_date = models.DateTimeField(verbose_name=_('Create Date'), auto_now_add=True) update_date = models.DateTimeField(verbose_name=_('Date Modified'), auto_now=True) is_validated = models.BooleanField(verbose_name=_('Is Validated'), default=False) validate_attempt = models.IntegerField( verbose_name=_('Attempted Validation'), default=3) prop = models.CharField(verbose_name=_('Destination Property'), default=EMAIL, max_length=3, choices=DESTINATION_CHOICES) send_counter = models.IntegerField(verbose_name=_('OTP Sent Counter'), default=0) sms_id = models.CharField(verbose_name=_('SMS ID'), max_length=254, null=True, blank=True) reactive_at = models.DateTimeField( verbose_name=_('ReActivate Sending OTP')) def __str__(self): return self.destination class Meta: verbose_name = _('OTP Validation') verbose_name_plural = _('OTP Validations')
class Feedback(CreateUpdateModel): """ A Feedback model for recording the user drf_feedback. """ from django.utils.text import gettext_lazy as _ from django.contrib.auth import get_user_model ip = models.GenericIPAddressField(_('IP'), ) name = models.CharField(_('Name'), max_length=254) url = models.URLField(_('URL'), ) email = models.EmailField(_('Email'), ) mobile = models.CharField(_('Mobile Number'), max_length=15, blank=True) message = models.TextField(_('Message'), ) created_by = models.ForeignKey(get_user_model(), on_delete=models.PROTECT, null=True, blank=True) def __str__(self): return 'Feedback -- ' + str(self.name) class Meta: from django.utils.text import gettext_lazy as _ ordering = ('-create_date', ) verbose_name = _('Feedback') verbose_name_plural = _('Feedbacks')
class OutletStockRequest(CreateUpdateModel): """ Represents request for Raw Material in the system Author: Himanshu Shankar (https://himanshus.com) """ batch_id = models.PositiveIntegerField(verbose_name=_("Batch Request ID")) stock = models.ForeignKey(to=OutletStock, on_delete=models.PROTECT, verbose_name=_("Outlet Stock")) quantity = models.DecimalField(verbose_name=_("Quantity"), decimal_places=3, max_digits=10) fulfilled_on = models.DateField(verbose_name=_("Fulfilled On?"), help_text=_("When was this request " "fulfilled?"), null=True, blank=True) def save(self, force_insert=False, force_update=False, using=None, update_fields=None): from django.utils import timezone super(OutletStockRequest, self).save(force_insert=force_insert, force_update=force_update, using=using, update_fields=update_fields) if self.fulfilled_on: OutletProcurement.objects.create( created_by=self.created_by, stock=self.stock, quantity=self.quantity, date=timezone.now() ) def __str__(self): return str(self.stock) class Meta: verbose_name = _("Outlet Stock Request") verbose_name_plural = _("Outlet Stock Requests")
class Post(TimeStampedModel): """ Concrete model for Posts """ STATUS_CHOICES = ( ("draft", "Draft"), ("published", "Published"), ) title = models.CharField(verbose_name=_("Title"), max_length=250) slug = models.SlugField(max_length=250, unique_for_date="publish") author = models.ForeignKey(User, on_delete=models.CASCADE, related_name="blog_posts") body = models.TextField(verbose_name=_("Body")) publish = models.DateTimeField(verbose_name=_("Published On"), default=timezone.now) status = models.CharField(verbose_name=_("Status"), max_length=10, choices=STATUS_CHOICES, default="draft") objects = models.Manager() published = PublishedManager() tags = TaggableManager() def get_absolute_url(self): return reverse( "blog:post_detail", args=[ self.publish.year, self.publish.month, self.publish.day, self.slug ], ) class Meta: ordering = ("-publish", ) def __str__(self): return self.title
class Code(models.Model): code = models.CharField(_('Code'), max_length=64, unique=True) created_at = models.DateTimeField(_('Created_at'), default=datetime.datetime.now) ended_at = models.DateTimeField(_('Ended_at'), default=datetime.datetime.now) gold = models.PositiveIntegerField(_('Gold'), default=0) rock = models.PositiveIntegerField(_('Rock'), default=0) feat = models.PositiveIntegerField(_('Feat'), default=0) hp = models.PositiveIntegerField(_('Hp'), default=0) prods = models.TextField(_('Prods'), blank=True) nums = models.TextField(_('Nums'), blank=True) channels = models.ManyToManyField('Channel', blank=True) class Meta: verbose_name = _('Code') verbose_name_plural = _('Codes') def __unicode__(self): return self.code
def to_python(self, value): if value is None: return None, None # if we already have a tuple/list of dates just return them try: beginning, end = value if isinstance(beginning, self.type_) and isinstance(end, self.type_): return beginning, end except (ValueError, TypeError): pass # Try to coerce the value to unicode. unicode_value = force_text(value, strings_only=True) if isinstance(unicode_value, six.text_type): value = unicode_value.strip() else: raise ValidationError(_("Date range value: " + str(value) + " was not able to be converted to unicode.")) if self.widget.clearable(): if value.strip() == '': return None, None if self.widget.separator in value: str_dates = value.split(self.widget.separator, 2) try: beginning = super().to_python(str_dates[0]) except ValidationError as e: raise ValidationError(format_lazy('Error in period beginning: {}', e.message), e.code) try: end = super().to_python(str_dates[1]) except ValidationError as e: raise ValidationError(format_lazy('Error in period end: {}', e.message), e.code) return beginning, end else: raise ValidationError(_("Invalid date range format."), code='invalid')
def post(self, request, repo): pk = request.POST.get('pk') release_file = models.ReleaseFile.objects.get(pk=pk) assert release_file.release.package.repository == self.repository messages.info( request, _("Mirroring %s in the background") % release_file.filename) download_file.delay(pk) return redirect( 'dashboard:package_detail', repo=self.repository.slug, name=release_file.release.package.name)
class UserActivateSerializer(serializers.Serializer): username_email = UsernameEmail() activation_code = serializers.CharField() default_error_messages = { 'incorrect_user_code': _('User not found or invalid/expired code provided'), } def save(self): user = self.validated_data['username_email'] activation_code = self.validated_data['activation_code'] if not user or user.activate(activation_code) is False: self.fail('incorrect_user_code')
def _get_googlemap_link(self, cls, name): url = """<a href="http://maps.google.co.jp/maps?near=%(latitude)s,%(longitude)s&z=%(zoom)s" target="_blank">%s</a>""" url = url % _('open map') try: kwargs = { 'latitude': getattr(cls, name).latitude, 'longitude': getattr(cls, name).longitude, 'zoom': getattr(cls, name).zoom, } return mark_safe(url % kwargs) except: # Fail silently return ''
def _get_model_entry(slug): app_label, model_slug = slug.split('.') try: ct = ContentType.objects.get(app_label=app_label, model=model_slug) model_class = ct.model_class() except ContentType.DoesNotExist: raise Http404(_('Content type not found')) registry = utils.get_registry() if model_class not in registry: raise Http404(u'No registered model found for given query.') return model_class
def _can_user_update_education_group_year_child(person, egy_child, raise_exception): group_type_only_central_can_update = (GroupType.MAJOR_LIST_CHOICE.name, GroupType.MINOR_LIST_CHOICE.name) result = person.is_central_manager or ( egy_child.education_group_type.name not in group_type_only_central_can_update and not egy_child.is_minor ) can_raise_exception( raise_exception, result, _("You cannot modify content for %(education_group_types)s") % { "education_group_types": ", ".join([str(GroupType.MAJOR_LIST_CHOICE.value), str(GroupType.MINOR_LIST_CHOICE.value)]) }) return result
class DRFUserAdmin(UserAdmin): """ Overrides UserAdmin to show fields name & mobile and remove fields: first_name, last_name """ fieldsets = ( (None, { 'fields': ('username', 'password') }), (_('Personal info'), { 'fields': ('name', 'email', 'mobile', 'is_whatsapp') }), (_('Permissions'), { 'fields': ('is_active', 'is_staff', 'is_superuser', 'groups', 'user_permissions') }), (_('Important dates'), { 'fields': ('last_login', 'date_joined') }), ) list_display = ('username', 'email', 'name', 'mobile', 'is_staff') search_fields = ('username', 'name', 'email', 'mobile') readonly_fields = ('date_joined', 'last_login')
def __init__(self, year, order, num_segments): self.order = order self.num_segments = num_segments year_start = datetime.date(year, 1, 1) year_end = datetime.date(year, 12, 31) segment = (year_end - year_start) / num_segments if order > num_segments: raise ValueError(_("Order cannot be higher tha number of year " "segments.")) self.start = year_start + (order - 1) * segment self.end = year_start + order * segment
def amount_complete(self): if self._amount_complete: return self._amount_complete if self.type == self.TYPE_DEBIT: # debits - credits self._amount_complete = ( self.category.get_debit_balance(self.date_start, self.date_end) - self.category.get_credit_balance(self.date_start, self.date_end)) elif self.type == self.TYPE_CREDIT: # credits - debits self._amount_complete = ( self.category.get_credit_balance(self.date_start, self.date_end) - self.category.get_debit_balance(self.date_start, self.date_end)) elif self.type == self.TYPE_SAVINGS: # sum of the balances of savings accounts accounts = Account.objects.get_queryset(self.user).filter(is_savings=True) self._amount_complete = sum( account.get_balance(self.date_start, self.date_end) for account in accounts) else: raise Exception(_('Tipo de meta inválido')) return self._amount_complete
from cms.models.pluginmodel import CMSPlugin from django.conf import settings from django.db import models from django.utils.text import ugettext_lazy as _ from library.models import Category SORT_CHOICES = ( (1, _("alphabet")), (2, _("preset")), ) class PersonsList(CMSPlugin): # db_table 'cmsplugin_personslist' block_title = models.CharField(_('block title'), max_length=255, null=True, blank=True) sorting = models.IntegerField(_('sorting'), choices=SORT_CHOICES, default=2) per_page = models.IntegerField(_('persons count in list'), default=4) template = models.CharField(_('persons list template'), max_length=255, choices=settings.PERSONS_LIST_TEMPLATES) categories = models.ManyToManyField( Category, related_name='persons_plugin_categories', ) class PersonsInCategory(CMSPlugin): # db_table 'cmsplugin_personsincategory' block_title = models.CharField(_('block title'), max_length=255, null=True, blank=True) sorting = models.IntegerField(_('sorting'), choices=SORT_CHOICES, default=2) per_page = models.IntegerField(_('persons count in list'), default=4) template = models.CharField( verbose_name = _('persons list template'), max_length = 255,
def __unicode__(self): return _(u'%s (%s)') % (self.label, self.site.name)
def promote_tab(self): return _('Promote'), self.promote_panels
def save(self, commit=True): user = super().save(commit=False) user.first_name = self.cleaned_data['first_name'] user.save() # create the categories initial_balance_category = Category.objects.create( user=user, name=_('Saldo Inicial')) # create the accounts checking_account = Account.objects.create( user=user, name=_('Conta Corrente'), description=_('Conta para os seus gastos diários'), is_savings=False) savings_account = Account.objects.create( user=user, name=_('Poupança'), description=_('Sua conta poupança, invista seu dinheiro'), is_savings=True) money_account = Account.objects.create( user=user, name=_('Dinheiro'), description=_('Sua conta para gastos em dinheiro'), is_savings=False) # initial balance transactions Transaction.objects.create( user=user, account=checking_account, category=initial_balance_category, date=datetime.today(), description=_('Saldo inicial da conta corrente'), type=Transaction.TYPE_CREDIT, amount=0, payed=True) Transaction.objects.create( user=user, account=savings_account, category=initial_balance_category, date=datetime.today(), description=_('Saldo inicial da conta poupança'), type=Transaction.TYPE_CREDIT, amount=0, payed=True) Transaction.objects.create( user=user, account=money_account, category=initial_balance_category, date=datetime.today(), description=_('Saldo inicial da conta dinheiro'), type=Transaction.TYPE_CREDIT, amount=0, payed=True) return user
def form_invalid(self, form): messages.error(self.request, _("Invalid package name")) return redirect(self.get_success_url())
def content_tab(self): return _('Content'), self.content_panels
def __unicode__(self): return _(u'%dpx x %dpx') % (self.width, self.height)
def clean_password1(self): password1 = self.cleaned_data.get('password1', '') if len(password1) < settings.MIN_PASSWORD_LENGTH: raise forms.ValidationError( _('Senha deve ter no mínimo 6 caracteres.')) return password1
def get_status_display(self): """get human readable status""" sl = list(self.STATUS_LIST) sl.append(('expired', _('Activation key has expired'))) sl = dict(sl) return sl.get(self.status)
def __unicode__(self): return _(" ".join([u'作業日報 - ' , self.writer.last_name ,str(self.date)] ) )
def settings_tab(self): return _('Settings'), self.settings_panels, {'classname': 'settings'}