def get_tagged_addrs(user):
"""Generate a list of tagged addresses for a user"""
query1 = Session.query(Message.to_address)
query2 = Session.query(Message.from_address)
addrs = [addr.address for addr in user.addresses
if '+*' not in addr.address and '-*' not in addr.address]
addrs.append(user.email)
tagged_addrs = [addr.address for addr in user.addresses
if '+*' in addr.address or '-*' in addr.address]
if tagged_addrs:
tagged_opts1 = func._(or_(*[Message.to_address
.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs]))
tagged_opts2 = func._(or_(*[Message.from_address
.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs]))
query1 = query1.filter(func._(
or_(tagged_opts1, Message.to_address.in_(addrs))))
query2 = query2.filter(func._(
or_(tagged_opts2, Message.from_address.in_(addrs))))
else:
query1 = query1.filter(Message.to_address.in_(addrs))
query2 = query2.filter(Message.from_address.in_(addrs))
query1 = query1.distinct()
query2 = query2.distinct()
to_addrs = [val.to_address for val in query1]
from_addrs = [val.from_address for val in query2]
all_addrs = set(to_addrs + from_addrs)
return [str(crc32(val)) for val in all_addrs]
def __init__(self, dbsession, user):
"init"
self.dbsession = dbsession
self.user = user
self.query = self.dbsession.query(func.count(MailQueueItem.id))
if self.user.is_domain_admin:
dquery = self.dbsession.query(Domain).join(downs,
(oa, downs.c.organization_id == oa.c.organization_id))\
.filter(Domain.status == true())\
.filter(oa.c.user_id == self.user.id).all()
# domains = [domain.name for domain in dquery]
domains = []
for domain in dquery:
domains.append(domain.name)
for domain_alias in domain.aliases:
if domain_alias.status:
domains.append(domain_alias.name)
if not domains:
domains.append('xx')
self.query = self.query.filter(
func._(
or_(MailQueueItem.to_domain.in_(domains),
MailQueueItem.from_domain.in_(domains))))
if self.user.is_peleb:
addrs = [
addr.address for addr in self.user.addresses
if '+*' not in addr.address and '-*' not in addr.address
]
addrs.append(self.user.email)
tagged_addrs = [
addr.address for addr in self.user.addresses
if '+*' in addr.address or '-*' in addr.address
]
if tagged_addrs:
tagged_to = func._(
or_(*[
MailQueueItem.to_address.like(
TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs
]))
tagged_from = func._(
or_(*[
MailQueueItem.from_address.like(
TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs
]))
self.query = self.query\
.filter(func._(
or_(tagged_to,
tagged_from,
MailQueueItem.to_address.in_(addrs),
MailQueueItem.from_address.in_(addrs))
)
)
else:
self.query = self.query\
.filter(func._(
or_(MailQueueItem.to_address.in_(addrs),
MailQueueItem.from_address.in_(addrs))))
def _build_user_filter(self):
"Build user filter"
addrs = [addr.address for addr in self.user.addresses
if '+*' not in addr.address and '-*' not in addr.address]
addrs.append(self.user.email)
tagged_addrs = [addr.address for addr in self.user.addresses
if '+*' in addr.address or '-*' in addr.address]
if self.direction and self.direction == 'in':
if tagged_addrs:
tagged_opts = func._(or_(*[self.model.to_address
.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs]))
self.query = self.query\
.filter(
func._(
or_(tagged_opts,
self.model.to_address.in_(addrs))))
else:
self.query = self.query\
.filter(self.model.to_address.in_(addrs))
elif self.direction and self.direction == 'out':
if tagged_addrs:
tagged_opts = func._(or_(*[self.model.from_address
.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs]))
self.query = self.query\
.filter(
func._(
or_(tagged_opts,
self.model.from_address.in_(addrs))))
else:
self.query = self.query\
.filter(self.model.from_address.in_(addrs))
else:
if tagged_addrs:
tagged_to = func._(or_(*[self.model.to_address
.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs]))
tagged_from = func._(or_(*[self.model.from_address
.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs]))
self.query = self.query\
.filter(func._(
or_(tagged_to, tagged_from,
self.model.to_address.in_(addrs),
self.model.from_address.in_(addrs))))
else:
self.query = self.query\
.filter(func._(
or_(self.model.to_address.in_(addrs),
self.model.from_address.in_(addrs))))
def count(self):
"Get the count"
if self.user.is_domain_admin:
dquery = self.dbsession.query(Domain).join(downs,
(oa, downs.c.organization_id == oa.c.organization_id))\
.filter(Domain.status == true())\
.filter(oa.c.user_id == self.user.id).all()
# domains = [domain.name for domain in dquery]
domains = []
for domain in dquery:
domains.append(domain.name)
for domain_alias in domain.aliases:
if domain_alias.status:
domains.append(domain_alias.name)
self.query = self.query.filter(MessageTotals.id.in_(domains))
elif self.user.is_peleb:
addrs = [
addr.address for addr in self.user.addresses
if '+*' not in addr.address and '-*' not in addr.address
]
tagged_addrs = [
addr.address for addr in self.user.addresses
if '+*' in addr.address or '-*' in addr.address
]
addrs.append(self.user.email)
if tagged_addrs:
tagged_to = func._(
or_(*[
Message.to_address.like(
TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs
]))
tagged_from = func._(
or_(*[
Message.from_address.like(
TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs
]))
self.query = self.query.filter(
func._(
or_(tagged_to, tagged_from,
Message.to_address.in_(addrs),
Message.from_address.in_(addrs))))
else:
self.query = self.query.filter(
func._(
or_(Message.to_address.in_(addrs),
Message.from_address.in_(addrs))))
value = self.query.one()
return int(value.total or 0)
def get(self, hostname=None):
"Return the query object"
if hostname is not None:
self.query = self.query.filter(Message.hostname == hostname)
if self.user.is_domain_admin:
domainquery = self.dbsession.query(Domain).join(downs,
(oa, downs.c.organization_id == oa.c.organization_id))\
.filter(Domain.status == true())\
.filter(oa.c.user_id == self.user.id).all()
dquery = []
for domain in domainquery:
dquery.append(domain.name)
if domain.aliases:
for domain_alias in domain.aliases:
dquery.append(domain_alias.name)
if not dquery:
dquery.append('xx')
self.query = self.query.filter(func._(
or_(Message.to_domain.in_(dquery),
Message.from_domain.in_(dquery))))
if self.user.is_peleb:
addrs = [addr.address for addr in self.user.addresses
if '+*' not in addr.address and '-*' not in addr.address]
addrs.append(self.user.email)
tagged_addrs = [addr.address for addr in self.user.addresses
if '+*' in addr.address or '-*' in addr.address]
if tagged_addrs:
tagged_to = func._(or_(*[Message.to_address
.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs]))
tagged_from = func._(or_(*[Message.from_address
.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs]))
self.query = self.query.filter(
func._(or_(tagged_to, tagged_from,
Message.to_address.in_(addrs),
Message.from_address.in_(addrs))))
else:
self.query = self.query.filter(
func._(or_(Message.to_address.in_(addrs),
Message.from_address.in_(addrs))))
cachekey = 'dailytotals-%s-%s' % (self.user.username, hostname)
try:
self.query = self.query.\
options(FromCache('sql_cache_short', cachekey))
except PylibmcError:
pass
return self.query.one()
def __init__(self, dbsession, user):
"init"
self.dbsession = dbsession
self.user = user
self.query = self.dbsession.query(func.count(MailQueueItem.id))
if self.user.is_domain_admin:
dquery = self.dbsession.query(Domain).join(downs,
(oa, downs.c.organization_id == oa.c.organization_id))\
.filter(Domain.status == true())\
.filter(oa.c.user_id == self.user.id).all()
# domains = [domain.name for domain in dquery]
domains = []
for domain in dquery:
domains.append(domain.name)
for domain_alias in domain.aliases:
if domain_alias.status:
domains.append(domain_alias.name)
if not domains:
domains.append('xx')
self.query = self.query.filter(
func._(or_(MailQueueItem.to_domain.in_(domains),
MailQueueItem.from_domain.in_(domains))))
if self.user.is_peleb:
addrs = [addr.address for addr in self.user.addresses
if '+*' not in addr.address and '-*' not in addr.address]
addrs.append(self.user.email)
tagged_addrs = [addr.address for addr in self.user.addresses
if '+*' in addr.address or '-*' in addr.address]
if tagged_addrs:
tagged_to = func._(or_(*[MailQueueItem.to_address
.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs]))
tagged_from = func._(or_(*[MailQueueItem.from_address
.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs]))
self.query = self.query\
.filter(func._(
or_(tagged_to,
tagged_from,
MailQueueItem.to_address.in_(addrs),
MailQueueItem.from_address.in_(addrs))
)
)
else:
self.query = self.query\
.filter(func._(
or_(MailQueueItem.to_address.in_(addrs),
MailQueueItem.from_address.in_(addrs))))
def count(self):
"Get the count"
if self.user.is_domain_admin:
dquery = self.dbsession.query(Domain).join(downs,
(oa, downs.c.organization_id == oa.c.organization_id))\
.filter(Domain.status == true())\
.filter(oa.c.user_id == self.user.id).all()
# domains = [domain.name for domain in dquery]
domains = []
for domain in dquery:
domains.append(domain.name)
for domain_alias in domain.aliases:
if domain_alias.status:
domains.append(domain_alias.name)
self.query = self.query.filter(MessageTotals.id.in_(domains))
elif self.user.is_peleb:
addrs = [addr.address for addr in self.user.addresses
if '+*' not in addr.address and '-*' not in addr.address]
tagged_addrs = [addr.address for addr in self.user.addresses
if '+*' in addr.address or '-*' in addr.address]
addrs.append(self.user.email)
if tagged_addrs:
tagged_to = func._(or_(*[Message.to_address
.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs]))
tagged_from = func._(or_(*[Message.from_address
.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs]))
self.query = self.query.filter(func._(or_(
tagged_to, tagged_from,
Message.to_address.in_(addrs),
Message.from_address.in_(addrs))))
else:
self.query = self.query.filter(func._(
or_(Message.to_address.in_(addrs),
Message.from_address.in_(addrs))))
value = self.query.one()
return int(value.total or 0)
def get_tagged_addrs(user):
"""Generate a list of tagged addresses for a user"""
query1 = Session.query(Message.to_address)
query2 = Session.query(Message.from_address)
addrs = [
addr.address for addr in user.addresses
if '+*' not in addr.address and '-*' not in addr.address
]
addrs.append(user.email)
tagged_addrs = [
addr.address for addr in user.addresses
if '+*' in addr.address or '-*' in addr.address
]
if tagged_addrs:
tagged_opts1 = func._(
or_(*[
Message.to_address.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs
]))
tagged_opts2 = func._(
or_(*[
Message.from_address.like(TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs
]))
query1 = query1.filter(
func._(or_(tagged_opts1, Message.to_address.in_(addrs))))
query2 = query2.filter(
func._(or_(tagged_opts2, Message.from_address.in_(addrs))))
else:
query1 = query1.filter(Message.to_address.in_(addrs))
query2 = query2.filter(Message.from_address.in_(addrs))
query1 = query1.distinct()
query2 = query2.distinct()
to_addrs = [val.to_address for val in query1]
from_addrs = [val.from_address for val in query2]
all_addrs = set(to_addrs + from_addrs)
return [str(crc32(val)) for val in all_addrs]
def get(self, hostname=None):
"Return the query object"
if hostname is not None:
self.query = self.query.filter(Message.hostname == hostname)
if self.user.is_domain_admin:
domainquery = self.dbsession.query(Domain).join(downs,
(oa, downs.c.organization_id == oa.c.organization_id))\
.filter(Domain.status == true())\
.filter(oa.c.user_id == self.user.id).all()
dquery = []
for domain in domainquery:
dquery.append(domain.name)
if domain.aliases:
for domain_alias in domain.aliases:
dquery.append(domain_alias.name)
if not dquery:
dquery.append('xx')
self.query = self.query.filter(
func._(
or_(Message.to_domain.in_(dquery),
Message.from_domain.in_(dquery))))
if self.user.is_peleb:
addrs = [
addr.address for addr in self.user.addresses
if '+*' not in addr.address and '-*' not in addr.address
]
addrs.append(self.user.email)
tagged_addrs = [
addr.address for addr in self.user.addresses
if '+*' in addr.address or '-*' in addr.address
]
if tagged_addrs:
tagged_to = func._(
or_(*[
Message.to_address.like(
TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs
]))
tagged_from = func._(
or_(*[
Message.from_address.like(
TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs
]))
self.query = self.query.filter(
func._(
or_(tagged_to, tagged_from,
Message.to_address.in_(addrs),
Message.from_address.in_(addrs))))
else:
self.query = self.query.filter(
func._(
or_(Message.to_address.in_(addrs),
Message.from_address.in_(addrs))))
cachekey = 'dailytotals-%s-%s' % (self.user.username, hostname)
try:
self.query = self.query.\
options(FromCache('sql_cache_short', cachekey))
except PylibmcError:
pass
return self.query.one()
def _build_user_filter(self):
"Build user filter"
addrs = [
addr.address for addr in self.user.addresses
if '+*' not in addr.address and '-*' not in addr.address
]
addrs.append(self.user.email)
tagged_addrs = [
addr.address for addr in self.user.addresses
if '+*' in addr.address or '-*' in addr.address
]
if self.direction and self.direction == 'in':
if tagged_addrs:
tagged_opts = func._(
or_(*[
self.model.to_address.like(
TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs
]))
self.query = self.query\
.filter(
func._(
or_(tagged_opts,
self.model.to_address.in_(addrs))))
else:
self.query = self.query\
.filter(self.model.to_address.in_(addrs))
elif self.direction and self.direction == 'out':
if tagged_addrs:
tagged_opts = func._(
or_(*[
self.model.from_address.like(
TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs
]))
self.query = self.query\
.filter(
func._(
or_(tagged_opts,
self.model.from_address.in_(addrs))))
else:
self.query = self.query\
.filter(self.model.from_address.in_(addrs))
else:
if tagged_addrs:
tagged_to = func._(
or_(*[
self.model.to_address.like(
TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs
]))
tagged_from = func._(
or_(*[
self.model.from_address.like(
TAGGED_RE.sub(r'\g<one>%', taddr))
for taddr in tagged_addrs
]))
self.query = self.query\
.filter(func._(
or_(tagged_to, tagged_from,
self.model.to_address.in_(addrs),
self.model.from_address.in_(addrs))))
else:
self.query = self.query\
.filter(func._(
or_(self.model.to_address.in_(addrs),
self.model.from_address.in_(addrs))))
