def __new__(cls, name, bases, attrs):
module = attrs.pop('__module__')
parents = [b for b in bases if isinstance(b, ProfileBase)]
if parents:
fields = []
for obj_name, obj in attrs.items():
if isinstance(obj, db_models.Field): fields.append(obj_name)
User.add_to_class(obj_name, obj)
UserAdmin.fieldsets = list(UserAdmin.fieldsets)
UserAdmin.fieldsets.append((name, {'fields': fields}))
return super(ProfileBase, 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, UserBase)]
if parents:
fields = []
for obj_name, obj in attrs.items():
if isinstance(obj, models.Field):
fields.append(obj_name)
User.add_to_class(obj_name, obj)
return super(UserBase, 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, ProfileBase)]
if parents:
fields = []
for obj_name, obj in attrs.items():
if isinstance(obj, models.Field):
fields.append(obj_name)
User.add_to_class(obj_name, obj) ####最重要的步骤
UserAdmin.fieldsets = list(UserAdmin.fieldsets)
UserAdmin.fieldsets.append((name, {'fields': fields}))
return type.__new__(cls, name, bases, attrs)
def __new__(cls,name,bases,attrs):
module = attrs.pop('__module__')
parents = [b for b in bases if isinstance(b, ProfileBase)]
if parents:
fields = []
for obj_name, obj in list(attrs.items()):
if isinstance(obj, models.Field): fields.append(obj_name)
User.add_to_class(obj_name, obj)
UserAdmin.fieldsets = list(UserAdmin.fieldsets)
UserAdmin.fieldsets.insert(1, (name, {'fields': fields}))
UserAdmin.list_display = tuple(list(UserAdmin.list_display) + fields)
UserAdmin.list_display = tuple(list(UserAdmin.list_display) + ['is_superuser'])
return super().__new__(cls, name, bases, attrs)
def setUp(self):
class PeopleTestModel(models.Model):
people = PeoplePlug(allowed_people=[User])
class AnotherPeopleTestModel(models.Model):
people = PeoplePlug(allowed_people=[User,Candidate])
class YetAnotherTestModel(models.Model):
people = PeoplePlug()
self.PeopleTestModel = PeopleTestModel
management.call_command('syncdb', verbosity=0, interactive=False)
self.test_model = PeopleTestModel.objects.create()
self.another_test_model = AnotherPeopleTestModel.objects.create()
self.yet_another_test_model = YetAnotherTestModel.objects.create()
management.call_command('loaddata', fixture_file_path, verbosity=1)
@property
def screen_name(user): return user.username
User.add_to_class("screen_name",screen_name )
def setUp(self):
management.call_command('syncdb', verbosity=0, interactive=False)
@property
def communication_sending_email(user):
return "*****@*****.**"
@property
def communication_receiving_email(user):
return user.email
User.add_to_class('communication_sending_email',communication_sending_email)
User.add_to_class('communication_receiving_email',communication_receiving_email)
@property
def screen_name(user): return user.username
User.add_to_class("screen_name",screen_name )
DisAllowedUserOfAnotherType.add_to_class('communication_sending_email',communication_sending_email)
DisAllowedUserOfAnotherType.add_to_class('communication_receiving_email',communication_receiving_email)
self.test_model = TestModel.objects.create()
self.user = User(username="******",email="*****@*****.**",password="******")
self.user.save()
self.test_model_deletable = TestModel.objects.create()
self.allowed_user_of_another_type = AllowedUserOfAnotherType(screen_name="asdf")
self.allowed_user_of_another_type.save()
self.disallowed_user_of_another_type = DisAllowedUserOfAnotherType(screen_name="asdf")
self.disallowed_user_of_another_type.save()
self.recipients = [
User(username="******",email="*****@*****.**",password="******"),
# User(username="******",email="*****@*****.**",password="******"),
# User(username="******",email="*****@*****.**",password="******"),
]
for one in self.recipients:
one.save()
self.message = "ba ba black sheep.have you any wool"
self.title = "something about a sheep"
from django.db import models as mdls
from django.contrib.auth.models import User as DjangoUser
from django.contrib.auth.models import Group
from django.db.models.signals import post_save
from django.dispatch import receiver
from home.choices import *
def get_name(self):
return "%s %s" % (self.first_name, self.last_name)
DjangoUser.add_to_class("__str__", get_name)
class UserProfile(mdls.Model):
user = mdls.OneToOneField(DjangoUser, on_delete=mdls.CASCADE)
change_pwd = mdls.BooleanField(default=False)
date_of_birth = mdls.DateField(default="1901-01-01")
salesforce_id = mdls.CharField(default="xxxxxx19010101", max_length=14)
@receiver(post_save, sender=DjangoUser)
def create_user_profile(sender, instance, created, **kwargs):
if created:
UserProfile.objects.create(user=instance)
@receiver(post_save, sender=DjangoUser)
def save_user_profile(sender, instance, **kwargs):
instance.userprofile.save()
from django.contrib.auth.models import User
from django.db import models
from django.dispatch import receiver
# User class extensions
def user_unicode(self):
"""Change user string representation to use the user's email address."""
return self.email
User.add_to_class('__unicode__', user_unicode)
@property
def user_display_name(self):
"""Return this user's display name, or 'Anonymouse' if they don't have a profile."""
try:
return self.profile.display_name
except UserProfile.DoesNotExist:
return None
User.add_to_class('display_name', user_display_name)
class UserProfile(models.Model):
user = models.OneToOneField(User, primary_key=True, related_name='profile')
display_name = models.CharField(max_length=256, default='Anonymous')
@receiver(models.signals.post_save, sender=User)
def create_user_profile(sender, **kwargs):
"""Create a user profile as soon as a user is created."""
if kwargs['created']:
class RolUsuarioProyecto(models.Model):
usuario = models.ForeignKey(User)
proyecto = models.ForeignKey(Proyecto)
rol = models.ForeignKey(Group, null=True)
def tienePermiso(self, permiso):
for grupo in self.groups.all():
for permisoUsuario in grupo.permissions.all():
if permisoUsuario.codename == permiso:
return True
return False
User.add_to_class('tienePermiso', tienePermiso)
def tienePermisoProyecto(self, permisoCodename, id_proyecto):
proyecto = Proyecto.objects.get(pk=id_proyecto)
for grupo in self.groups.filter(Proyecto=proyecto):
for permisoUsuario in grupo.permissions.all():
if permisoUsuario.codename == permisoCodename:
return True
return False
User.add_to_class('tienePermisoProyecto', tienePermisoProyecto)
def puede_agregar_proyectos(self):
else:
return _("No trial")
# add User.get_subscription() method
def __user_get_subscription(user):
if not hasattr(user, "_subscription_cache"):
sl = Subscription.objects.filter(group__in=user.groups.all())[:1]
if sl:
user._subscription_cache = sl[0]
else:
user._subscription_cache = None
return user._subscription_cache
User.add_to_class("get_subscription", __user_get_subscription)
def __user_get_active_subscription(user):
try:
return user.usersubscription_set.get(active=True)
except UserSubscription.DoesNotExist:
return None
User.add_to_class("get_active_subscription", __user_get_active_subscription)
class UserSubscriptionManager(models.Manager):
def unsubscribe_expired(self):
"""Unsubscribes all users whose subscription has expired.
# encoding:utf-8
from django.db import models
from django.contrib.auth.models import User
User.add_to_class('dni', models.CharField(max_length=9, unique=True, null=True))
User.add_to_class('es_profesor', models.BooleanField(default=False, blank=True))
class Grado(models.Model):
"""
Modelo de Grado
:param: titulo: Titulo del grado
:param: identificador: Identificador único del grado
:param: usuarios: Lista de usuarios que estudian el grado
:param: profesores: Lista de profesores que dan el grad
"""
titulo = models.CharField(max_length=200)
identificador = models.CharField(max_length=3)
usuarios = models.ManyToManyField(User, related_name="usuarios")
profesores = models.ManyToManyField(User, related_name="profesores")
def __unicode__(self):
return self.titulo
class Meta:
ordering = ('titulo',)
DIAS_DE_LA_SEMANA = (
lambda user: {
'username': user.username,
'email': user.email,
'initials': user.get_initials()
}, contributors))
json_contributors = json.dumps(mapped_contributors)
serialize: str = serializers.serialize('json', [self])
return serialize[:-1] + ',{\"contributors\":' + json_contributors + '}]'
class Contribution(models.Model):
task = models.ForeignKey(Task, on_delete=models.CASCADE)
user = models.ForeignKey(User, on_delete=models.CASCADE)
join_date = models.DateTimeField(auto_now_add=True)
# extension method to User class
def get_initials(self) -> str:
name: str = self.first_name
last_name: str = self.last_name
if name is None or len(name) < 1 \
or last_name is None or len(last_name) < 1:
user = self.username.upper()
return user if len(user) <= 2 else user[:2]
return (name[:1] + last_name[:1]).upper()
User.add_to_class('get_initials', get_initials)
user=self, category=Subscription.COALITION
):
return True
def has_characters(self):
return Api.objects.filter(user=self).exclude(
accounttype=Api.CORPORATION
).exists()
def all_characters(self):
characters = []
apis = Api.objects.filter(user=self).exclude(
accounttype=Api.CORPORATION
)
for api in apis:
characters += list(api.characterapi_set.all())
return characters
User.add_to_class("create_related", create_related)
User.add_to_class("is_inactive", is_inactive)
User.add_to_class("days_since_last_login", days_since_last_login)
User.add_to_class("inactive_dict", inactive_dict)
User.add_to_class("corporation_access", corporation_access)
User.add_to_class("alliance_access", alliance_access)
User.add_to_class("coalition_access", coalition_access)
User.add_to_class("has_characters", has_characters)
User.add_to_class("all_characters", all_characters)
from django.db.models.signals import post_save
from django.core.urlresolvers import reverse
from django.conf import settings
import datetime
import re, os
from pytils.translit import slugify
from sorl.thumbnail import ImageField as SorlImageField
from geo.models import CustomLocation
##########################################################################
##########################################################################
User.add_to_class(
'phone',
models.CharField(max_length=20, verbose_name=u'телефон', blank=True))
def get_user_name(self):
return self.get_full_name() if self.get_full_name() else self.username
User.add_to_class('get_user_name', get_user_name)
User.add_to_class('__unicode__', get_user_name)
##########################################################################
##########################################################################
class ActiveManager(models.Manager):
from django.contrib.auth.models import Group, User
from accounts.models import PrintDisclaimer
def is_regular_student(self):
return self.has_perm('booking.is_regular_student')
def has_print_disclaimer(self):
return PrintDisclaimer.objects.filter(user=self).exists()
def subscribed(self):
group, _ = Group.objects.get_or_create(name='subscribed')
return group in self.groups.all()
User.add_to_class("is_regular_student", is_regular_student)
User.add_to_class("has_print_disclaimer", has_print_disclaimer)
User.add_to_class("subscribed", subscribed)
import os
from django.contrib.auth.models import User
from django.core.validators import RegexValidator
from django.db import models
from .actions import get_bucket_object
GOOGLE_APPLICATION_CREDENTIALS = os.getenv("GOOGLE_APPLICATION_CREDENTIALS", None)
def get_user_label(self):
return f"{self.first_name} {self.last_name} ({self.email})"
User.add_to_class("__str__", get_user_label)
class UserAdmissions(User):
class Meta:
proxy = True
class Country(models.Model):
code = models.CharField(max_length=3, primary_key=True)
name = models.CharField(max_length=30)
def __str__(self):
return f"{self.name} ({self.code})"
class City(models.Model):
name = models.CharField(max_length=30)
country = models.ForeignKey(Country, on_delete=models.CASCADE)
def __str__(self):
return self.name
INACTIVE = 'INACTIVE'
ACTIVE = 'ACTIVE'
from django import forms
from django.contrib.auth.models import User
from django.forms import ModelForm
from django.db import models
# Create your models here.
#EDICION DE MODELO USER
User.add_to_class('usuario_sico', models.CharField(max_length=10, null=False, blank=False))
User.add_to_class('contrasenia_sico', models.CharField(max_length=10, null=False, blank=False))
#User.add_to_class('amigos', models.ManyToManyField('self', symmetrical=True, blank=True))
#FORMULARIOS
class SignUpForm(ModelForm):
class Meta:
model = User
fields = ['username', 'password', 'email', 'first_name', 'last_name', 'usuario_sico', 'contrasenia_sico']
widgets = {
'password': forms.PasswordInput(),
'contrasenia_sico': forms.PasswordInput(),
}
verifications = models.IntegerField(default=0)
verification_time = models.DateTimeField(null=True, blank=True)
timeseries_id = models.CharField(max_length=36)
negation = models.BooleanField(default=False)
class Meta:
indexes = [
models.Index(fields=['tag_id'])
]
unique_together = (('bin', 'roi', 'user_id', 'tag_id', 'negation'),)
# add some fields and methods to User and Group
# FIXME not recommended
Group.add_to_class('power', models.IntegerField(default=0))
def get_group_power(self):
if self.power:
return self.power
return 0
Group.add_to_class('get_group_power', get_group_power)
def get_user_power(self):
power = 0
for g in self.groups.all():
if g.get_group_power() > power:
power = g.get_group_power()
return power
User.add_to_class('get_user_power', get_user_power)
blank=True,
related_name='children',
verbose_name=_('parent'),
help_text=_('The group\'s parent group. None, if it is a root node.'
)).contribute_to_class(Group, 'parent')
MPTTModelBase.register(Group, order_insertion_by=['name'])
# enhance User class by adding a new method that returns all groups
def get_all_groups(self, only_ids=False):
"""
Returns all groups the user is member of AND all descendants groups of those
groups.
"""
direct_groups = self.groups.all()
groups = set()
for group in direct_groups:
descendants = group.get_descendants(include_self=True).all()
for descendant in descendants:
if only_ids:
groups.add(descendant.id)
else:
groups.add(descendant)
return groups
User.add_to_class('get_all_groups', get_all_groups)
from datetime import date
from django.db.models.functions import TruncMonth
from django.db import models
from django.contrib.auth.models import User
from django.db.models import Count
from django.shortcuts import get_object_or_404
from portal.emails import RegistraOcorrenciaMail, RegistraEncaminhamentoMail, RegistraAutorizacaoSaidaMail
def get_user_name(self):
return self.first_name + ' ' + self.last_name
User.add_to_class("__str__", get_user_name)
class Empresa(models.Model):
razao_social = models.CharField(max_length=255)
nome_fantasia = models.CharField(max_length=255)
cnpj = models.CharField(max_length=18, null=True, blank=True)
ie = models.CharField(max_length=45, null=True, blank=True)
im = models.CharField(max_length=45, null=True, blank=True)
endereco = models.CharField(max_length=255, null=True, blank=True)
bairro = models.CharField(max_length=255, null=True, blank=True)
cep = models.CharField(max_length=10, null=True, blank=True)
cidade = models.CharField(max_length=150, null=True, blank=True)
uf = models.CharField(max_length=2, null=True, blank=True)
fone = models.CharField(max_length=13, null=True, blank=True)
email = models.CharField(max_length=50, null=True, blank=True)
from django.db import models
from django.contrib.auth.models import User
from datetime import datetime
from django.utils import timezone
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
import time
# add as_dict mthod to User
def user_as_dict(self):
return dict(id=self.id, username=self.username, photo=reverse('get_user_photo', kwargs={'id':self.id}))
User.add_to_class("as_dict",user_as_dict)
class Itinerary(models.Model):
created_by = models.ForeignKey(User, related_name="itineraries")
title = models.CharField(max_length=100)
description = models.CharField(max_length=3000, blank=True)
place_id = models.CharField(max_length=100, blank=True)
place_lat = models.CharField(max_length=100, blank=True)
place_lng = models.CharField(max_length=100, blank=True)
place_name = models.CharField(max_length=100, blank=True)
start_date = models.DateField()
end_date = models.DateField()
participants = models.ManyToManyField(User, blank=True)
photo = models.FileField(upload_to="pictures", blank=True)
timestamp = models.DateTimeField(auto_now=True)
def as_dict(self):
return dict(
id=self.id,
created_by=self.created_by.as_dict(),
))
def google_authenticated(self):
try:
self.user.social_auth.get(provider='google-oauth2')
return True
except UserSocialAuth.DoesNotExist:
return False
def _user_meta(self, organization=None):
return UserMeta.objects.get_or_create(
user=self, defaults={'organization': organization})[0]
User.add_to_class('bom_profile', _user_meta)
class PartClass(models.Model):
code = models.CharField(max_length=3, unique=True)
name = models.CharField(max_length=255, default=None)
comment = models.CharField(max_length=255, default=None, blank=True)
def __str__(self):
return u'%s' % (self.code + ': ' + self.name)
class Manufacturer(models.Model):
name = models.CharField(max_length=128, default=None)
organization = models.ForeignKey(Organization, on_delete=models.CASCADE)
from django.core.urlresolvers import reverse
from django.db import models
from django.db.models import Max
from django.utils.translation import ugettext_lazy as _lazy
from oneanddone.tasks.models import TaskAttempt
# User class extensions
def user_unicode(self):
"""
Change user string representation to use the user's email address.
"""
return u'{name} ({email})'.format(
name=self.display_name or u'Anonymous', email=self.display_email)
User.add_to_class('__unicode__', user_unicode)
@property
def user_display_email(self):
"""
If a user has not consented to receive emails
return 'Email consent denied'.
"""
no_consent_email = 'Email consent denied'
try:
if self.profile.consent_to_email:
return self.email
except UserProfile.DoesNotExist:
return no_consent_email
return no_consent_email
return u'{name} <{email}>'.format(name=name, email=self.email)
def user_gravatar_url(self, size):
email = hashlib.md5(self.email.lower()).hexdigest()
data = {'s': str(size)}
if not settings.DEBUG:
append = '_big' if size > 44 else ''
data['d'] = settings.SITE_URL + static('img/anon' + append + '.jpg')
return '//www.gravatar.com/avatar/{email}?{data}'.format(
email=email, data=urllib.urlencode(data))
User.add_to_class('gravatar_url', user_gravatar_url)
User.add_to_class('display_name', user_display_name)
User.add_to_class('translated_locales', user_translated_locales)
User.add_to_class('translators', UserTranslationsManager())
class UserProfile(models.Model):
# This field is required.
user = models.OneToOneField(User, related_name='profile')
# Other fields here
quality_checks = models.BooleanField(default=True)
force_suggestions = models.BooleanField(default=False)
def validate_cldr(value):
}
else:
return _("No trial")
# add User.get_subscription() method
def __user_get_subscription(user):
if not hasattr(user, '_subscription_cache'):
sl = Subscription.objects.filter(group__in=user.groups.all())[:1]
if sl:
user._subscription_cache = sl[0]
else:
user._subscription_cache = None
return user._subscription_cache
User.add_to_class('get_subscription', __user_get_subscription)
class ActiveUSManager(models.Manager):
"""Custom Manager for UserSubscription that returns only live US objects."""
def get_query_set(self):
return super(ActiveUSManager, self).get_query_set().filter(active=True)
class UserSubscription(models.Model):
user = models.ForeignKey(User)
subscription = models.ForeignKey(Subscription)
expires = models.DateField(null=True, default=datetime.date.today)
active = models.BooleanField(default=True)
cancelled = models.BooleanField(default=True)
def _new_handle_m2m_field(self, obj, field):
try:
field.rel.through._meta
except AttributeError:
return
return _original_handle_m2m_field(self, obj, field)
_PythonSerializer.handle_m2m_field = _new_handle_m2m_field
# Add custom methods to User model for permissions checks.
from django.contrib.auth.models import User # noqa
from awx.main.access import * # noqa
User.add_to_class('get_queryset', get_user_queryset)
User.add_to_class('can_access', check_user_access)
User.add_to_class('can_access_with_errors', check_user_access_with_errors)
User.add_to_class('accessible_objects', user_accessible_objects)
User.add_to_class('admin_role', user_admin_role)
@property
def user_get_organizations(user):
return Organization.objects.filter(member_role__members=user)
@property
def user_get_admin_of_organizations(user):
return Organization.objects.filter(admin_role__members=user)
name = models.CharField(max_length=100)
access_method = models.IntegerField(choices=cconstants.ACCESS_METHOD,default=cconstants.ACCESS_METHOD_SSH)
access_login = models.CharField(max_length=50)
access_password = models.CharField(max_length=50)
access_ip = models.IPAddressField()
access_port = models.IntegerField(default=22)
class Meta:
verbose_name = 'Gateway'
verbose_name_plural = 'Gateways'
def __unicode__(self):
return self.name
User.add_to_class('gateways', models.ManyToManyField(Gateway,blank=True,null=True))
class User(User):
class Meta:
proxy = True
permissions = (
("can_list_gateways", "Can list gateways"),
)
class UserGateways(models.Model):
user = models.ForeignKey(User)
gateway = models.ForeignKey(Gateway)
class Meta:
db_table = 'auth_user_gateways'
def get_coin(self, coin):
try:
return self.coins.all().get(name__iexact=coin)
except Coin.DoesNotExist as e:
raise Http404("Invalid Coin")
def add_coin(self, coin):
try:
self.get_coin(coin)
except Http404 as e:
self.coins.create(name=coin, user=self)
User.add_to_class('get_coin', get_coin)
User.add_to_class('add_coin', add_coin)
"""
class JSONField(models.TextField):
def to_python(self, value):
if value == "":
return None
try:
if isinstance(value, str):
return json.loads(value)
except ValueError:
pass
return value
def from_db_value(self, value, *args):
#-*- coding: utf-8 -*-
from django.db import models
from event import Event
import datetime
#--------------------------------------------------------------------------------
# Extending a bit the User model
# compatible with bureau_manager
from django.contrib.auth.models import User
def user_is_readonly(self):
return bool(self.groups.filter(name='readonly').count())
User.add_to_class('is_readonly', user_is_readonly)
#---------------------------------------------------------------------------------
class Vclans(models.Model):
idvclan = models.CharField(max_length=255, blank=True)
idgruppo = models.CharField(verbose_name="ID gruppo", max_length=255, blank=True)
idunitagruppo = models.CharField(verbose_name="ID unità gruppo", max_length=255, blank=True)
# ordinale = models.CharField(max_length=255, blank=True)
nome = models.CharField(max_length=255, blank=True)
regione = models.CharField(max_length=255, blank=True)
updated_at = models.DateTimeField(blank=True, null=True, auto_now=True)
created_at = models.DateTimeField(blank=True, null=True, auto_now_add=True)
arrivato_al_campo = models.NullBooleanField(default=None)
# current max length of a tz is 30, going with 48 to be safe
timezone = models.CharField(max_length = 48, default = get_default_timezone)
def __unicode__(self):
return self.timezone
def get_timezone_for_user(self):
"""
Magic method that provides attribute like access to getting a users
timezone. Make sure to select_related on 'timezone'
Example:
my_user_object.tz
"""
if getattr(self, '_timezone', None):
return self._timezone
try:
tz = self.timezone
except TimezoneStore.DoesNotExist:
tz, created = TimezoneStore.objects.get_or_create(user = self)
# cache the timezone object for this user
self._timezone = tz.timezone
return tz.timezone
User.add_to_class('tz', property(get_timezone_for_user))
# implementing the desired features.
#
# TODO replace this with a proper subclass of the User class.
def user_unicode(self):
c = []
if self.last_name:
c.append(self.last_name)
if self.first_name:
c.append(self.first_name)
if c:
return ', '.join(c)
else:
return self.username
User.add_to_class('__unicode__', user_unicode)
def user_fullname(self):
c = []
if self.first_name:
c.append(self.first_name)
if self.last_name:
c.append(self.last_name)
if c:
return ' '.join(c)
else:
return self.username
User.add_to_class('fullname', user_fullname)
def public_name(self):
"""represents the name in following format: Ali K."""
if self.first_name and self.last_name:
return "%s %s." % (self.first_name, self.last_name[0])
if self.first_name and not self.last_name:
return self.first_name
if self.last_name and not self.first_name:
return self.last_name
if not self.first_name and not self.last_name:
return self.username
User.add_to_class('public_name', public_name)
class Route(models.Model):
"""
The route defines the start and arrival destinations in coordinates
"""
start_latitude = models.FloatField(_("Start Latitude"), help_text=_("Start location's latitude (departure) in decimal degrees (ex: 40.990033)."))
start_longitude = models.FloatField(_("Start Longitude"), help_text=_("Start location's longitude (departure) in decimal degrees (ex: 29.0424)."))
start_radius = models.FloatField(_("Start Radius"), default=4, help_text=_("The radius of the circle around departure point"))
start_address = models.CharField(_("Start Address"), max_length=255, blank=True, help_text=_("Human readable address for start location"))
end_latitude = models.FloatField(_("End Latitude"), help_text=_("End location's latitude (arrival) in decimal degrees (ex: 40.990033)."))
end_longitude = models.FloatField(_("End Longitude"), help_text=_("End location's longitude (arrival) in decimal degrees (ex: 29.0424)."))
end_radius = models.FloatField(_("End Radius"), default=4, help_text=_("The radius of the circle around arrival point (in km)"))
end_address = models.CharField(_("End Address"), max_length=255, blank=True, help_text=_("Human readable address for destination location"))
from django.db import models
from django.contrib.auth.models import User
def get_common_name(self):
return "%s %s" % (
self.first_name, self.last_name
) if self.first_name and self.last_name else self.username
User.add_to_class("__str__", get_common_name)
from django.contrib.auth.models import User
from core.models import (SkillRating, SpecializationAssign,
SkillAssign)
from course.models import CourseRating, SectionAssign
# Adding functions to User class
def user_institute(self):
return '<a href="/admin/core/institute/%s/" target="_blank">%s</a>' % (self.get_profile().institute.id, self.get_profile().institute)
user_institute.allow_tags = True
user_institute.short_description = 'Institute'
User.add_to_class('user_institute', user_institute)
def add_specialization(self, specialization):
assign = SpecializationAssign()
assign.specialization = specialization
assign.user = self
assign.save()
User.add_to_class('add_specialization', add_specialization)
def has_specialization(self, specialization):
return SpecializationAssign.objects.filter(specialization=specialization, user=self).count() > 0
User.add_to_class('has_specialization', has_specialization)
def add_skill(self, skill):
assign = SkillAssign()
assign.skill = skill
types = (
('SENT', 'Sent'),
('REC', 'Received'),
('USER', 'User'),
('OBL', 'Oblivious'),
)
type = models.CharField(max_length=4, choices=types)
email = models.EmailField(blank=True, max_length=75)
date = models.DateField(auto_now_add=True)
class AddressLog(models.Model):
reasons = (('SPAM', 'Spam'), ('NREG', 'Not Registered'))
email = models.EmailField(max_length=75)
reason = models.CharField(max_length=4, choices=reasons)
attempt = models.IntegerField()
date = models.DateTimeField(auto_now_add=True)
class ImportLog(models.Model):
date = models.DateTimeField(auto_now=True)
def get_account(self):
return self.userprofile.account
User.add_to_class('get_account', get_account)
class Subscribe(models.Model):
user_from = models.ForeignKey(User,
related_name='rel_from_set',
related_query_name='rel_from_set',
on_delete=models.CASCADE)
user_to = models.ForeignKey(User,
related_name='rel_to_set',
related_query_name='rel_to_set',
on_delete=models.CASCADE)
created = models.DateTimeField(auto_now_add=True, db_index=True)
class Meta:
ordering = ('-created',)
def __str__(self):
return '{} follows {}'.format(self.user_from, self.user_to)
User.add_to_class('photos',
models.ManyToManyField(Photo,
through=PhotoUser,
related_name='owners',
related_query_name='owners',
blank=True, ))
User.add_to_class('following',
models.ManyToManyField(User,
through=Subscribe,
related_name='followers',
symmetrical=False))
.annotate(translations_count=translations_count(),
translations_approved_count=translations_count(Q(translation__approved=True)),
translations_unapproved_count=translations_count(Q(translation__approved=False, translation__fuzzy=False)),
translations_needs_work_count=translations_count(Q(translation__fuzzy=True)))
.exclude(translations_count=0)
.distinct().order_by('-translations_count')[:limit]
)
# User class extensions
@property
def user_display_name(self):
name = self.first_name or self.email.split('@')[0]
return u'{name} <{email}>'.format(name=name, email=self.email)
User.add_to_class('display_name', user_display_name)
User.add_to_class('translators', UserTranslationsManager())
def user_gravatar_url(self, size):
email = hashlib.md5(self.email.lower()).hexdigest()
data = {'s': str(size)}
if not settings.DEBUG:
append = '_big' if size > 44 else ''
data['d'] = settings.SITE_URL + static('img/anon' + append + '.jpg')
return '//www.gravatar.com/avatar/{email}?{data}'.format(
email=email, data=urllib.urlencode(data))
User.add_to_class('gravatar_url', user_gravatar_url)
return False
def user_get_q_sel_email_feed_frequency(self):
#print 'looking for frequency for user %s' % self
try:
feed_setting = EmailFeedSetting.objects.get(subscriber=self,
feed_type='q_sel')
except Exception, e:
#print 'have error %s' % e.message
raise e
#print 'have freq=%s' % feed_setting.frequency
return feed_setting.frequency
User.add_to_class('is_approved', models.BooleanField(default=False))
User.add_to_class('email_isvalid', models.BooleanField(default=False))
User.add_to_class('email_key', models.CharField(max_length=32, null=True))
User.add_to_class('reputation', models.PositiveIntegerField(default=1))
User.add_to_class('gravatar', models.CharField(max_length=32))
User.add_to_class(
'favorite_questions',
models.ManyToManyField(Question,
through=FavoriteQuestion,
related_name='favorited_by'))
User.add_to_class(
'badges',
models.ManyToManyField(Badge, through=Award, related_name='awarded_to'))
User.add_to_class('gold', models.SmallIntegerField(default=0))
User.add_to_class('silver', models.SmallIntegerField(default=0))
User.add_to_class('bronze', models.SmallIntegerField(default=0))
user_vote.set_rate(rate)
user_vote.save()
return user_vote
except Vote.DoesNotExist:
new_user_vote = Vote(voted_question=question, user=user)
new_user_vote.set_rate(rate)
new_user_vote.save()
return new_user_vote
def vote_answer(user, answer, rate):
try:
user_vote = user.vote_set.get(voted_answer=answer)
except Vote.DoesNotExist:
new_user_vote = Vote(voted_answer=answer, user=user)
new_user_vote.set_rate(rate)
new_user_vote.save()
return new_user_vote
if user_vote.rate == rate:
user_vote.delete()
return None
else:
user_vote.set_rate(rate)
user_vote.save()
return user_vote
User.add_to_class('vote_question', vote_question)
User.add_to_class('vote_answer', vote_answer)
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.contrib.auth.models import User
from django.db import models
from django.utils import timezone
User.add_to_class('mobile_no', models.CharField(max_length=13, default=None, blank=False, unique=True))
User.add_to_class('qualification', models.CharField(max_length=400, default=None))
User.add_to_class('address', models.TextField(max_length=500, blank=True))
User.add_to_class('mobile_verified', models.BooleanField(default=False))
User.add_to_class('finalized', models.BooleanField(default=False))
User.add_to_class('profile_pic', models.CharField(max_length=400, default="/BeingMomin/media/images/profiles/default_profile.jpg"))
class locality_mapping(models.Model):
id = models.AutoField(auto_created=True, primary_key=True)
user = models.ForeignKey(User)
locality_key = models.CharField(max_length=400)
tahsil = models.CharField(max_length=400)
district = models.CharField(max_length=400)
state = models.CharField(max_length=400)
class Meta(object):
db_table = 'AmbassadorPortal_locality_mapping'
class people(models.Model):
id = models.AutoField(auto_created=True, primary_key=True)
name = models.CharField(max_length=300, default="")
COUNTRIES = product_details.get_regions(settings.LANGUAGE_CODE).items()
COUNTRIES.append(('', '---')) # Empty choice
SHA1_RE = re.compile('^[a-f0-9]{40}$')
ACTIVATION_EMAIL_SUBJECT = _lazy('Please activate your Firefox Affiliates '
'account')
# Extra User Methods
def has_created_badges(self):
"""Return whether a user has created a badge or not. Bypasses cache."""
badge_count = BadgeInstance.objects.no_cache().filter(user=self).count()
return badge_count > 0
User.add_to_class('has_created_badges', has_created_badges)
def get_linked_account(self):
"""
Return the FacebookUser linked with this account, or None if no account has
been linked.
"""
return get_object_or_none(FacebookUser, _account_link__affiliates_user=self,
_account_link__is_active=True)
User.add_to_class('get_linked_account', get_linked_account)
@receiver(models.signals.post_save, sender=User)
def add_default_permissions(sender, **kwargs):
"""Add default set of permissions to users when they are first created."""
from django.db import models
from django.conf import settings
from django.contrib.auth.models import User
class Profile(models.Model):
user = models.OneToOneField(settings.AUTH_USER_MODEL) # AUTH_USER_MODEL = 'auth.User'
date_of_birth = models.DateField(blank=True, null=True)
photo = models.ImageField(upload_to='users/%Y/%m/%d', blank=True)
def __str__(self):
return 'Profile for user {}'.format(self.user.username)
class Contact(models.Model):
user_from = models.ForeignKey(User, related_name='rel_from_set')
user_to = models.ForeignKey(User, related_name='rel_to_set')
created = models.DateTimeField(auto_now_add=True, db_index=True)
class Meta:
ordering = ('-created',)
def __str__(self):
return '{} follows {}'.format(self.user_from, self.user_to)
# 给User模型动态增加一个字段 following：我关注了哪些人。 followers：哪些人关注了我
User.add_to_class('following', models.ManyToManyField('self', # 这里是填另一个模型的名称，因为例子是用户与用户的关系，因此用self即可
through=Contact,
related_name='followers',
symmetrical=False)) # 非对称：“甲关注乙，乙不会自动关注甲”
from django.db import models
from django.contrib.auth.models import User
#Agregamos dos campos mas al modelo User que viene por defecto en Django.
User.add_to_class('direccion', models.CharField(null=True,blank=True, max_length=500))
User.add_to_class('telefono', models.PositiveIntegerField(null=True,blank=True))
User.add_to_class('estado_login',models.BooleanField(default=False))
class PerfilUsuario(models.Model):
TIPO=(
('operario','operario'),
('supervisor','supervisor'),
)
tipo = models.CharField(max_length=20,choices=TIPO)
fecha_registro = models.DateField(auto_now=True)
fecha_caducidad = models.DateField()
estado = models.BooleanField()
online = models.BooleanField()
usuario =models.ForeignKey(User)
def __unicode__(self):
return '%s y %s' %(self.usuario,self.tipo)
def patch_user_class():
"""access biz_type, introduced_by and postcode through prefixing 'md_' e.g user.md_biz_type.
"""
from apps.plus_groups.models import TgGroup, User_Group
User._meta.db_table = 'tg_user'
# Patching the User class
User.add_to_class('__getattr__', __getattr__)
User.add_to_class('__setattr__', __setattr__)
# EXPERIMENT ... make username alias of user_name
User.add_to_class('user_name', UserNameField(unique=True, max_length=255))
#User.add_to_class('user_name',models.CharField(max_length=255,unique=True))
#del User.username
#User.add_to_class('username',AliasOf('user_name'))
# EXPERIMENT END
User.add_to_class('email_address',
models.CharField(max_length=255, unique=True))
#remove the existing django groups relation
gr = User._meta.get_field('groups')
User._meta.local_many_to_many.remove(gr)
del User.groups
# add ours new relation for groups
User.add_to_class(
'groups',
models.ManyToManyField(TgGroup,
through=User_Group,
related_name='users'))
User.add_to_class('description', models.TextField())
User.add_to_class('organisation', models.CharField(max_length=255))
User.add_to_class('title', models.CharField(max_length=255, null=True))
User.add_to_class('mobile', models.CharField(max_length=30))
User.add_to_class('work', models.CharField(max_length=30))
User.add_to_class('home', models.CharField(max_length=30))
User.add_to_class('fax', models.CharField(max_length=30))
User.add_to_class('place', models.CharField(max_length=150, null=True))
User.add_to_class('created',
models.DateTimeField(default=datetime.datetime.now))
User.add_to_class('email2', models.CharField(max_length=255))
User.add_to_class('email3', models.CharField(max_length=255))
User.add_to_class('skype_id', models.TextField())
User.add_to_class('sip_id', models.TextField())
User.add_to_class('website', models.TextField())
User.add_to_class('homeplace', models.ForeignKey(Location, null=True))
User.add_to_class('address', models.TextField())
User.add_to_class('country',
models.CharField(null=True, default="", max_length=2))
User.add_to_class(
'homehub', models.ForeignKey("plus_groups.TgGroup", null=True)
) # we need this for PSN, XXX need to decide how to make it compatible with hubspace for hub+
User.add_to_class('psn_id', models.CharField(max_length=50, null=True))
User.add_to_class(
'psn_password_hmac_key', models.CharField(max_length=50, null=True)
) #this is just for the bizare hmacing of psn passwords by a field formly known as "fullname"
User.add_to_class('cc_messages_to_email', models.BooleanField(
default=False)) # internal messages get reflected to email
User.add_to_class('has_avatar', models.BooleanField(default=False))
User.email = AliasOf('email_address')
if settings.PROJECT_THEME == 'plus':
User.post_or_zip = AliasOf('md_postcode')
User.add_to_class(
'public_field', models.SmallIntegerField(null=True)
) # this will be phased out as it is redundant with the new permissions system
else:
User.add_to_class(
'post_or_zip',
models.CharField(null=True, default="", max_length=30))
User.is_active = AliasOf(
'active'
) # This takes precedence over the existing is_active field in django.contrib.auth.models
User.add_to_class(
'active', models.SmallIntegerField(null=True)
) # not currently shown, however setting this to 0 will stop the user logging in
#User.add_to_class('image', models.CharField(null=True, default="", max_length= XXXX)
User.set_password = set_password
User.check_password = check_password
User.is_member_of = is_member_of
User.is_direct_member_of = is_direct_member_of
User.get_enclosures = get_enclosures
User.get_enclosure_set = get_enclosure_set
User.is_group = lambda (self): False
User.is_user = lambda (self): True
User.save = user_save
User.post_save = post_save
User.is_admin_of = lambda self, group: self.is_member_of(group.
get_admin_group())
def is_site_admin(self):
from apps.plus_permissions.default_agents import get_all_members_group
return self.is_admin_of(get_all_members_group())
User.is_site_admin = is_site_admin
def send_tweet(self, msg):
from apps.microblogging.models import send_tweet
return send_tweet(self, msg)
User.send_tweet = send_tweet
def message(self, sender, subject, body, message_extra=""):
if not self.active:
return # don't send messages to inactive members
from messages.models import Message
from django.core.mail import send_mail
from django.core.urlresolvers import reverse
from django.utils.translation import ugettext_lazy as _, ugettext
m = Message(subject=subject, body=body, sender=sender, recipient=self)
m.save()
if self.cc_messages_to_email:
# recipient wants emails cc-ed
link = 'http://' + settings.DOMAIN_NAME + reverse('messages_all')
settings_link = 'http://' + settings.DOMAIN_NAME + reverse(
'acct_settings')
main = _("""
%(sender)s has sent you a new message on %(account_name)s .
---------------------------------------------------------------
%(body)s
---------------------------------------------------------------
Click %(link)s to see your account.
If you do not want to receive emails when you receive messages on %(account_name)s, please change your settings here : %(settings_link)s
%(message_extra)s
""") % {
'account_name': settings.SITE_NAME,
'body': body,
'link': link,
'sender': sender.get_display_name(),
'settings_link': settings_link,
"message_extra": message_extra
}
self.email_user(subject, main, settings.SERVER_EMAIL)
return m
User.message = message
def group_invite_message(self,
group,
invited_by,
accept_url,
special_message=''):
self.message(
invited_by,
Template(settings.GROUP_INVITE_SUBJECT_TEMPLATE).render(
Context({'group_name': group.get_display_name()})),
Template(settings.GROUP_INVITE_TEMPLATE).render(
Context({
'first_name': self.first_name,
'last_name': self.last_name,
'sponsor': invited_by.get_display_name(),
'group_name': group.get_display_name(),
'site_name': settings.SITE_NAME,
'special_message': special_message,
'signup_link': accept_url,
})) + """
%s""" % accept_url)
User.group_invite_message = group_invite_message
User.hubs = lambda self: self.groups.filter(
group_type=settings.GROUP_HUB_TYPE, level='member')
User.change_avatar = lambda self: True
def is_following(self, other_user):
from apps.microblogging.models import Following
return Following.objects.is_following(self, other_user)
User.is_following = is_following
def is_followed_by(self, other_user):
from apps.microblogging.models import Following
return Following.objects.is_following(other_user, self)
User.is_followed_by = is_followed_by
AnonymousUser.is_member_of = lambda *args, **kwargs: False
AnonymousUser.is_direct_member_of = lambda *args, **kwarg: False
logo = models.ImageField(upload_to='media/logos', null=True, blank=True)
web = models.URLField(max_length=25, null=True, blank=True)
email = models.EmailField(max_length=25, null=True, blank=True)
class Meta:
verbose_name_plural = "sucursales"
class Bodega(Entidad):
sucursal = models.ForeignKey(Sucursal, null=True)
class Meta:
ordering = ['name', ]
User.add_to_class('sucursal', models.ForeignKey(Sucursal, null=True))
class Marca(Entidad):
pass
class Categoria(Entidad):
pass
class Producto(Entidad):
no_parte = models.CharField(max_length=25, null=True, blank=True,
verbose_name="numero de parte")
medida = models.CharField(max_length=25, null=True, blank=True)
modelo = models.CharField(max_length=60, null=True, blank=True)
import logging
stdlogger = logging.getLogger(__name__)
dbalogger = logging.getLogger('dba')
def log_create(obj):
dbalogger.info('{} was created: {}'.format(obj.__class__.__name__,
obj.__str__()))
def get_user_info(self):
return self.first_name + ' ' + self.last_name + ' (username='******')'
User.add_to_class("__str__", get_user_info)
# Singleton class
class SingletonModel(models.Model):
class Meta:
abstract = True
def set_cache(self):
cache.set(self.__class__.__name__, self)
def save(self, *args, **kwargs):
self.pk = 1
super(SingletonModel, self).save(*args, **kwargs)
self.set_cache()
POLARITY_CHOICES = (
(u"NNE", u"very negative"),
(u"NEG", u"negative"),
(u"NEU", u"neuter"),
(u"POS", u"positive"),
(u"PPO", u"very positive"),
)
POS_CHOICES = ((u"NP", u"Noun phrase"), (u"?", u"not defined"))
# user json function
def user_json(user):
return {"id": user.id, "username": user.username}
User.add_to_class("json", user_json)
# Create your models here.
# from many database to just one. just a test.
class Corpus(models.Model):
# the corpus of document. A user may have a lot of corpora
name = models.CharField(max_length=32, unique=True)
owner = models.ManyToManyField(User, through="Owners", null=True, blank=True)
def __unicode__(self):
return self.name
def json(self):
return {"id": self.id, "name": self.name}
:atrb: phone Nurse's phone number
:atrb: email Nurse's e-mail address
"""
def user_data(self):
if hasattr(self, 'patient'): return self.patient
if hasattr(self, 'doctor'): return self.doctor
if hasattr(self,'nurse'): return self.nurse
else:return "invalid_user"
def user_type(self):
if hasattr(self, 'patient'): return 'patient'
if hasattr(self, 'doctor'): return 'doctor'
if hasattr(self,'nurse'): return 'nurse'
else: return "invalid_user"
User.add_to_class('user_data',user_data)
User.add_to_class('user_type',user_type)
class Nurse(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE, default=None)
username = models.CharField(max_length=50, default="")
first_name = models.CharField(max_length=50, default='')
last_name = models.CharField(max_length=50, default='')
email = models.CharField (max_length = 100, default = '')
phone = models.CharField (max_length = 10 , default = '')
hospital = models.ForeignKey(Hospital,on_delete = models.CASCADE, default = None)
def createNurse(user_form,nurse_form,user):
credential = User.objects.create_user(
username = user_form['username'],
email = user_form['email'],
from django.contrib.auth.models import User
# User class extensions
def user_unicode(self):
"""Use email address for string representation of user."""
return self.email
User.add_to_class('__unicode__', user_unicode)
if not nickname:
return ""
first_letter_str = pypinyin.lazy_pinyin(self.get_nickname(),
pypinyin.FIRST_LETTER)[0]
first_letter = first_letter_str[0]
if not first_letter.isalpha():
return "#"
return first_letter
def __str__(self):
return "uid: %s" % self.user_id
class CoachMemberRef(models.Model):
member = models.ForeignKey(Member)
coach = models.ForeignKey(Coach)
primary = models.BooleanField("主教练", default=False)
class Meta:
db_table = "member_coach"
unique_together = ("member", "coach")
verbose_name = "学员教练关联"
verbose_name_plural = "学员教练关联"
def get_str_render(self):
return "%s-%s" % (self.id, self.username)
User.add_to_class("__str__", get_str_render)
from django.db import models
from django.contrib.auth.models import User
from ..ak import instrument_choices
from django.utils.translation import ugettext_lazy as _
User.__unicode__ = lambda self: u"%s %s" % (self.first_name, self.last_name)
next(field for field in User._meta.fields if field.name == "first_name").blank = False
next(field for field in User._meta.fields if field.name == "last_name").blank = False
next(field for field in User._meta.fields if field.name == "email").blank = False
User.add_to_class("address", models.CharField(_("address"), max_length=128, blank=True, null=True))
User.add_to_class("zip", models.CharField(_("zip"), max_length=5, blank=True, null=True))
User.add_to_class("city", models.CharField(_("city"), max_length=128, blank=True, null=True))
User.add_to_class("phone", models.CharField(_("phone"), max_length=16, blank=True, null=True))
User.add_to_class("second_phone", models.CharField(_("second phone"), max_length=16, blank=True, null=True))
User.add_to_class("nation", models.CharField(_("nation"), max_length=128, blank=True, null=True))
User.add_to_class("instrument", models.CharField(_("instrument"), max_length=2, choices=instrument_choices))
User.add_to_class("has_key", models.BooleanField(_("has key"), default=False))
User.add_to_class("medals_earned", models.IntegerField(_("medals earned"), default=0))
User.add_to_class("medals_awarded", models.IntegerField(_("medals awarded"), default=0))
from django.db import models
from django.urls import reverse
from django.contrib.auth.models import User
from pmanager.models import Leaders
from datetime import datetime
def get_first_name(self):
return self.first_name
User.add_to_class("__str__", get_first_name)
#ForeignKey(User, null=True, on_delete=models.SET_NULL)
class Initi(models.Model):
mub_name = models.CharField(max_length=250)
leader = models.ForeignKey(User, models.SET_NULL, blank=True, null=True)
def get_absolute_url(self):
return reverse('initiatives:reports', kwargs={'pk': self.pk})
def __str__(self):
return self.mub_name
class Goals(models.Model):
goal = models.CharField(max_length=500)
mub = models.ForeignKey(Initi, on_delete=models.CASCADE)
def __str__(self):
def __cmp__(self, other):
return cmp(self.name, other.name)
def create_user_profile(sender, instance, created, **kwargs):
if created:
UserProfile.objects.create(user=instance)
post_save.connect(create_user_profile, sender=User)
@classmethod
def user_create(cls, **kwargs):
user = User()
for k, v in kwargs.iteritems():
if k == 'password':
user.set_password(v)
else:
setattr(user, k, v)
user.save()
for k, v in kwargs.iteritems():
setattr(user.profile, k, v)
user.profile.save()
return user
User.add_to_class('create', user_create)
brand_logo_img = models.ImageField(upload_to='config_images',
null=True,
blank=True)
header_background_img = models.ImageField(upload_to='config_images',
null=True,
blank=True)
log_in_img = models.ImageField(upload_to='config_images',
null=True,
blank=True)
sign_up_img = models.ImageField(upload_to='config_images',
null=True,
blank=True)
change_password_img = models.ImageField(upload_to='config_images',
null=True,
blank=True)
reset_password_img = models.ImageField(upload_to='config_images',
null=True,
blank=True)
successful_sign_up_msg = models.TextField(
default='Thank you for signing up!')
acceptable_use_policy = models.TextField()
def get_full_name(self):
return self.first_name + " " + self.last_name
User.add_to_class("__str__", get_full_name)
class UserProfile(models.Model):
"""A user profile."""
user = models.OneToOneField(User)
twitter = models.CharField(u'Twitter Benutzername', max_length=24, blank=True)
flattr = models.CharField(u'Flattr Benutzername', max_length=128, blank=True,
help_text=mark_safe(u'Falls angegeben, wird bei deinen \
Zusammenfassungen jeweils ein \
<a href="https://flattr.com/">Flattr</a> Button angezeigt.'))
def __unicode__(self):
return u'Profile for %s' % self.user.username
User.profile = property(lambda u: UserProfile.objects.get_or_create(user=u)[0])
def name(self):
"""Return either full user first and last name or the username, if no
further data is found."""
if self.first_name or self.last_name:
return ' '.join(filter(None, [self.first_name, self.last_name]))
return self.username
User.add_to_class('name', name)
def create_user_profile(sender, instance, created, **kwargs):
if created:
UserProfile.objects.create(user=instance)
post_save.connect(create_user_profile, sender=User)
books = Book.objects.filter(quote__user=self).annotate(
updated_at=Max('quote__updated_at')).order_by('-updated_at')
return books
def get_user_profile_picture_url(user):
if user.is_authenticated():
profile_picture_url = "https://graph.facebook.com/{0}/picture".format(
user.social_auth.get().uid)
else:
profile_picture_url = ""
return profile_picture_url
User.add_to_class("recent_books", recent_books)
class Quote(models.Model):
quotation = models.TextField(max_length=1000)
photo = models.ImageField(upload_to='bookshot')
user = models.ForeignKey(User)
book = models.ForeignKey('Book', null=True, blank=True, default=None)
created_at = models.DateTimeField(null=True, default=None)
updated_at = models.DateTimeField(null=True, default=None)
def read_text_from_image(self, crop_rect, cropped_filepath=None):
if not cropped_filepath:
ts = int(timezone.now().timestamp())
from django.db import models
from django.db.models.signals import post_save
from django.contrib.auth.models import User
from django.utils.translation import ugettext_lazy as _
from taggit.managers import TaggableManager
import actstream.models
from actstream import actions
User.add_to_class('following', lambda self: actstream.models.following(self)[::-1])
User.add_to_class('followers', lambda self: actstream.models.followers(self)[::-1])
User.add_to_class('action_list', lambda self: actstream.models.actor_stream(self))
@property
def created_at(self):
return self.date_joined
User.add_to_class('created_at', created_at)
class UserProfile(models.Model):
user = models.OneToOneField(User)
realname = models.CharField(null=True, max_length=20, verbose_name=_("name"), help_text=_("how you want your name on RedPanal?") )
about = models.TextField(blank=True, null=True, verbose_name=_("about"), help_text=_("something about you"))
website = models.URLField(blank=True, null=True, verbose_name=_("website"), help_text=_("your website"))
location = models.CharField(blank=True, null=True, max_length=50, verbose_name=_("location"), help_text=_("where do you live"))
tags = TaggableManager(blank=True)
def get_absolute_url(self):
return self.user.get_absolute_url()
def __unicode__(self):
photo = models.ImageField(upload_to='users/%Y/%m/%d', blank=True)
def __str__(self):
return 'Profile for user {}'.format(self.user.first_name)
class Contact(models.Model):
user_from = models.ForeignKey('auth.User',
related_name='rel_from_set',
on_delete=models.CASCADE)
user_to = models.ForeignKey('auth.User',
related_name='rel_to_set',
on_delete=models.CASCADE)
created = models.DateTimeField(auto_now_add=True, db_index=True)
class Meta:
ordering = ('-created', )
def __str__(self):
return '{} follows {}'.format(self.user_from, self.user_to)
User.add_to_class(
'following',
models.ManyToManyField('self',
through=Contact,
related_name='followers',
symmetrical=False))
# Create your models here.
from django.conf import settings
from django.contrib.auth.models import User
class Profile(models.Model):
user = models.OneToOneField(settings.AUTH_USER_MODEL)
date_of_birth = models.DateField(blank=True,null=True)
photo = models.ImageField(upload_to='users/%Y/%m/%d',blank=True)
def __str__(self):
return 'Profile for user {}'.format(self.user.username)
class Contact(models.Model):
user_from = models.ForeignKey(User, related_name='rel_from_set')
user_to = models.ForeignKey(User, related_name='rel_to_set')
created = models.DateTimeField(auto_now_add=True, db_index=True)
class Meta:
ordering = ('-created',)
def __str__(self):
return '{} follows {}'.format(self.user_from, self.user_to)
User.add_to_class('following',
models.ManyToManyField('self',
through=Contact,
related_name='followers',
symmetrical=False))
except:
response = {
'success': False,
'error_message': f'User with email {email} does not exist :('
}
raise InvalidUserException(response, status_code=status_codes.HTTP_400_BAD_REQUEST)
def get_user_by_email_or_none(email):
try:
return User.objects.get(email=email)
except:
return None
User.add_to_class("get_user_or_raise_exception", get_user_or_raise_exception)
User.add_to_class("get_user_or_none", get_user_or_none)
User.add_to_class("get_user_by_email_or_raise_exception", get_user_by_email_or_raise_exception)
User.add_to_class("get_user_by_email_or_none", get_user_by_email_or_none)
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
address = models.TextField(blank=True)
phone_no = models.BigIntegerField(null=False,
validators=[
validate_phone_no
])
city = models.CharField(max_length=100, blank=True)
state = models.CharField(max_length=100, blank=True)
country = models.CharField(max_length=100, blank=True)
