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'}
