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