def __new__(cls, name, bases, attrs):
module = attrs.pop('__module__')
parents = [b for b in bases if isinstance(b, ProfileGroupBase)]
if parents:
fields = []
for obj_name, obj in attrs.items():
if isinstance(obj, models.Field):
fields.append(obj_name)
Group.add_to_class(obj_name, obj)
return super(ProfileGroupBase, cls).__new__(cls, name, bases, attrs)
def datatable(self, request):
def get_permission_list(self):
return " | ".join(self.permissions.values_list("name", flat=True))
Group.add_to_class("get_permission_list", get_permission_list)
qs = Group.objects.all()
defer = ['id', 'name', 'get_permission_list']
d = Datatable(request, qs, defer, key="id")
return d.get_data()
def __new__(cls, name, bases, attrs):
module = attrs.pop("__module__")
parents = [b for b in bases if isinstance(b, GroupBase)]
if parents:
fields = []
for obj_name, obj in attrs.items():
if isinstance(obj, models.Field):
fields.append(obj_name)
Group.add_to_class(obj_name, obj)
return super(GroupBase, cls).__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, attrs):
module = attrs.pop('__module__')
parents = [b for b in bases if isinstance(b, GroupBaseMetaClass)]
if parents:
#fields = []
for obj_name, obj in attrs.items():
#if isinstance(obj, db_models.Field): fields.append(obj_name)
Group.add_to_class(obj_name, obj)
#GroupAdmin.fieldsets = list(GroupAdmin.fieldsets)
#GroupAdmin.fieldsets.append((name, {'fields': fields}))
return super(GroupBaseMetaClass, cls).__new__(cls, name, bases, attrs)
from django.db import models
from django.contrib.auth.models import Group, User
from django.utils.translation import ugettext_lazy as _
# Create your models here.
class ServiceType(models.Model):
name = models.TextField(blank=True)
def __str__(self):
return self.name
class Meta:
app_label = 'auth'
Group.add_to_class(
'service_type',
models.ManyToManyField(
ServiceType,
verbose_name=_('Service Type'),
blank=True,
))
def __unicode__(self):
return self.group.name
def get_absolute_url(self):
return '/usergroup/%d/' % self.id
def get_members(self):
return User.objects.filter(groups__pk=self.group.pk)
# iako ovo izgleda jako cudno (grupna prava za grupe), zapravo je jako korisno
# grupa ima sama sebi dodijeljena neka prava (npr. VIEW)
# problem oko related_name, umjesto defaultnog 'group' stavio sam 'groups' (ikicic)
# 'permissions' would be in conflict with the existing Group.permissions!
Group.add_to_class('objpermissions',
generic.GenericRelation(ObjectPermission, related_name='groups'))
# Manually extending an existing class, not such a smart idea...
group__object_permissions = MODEL_DEFAULT + [ADD_MEMBERS]
def group__user_has_perm(self, user, type):
"""
Manual implementation of user_has_perm (BasePermissionsModel), as we can't
extend Group class.
"""
data = self.data
if data:
if user.id == data.author_id:
return True
if type == VIEW and not data.hidden:
return True
return has_group_perm(user, self, type)
from utils.aoi_utils import simplify_geom, force2d
from django.contrib import admin
import rasterio
from rasterio import mask
from osm_export_tool.mapping import Mapping
from hdx_exports.hdx_export_set import HDXExportSet
LOG = logging.getLogger(__name__)
MAX_TILE_COUNT = 10000
DIR = os.path.dirname(os.path.abspath(__file__))
RASTER = rasterio.open(os.path.join(DIR,'osm_nodes.tif'))
Group.add_to_class('is_partner', models.BooleanField(null=False, default=False))
def get_geodesic_area(geom):
bbox = geom.envelope
"""
Uses the algorithm to calculate geodesic area of a polygon from OpenLayers 2.
See http://bit.ly/1Mite1X.
Args:
geom (GEOSGeometry): the export extent as a GEOSGeometry.
Returns
area (float): the geodesic area of the provided geometry.
"""
area = 0.0
coords = bbox.coords[0]
from django.db import models
from django.contrib.auth.models import User, Group, Permission
from django.contrib.contenttypes.models import ContentType
"""
Se utiliza la clase User por de defecto en Django para la creacion de los usuarios, pero
se incluyen 3 atributos:
- direccion: direccion del usuario
- telefono: numero del telefono del usuario
- observacion: observacion sobre el usuario por parte del administrador del sistema
"""
User.add_to_class('direccion', models.TextField(null=True, blank=True))
User.add_to_class('telefono', models.PositiveIntegerField(null=True, blank=True))
User.add_to_class('observacion', models.TextField(null=True, blank=True))
Group.add_to_class('Usuario', models.ForeignKey(User, null=True))
Group.add_to_class('Fecha', models.DateTimeField(auto_now=True, null=True))
class Proyecto(models.Model):
"""
Clase Proyecto:
* Contiene los campos de la tabla proyecto en la base de datos
* Variales
- Lider: es el usuario lider del proyecto
- Nombre: es el nombre que posee el proyecto
- Descripcion: es la decripcion del proyecto
- Fecha de inicio: es la fecha en que el proyecto dara inicio
- Fecha de finalizacion: es la fecha en la que el proyecto estara finalizado
- Fecha: es la fecha de creacion del proyecto
#*-* coding: utf-8 *-*
from django.db import models
from django.contrib.auth.models import User
from django.contrib.auth.models import Group
Group.add_to_class('is_project', models.BooleanField(verbose_name='Группа проекта', default=False))
from django.utils.translation import ugettext, ugettext_lazy as _
from django.contrib.auth import models as auth
from django.contrib.auth.models import Group
import django.contrib.auth.signals
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes import generic
from django.db.models import validators
from django.utils import timezone
from django.contrib.admin.util import quote
from django.utils.encoding import smart_text
from django.core.mail import send_mail
from keops.db import models
from .element import ElementManager
Group.add_to_class('module_category', models.ForeignKey('base.modulecategory', verbose_name=_('category')))
class CompanyManager(ElementManager):
def get_queryset(self):
return super(CompanyManager, self).get_queryset().defer('image') # default defer image
# Company/data context
class Company(models.Model):
"""
Company configuration model.
"""
parent_company = models.ForeignKey('self')
name = models.CharField(_('name'), max_length=100, null=False)
logo = models.ImageField('logo')
extra_fields.setdefault('is_superuser', False)
return self._create_user(email, password, **extra_fields)
def create_superuser(self, email=None, password=None, **extra_fields):
extra_fields.setdefault('is_staff', True)
extra_fields.setdefault('is_superuser', True)
if extra_fields.get('is_staff') is not True:
raise ValueError('Superuser must have is_staff=True.')
if extra_fields.get('is_superuser') is not True:
raise ValueError('Superuser must have is_superuser=True.')
return self._create_user(email, password, **extra_fields)
Group.add_to_class('description', models.CharField(max_length=180,null=True, blank=True))
Group.add_to_class('school_id', models.ForeignKey('app.School',on_delete=models.SET_NULL,blank=True,null=True,help_text='Школа'))
# Group.add_to_class('creator_id', models.ForeignKey('app.User',on_delete=models.SET_NULL,blank=True,null=True,help_text='zxc'))
def content_file_name_logo(instance, filename):
return os.path.join(str(instance.id),'logo',filename)
def content_file_name_courses(instance, filename):
return os.path.join(str(instance.creator_id.school_id.id),'courses',str(instance.title)+"_"+str(instance.creator_id.school_id.id) ,filename)
def content_file_name_hw(instance, filename):
return os.path.join(str(instance.student_id.school_id.id),'hw',str(instance.course_id.title),str(instance.lesson_id.id) ,filename)
def content_file_name_ex(instance, filename):
return os.path.join(str(instance.creator_id.school_id.id),'exercise',str(instance.lesson_id.id),str(instance.id),filename)
from .attendance import *
from .enroll import *
from .group import *
from .medical_group import *
from .schedule import *
from .semester import *
from .sport import *
from .student import *
from .trainer import *
from .training import *
from .training_class import *
from .reference import *
from .medical_group_reference import MedicalGroupReference
from .enums import *
from django.contrib.auth.models import Group as DjangoGroup
DjangoGroup.add_to_class(
'verbose_name',
models.CharField(
max_length=180,
null=True,
blank=False,
unique=True,
))
DjangoGroup.add_to_class("__str__", lambda self: str(self.verbose_name))
DjangoGroup.add_to_class("natural_key", lambda self:
(str(self.verbose_name), ))
]
def get_group_user(instance, **kwargs):
return instance.modified_by
# register(Poll, get_user=get_poll_user)
# monkey-patch original Group model
# Group.add_to_class('modified_by', models.ForeignKey(
# 'accounts.User',
# on_delete=models.CASCADE,
# blank=True,
# null=True,
# related_name='%(app_label)s_%(class)s_modified_by',
# ))
Group.add_to_class('is_supervisor', models.BooleanField(default=False))
Group.add_to_class('is_admin', models.BooleanField(default=False))
# Group.add_to_class('history', HistoricalRecords())
# simple_history register Groups and Permissions
register(Group)
register(Permission)
class EmailAddressManager(models.Manager):
"""Custom manager for email addresses."""
def set_as_primary(self, email, user=None):
"""
Sets an email as primary for a particular user.
"""
if isinstance(email, int):
email = self.get_queryset().get(pk=email)
if isinstance(email, str):
from django.db import models
from django.contrib.auth.models import Group
from django.contrib.auth.models import User
class Instance(models.Model):
hostname = models.CharField(max_length=120, primary_key=True)
alias = models.CharField(max_length=30)
port = models.IntegerField()
key = models.CharField(max_length=100)
https = models.BooleanField()
main = models.BooleanField(default=False)
group = models.ForeignKey(Group, null=True, on_delete=models.SET_NULL)
Group.add_to_class('active', models.BooleanField(default=True))
from django.db import models
# Create your models here.
from django.contrib.auth.models import AbstractUser
from django.contrib.auth.models import Group
Group.add_to_class('alias',
models.CharField(max_length=64, blank=True, null=True))
class UserProfile(AbstractUser):
nick_name = models.CharField(max_length=50, verbose_name=u"nick name")
from django.contrib.contenttypes.models import ContentType
from django.contrib.auth.models import Permission, Group
from django.db import models
from constants.global_constant import PERMISSION_CODENAME_FORMAT
from django.contrib.auth import get_user_model
ContentType._meta.get_field("app_label").max_length = 1000
Permission._meta.get_field("codename").max_length = 1000
def custom(self):
def __get_permission_name(perm, curr_instance):
return perm.content_type.model + ' | ' + str(curr_instance)
if self.uuid_codename:
__Class = PERMISSION_CODENAME_FORMAT.get(self.content_type.model, None)
if __Class:
instance = __Class.objects.get(pk=str(self.uuid_codename))
return __get_permission_name(self, instance)
else:
return self.content_type.model + ' | ' + self.name
Permission.add_to_class('uuid_codename', models.CharField(max_length=1000))
Permission._meta.get_field("codename")._unique = True
Permission._meta.get_field("name").max_length = 1000
Permission.__str__ = custom
Group.add_to_class('owner', models.ForeignKey(get_user_model()))
class CodeQuery(models.Model):
code = models.TextField()
result = models.TextField(null=True)
last_updated = models.DateTimeField(auto_now=True)
closed = models.BooleanField(default=False)
class Message(models.Model):
room = models.ForeignKey(Group,
null=False,
blank=False,
on_delete=models.CASCADE)
sender = models.ForeignKey(User, on_delete=models.CASCADE, null=True)
message = models.TextField()
sended_at = models.DateTimeField(auto_now_add=True)
isCodeQuery = models.BooleanField(default=False)
codeQuery = models.OneToOneField(CodeQuery,
on_delete=models.CASCADE,
null=True)
def __str__(self):
return self.message
def get_absolute_url(self):
return reverse('join-room', args=[self.name])
Group.add_to_class('get_absolute_url', get_absolute_url)
User.add_to_class('online', models.BooleanField(default=False))
from django.db import models
from django.contrib.auth.models import Group
# Create your models here.
# Added status field in Existing Group Model
Group.add_to_class('status', models.BooleanField(default=True))
from django.db import models
from colorfield.fields import ColorField
from django.contrib.auth.models import Group, User
Group.add_to_class('Livello', models.IntegerField(default=0))
Group.add_to_class('Colore', ColorField(default='#FF0000'))
User.add_to_class('Foto',
models.ImageField(upload_to='utenti/foto', default='null'))
User.add_to_class('Bio', models.TextField(blank=True))
from django.db import models
from django.contrib.auth.models import Group
"""
Hier wird die auth_group um neue Felder erweitert
"""
Group.add_to_class('code', models.CharField(max_length=3, null=True))
from django.db import models
from django.utils import timezone
from django.contrib.auth.models import User
from django.contrib.auth.models import Group
Group.add_to_class('description', models.CharField(max_length=100, null=True))
Group.add_to_class('is_active', models.BooleanField(blank=True, null=True))
Group.add_to_class('created_at', models.DateTimeField(default=timezone.now))
User.add_to_class('pwd', models.CharField(max_length=100, null=True))
User.add_to_class(
'role',
models.ForeignKey(Group,
related_name='group',
on_delete=models.CASCADE,
null=True))
User.add_to_class('is_login', models.BooleanField(blank=True, null=True))
class UserProfile(models.Model):
objects = None
user = models.ForeignKey(User, on_delete=models.CASCADE, null=True)
login_time = models.DateTimeField(default=timezone.now)
logout_time = models.DateTimeField(blank=True, null=True)
duration = models.CharField(max_length=100, null=True)
created_date = models.DateTimeField(default=timezone.now)
published_date = models.DateTimeField(blank=True, null=True)
class Meta:
db_table = "UserProfile"
customer.user = self
customer.first_name = self.first_name
customer.last_name = self.last_name
customer.save()
def clean(self):
self.email = self.email.lower()
if self.employee_id is not None and self.employee.owner_id != self.owner_id:
raise ValidationError({"employee": "Employee does not belong to the same owner as user"})
if self.verified:
self.link_to_customers()
def has_perm(self, perm, obj=None):
if self.employee_id is not None and perm in ['c.scheduling.view_customer', 'c.scheduling.view_service',
'c.scheduling.view_appointment', 'c.scheduling.view_schedule']:
return True
if perm.startswith('c.'):
perm = perm[2:]
return AbstractUser.has_perm(self, perm, obj)
def _get_owner(self: Group):
if not hasattr(self, 'groupprofile'):
return None
return self.groupprofile.owner_id
Group.add_to_class('owner_id', property(_get_owner))
from django.dispatch import receiver
from django.utils.translation import ugettext_lazy as _
from django.contrib.auth.models import Group, Permission
from django.contrib.contenttypes.models import ContentType
import datetime
from multiselectfield import MultiSelectField
MY_FORMATS = (('ebook', "Ebook"), ('audio', "Audio Book"),
('hard_cover', 'Hard Cover'), ('paper_back', 'Paper Back'))
SITES_TO_SEARCH = (('kobo', "Kobo"), ('google_books', "Google Books"),
('scribd', "Scribd"), ('audio_books', "Audio Books"),
('test_store', "Test Book Store"), ('livraria cultura',
"Livraria Cultura"))
Group.add_to_class(
'formats', MultiSelectField(choices=MY_FORMATS, max_length=50, blank=True))
Group.add_to_class(
'search_sites',
MultiSelectField(choices=SITES_TO_SEARCH, max_length=80, blank=True))
Group.add_to_class(
'contact_user',
models.OneToOneField(User, on_delete=models.CASCADE, null=True))
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
def query_handler(self, date):
try: #user made queries on this date
q_set = Query_Manager.objects.get(last_date=date)
# current_svn_version = models.PositiveIntegerField(blank=True,null=True)
# fun_svn_version = models.PositiveIntegerField(blank=True,null=True)
# uat_svn_version = models.PositiveIntegerField(blank=True,null=True)
def __str__(self):
if self.jenkins_server:
return "%s(%s)" % (self.job_name, self.jenkins_server.server_name)
else:
return "%s()" % (self.job_name)
class Meta:
unique_together = (("job_name", "jenkins_server"), )
Group.add_to_class('jenkins_job', models.ManyToManyField(JenkinsJob,
blank=True))
MyUser.add_to_class('jenkins_job',
models.ManyToManyField(JenkinsJob, blank=True))
# dp_models.Project.add_to_class('fun_job',models.ForeignKey(JenkinsJob,blank=True))
@receiver(post_delete, sender=JenkinsJob)
def delete_job_after(sender, instance, **kwargs):
js_obj = JenkinsApi(instance.jenkins_server)
if js_obj.jk_ping():
js_obj.delete_job(instance.job_name)
@receiver(pre_save, sender=JenkinsJob)
from django.db import models
from django.contrib.auth.models import AbstractBaseUser, BaseUserManager, Group
from django.utils.translation import gettext as _
Group.add_to_class('description', models.TextField(max_length=140, null=True))
Group.add_to_class('isPrivate', models.BooleanField(default=False))
'''
class InviteManager(models.Manager):
def create_invite(self, toUser=None, fromUser=None, groupID=None):
invite = self.model(toUser=self.toUser, fromUser=self.fromUser, groupID=self.groupID)
return invite
class Invite(models.Model):
toUser = models.ForeignKey(User, related_name='received_invite', verbose_name=_('invitee'))
fromUser = models.ForeignKey(User, related_name='sent_invite', verbose_name=_('inviter'))
groupID = models.ForeignKey(Group, )
'''
class UserManager(BaseUserManager):
def create_user(self, email=None, password=None):
user = self.model(email=self.normalize_email(email))
user.set_password(password)
return user
def create_normal_user(self,
email=None,
first_name=None,
last_name=None,
password=None):
user = self.create_user(email=email, password=password)
from django.db import models
from django.contrib.auth.models import Group
# Create your models here.
class Raport(models.Model):
title = models.CharField(max_length=100)
content = models.TextField()
author_name = models.CharField(max_length=100)
author_lastname = models.CharField(max_length=100)
dateTime = models.DateTimeField(auto_now_add=True)
objects = models.Manager()
@classmethod
def create(cls, title, content, author_name, author_lastname):
raport = cls(title=title, content=content, author_name=author_name, author_lastname=author_lastname)
return raport
class Task(models.Model):
title = models.TextField()
complete = models.BooleanField(default=False)
Group.add_to_class('calendar_link', models.TextField(blank=True))
# "Does the user have a specific permission?"
# # Simplest possible answer: Yes, always
# return True
# def has_module_perms(self, app_label):
# "Does the user have permissions to view the app `app_label`?"
# # Simplest possible answer: Yes, always
# return True
# @property
# def is_staff(self):
# "Is the user a member of staff?"
# # Simplest possible answer: All admins are staff
# return self.is_admin
Group.add_to_class('VG', models.CharField(max_length=180,null=True, blank=True))
Group.add_to_class('rol', models.CharField(max_length=180,null=True, blank=True))
class TAapplicationmodel(models.Model):
firmname=models.TextField()
addr1=models.TextField()
addr2=models.TextField()
tot=models.TextField()
item_name=models.TextField()
part_no=models.TextField()
desc=models.TextField()
spec=models.TextField()
dal_mdi=models.TextField()
bom=models.TextField()
sop_acbs = models.TextField()
managed = True
db_table = 'ab_suggestions'
ordering = ['-updated_at']
# class AbRoles(models.Model):
# name = models.CharField(max_length=191)
# guard_name = models.CharField(max_length=191)
# created_at = models.DateTimeField(auto_now_add=True, blank=True, null=True)
# updated_at = models.DateTimeField(auto_now=True, blank=True, null=True)
# class Meta:
# managed = True
# db_table = 'ab_roles'
Group.add_to_class(
'created_at', models.DateTimeField(auto_now_add=True,
blank=True,
null=True))
Group.add_to_class('updated_at',
models.DateTimeField(auto_now=True, blank=True, null=True))
Group.add_to_class('guard_name',
models.CharField(blank=True, null=True, max_length=191))
# class AbPermissions(models.Model):
# name = models.CharField(max_length=191)
# guard_name = models.CharField(max_length=191)
# created_at = models.DateTimeField(blank=True, null=True)
# updated_at = models.DateTimeField(blank=True, null=True)
# class Meta:
# managed = True
# db_table = 'ab_permissions'
from django.db import models
from azienda.models import Company
from django.contrib.auth.models import Group
#Base
from user.models import UserProfile
#Esterno
from guardian.models import GroupObjectPermission
#monkey path
Group.add_to_class(
'description',
models.CharField(verbose_name='Descrizione', max_length=120, default=""))
@date 18-01-2017
@version 1.0.0
"""
from django.db import models
from django.contrib.auth.models import (Group, User)
from utils.models import (
TipoDocumento, )
from organizaciones.models import (
Vocero, )
"""
Se agrega un campo de descripcion al modelo group para describir el grupo de usuarios
"""
Group.add_to_class('descripcion', models.TextField(blank=True))
class UserProfile(models.Model):
"""!
Clase que construye el modelo de datos para el perfil de usuario
@author Ing. Leonel P. Hernandez M. (lhernandez at cenditel.gob.ve)
@copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
@date 18-01-2017
@version 1.0.0
"""
fk_user = models.OneToOneField(User)
fk_tipo_documento = models.ForeignKey(TipoDocumento)
id_perfil = models.CharField(unique=True,
max_length=12,
from django.db import models
from django.contrib.auth.models import Group
Group.add_to_class(
'rank', models.PositiveIntegerField(default=1, null=False, blank=False))
# class UserHierachy(models.Model):
# group = models.ForeignKey(Group, on_delete=models.DO_NOTHING)
# rank = models.PositiveIntegerField(default=0)
# created_date = models.DateTimeField(auto_now_add=True)
# class Meta:
# ordering = ("id",)
def for_user(self, user):
return self.filter(id=user.org_id)
def for_admin(self, user):
return self.filter(id=user.org_id)
class SameOrgQuerySet(models.QuerySet):
def for_user(self, user):
return self.filter(org_id=user.org_id)
def for_admin(self, user):
return self.filter(org_id=user.org_id)
class UserOwnerQuerySet(models.QuerySet):
def for_user(self, user):
return self.filter(owner_id=user.pk)
def for_admin(self, user):
return self.filter(org_id=user.org_id)
class GroupQuerySet(models.QuerySet):
def for_user(self, user):
return self.filter(name__startswith='org_{0}_'.format(user.org_id))
# Dirty monkey patch
Group.add_to_class('manager', GroupQuerySet.as_manager()) #@UndefinedVariable
from django.db import models
from phonenumber_field.modelfields import PhoneNumberField
from django.contrib.auth.models import (
BaseUserManager, AbstractBaseUser, PermissionsMixin, Group
)
class Wage(models.Model):
name = models.CharField(max_length=100,unique=True)
amount = models.DecimalField(max_digits=4, decimal_places=2, default=11.80)
def __str__(self):
return f'{self.name} - ${self.amount}'
Group.add_to_class('hourly_rate', models.ForeignKey(Wage,models.PROTECT))
class EmployeeManager(BaseUserManager):
def create_user(self, first_name, last_name, email, password=None):
if not email:
raise ValueError('Users must have an email address')
user = self.model(
email=self.normalize_email(email),
first_name = first_name,
last_name = last_name,
)
user.set_password(password)
user.save(using=self._db)
return user
def create_staffuser(self, first_name, last_name, email, password):
user = self.create_user(
from django.contrib.auth.models import User, Group
from django.db import models
from primer.db.models import UUIDField
# Monkey Patch User Model
User.add_to_class('uuid', UUIDField())
User.add_to_class('created', models.DateTimeField(auto_now_add=True, editable = False, blank = True, null = True))
User.add_to_class('modified', models.DateTimeField(auto_now=True, blank = True, null = True))
# Monkey Patch Group Model
Group.add_to_class('uuid', UUIDField())
Group.add_to_class('created', models.DateTimeField(auto_now_add=True, editable = False, blank = True, null = True))
Group.add_to_class('modified', models.DateTimeField(auto_now=True, blank = True, null = True))
import uuid
from django.contrib.auth.models import Group
from django.db import models
from django.utils.translation import gettext_lazy as _
from django_currentuser.db.models import CurrentUserField
from django_currentuser.middleware import get_current_user
Group.add_to_class(
'uuid',
models.UUIDField('UUID',
db_index=True,
editable=False,
default=uuid.uuid4,
unique=True))
Group.add_to_class(
'label',
models.CharField(_('Label'),
max_length=150,
help_text=_('Label of the group.')))
# CreationModel
Group.add_to_class(
'created_at',
models.DateTimeField(_('Created at'),
auto_now_add=True,
editable=False,
help_text=_('Date when it was created.')))
Group.add_to_class(
'created_by',
CurrentUserField(verbose_name=_('Created by'),
related_name='created_%(class)s',
from django.contrib.auth.models import AbstractUser, BaseUserManager, Group
from django.db import models
from django.utils.translation import ugettext_lazy as _
from almacenes.models import Almacen
from tiendas.models import Tienda
def has_almacen(self, almacen):
return self.almacenes.filter(id=almacen.id).exists()
Group.add_to_class(
'almacenes',
models.ManyToManyField('almacenes.Almacen',
limit_choices_to={'activo': True},
blank=True,
related_name='groups'))
Group.add_to_class('has_almacen', has_almacen)
class UserManager(BaseUserManager):
use_in_migrations = True
def _create_user(self, email, password, **extra_fields):
if not email:
raise ValueError('El usuario necesita un email.')
email = self.normalize_email(email)
user = self.model(email=email, **extra_fields)
user.set_password(password)
from __future__ import unicode_literals
from django.db import models
from django.contrib.auth.models import User, Group
from audit_log.models.managers import AuditLog
Group.add_to_class('menu', models.TextField())
class Archivos(models.Model):
titulo = models.CharField(max_length=150)
contenido = models.TextField()
audit_log = AuditLog()
class Meta:
permissions = (
("view_archivos", "Puede ver los registros"),
("options_archivos", "Puede ver los options"),
)
def __str__(self):
return self.titulo
def __unicode__(self):
return self.titulo
