def create(cls, user, email, obj, role=APP_ROLE_READ):
"""
Invites a user to an object.
Params are supposed to be:
user invites email to obj with role
This will find the user if he already exists.
"""
cls._setup_lookups()
if role not in APP_ROLES:
raise ex.AppException('Check your role(%s) param' % (type, role), ex.INVALID)
if not obj or not user or type(obj).__name__ not in cls.put_types:
raise ex.AppException('Check your user and org params. They must not be None.' % (type, role), ex.INVALID)
type_ = cls.put_types[type(obj).__name__].strip()
invited = Session.query(User).filter_by(email=email).first()
invites = Session.query(Invite).filter_by(invited_email=email, object_id=obj.id, type=type_)
invites = invites.filter(Invite.status.in_([STATUS_APPROVED, STATUS_PENDING])).first()
if (invited and obj.get_role(invited)) or invites:
raise ex.AppException('User has already been added to this %s' % type(obj).__name__, ex.DUPLICATE)
inv = Invite(role=role, type=type_, invited_email=email,
user=user, invited_user=invited,
object_id=obj.id, status=STATUS_PENDING)
Session.flush()
Session.add(activity.InviteEvent(user, inv))
return inv
def get_number_comments(self, status=None):
if not status:
return Session.query(sa.func.count(Comment.id)).filter_by(change_id=self.id).first()[0]
date = Session.query(func.max(CommentStatus.created_date).label('date'), Comment.id)
date = date.filter(CommentStatus.comment_id==Comment.id).filter(Comment.change_id==self.id)
date = date.group_by(CommentStatus.comment_id, Comment.id)
subq = date.subquery()
q = Session.query(func.count(Comment.id)).outerjoin((subq, subq.c.id==Comment.id))
q = q.outerjoin((CommentStatus, CommentStatus.comment_id==Comment.id))
q = q.filter(Comment.change_id==self.id).filter(Comment.status!=STATUS_REMOVED)
q = q.filter(Comment.in_reply_to_id==None)
if status == STATUS_OPEN:
q = q.filter(sa.or_(
CommentStatus.id==None,
sa.and_(CommentStatus.created_date==subq.columns.date, CommentStatus.status==status)
))
return q.scalar()
else:
q = q.filter(
sa.and_(CommentStatus.created_date==subq.columns.date, CommentStatus.status==status)
)
return q.scalar()
def get(cls, sid=None, email=None):
if sid and email:
return Session.query(BetaEmail).filter( sa.or_(BetaEmail.email==(email and email.lower() or ''), BetaEmail.sid==sid) ).first()
if sid:
return Session.query(BetaEmail).filter( BetaEmail.sid==sid ).first()
if email:
return Session.query(BetaEmail).filter( BetaEmail.email==(email and email.lower() or '') ).first()
return None
def interested_users(self):
# people invited to this file...
# people with changes on this file,
# people with comments on this file.
from desio.model.users import User
cus = self.get_user_connections(status=STATUS_APPROVED)
users = [cu.user for cu in cus if cu.user]
contributors = Session.query(User).join(Change).filter(Change.entity_id==self.id).all()
commenters = Session.query(User).join(Comment).join((Change, Comment.change_id==Change.id)).filter(Change.entity_id==self.id).all()
return list(set(users + contributors + commenters))
def _create_parent_directories(self):
"""
Check if the parent directory exists and if it doesn't create it.
self.path is the path part of the full filepath already so name
here is actually the name of the directory.
"""
path = self.path.lstrip("/")
if not path:
# if path is '' then there's no parent to create because
# we are at root.
return
segments = path.split(u"/")
current_path = u"/"
for segment in segments:
q = Session.query(Directory)
q = q.filter_by(path=current_path)
q = q.filter_by(name=segment)
directory = q.first()
if not directory:
directory = Directory(path=current_path, name=segment, project=self.project)
Session.add(directory)
current_path = directory.full_path
def remove_user(self, user):
q = Session.query(self.connection_class).filter(getattr(self.connection_class, self.object_id_name)==self.id)
q = q.filter(self.connection_class.user_id==user.id)
cu = q.first()
if cu:
Session.delete(cu)
return True
return False
def interested_users(self):
from desio.model.users import User
cus = self.get_user_connections(status=STATUS_APPROVED)
users = [cu.user for cu in cus if cu.user]
contributors = Session.query(User).join(Change).filter(Change.project_id==self.id).all()
return list(set(users + contributors))
def get_comments(self):
"""
Get the comments associated with this change(_extract).
"""
q = Session.query(Comment)
q = q.filter_by(status=STATUS_EXISTS)
q = q.filter_by(**{self._comment_attribute: self})
q = q.order_by(sa.asc(Comment.created_date))
return q.all()
def get_changes(self):
"""
Fetch change for this file.
"""
q = Session.query(Change)
q = q.filter_by(entity=self)
q = q.filter_by(project=self.project)
q = q.order_by(sa.desc(Change.version))
return q.all()
def interested_users(self):
# people invited to this file...
# people with changes on this file,
# people with comments on this file.
from desio.model.users import User
commenters = Session.query(User).join(Comment).filter(Comment.in_reply_to_id==self.id).all()
return list(set([self.creator] + commenters))
def remove_user(self, user):
q = Session.query(self.connection_class).filter(
getattr(self.connection_class, self.object_id_name) == self.id)
q = q.filter(self.connection_class.user_id == user.id)
cu = q.first()
if cu:
Session.delete(cu)
return True
return False
def get_user_connection(self, user, status=STATUS_APPROVED):
"""
Find a single user's membership within this org
"""
if not user: return None
q = Session.query(self.connection_class).filter(self.connection_class.user_id==user.id)
if status:
q = q.filter(self.connection_class.status==status)
return q.filter(getattr(self.connection_class, self.object_id_name)==self.id).first()
def get_comments(self):
"""
Get the comments associated with this change(_extract).
"""
q = Session.query(Comment)
q = q.filter_by(status=STATUS_EXISTS)
q = q.join(Change)
q = q.filter(Change.entity_id==self.id)
q = q.order_by(sa.asc(Comment.created_date))
return q.all()
def authenticate(username, password, redirect_after=True, from_http_auth=False):
q = Session.query(users.User)
q = q.filter(sa.or_(users.User.username==username, users.User.email==username))
u = q.first()
if u and u.is_active and u.does_password_match(password):
return login(u, redirect_after=redirect_after, from_http_auth=from_http_auth)
else:
raise exceptions.ClientException('Email and password do not match.', code=exceptions.MISMATCH, field='password')
return None
def get_user_connections(self, status=None):
"""
Get all memberships in this org.
"""
q = Session.query(self.connection_class).filter(getattr(self.connection_class, self.object_id_name)==self.id)
if status and isinstance(status, basestring):
q = q.filter(self.connection_class.status==status)
if status and isinstance(status, (list, tuple)):
q = q.filter(self.connection_class.status.in_(status))
return q.all()
def get_user_connections(self, status=None):
"""
Get all memberships in this org.
"""
q = Session.query(self.connection_class).filter(
getattr(self.connection_class, self.object_id_name) == self.id)
if status and isinstance(status, basestring):
q = q.filter(self.connection_class.status == status)
if status and isinstance(status, (list, tuple)):
q = q.filter(self.connection_class.status.in_(status))
return q.all()
def get_invites(self, status=STATUS_PENDING, has_user=None):
q = Session.query(Invite).filter_by(object_id=self.id, type=INVITE_TYPE_ORGANIZATION)
if has_user == False:
q = q.filter(Invite.invited_user_id==None)
if has_user == True:
q = q.filter(Invite.invited_user_id!=None)
q = q.filter(Invite.status.in_([status]))
q = q.order_by(sa.desc(Invite.created_date))
return q.all()
def last_modified(self):
"""
Return the most recent last_modified date, wether it is the project metadata change
or one of the entities in it.
"""
last_changed_file = Session.query(sa.func.max(Entity.last_modified_date)).filter_by(project=self).first()[0]
if last_changed_file:
return max(self.last_modified_date, last_changed_file)
return self.last_modified_date
def get_invites(self, status=STATUS_PENDING, has_user=None):
from desio.model.users import Invite, INVITE_TYPE_ENTITY
q = Session.query(Invite).filter_by(object_id=self.id, type=INVITE_TYPE_ENTITY)
if has_user == False:
q = q.filter(Invite.invited_user_id==None)
if has_user == True:
q = q.filter(Invite.invited_user_id!=None)
q = q.filter(Invite.status.in_([status]))
q = q.order_by(sa.desc(Invite.created_date))
return q.all()
def attach_user(self, user, role=APP_ROLE_READ, status=STATUS_APPROVED):
cu = Session.query(self.connection_class) \
.filter(getattr(self.connection_class, self.object_name)==self) \
.filter(self.connection_class.user==user).first()
if cu:
cu.role = role
cu.status = status
return cu
cu = self.connection_class(user=user, role=role, status=status)
setattr(cu, self.object_name, self)
Session.add(cu)
return cu
def get_user_connection(self, user, status=STATUS_APPROVED):
"""
Find a single user's membership within this org
"""
if not user: return None
q = Session.query(self.connection_class).filter(
self.connection_class.user_id == user.id)
if status:
q = q.filter(self.connection_class.status == status)
return q.filter(
getattr(self.connection_class, self.object_id_name) ==
self.id).first()
def attach_user(self, user, role=APP_ROLE_READ, status=STATUS_APPROVED):
cu = Session.query(self.connection_class) \
.filter(getattr(self.connection_class, self.object_name)==self) \
.filter(self.connection_class.user==user).first()
if cu:
cu.role = role
cu.status = status
return cu
cu = self.connection_class(user=user, role=role, status=status)
setattr(cu, self.object_name, self)
Session.add(cu)
return cu
def completion_status(self):
"""
Users can 'complete' comments.
This will get the most recent row from CommentStatus.
Should be either 'open' or 'completed'
"""
cs = Session.query(CommentStatus).filter_by(comment_id=self.id).order_by(sa.desc(CommentStatus.created_date)).first()
if not cs:
#create a default
cs = CommentStatus(user=self.creator, created_date=self.created_date, status=STATUS_OPEN, comment=self)
Session.add(cs)
Session.flush()
return cs
def get_projects(self, user):
from desio.model import projects
q = Session.query(projects.Project).filter_by(organization=self, status=STATUS_APPROVED)
# this is kind of hairy. If org.is_read_open, the user can see all projects, otherwise,
# we get based on connections
#if not self.is_read_open and self.get_role(user) != APP_ROLE_ADMIN:
# q = q.join(projects.ProjectUser).filter(sa.and_(projects.ProjectUser.user==user, projects.ProjectUser.status==STATUS_APPROVED))
projects = q.order_by(sa.desc(projects.Project.last_modified_date)).all()
#this will return all the projects the user can see
return [p for p in projects if p.get_role(user)]
def fset(self, value):
if self.path and self.name:
old_path = self.full_path
q = Session.query(Entity).filter(Entity.path.like(old_path + '%'))
entities = q.all()
self._name = value
new_path = self.full_path
for e in entities:
e.path = new_path + e.path[len(old_path):]
else:
self._name = value
def get_change(self, version=None):
"""
Fetch single change for this file.
"""
q = Session.query(Change)
q = q.filter_by(entity=self)
q = q.filter_by(project=self.project)
#get HEAD if no change eid specified.
if version:
q = q.filter_by(version=version)
else:
q = q.order_by(sa.desc(Change.version))
return q.first()
def get_unique_slug(organization, name, max=100):
import re
from pylons_common.lib.utils import uuid
def gen_slug(input, addon=u''):
return (u'-'.join(re.findall('[a-z0-9]+', input, flags=re.IGNORECASE)))[:max].lower() + addon
for c in range(20):
slug = gen_slug(name, addon=(c and unicode(c) or u''))
project = Session.query(Project
).filter(Project.organization==organization
).filter(Project.slug==slug
).first()
if not project: return slug
return utils.uuid() #they have 20 projects named similarly, now they get eids!
def authenticate(username,
password,
redirect_after=True,
from_http_auth=False):
q = Session.query(users.User)
q = q.filter(
sa.or_(users.User.username == username, users.User.email == username))
u = q.first()
if u and u.is_active and u.does_password_match(password):
return login(u,
redirect_after=redirect_after,
from_http_auth=from_http_auth)
else:
raise exceptions.ClientException('Email and password do not match.',
code=exceptions.MISMATCH,
field='password')
return None
def get_user(key='user'):
"""
Gets the user model object if user has logged on. Will be the pretend
user if an admin is pretending to be someone.
Returns/sets a cached copy (from the context c var)
"""
if getattr(c, key):
return getattr(c, key)
user_id = session.get(key)
if user_id:
setattr(c, key, Session.query(users.User).outerjoin(users.UserPreference).filter(users.User.id == user_id).first())
if session['user'] == session['real_user']:
c.user = c.real_user = getattr(c, key)
else:
setattr(c, key, None)
return getattr(c, key)
def get_user(key='user'):
"""
Gets the user model object if user has logged on. Will be the pretend
user if an admin is pretending to be someone.
Returns/sets a cached copy (from the context c var)
"""
if getattr(c, key):
return getattr(c, key)
user_id = session.get(key)
if user_id:
setattr(
c, key,
Session.query(users.User).outerjoin(
users.UserPreference).filter(users.User.id == user_id).first())
if session['user'] == session['real_user']:
c.user = c.real_user = getattr(c, key)
else:
setattr(c, key, None)
return getattr(c, key)
def get_activities(organization=None, project=None, entity=None, user=None, limit=None, order_by='created_date', sort_direction='desc', offset=None):
"""
always use this to query activities
- Will be slow due to multiple queries on get_message() call to each activity
- can do some kind of caching: run through all the activites, get all the user, project, & entity ids,
query them, put them in a dict. Then override the user, project, entity properties to
make use of the dict.
- users prolly will want many of the same events (comments?) over a close time span. Can
do that here.
offset should be a datetime. will find stuff older than the datetime
"""
q = Session.query(Activity)
if organization:
q = q.filter_by(organization_id=organization.id)
if project:
q = q.filter_by(project_id=project.id)
if entity:
q = q.filter_by(entity_id=entity.id)
if user:
q = q.filter_by(user_id=user.id)
if offset:
q = q.filter(Activity.created_date < offset)
if order_by and sort_direction:
d = getattr(sa, sort_direction)
q = q.order_by(d(getattr(Activity, order_by)))
if limit:
q = q.limit(limit)
return q.all()
def get_entities(self, filepath=None, only_type=None, only_status=STATUS_EXISTS, order_by_field=u'last_modified_date', desc=True):
"""
Get all project entities that have the given path and the given name if any.
And which status is STATUS_EXISTS.
Optionally that are at the given path or deeper???.
Note: It is VERY important that filepath ends with / when you want to
see a directory, otherwise it's interpreted as a filename.
/foo/bar/gaz <- is a file (returns 1 result)
/foo/bar/gaz/ <- is a directory (returns contents)
"""
q = Session.query(Entity)
q = q.filter_by(project=self)
name = None
if filepath is not None:
path, name = os.path.split(filepath)
q = q.filter_by(path=path)
if only_status is not None:
q = q.filter_by(status=only_status)
if only_type:
q = q.filter_by(type=only_type)
if name:
q = q.filter_by(name=name)
return q.first()
order_by_field = getattr(Entity, order_by_field, Entity.last_modified_date)
order_by = sa.asc(order_by_field)
if desc:
order_by = sa.desc(order_by_field)
q = q.order_by(order_by)
return q.all()
def object(self):
if not getattr(self, '_object', None):
self._setup_lookups()
self._object = Session.query(self.fetch_types[self.type.strip()]).filter_by(id=self.object_id).first()
return self._object
def get_entity_users(self, status=STATUS_APPROVED):
from desio.model import projects
q = Session.query(projects.EntityUser).filter(projects.EntityUser.user_id==self.id)
if status:
q = q.filter(projects.EntityUser.status==status)
return q.all()
def get_user_connections(self, status=STATUS_APPROVED):
q = Session.query(OrganizationUser).filter(OrganizationUser.user_id==self.id)
if status:
q = q.filter(OrganizationUser.status==status)
return q.all()
def get_organizations(self, status=STATUS_APPROVED):
"""
Orgs explicitly attached to.
"""
orgs = Session.query(Organization).filter_by(creator=self).all()
return list(set([r.organization for r in self.get_user_connections(status=status)] + orgs))
