コード例 #1
0
ファイル: models.py プロジェクト: xaustin/austin_django_demo
 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)
コード例 #2
0
    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()
コード例 #3
0
ファイル: models.py プロジェクト: MoLice/oneingdufs
    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)
コード例 #4
0
ファイル: models.py プロジェクト: zys7832/sms
    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)
コード例 #5
0
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,
    ))
コード例 #6
0
ファイル: models.py プロジェクト: ikicic/skoljka
    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)
コード例 #7
0
ファイル: models.py プロジェクト: andrestone/osm-export-tool
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]
コード例 #8
0
ファイル: models.py プロジェクト: RodrigoSantosBacchetto/SGP
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
コード例 #9
0
ファイル: models.py プロジェクト: kotaba/jv-django
#*-* 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))
コード例 #10
0
ファイル: auth.py プロジェクト: mofei2816/keops
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')
コード例 #11
0
        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)
コード例 #12
0
ファイル: __init__.py プロジェクト: SgMakarov/SWP_sport_back
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), ))
コード例 #13
0
]

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):
コード例 #14
0
ファイル: models.py プロジェクト: vycontrol/vycontrol
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))
コード例 #15
0
ファイル: models.py プロジェクト: zhaobin022/xadmintest
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")
コード例 #16
0
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()))
コード例 #17
0
ファイル: models.py プロジェクト: darshDM/chat-room-channels
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))
コード例 #18
0
ファイル: models.py プロジェクト: singhnk288/Django-CMS
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))
コード例 #19
0
ファイル: models.py プロジェクト: EliaMenoni/acheron-website
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))
コード例 #20
0
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))
コード例 #21
0
ファイル: models.py プロジェクト: veerapandian22/vtrack
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"
コード例 #22
0
ファイル: models.py プロジェクト: Gchahm/Kalendario_API
            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))
コード例 #23
0
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)
コード例 #24
0
ファイル: models.py プロジェクト: zhaobin022/pbv2
    # 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)
コード例 #25
0
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)
コード例 #26
0
ファイル: models.py プロジェクト: Mlitwin98/reports-manager
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))
コード例 #27
0
#         "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()
コード例 #28
0
        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'
コード例 #29
0
ファイル: models.py プロジェクト: Sirbin/ProEurope-Project
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=""))
コード例 #30
0
@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,
コード例 #31
0
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",)
コード例 #32
0
    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
コード例 #33
0
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(
コード例 #34
0
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))
コード例 #35
0
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',
コード例 #36
0
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)
コード例 #37
0
ファイル: models.py プロジェクト: Marcelo1180/apilabo
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