def setUp(self): self.start_dt = datetime.datetime.now() self.test_user_list = [] for i in xrange(100): random_delta = datetime.timedelta(seconds=random.randrange(1000)) random_dt = self.start_dt - random_delta user = User(team=random.choice(consts.TEAM_CHOICES), username=str(i), last_ping=random_dt) user.save() self.test_user_list.append(user) for team in consts.TEAM_CHOICES: UserManager.assign_player(team)
class User(Model): __tablename__ = 'User' fields = ('id', 'first_name', 'last_name', 'username') id = Column(Integer, primary_key=True) first_name = Column(String(70)) last_name = Column(String(70)) username = Column(String(35)) join_date = Column(DateTime, default=datetime.now()) objects = UserManager() def __init__(self, id, first_name, last_name, username): self.id = id self.first_name = first_name self.last_name = last_name self.username = username def get_fullname(self): fullname = None if self.first_name: fullname = self.first_name if fullname: if self.last_name: fullname += ' ' + self.last_name else: fullname = self.last_name return fullname
class User(AbstractBaseUser): """ User is the app`s user model """ name = models.CharField(_('Name'), max_length=150, db_index=True, unique=True) email = models.EmailField(_('Email'), max_length=255, db_index=True, unique=True) joined = models.DateTimeField(_('Joined'), auto_now_add=True) USERNAME_FIELD = 'email' REQUIRED_FIELDS = [ 'name', ] objects = UserManager() def __unicode__(self): return '%s - %s' % ( self.name, self.email, ) def get_full_name(self): return '%s' % self.name def get_short_name(self): return '%s' % self.name
class User(AbstractBaseUser, PermissionsMixin): email = models.EmailField(_('email address'), unique=True) first_name = models.CharField(_('first name'), max_length=30, blank=True) last_name = models.CharField(_('last name'), max_length=30, blank=True) date_joined = models.DateTimeField(_('date joined'), auto_now_add=True) is_acive = models.BooleanField(_('active'), default=True) avatar = models.ImageField(upload_to='avatars/', null=True, blank=True) objects = UserManager() USERNAME_FIELD = 'email' REQUIRED_FIELDS = [] class Meta: verbose_name = _('user') verbose_name_plural = _('users') def get_full_name(self): ''' Returns the first_name plus the last_name, with a space in between. ''' full_name = '%s %s' % (self.first_name, self.last_name) return full_name.strip() def get_short_name(self): ''' Returns the short name of the user. ''' return self.first_name def email_user(self, subject, message, from_email=None, **kwargs): ''' Sends an email to this User. ''' send_mail(subject, message, from_email, [self.email], **kwargs)
def nominate(self): if ServerManager.has_active_server(): return post_message( 'Someone else is already making tea, I\'ll save your nomination for later :smile:', self.channel) try: slack_id = MENTION_RE.search(self.command_body).groups()[0] except AttributeError: return post_message('You must nominate another user to brew!', self.channel) nominated_user = UserManager.get_by_slack_id(slack_id) if self.request_user.nomination_points < NOMINATION_POINTS_REQUIRED: return post_message( 'You can\'t nominate someone unless you brew tea %s times!' % NOMINATION_POINTS_REQUIRED, self.channel) # Subtract nomination points from request user. nominated_user.nomination_points -= NOMINATION_POINTS_REQUIRED server = Server(user_id=nominated_user.id) session.add(server) session.flush() session.add(Customer(user_id=self.request_user.id, server_id=server.id)) session.commit() brew_countdown.apply_async(countdown=BREW_COUNTDOWN, args=(self.channel, )) return post_message( '%s has nominated %s to make tea! Who wants in?' % (self.request_user.first_name, nominated_user.first_name), self.channel)
def create(self, validated_data): user, token = UserManager.create_user( email=validated_data['email'], password=validated_data['password'], group=validated_data['group'] ) request = self.context.get('request') if request and request.META.get('HTTP_ORIGIN'): link = request.META.get('HTTP_ORIGIN')+settings.DEFAULT_ACTIVATE_URL+str(token.code) send_token_email.delay(user.pk, link) return user
def stats(self): """ Get stats for user(s) - (# of teas drunk, # of teas brewed, # of times brewed, # of teas received) :param command_body: can either be empty (get stats for all users) or can reference a specific user """ try: slack_id = MENTION_RE.search(self.command_body).groups()[0] except AttributeError: slack_id = None if slack_id: users = [UserManager.get_by_slack_id(slack_id)] else: users = session.query(User).filter(User.tea_type.isnot(None)).all() results = [] for user in users: results.append({ 'real_name': user.real_name, 'teas_drunk': user.teas_drunk, 'teas_brewed': user.teas_brewed, 'times_brewed': user.times_brewed, 'teas_received': user.teas_received }) return post_message( '', self.channel, attachments=[{ "fallback": "Teabot Stats", "pretext": "", "author_name": "%s" % result['real_name'], "fields": [ { "value": "Number of tea cups consumed -> %(teas_drunk)s\nNumber of tea cups brewed -> %(teas_brewed)s\nNumber of times you've brewed tea -> %(times_brewed)s\nNumber of tea cups you were served -> %(teas_received)s" % result, "short": False }, ] } for result in results])
class User(AbstractBaseUser, PermissionsMixin): main_character_id = models.PositiveIntegerField(primary_key=True) email = models.EmailField(max_length=255, null=True, blank=True) is_staff = models.BooleanField(default=False) is_active = models.BooleanField(default=False) USERNAME_FIELD = 'main_character_id' REQUIRED_FIELDS = [] objects = UserManager() class Meta: verbose_name = 'user' verbose_name_plural = 'users' @property def main_character(self): if self.characters.filter(id=self.main_character_id).exists(): return self.characters.get(id=self.main_character_id) elif EVECharacter.objects.filter(id=self.main_character_id).exists(): logger.warn( "User with main character ID %s has detached main character model" % self.get_full_name()) return EVECharacter.objects.get(id=self.main_character_id) else: return None def get_full_name(self): return str(self.main_character_id) def get_short_name(self): if self.main_character: return str(self.main_character) else: return self.get_full_name() def __unicode__(self): if self.main_character: return str(self.main_character).encode('utf-8') else: logger.debug( "Missing character model for user with main character id %s, returning id as __unicode__." % self.main_character_id) return self.get_short_name().encode('utf-8')
class AbstractUser(AbstractBaseUser, PermissionsMixin): email = models.EmailField(_('Email address'), null=False, blank=False, unique=True) is_staff = models.BooleanField( _('Staff status'), default=False, help_text=_( 'Designates whether the user can log into this admin site.')) date_joined = models.DateTimeField(_('Date joined'), auto_now_add=True, editable=False) last_seen = models.DateTimeField(_('Last seen'), null=True, blank=True, editable=False) updated_at = models.DateTimeField(_('Updated at'), auto_now=True, editable=False) USERNAME_FIELD = 'email' objects = UserManager() class Meta: abstract = True ordering = [ '-id', ] def __str__(self): return force_bytes('%s' % self.email) def __unicode__(self): return u'%s' % self.email
def dispatch(self, event): self.channel = event[0].get('channel', '') text = event[0].get('text', '') try: slack_user_id, command, command_body = COMMAND_RE.search( text).groups() if slack_user_id != self.teabot.slack_id: return command = command.strip() self.command_body = command_body.strip() self.request_user = UserManager.get_by_slack_id(event[0].get( 'user', '')) if not self.request_user: return # Call the appropriate function getattr(self, command)() except AttributeError: regex = TEABOT_MENTION_RE.search(text) if regex and regex.groups()[0] == self.teabot.slack_id: post_message('No idea what that means mate.', self.channel)
class User(AbstractBaseUser, PermissionsMixin): """User model. Attributes: ADMIN (str): Description CHOISE_USER_TYPE (TYPE): Description created (Datetime): Description email (String): Email is unique in all project first_name (String): First name of user is_active (Boolean): If user is active last_name (String): Last name of user modified (Datetime): Modified datetime objects (Queryset): Queryse Django REQUIRED_FIELDS (tuple): Description USER (str): Description user_type (TYPE): Choice (ADMIN, USER). USERNAME_FIELD (str): Description Deleted Attributes: address (String): Address of user company (String): Company of user dni (String): DNI is unique in all project is_admin (Boolean): True if user permission to admin phone_number (String): Phone number of user postal_code (String): Postal code of user province (ForeignKey): Province FK town (ForeignKey): Town FK """ USER = '******' ADMIN = 'admin' MANAGER = 'manager' CHOISE_USER_TYPE = ( (USER, _('User')), (ADMIN, _('Admin')), (MANAGER, _('Manager')), ) REQUIRED_FIELDS = ('first_name', 'last_name') USERNAME_FIELD = 'email' user_type = models.CharField(max_length=7, blank=False, null=False, choices=CHOISE_USER_TYPE, verbose_name=_('Type')) email = models.EmailField(unique=True, verbose_name=_('Email')) first_name = models.CharField(max_length=50, verbose_name=_('First name')) last_name = models.CharField(max_length=50, verbose_name=_('Last name')) is_active = models.BooleanField(default=False, verbose_name=_('Is active')) role = models.ForeignKey('Role', null=True, blank=True, verbose_name=_('Role')) created = models.DateTimeField(auto_now_add=True, editable=False, verbose_name=_('Created')) modified = models.DateTimeField(auto_now=True, editable=False, verbose_name=_('Modified')) force_change_password = models.BooleanField(default=True) objects = UserManager() class Meta: """class. Attributes: db_table (str): Description verbose_name (TYPE): Description verbose_name_plural (TYPE): Description """ verbose_name = _('User') verbose_name_plural = _('Users') db_table = 'auth_user' @property def username(self): """Return username.""" return self.email @property def get_short_name(self): """Return short name.""" return self.email @property def is_staff(self): """Return staff.""" return self.is_admin @property def full_name(self): """Return full name.""" return self.get_full_name() @property def is_user(self): """Return user.""" return self.user_type == self.USER @property def is_admin(self): """Return admin.""" return self.user_type == self.ADMIN @property def is_super(self): """Return super.""" return self.user_type == self.ADMIN @property def is_manager(self): """Return manager.""" return self.user_type == self.MANAGER def get_full_name(self): """Full name of user. Returns: String: u'%s %s' % (self.first_name, self.last_name) """ return u'%s %s' % (self.first_name, self.last_name) @staticmethod def get_or_register(email, first_name, last_name, user_type): """Get or Register user. Args: email (str): Email of user first_name (str): First name last_name (str): Last name Returns: User: user """ password = uuid.uuid4().hex[:6].upper() user = None if not User.objects.filter(email=email).exists(): user = User.objects.create(email=email, first_name=first_name, last_name=last_name, user_type=user_type, is_active=True) user.set_password(password) user.save() else: user = User.objects.get(email=email) user.save() password = None return user, password
def player_is_valid(self): for team in consts.TEAM_CHOICES: self.assertEqual(UserManager.check_if_player_is_valid(team))
def test_get_player(self): for team in consts.TEAM_CHOICES: player = UserManager.get_player(team) self.assertEqual(player.is_player, True)
{ "value": "Number of tea cups consumed -> %(teas_drunk)s\nNumber of tea cups brewed -> %(teas_brewed)s\nNumber of times you've brewed tea -> %(times_brewed)s\nNumber of tea cups you were served -> %(teas_received)s" % result, "short": False }, ] } for result in results]) def register(self): if not self.command_body: return post_message( 'You didn\'t tell me what type of tea you like. Try typing `@teabot register green tea`', self.channel) message = 'Welcome to the tea party %s' % self.request_user.first_name if self.request_user.tea_type: message = 'I have updated your tea preference.' self.request_user.tea_type = self.command_body session.commit() return post_message(message, self.channel) def yo(self): return post_message('Sup?', self.channel) if __name__ == '__main__': Listener(UserManager.get_by_username('teabot')).listen()