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()