def handle_person(database, source_system, affiliations, send_notifications,
email_config, data):
pe = Factory.get('Person')(database)
ac = Factory.get('Account')(database)
et = EmailTarget(database)
ef = EmailForward(database)
ed = EmailDomain(database)
if (data.get('resourceType') == 'persons' and
'affiliation' in data.get(
'urn:ietf:params:event:SCIM:modify', {}).get(
'attributes', [])):
ident = int(data.get('sub').split('/')[-1])
if not pe.list_affiliations(
person_id=ident,
source_system=source_system,
affiliation=affiliations):
return
pe.clear()
pe.find(ident)
removed_forwards = defaultdict(list)
for account_id in map(lambda x: x['account_id'],
pe.get_accounts(
filter_expired=False)):
try:
et.clear()
et.find_by_target_entity(account_id)
except Errors.NotFoundError:
continue
ef.clear()
ef.find(et.entity_id)
for forward in map(lambda x: x['forward_to'],
ef.get_forward()):
try:
ed.clear()
ed.find_by_domain(forward.split('@')[-1])
except Errors.NotFoundError:
ac.clear()
ac.find(account_id)
ef.delete_forward(forward)
removed_forwards[ac.get_primary_mailaddress()
].append(forward)
logger.info(
'Deleted forward {} from {}'.format(
forward, ac.account_name))
if send_notifications:
for k, v in removed_forwards.items():
sendmail(
toaddr=k,
fromaddr=email_config.sender,
subject=email_config.subject,
body=email_config.body_template.format('\n'.join(v)))
database.commit()
def __init__(self):
"""Initialize the Utils."""
self.db = Factory.get('Database')(client_encoding='UTF-8')
self.en = Factory.get('Entity')(self.db)
self.ac = Factory.get('Account')(self.db)
self.pe = Factory.get('Person')(self.db)
self.gr = Factory.get('Group')(self.db)
self.co = Factory.get('Constants')(self.db)
self.ed = EmailDomain(self.db)
self.eq = EmailQuota(self.db)
self.ef = EmailForward(self.db)
self.et = Factory.get('EmailTarget')(self.db)
self.dg = DistributionGroup(self.db)
def init_account_mail(self, use_mail_module):
u""" Cache account mail addresses.
This method builds a dict cache that maps account_id -> primary email
address, and assigns the `dict.get` method to `self.account_mail`.
NOTE: The LDAP_PERSON['mail_target_types'] setting decides which email
target types are considered.
:param bool use_mail_module:
If True, Cerebrum.modules.Email will be used to populate this
cache; otherwise the `self.account_mail` method will be None (not
implemented).
"""
# Set self.account_mail = None if not use_mail_module, otherwise
# function: account_id -> ('address' or None).
if use_mail_module:
timer = make_timer(self.logger,
"Fetching account e-mail addresses...")
# Get target types from config
mail_target_types = []
for value in ldapconf('PERSON', 'mail_target_types', []):
code = self.const.human2constant(value, self.const.EmailTarget)
if code is None:
self.logger.warn("Unknown EmailTarget %r in setting %s",
value, "LDAP_PERSON['mail_target_types']")
else:
mail_target_types.append(code)
# We don't want to import this if mod_email isn't present.
from Cerebrum.modules.Email import EmailDomain, EmailTarget
targets = EmailTarget(self.db).list_email_target_primary_addresses
rewrite = EmailDomain(self.db).rewrite_special_domains
# Look up target addrs. Note that the reversed order causes the
# lesser prioritized target types to be overwritten by targets with
# higher priority.
mail = {}
for code in reversed(mail_target_types):
target_timer = make_timer(self.logger)
for row in targets(target_type=code):
try:
mail[int(row['target_entity_id'])] = "@".join(
(row['local_part'], rewrite(row['domain'])))
except TypeError:
continue
target_timer("...target_type '{!s}' done".format(code))
self.account_mail = mail.get
timer("...account e-mail addresses done.")
else:
self.account_mail = None
def __init__(self):
"""Initialize the Utils."""
self.db = Factory.get('Database')(client_encoding='UTF-8')
self.en = Factory.get('Entity')(self.db)
self.ac = Factory.get('Account')(self.db)
self.pe = Factory.get('Person')(self.db)
self.gr = Factory.get('Group')(self.db)
self.co = Factory.get('Constants')(self.db)
self.ed = EmailDomain(self.db)
self.eq = EmailQuota(self.db)
self.ef = EmailForward(self.db)
self.et = Factory.get('EmailTarget')(self.db)
self.dg = DistributionGroup(self.db)
def handle_person(database, source_system, affiliations, send_notifications,
email_config, data):
pe = Factory.get('Person')(database)
ac = Factory.get('Account')(database)
et = EmailTarget(database)
ef = EmailForward(database)
ed = EmailDomain(database)
if (data.get('resourceType') == 'persons' and 'affiliation' in data.get(
'urn:ietf:params:event:SCIM:modify', {}).get('attributes', [])):
ident = int(data.get('sub').split('/')[-1])
if not pe.list_affiliations(person_id=ident,
source_system=source_system,
affiliation=affiliations):
return
pe.clear()
pe.find(ident)
removed_forwards = defaultdict(list)
for account_id in map(lambda x: x['account_id'],
pe.get_accounts(filter_expired=False)):
try:
et.clear()
et.find_by_target_entity(account_id)
except Errors.NotFoundError:
continue
ef.clear()
ef.find(et.entity_id)
for forward in map(lambda x: x['forward_to'], ef.get_forward()):
try:
ed.clear()
ed.find_by_domain(forward.split('@')[-1])
except Errors.NotFoundError:
ac.clear()
ac.find(account_id)
ef.delete_forward(forward)
removed_forwards[ac.get_primary_mailaddress()].append(
forward)
logger.info('Deleted forward {} from {}'.format(
forward, ac.account_name))
if send_notifications:
for k, v in removed_forwards.items():
sendmail(toaddr=k,
fromaddr=email_config.sender,
subject=email_config.subject,
body=email_config.body_template.format('\n'.join(v)))
database.commit()
def _fetch_primary_mail_addresses(self, user_dict):
"""
Fetch primary email addresses for users in user_dict.
Add key, value pair 'mail', <primary address> if found.
@param user_dict: account_id -> account info mapping
@type user_dict: dict
"""
from Cerebrum.modules.Email import EmailDomain, EmailTarget
etarget = EmailTarget(self.db)
rewrite = EmailDomain(self.db).rewrite_special_domains
for row in etarget.list_email_target_primary_addresses(
target_type=self.co.email_target_account):
v = user_dict.get(int(row['target_entity_id']))
if not v:
continue
try:
v['mail'] = "@".join(
(row['local_part'], rewrite(row['domain'])))
except TypeError:
pass # Silently ignore
def fetch_forward_info(self):
"""
Fetch forward info for all users with both AD and exchange spread.
"""
from Cerebrum.modules.Email import EmailDomain, EmailTarget, EmailForward
etarget = EmailTarget(self.db)
rewrite = EmailDomain(self.db).rewrite_special_domains
eforward = EmailForward(self.db)
# We need a email target -> entity_id mapping
target_id2target_entity_id = {}
for row in etarget.list_email_targets_ext():
if row['target_entity_id']:
te_id = int(row['target_entity_id'])
target_id2target_entity_id[int(row['target_id'])] = te_id
# Check all email forwards
for row in eforward.list_email_forwards():
te_id = target_id2target_entity_id.get(int(row['target_id']))
acc = self.get_account(account_id=te_id)
# We're only interested in those with AD and exchange spread
if acc.to_exchange:
acc.add_forward(row['forward_to'])
class CerebrumUtils(object):
"""Utility-class containing often used functions for Exchange."""
def __init__(self):
"""Initialize the Utils."""
self.db = Factory.get('Database')(client_encoding='UTF-8')
self.en = Factory.get('Entity')(self.db)
self.ac = Factory.get('Account')(self.db)
self.pe = Factory.get('Person')(self.db)
self.gr = Factory.get('Group')(self.db)
self.co = Factory.get('Constants')(self.db)
self.clconst = Factory.get('CLConstants')(self.db)
self.ed = EmailDomain(self.db)
self.eq = EmailQuota(self.db)
self.ef = EmailForward(self.db)
self.et = Factory.get('EmailTarget')(self.db)
self.dg = DistributionGroup(self.db)
####
# Person related methods
####
def get_person_accounts(self, person_id, spread=None):
"""Return a list of account information.
:type person_id: int
:param person_id: The person id to look up by.
:rtype: list
:return: A list of (account_id, username) tuples."""
ret = [(x['account_id'], x['name']) for x in
self.ac.search(owner_id=person_id,
owner_type=self.co.entity_person,
spread=self.co.spread_exchange_account)]
self.db.rollback()
return ret
def get_person_names(self, account_id=None, person_id=None):
"""Return a persons names.
:type account_id: int
:param account_id: The user to look up names by.
:type person_id: int
:param person_id: The person to look up names by.
:rtype: tuple
:return: (first_name, last_name, full name).
"""
# TODO: search_name_with_language?
if account_id:
self.ac.clear()
self.ac.find(account_id)
self.pe.clear()
self.pe.find(self.ac.owner_id)
elif person_id:
self.pe.clear()
self.pe.find(person_id)
else:
raise AssertionError('Called w/o person or account id')
ret = (self.pe.get_name(self.co.system_cached, self.co.name_first),
self.pe.get_name(self.co.system_cached, self.co.name_last),
self.pe.get_name(self.co.system_cached, self.co.name_full,))
self.db.rollback()
return ret
def get_person_membership_groupnames(self, person_id):
"""List all the groups the person is a member of.
:type person_id: int
:param person_id: The persons entity_id.
:rtype: list
:return: list(string) of groupnames."""
ret = [x['group_name'] for x in self.gr.search_members(
member_id=person_id, indirect_members=True)]
self.db.rollback()
return ret
def is_electronic_reserved(self, person_id=None, account_id=None):
"""Check if a person has reserved themself from listing.
:type person_id: int
:param person_id: The persons entity_id.
:type account_id: int
:param account_id: The accounts entity_id.
:rtype: bool
:return: True if reserved, False otherwise."""
if person_id:
self.pe.clear()
self.pe.find(person_id)
ret = self.pe.has_e_reservation()
elif account_id:
self.ac.clear()
self.ac.find(account_id)
ret = self.ac.owner_has_ereservation()
# TODO: This is sane?
else:
ret = True
self.db.rollback()
return ret
####
# Account related methods
####
def get_account_mailaddrs(self, account_id):
"""Collect mailaddresses of an account.
:type account_id: int
:param account_id: The account_id representing the object.
:rtype: list
:return: A list of addresses."""
self.et.clear()
self.et.find_by_target_entity(account_id)
addrs = ['%s@%s' % (x['local_part'], x['domain'])
for x in self.et.get_addresses()]
self.db.rollback()
return addrs
def get_account_forwards(self, account_id):
"""Collect an accounts forward addresses.
:param int account_id: The account_id representing the object.
:return: A list of forward addresses."""
self.ef.clear()
self.ef.find_by_target_entity(account_id)
r = []
for fwd in self.ef.get_forward():
# Need to do keys() for now, db_row is stupid.
if 'enable' in fwd.keys() and fwd['enable'] == 'T':
r.append(fwd['forward_to'])
self.db.rollback()
return r
def get_account_local_delivery(self, account_id):
"""Check if this account should have local delivery.
:param int account_id: The account_id representing the object.
:rtype: bool
:return: Local delivery on or off."""
self.ef.clear()
self.ef.find_by_target_entity(account_id)
return self.ef.local_delivery
def get_account_name(self, account_id):
"""Return information about the account.
:type account_id: int
:param acccount_id: The accounts entity id.
:rtype: string
:return: The accounts name."""
self.ac.clear()
self.ac.find(account_id)
ret = self.ac.account_name
self.db.rollback()
return ret
def get_account_owner_info(self, account_id):
"""Return the type and id of the accounts owner.
:type account_id: int
:param acccount_id: The accounts entity id.
:rtype: tuple
:return: (entity_type, entity_id)."""
self.ac.clear()
self.ac.find(account_id)
ret = (self.ac.owner_type, self.ac.owner_id)
self.db.rollback()
return ret
def get_account_spreads(self, account_id):
"""Return the accounts spread codes.
:type account_id: int
:param acccount_id: The accounts entity id.
:rtype: list
:return: A list of the accounts spread codes."""
self.ac.clear()
self.ac.find(account_id)
ret = [x['spread'] for x in self.ac.get_spread()]
self.db.rollback()
return ret
def get_account_primary_email(self, account_id):
"""Return the accounts primary address.
:type account_id: int
:param acccount_id: The accounts entity id.
:rtype: str
:return: The accounts primary email-address."""
self.ac.clear()
self.ac.find(account_id)
ret = self.ac.get_primary_mailaddress()
self.db.rollback()
return ret
def get_account_id(self, uname):
"""Get an accounts entity id.
:type uname: str
:param uname: The users name.
:rtype: int
:return: The entity id of the account."""
self.ac.clear()
self.ac.find_by_name(uname)
ret = self.ac.entity_id
self.db.rollback()
return ret
def get_primary_account(self, person_id):
"""Get a persons primary account.
:type person_id: int
:param person_id: The persons entity id.
:rtype: int
:return: The primary accounts entity_id or None if no primary."""
self.pe.clear()
self.pe.find(person_id)
ret = self.pe.get_primary_account()
self.db.rollback()
return ret
def get_account_group_memberships(self, uname, group_spread):
"""Get a list of group names, which the user (and users owner, if
person), is a member of.
:type uname: string
:param uname: The accounts name.
:type group_spread: _SpreadCode
:param group_spread: Spread to filter groups by.
:rtype: list(tuple)
:return: A list of tuples contining group-name and -id."""
self.ac.clear()
self.ac.find_by_name(uname)
groups = []
# Fetch the groups the person is a member of
if self.ac.owner_type == self.co.entity_person:
for group in self.gr.search(member_id=self.ac.owner_id,
spread=group_spread,
indirect_members=True):
groups.append((group['name'], group['group_id']))
# Fetch the groups the account is a member of
for group in self.gr.search(member_id=self.ac.entity_id,
spread=group_spread,
indirect_members=True):
groups.append((group['name'], group['group_id']))
self.db.rollback()
return groups
####
# Group related methods
####
def construct_group_names(self, uname, gname):
"""Construct Exchange related group names.
:param str uname: The users username.
:param str gname: The owning groups groupname.
:rtype: tuple(str)
:return: A tuple consisting of FirstName, LastName and DisplayName."""
fn = uname
ln = '(owner: %s)' % gname
dn = '%s (owner: %s)' % (uname, gname)
return (fn, ln, dn)
def get_group_information(self, group_id):
"""Get a groups name and description.
:type group_id: int
:param group_id: The groups entity id.
:rtype: tuple
:return: The groups name and description."""
# This function is kinda generic. We don't care
# (yet) if it's a distribution or security group.
r = self.gr.search(group_id=group_id)[0]
ret = (r['name'], r['description'])
self.db.rollback()
return ret
def get_group_id(self, group_name):
"""Get a groups entity_id.
:type group_name: str
:param group_name: The groups name.
:rtype: int
:return: The groups entity_id."""
self.gr.clear()
self.gr.find_by_name(group_name)
ret = self.gr.entity_id
self.db.rollback()
return ret
def get_group_spreads(self, group_id):
"""Return the groupss spread codes.
:type group_id: int
:param group_id: The accounts entity id.
:rtype: list
:return: A list of the accounts spread codes."""
self.gr.clear()
self.gr.find(group_id)
ret = [x['spread'] for x in self.gr.get_spread()]
self.db.rollback()
return ret
def get_group_members(self, group_id, spread=None, filter_spread=None):
"""Collect a list of the usernames of all users in a group.
:type group_id: int
:param group_id: The groups entity_id.
:type spread: _SpreadCode
:param spread: The spread to filter by.
:type filter_spread: _SpreadCode
:param filter_spread: A spread that the user must also have.
:rtype: list
:return: A list of usernames who are members of group_id."""
found_accounts = []
r = []
for x in self.gr.search_members(group_id=group_id,
indirect_members=True,
member_spread=spread,
member_type=self.co.entity_account):
if x['member_id'] not in found_accounts:
if filter_spread in self.get_account_spreads(x['member_id']):
r.append({'name': self.get_account_name(x['member_id']),
'account_id': x['member_id']})
found_accounts.append(x['member_id'])
spreads = []
if spread:
spreads += [int(spread)]
if filter_spread:
spreads += [int(filter_spread)]
for x in self.gr.search_members(group_id=group_id,
indirect_members=True,
member_type=self.co.entity_person):
self.pe.clear()
self.pe.find(x['member_id'])
aid = self.pe.get_primary_account()
if aid:
self.ac.clear()
self.ac.find(aid)
if self.ac.entity_id not in found_accounts:
# If/elif used to allow usage without filter and
# filter_spread params
if spreads and \
set(spreads).issubset(
set([x['spread'] for x in self.ac.get_spread()])):
r.append({'name': self.ac.account_name,
'account_id': self.ac.entity_id})
found_accounts.append(self.ac.entity_id)
elif not spreads:
r.append({'name': self.ac.account_name,
'account_id': self.ac.entity_id})
found_accounts.append(self.ac.entity_id)
self.db.rollback()
return r
def get_parent_groups(self, id, spread=None, name_prefix=None):
"""Return all groups that the group is an indirect member of. Filter
by spread and the start of the group name.
:type id: int
:param id: The entity_id.
:type spread: _SpreadCode
:param _SpreadCode: The spread code to filter by, default is None.
:type name_prefix: str
:param name_prefix: Check if the group starts with this, default None.
:rtype: list
:return: A list of appropriate groups."""
if name_prefix:
np = '%s%%' % name_prefix
else:
np = None
groups = []
for group in self.gr.search(member_id=id, indirect_members=True,
spread=spread, name=np):
groups.append(group['name'])
self.db.rollback()
return groups
####
# Other utility methods
####
def load_params(self, event):
"""Get the change params of an event.
:type event: dbrow
:param event: The db row returned by Change- or EventLog.
:rtype: dict or None
:return: The change params."""
params = event['change_params']
if isinstance(params, basestring):
return json.loads(params)
return params
def get_entity_type(self, entity_id):
"""Fetch the entity type code of an entity.
:type entity_id: int
:param entity_id: The entity id.
:rtype: long
:return: The entity type code."""
self.en.clear()
self.en.find(entity_id)
ret = self.en.entity_type
self.db.rollback()
return ret
def log_event(self, event, trigger):
"""Utility method used to create an event only in the EventLog.
:type event: dict
:param event: Dict representing an event (as returned from get_event).
:param trigger: str or list or tuple
:param trigger: The change type code we want to associate with the
event. Only the first value will be used."""
if isinstance(trigger, (list, tuple)):
trigger = trigger[0]
trigger = trigger.split(':')
ct = self.clconst.ChangeType(trigger[0], trigger[1])
params = self.load_params(event)
self.db.log_change(event['subject_entity'],
int(ct),
event['dest_entity'],
change_params=params,
skip_change=True,
skip_publish=True)
self.db.commit()
def log_event_receipt(self, event, trigger):
"""Log the "receipt" of a completed event in ChangeLog.
:type event: dict
:param event: Dict representing an event (as returned from get_event).
:param trigger: str or list or tuple
:param trigger: The change type code we want to associate with the
event. Only the first value will be used."""
# TODO: Set change_program from a sensible source to something smart
if isinstance(trigger, (list, tuple)):
trigger = trigger[0]
trigger = trigger.split(':')
ct = self.clconst.ChangeType(trigger[0], trigger[1])
parm = {'change_program': 'ExchangeIntegration',
'skip_event': True,
'skip_publish': True}
# Only log params if they actually contain something.
param = self.load_params(event)
if param:
parm['change_params'] = param
self.db.log_change(event['subject_entity'],
int(ct),
event['dest_entity'],
**parm)
self.db.commit()
####
# Email* utility methods
####
def get_email_target_info(self, target_id=None, target_entity=None):
"""Return the entity_type and entity_id of the entity the EmailTarget
points at. Look up by _either_ target_id or target_entity.
:type target_id: int
:param target_id: The EmailTargets id.
:type target_entity: int
:param target_entity: The targets target entity id.
:rtype: typle
:return: (entity_id, target_entity_id, target_entity_type, hard_quota,
soft_quota)."""
self.et.clear()
self.eq.clear()
if target_id:
self.et.find(target_id)
try:
self.eq.find(target_id)
except Errors.NotFoundError:
self.eq.clear()
elif target_entity:
self.et.find_by_target_entity(target_entity)
try:
self.eq.find(self.et.entity_id)
except Errors.NotFoundError:
self.eq.clear()
else:
self.db.rollback()
raise Errors.ProgrammingError(
'Must define either target_id og target_entity')
ret = (self.et.entity_id,
self.et.email_target_entity_id,
self.et.email_target_entity_type,
self.eq.get_quota_hard(),
self.eq.get_quota_soft())
self.db.rollback()
return ret
def get_email_domain_info(self, email_domain_id=None,
email_domain_name=None):
"""Return info about an EmailDomain.
:type email_domain_id: int
:param email_domain_id: The email domains id.
:rtype: dict
:return: {name: EmailDomain name, id: EmailDomain id}."""
self.ed.clear()
if email_domain_id:
self.ed.find(email_domain_id)
elif email_domain_name:
self.ed.find_by_domain(email_domain_name)
ret = {'name': self.ed.email_domain_name, 'id': self.ed.entity_id}
self.db.rollback()
return ret
####
# *Group utility methods
####
def get_distgroup_attributes_and_targetdata(self, subj_id):
"""Collect DistributionGroup specific information.
:type subj_id: int
:param subj_id: The entity-id of the DistributionGroup.
:rtype: dict
:return: A dict with DistributionGroup-specific data."""
# TODO: This might crash if someone where to add a spread, on a group
# which is not a DistributionGroup in Cerebrum
self.dg.clear()
self.dg.find(subj_id)
rl = True if self.dg.roomlist == 'T' else False
ret = self.dg.get_distgroup_attributes_and_targetdata(roomlist=rl)
self.db.rollback()
return ret
def get_distgroup_displayname(self, subj_id):
"""Get DisplayName for a DistributionGroup.
:type subj_id: int
:param subj_id: The DistributionGroups entity-id.
@rtype: Cerebrum.extlib.db_row.row
@return: Rows as returned by Entity.search_name_with_language()."""
self.dg.clear()
self.dg.find(subj_id)
ret = self.dg.search_name_with_language(
entity_id=subj_id,
name_variant=self.co.dl_group_displ_name,
name_language=self.co.language_nb)
self.db.rollback()
return ret
class CerebrumUtils(object):
"""Utility-class containing often used functions for Exchange."""
def __init__(self):
"""Initialize the Utils."""
self.db = Factory.get('Database')(client_encoding='UTF-8')
self.en = Factory.get('Entity')(self.db)
self.ac = Factory.get('Account')(self.db)
self.pe = Factory.get('Person')(self.db)
self.gr = Factory.get('Group')(self.db)
self.co = Factory.get('Constants')(self.db)
self.ed = EmailDomain(self.db)
self.eq = EmailQuota(self.db)
self.ef = EmailForward(self.db)
self.et = Factory.get('EmailTarget')(self.db)
self.dg = DistributionGroup(self.db)
####
# Person related methods
####
def get_person_accounts(self, person_id, spread=None):
"""Return a list of account information.
:type person_id: int
:param person_id: The person id to look up by.
:rtype: list
:return: A list of (account_id, username) tuples."""
ret = [(x['account_id'], x['name'])
for x in self.ac.search(owner_id=person_id,
owner_type=self.co.entity_person,
spread=self.co.spread_exchange_account)]
self.db.rollback()
return ret
def get_person_names(self, account_id=None, person_id=None):
"""Return a persons names.
:type account_id: int
:param account_id: The user to look up names by.
:type person_id: int
:param person_id: The person to look up names by.
:rtype: tuple
:return: A tuple consisting of first_name, last_name and the full name."""
# TODO: search_name_with_language?
if account_id:
self.ac.clear()
self.ac.find(account_id)
self.pe.clear()
self.pe.find(self.ac.owner_id)
elif person_id:
self.pe.clear()
self.pe.find(person_id)
else:
raise AssertionError('Called w/o person or account id')
ret = (self.pe.get_name(self.co.system_cached, self.co.name_first),
self.pe.get_name(self.co.system_cached, self.co.name_last),
self.pe.get_name(
self.co.system_cached,
self.co.name_full,
))
self.db.rollback()
return ret
def get_person_membership_groupnames(self, person_id):
"""List all the groups the person is a member of.
:type person_id: int
:param person_id: The persons entity_id.
:rtype: list
:return: list(string) of groupnames."""
ret = [
x['group_name']
for x in self.gr.search_members(member_id=person_id,
indirect_members=True)
]
self.db.rollback()
return ret
def is_electronic_reserved(self, person_id=None, account_id=None):
"""Check if a person has reserved themself from listing.
:type person_id: int
:param person_id: The persons entity_id.
:type account_id: int
:param account_id: The accounts entity_id.
:rtype: bool
:return: True if reserved, False otherwise."""
if person_id:
self.pe.clear()
self.pe.find(person_id)
ret = self.pe.has_e_reservation()
elif account_id:
self.ac.clear()
self.ac.find(account_id)
ret = self.ac.owner_has_ereservation()
# TODO: This is sane?
else:
ret = True
self.db.rollback()
return ret
####
# Account related methods
####
def get_account_mailaddrs(self, account_id):
"""Collect mailaddresses of an account.
:type account_id: int
:param account_id: The account_id representing the object.
:rtype: list
:return: A list of addresses."""
self.et.clear()
self.et.find_by_target_entity(account_id)
addrs = [
'%s@%s' % (x['local_part'], x['domain'])
for x in self.et.get_addresses()
]
self.db.rollback()
return addrs
def get_account_forwards(self, account_id):
"""Collect an accounts forward addresses.
:param int account_id: The account_id representing the object.
:return: A list of forward addresses."""
self.ef.clear()
self.ef.find_by_target_entity(account_id)
r = []
for fwd in self.ef.get_forward():
# Need to do keys() for now, db_row is stupid.
if 'enable' in fwd.keys() and fwd['enable'] == 'T':
r.append(fwd['forward_to'])
self.db.rollback()
return r
def get_account_local_delivery(self, account_id):
"""Check if this account should have local delivery.
:param int account_id: The account_id representing the object.
:rtype: bool
:return: Local delivery on or off."""
self.ef.clear()
self.ef.find_by_target_entity(account_id)
return self.ef.local_delivery
def get_account_name(self, account_id):
"""Return information about the account.
:type account_id: int
:param acccount_id: The accounts entity id.
:rtype: string
:return: The accounts name."""
self.ac.clear()
self.ac.find(account_id)
ret = self.ac.account_name
self.db.rollback()
return ret
def get_account_owner_info(self, account_id):
"""Return the type and id of the accounts owner.
:type account_id: int
:param acccount_id: The accounts entity id.
:rtype: tuple
:return: (entity_type, entity_id)."""
self.ac.clear()
self.ac.find(account_id)
ret = (self.ac.owner_type, self.ac.owner_id)
self.db.rollback()
return ret
def get_account_spreads(self, account_id):
"""Return the accounts spread codes.
:type account_id: int
:param acccount_id: The accounts entity id.
:rtype: list
:return: A list of the accounts spread codes."""
self.ac.clear()
self.ac.find(account_id)
ret = [x['spread'] for x in self.ac.get_spread()]
self.db.rollback()
return ret
def get_account_primary_email(self, account_id):
"""Return the accounts primary address.
:type account_id: int
:param acccount_id: The accounts entity id.
:rtype: str
:return: The accounts primary email-address."""
self.ac.clear()
self.ac.find(account_id)
ret = self.ac.get_primary_mailaddress()
self.db.rollback()
return ret
def get_account_id(self, uname):
"""Get an accounts entity id.
:type uname: str
:param uname: The users name.
:rtype: int
:return: The entity id of the account."""
self.ac.clear()
self.ac.find_by_name(uname)
ret = self.ac.entity_id
self.db.rollback()
return ret
def get_primary_account(self, person_id):
"""Get a persons primary account.
:type person_id: int
:param person_id: The persons entity id.
:rtype: int
:return: The primary accounts entity_id or None if no primary."""
self.pe.clear()
self.pe.find(person_id)
ret = self.pe.get_primary_account()
self.db.rollback()
return ret
def get_account_group_memberships(self, uname, group_spread):
"""Get a list of group names, which the user (and users owner, if
person), is a member of.
:type uname: string
:param uname: The accounts name.
:type group_spread: _SpreadCode
:param group_spread: Spread to filter groups by.
:rtype: list(tuple)
:return: A list of tuples contining group-name and -id."""
self.ac.clear()
self.ac.find_by_name(uname)
groups = []
# Fetch the groups the person is a member of
if self.ac.owner_type == self.co.entity_person:
for group in self.gr.search(member_id=self.ac.owner_id,
spread=group_spread,
indirect_members=True):
groups.append((group['name'], group['group_id']))
# Fetch the groups the account is a member of
for group in self.gr.search(member_id=self.ac.entity_id,
spread=group_spread,
indirect_members=True):
groups.append((group['name'], group['group_id']))
self.db.rollback()
return groups
####
# Group related methods
####
def construct_group_names(self, uname, gname):
"""Construct Exchange related group names.
:param str uname: The users username.
:param str gname: The owning groups groupname.
:rtype: tuple(str)
:return: A tuple consisting of FirstName, LastName and DisplayName."""
fn = uname
ln = '(owner: %s)' % gname
dn = '%s (owner: %s)' % (uname, gname)
return (fn, ln, dn)
def get_group_information(self, group_id):
"""Get a groups name and description.
:type group_id: int
:param group_id: The groups entity id.
:rtype: tuple
:return: The groups name and description."""
# This function is kinda generic. We don't care
# (yet) if it's a distribution or security group.
r = self.gr.search(group_id=group_id)[0]
ret = (r['name'], r['description'])
self.db.rollback()
return ret
def get_group_id(self, group_name):
"""Get a groups entity_id.
:type group_name: str
:param group_name: The groups name.
:rtype: int
:return: The groups entity_id."""
self.gr.clear()
self.gr.find_by_name(group_name)
ret = self.gr.entity_id
self.db.rollback()
return ret
def get_group_spreads(self, group_id):
"""Return the groupss spread codes.
:type group_id: int
:param group_id: The accounts entity id.
:rtype: list
:return: A list of the accounts spread codes."""
self.gr.clear()
self.gr.find(group_id)
ret = [x['spread'] for x in self.gr.get_spread()]
self.db.rollback()
return ret
def get_group_members(self, group_id, spread=None, filter_spread=None):
"""Collect a list of the usernames of all users in a group.
:type group_id: int
:param group_id: The groups entity_id.
:type spread: _SpreadCode
:param spread: The spread to filter by.
:type filter_spread: _SpreadCode
:param filter_spread: A spread that the user must also have.
:rtype: list
:return: A list of usernames who are members of group_id."""
found_accounts = []
r = []
for x in self.gr.search_members(group_id=group_id,
indirect_members=True,
member_spread=spread,
member_type=self.co.entity_account):
if x['member_id'] not in found_accounts:
if filter_spread in self.get_account_spreads(x['member_id']):
r.append({
'name': self.get_account_name(x['member_id']),
'account_id': x['member_id']
})
found_accounts.append(x['member_id'])
spreads = []
if spread:
spreads += [int(spread)]
if filter_spread:
spreads += [int(filter_spread)]
for x in self.gr.search_members(group_id=group_id,
indirect_members=True,
member_type=self.co.entity_person):
self.pe.clear()
self.pe.find(x['member_id'])
aid = self.pe.get_primary_account()
if aid:
self.ac.clear()
self.ac.find(aid)
if self.ac.entity_id not in found_accounts:
# If/elif used to allow usage without filter and
# filter_spread params
if spreads and \
set(spreads).issubset(
set([x['spread'] for x in self.ac.get_spread()])):
r.append({
'name': self.ac.account_name,
'account_id': self.ac.entity_id
})
found_accounts.append(self.ac.entity_id)
elif not spreads:
r.append({
'name': self.ac.account_name,
'account_id': self.ac.entity_id
})
found_accounts.append(self.ac.entity_id)
self.db.rollback()
return r
def get_parent_groups(self, id, spread=None, name_prefix=None):
"""Return all groups that the group is an indirect member of. Filter
by spread and the start of the group name.
:type id: int
:param id: The entity_id.
:type spread: _SpreadCode
:param _SpreadCode: The spread code to filter by, default is None.
:type name_prefix: str
:param name_prefix: Check if the group starts with this, default None.
:rtype: list
:return: A list of appropriate groups."""
if name_prefix:
np = '%s%%' % name_prefix
else:
np = None
groups = []
for group in self.gr.search(member_id=id,
indirect_members=True,
spread=spread,
name=np):
groups.append(group['name'])
self.db.rollback()
return groups
####
# Other utility methods
####
def unpickle_event_params(self, event):
"""Unpickle the change params of an event.
:type event: dbrow
:param event: The db row returned by Change- or EventLog.
:rtype: string
:return: The change params."""
# Hopefully, evertyhin will use UTF in the end
try:
return pickle.loads(event['change_params'])
except:
return pickle.loads(event['change_params'].encode('ISO_8859_15'))
def get_entity_type(self, entity_id):
"""Fetch the entity type code of an entity.
:type entity_id: int
:param entity_id: The entity id.
:rtype: long
:return: The entity type code."""
self.en.clear()
self.en.find(entity_id)
ret = self.en.entity_type
self.db.rollback()
return ret
def log_event(self, event, trigger):
"""Utility method used to create an event only in the EventLog.
:type event: dict
:param event: Dict representing an event (as returned from get_event).
:param trigger: str or list or tuple
:param trigger: The change type code we want to associate with the
event. Only the first value will be used."""
if isinstance(trigger, (list, tuple)):
trigger = trigger[0]
trigger = trigger.split(':')
ct = self.co.ChangeType(trigger[0], trigger[1])
param = self.unpickle_event_params(event)
self.db.log_change(event['subject_entity'],
int(ct),
event['dest_entity'],
change_params=param,
skip_change=True,
skip_publish=True)
self.db.commit()
def log_event_receipt(self, event, trigger):
"""Log the "receipt" of a completed event in ChangeLog.
:type event: dict
:param event: Dict representing an event (as returned from get_event).
:param trigger: str or list or tuple
:param trigger: The change type code we want to associate with the
event. Only the first value will be used."""
# TODO: Set change_program from a sensible source to something smart
if isinstance(trigger, (list, tuple)):
trigger = trigger[0]
trigger = trigger.split(':')
ct = self.co.ChangeType(trigger[0], trigger[1])
parm = {
'change_program': 'ExchangeIntegration',
'skip_event': True,
'skip_publish': True
}
# Only log params if they actually contain something.
param = self.unpickle_event_params(event)
if param:
parm['change_params'] = param
self.db.log_change(event['subject_entity'], int(ct),
event['dest_entity'], **parm)
self.db.commit()
####
# Email* utility methods
####
def get_email_target_info(self, target_id=None, target_entity=None):
"""Return the entity_type and entity_id of the entity the EmailTarget
points at. Look up by _either_ target_id or target_entity.
:type target_id: int
:param target_id: The EmailTargets id.
:type target_entity: int
:param target_entity: The targets target entity id.
:rtype: typle
:return: (entity_id, target_entity_id, target_entity_type, hard_quota,
soft_quota)."""
self.et.clear()
self.eq.clear()
if target_id:
self.et.find(target_id)
try:
self.eq.find(target_id)
except Errors.NotFoundError:
self.eq.clear()
elif target_entity:
self.et.find_by_target_entity(target_entity)
try:
self.eq.find(self.et.entity_id)
except Errors.NotFoundError:
self.eq.clear()
else:
self.db.rollback()
raise Errors.ProgrammingError(
'Must define either target_id og target_entity')
ret = (self.et.entity_id, self.et.email_target_entity_id,
self.et.email_target_entity_type, self.eq.get_quota_hard(),
self.eq.get_quota_soft())
self.db.rollback()
return ret
def get_email_domain_info(self,
email_domain_id=None,
email_domain_name=None):
"""Return info about an EmailDomain.
:type email_domain_id: int
:param email_domain_id: The email domains id.
:rtype: dict
:return: {name: EmailDomain name, id: EmailDomain id}."""
self.ed.clear()
if email_domain_id:
self.ed.find(email_domain_id)
elif email_domain_name:
self.ed.find_by_domain(email_domain_name)
ret = {'name': self.ed.email_domain_name, 'id': self.ed.entity_id}
self.db.rollback()
return ret
####
# *Group utility methods
####
def get_distgroup_attributes_and_targetdata(self, subj_id):
"""Collect DistributionGroup specific information.
:type subj_id: int
:param subj_id: The entity-id of the DistributionGroup.
:rtype: dict
:return: A dict with DistributionGroup-specific data."""
# TODO: This might crash if someone where to add a spread, on a group
# which is not a DistributionGroup in Cerebrum
self.dg.clear()
self.dg.find(subj_id)
rl = True if self.dg.roomlist == 'T' else False
ret = self.dg.get_distgroup_attributes_and_targetdata(roomlist=rl)
self.db.rollback()
return ret
def get_distgroup_displayname(self, subj_id):
"""Get DisplayName for a DistributionGroup.
:type subj_id: int
:param subj_id: The DistributionGroups entity-id.
@rtype: Cerebrum.extlib.db_row.row
@return: Rows as returned by Entity.search_name_with_language()."""
self.dg.clear()
self.dg.find(subj_id)
ret = self.dg.search_name_with_language(
entity_id=subj_id,
name_variant=self.co.dl_group_displ_name,
name_language=self.co.language_nb)
self.db.rollback()
return ret
import sys
from Cerebrum.Utils import Factory
from Cerebrum.modules.Email import EmailDomain
from Cerebrum.modules.Email import EmailAddress
from Cerebrum.modules.Email import EmailPrimaryAddressTarget
db = Factory.get('Database')()
db.cl_init(change_program='create_dg_moderator')
ac = Factory.get('Account')(db)
co = Factory.get('Constants')(db)
dg = Factory.get('DistributionGroup')(db)
gr = Factory.get('Group')(db)
et = Factory.get('EmailTarget')(db)
epat = EmailPrimaryAddressTarget(db)
ed = EmailDomain(db)
ea = EmailAddress(db)
group_name = 'groupadmin'
if len(sys.argv) > 1:
group_domain = sys.argv[1]
else:
group_domain = 'groups.uio.no'
ac.clear()
ac.find_by_name('bootstrap_account')
gr.clear()
gr.populate(
def get_domainid(db, domain_part):
domain = EmailDomain(db)
domain.find_by_domain(domain_part)
return domain.entity_id
def ed(self):
if not hasattr(self, '_ed'):
self._ed = EmailDomain(self._db)
return self._ed
import sys
from Cerebrum.Utils import Factory
from Cerebrum.modules.Email import EmailDomain
from Cerebrum.modules.Email import EmailAddress
from Cerebrum.modules.Email import EmailPrimaryAddressTarget
db = Factory.get('Database')()
db.cl_init(change_program='create_dg_moderator')
ac = Factory.get('Account')(db)
co = Factory.get('Constants')(db)
dg = Factory.get('DistributionGroup')(db)
gr = Factory.get('Group')(db)
et = Factory.get('EmailTarget')(db)
epat = EmailPrimaryAddressTarget(db)
ed = EmailDomain(db)
ea = EmailAddress(db)
group_name = 'groupadmin'
if len(sys.argv) > 1:
group_domain = sys.argv[1]
else:
group_domain = 'groups.uio.no'
ac.clear()
ac.find_by_name('bootstrap_account')
gr.clear()
gr.populate(ac.entity_id,
