Revision 6f6efdcd
Fusion du travail fait dans la branche 'nested_sets' vers le trunk.
git-svn-id: https://vigilo-dev.si.c-s.fr/svn@6116 b22e2e97-25c9-44ff-b637-2e5ceca36478
| vigiboard/controllers/root.py | ||
|---|---|---|
| 31 | 31 |
from pylons.i18n import ugettext as _, lazy_ugettext as l_ |
| 32 | 32 |
from sqlalchemy import asc |
| 33 | 33 |
from sqlalchemy.sql import func |
| 34 |
from sqlalchemy.orm import aliased |
|
| 34 | 35 |
from repoze.what.predicates import Any, All, in_group, \ |
| 35 | 36 |
has_permission, not_anonymous, \ |
| 36 | 37 |
NotAuthorizedError |
| ... | ... | |
| 41 | 42 |
from vigilo.models.tables import Event, EventHistory, CorrEvent, Host, \ |
| 42 | 43 |
SupItem, SupItemGroup, LowLevelService, \ |
| 43 | 44 |
StateName, State |
| 44 |
from vigilo.models.tables.grouphierarchy import GroupHierarchy |
|
| 45 | 45 |
from vigilo.models.functions import sql_escape_like |
| 46 | 46 |
from vigilo.models.tables.secondary_tables import EVENTSAGGREGATE_TABLE |
| 47 | 47 |
|
| ... | ... | |
| 147 | 147 |
|
| 148 | 148 |
# Application des filtres si nécessaire |
| 149 | 149 |
if supitemgroup: |
| 150 |
search['supitemgroup'] = supitemgroup |
|
| 151 |
aggregates.add_join((GroupHierarchy, GroupHierarchy.idchild == |
|
| 152 |
aggregates.items.c.idsupitemgroup)) |
|
| 153 |
aggregates.add_filter(GroupHierarchy.idparent == supitemgroup) |
|
| 150 |
base = DBSession.query(SupItemGroup).get(supitemgroup) |
|
| 151 |
if base: |
|
| 152 |
search['supitemgroup'] = supitemgroup |
|
| 153 |
sig = aliased(SupItemGroup) |
|
| 154 |
aggregates.add_join( |
|
| 155 |
(sig, aggregates.items.c.idsupitemgroup == sig.idgroup), |
|
| 156 |
) |
|
| 157 |
aggregates.add_filter(sig.left >= base.left) |
|
| 158 |
aggregates.add_filter(sig.right <= base.right) |
|
| 154 | 159 |
|
| 155 | 160 |
if host: |
| 156 | 161 |
search['host_'] = host |
| 157 | 162 |
host = sql_escape_like(host) |
| 158 |
aggregates.add_filter(aggregates.items.c.hostname.ilike( |
|
| 159 |
'%s' % host)) |
|
| 163 |
aggregates.add_filter(aggregates.items.c.hostname.ilike(host)) |
|
| 160 | 164 |
|
| 161 | 165 |
if service: |
| 162 | 166 |
search['service'] = service |
| 163 | 167 |
service = sql_escape_like(service) |
| 164 |
aggregates.add_filter(aggregates.items.c.servicename.ilike( |
|
| 165 |
'%s' % service)) |
|
| 168 |
aggregates.add_filter(aggregates.items.c.servicename.ilike(service)) |
|
| 166 | 169 |
|
| 167 | 170 |
if output: |
| 168 | 171 |
search['output'] = output |
| 169 | 172 |
output = sql_escape_like(output) |
| 170 |
aggregates.add_filter(Event.message.ilike('%s' % output))
|
|
| 173 |
aggregates.add_filter(Event.message.ilike(output)) |
|
| 171 | 174 |
|
| 172 | 175 |
if trouble_ticket: |
| 173 | 176 |
search['tt'] = trouble_ticket |
| 174 | 177 |
trouble_ticket = sql_escape_like(trouble_ticket) |
| 175 |
aggregates.add_filter(CorrEvent.trouble_ticket.ilike( |
|
| 176 |
'%s' % trouble_ticket)) |
|
| 178 |
aggregates.add_filter(CorrEvent.trouble_ticket.ilike(trouble_ticket)) |
|
| 177 | 179 |
|
| 178 | 180 |
if from_date: |
| 179 | 181 |
search['from_date'] = from_date.lower() |
| ... | ... | |
| 205 | 207 |
else: |
| 206 | 208 |
aggregates.add_filter(CorrEvent.timestamp_active <= to_date) |
| 207 | 209 |
|
| 210 |
|
|
| 208 | 211 |
# Calcul des éléments à afficher et du nombre de pages possibles |
| 209 | 212 |
total_rows = aggregates.num_rows() |
| 210 | 213 |
items_per_page = int(config['vigiboard_items_per_page']) |
| ... | ... | |
| 749 | 752 |
if parent_id is None: |
| 750 | 753 |
return self.get_root_host_groups() |
| 751 | 754 |
|
| 752 |
# TODO: Utiliser un schéma de validation |
|
| 753 |
parent_id = int(parent_id) |
|
| 755 |
parent = DBSession.query(SupItemGroup).get(parent_id) |
|
| 754 | 756 |
|
| 755 | 757 |
# On vérifie si le groupe parent fait partie des |
| 756 | 758 |
# groupes auxquel l'utilisateur a accès, et on |
| 757 | 759 |
# retourne une liste vide dans le cas contraire |
| 758 | 760 |
is_manager = in_group('managers').is_met(request.environ)
|
| 759 |
if not is_manager: |
|
| 760 |
direct_access = False |
|
| 761 |
user = get_current_user() |
|
| 762 |
user_groups = dict(user.supitemgroups()) |
|
| 763 |
# On regarde d'abord si le groupe fait partie de ceux |
|
| 764 |
# auquels l'utilisateur a explicitement accès, ou s'il |
|
| 765 |
# est un parent des groupes auxquels l'utilisateur a accès |
|
| 766 |
if parent_id in user_groups.keys(): |
|
| 767 |
direct_access = user_groups[parent_id] |
|
| 768 |
# Dans le cas contraire, on vérifie si le groupe est un |
|
| 769 |
# sous-groupe des groupes auxquels l'utilisateur a accès |
|
| 770 |
else: |
|
| 771 |
id_list = [ug for ug in user_groups.keys() if user_groups[ug]] |
|
| 772 |
child_groups = DBSession.query(SupItemGroup.idgroup |
|
| 773 |
).distinct( |
|
| 774 |
).join( |
|
| 775 |
(GroupHierarchy, |
|
| 776 |
GroupHierarchy.idchild == SupItemGroup.idgroup), |
|
| 777 |
).filter(GroupHierarchy.idparent.in_(id_list) |
|
| 778 |
).filter(GroupHierarchy.hops > 0 |
|
| 779 |
).all() |
|
| 780 |
for ucg in child_groups: |
|
| 781 |
if ucg.idgroup == parent_id: |
|
| 782 |
direct_access = True |
|
| 783 |
break |
|
| 784 |
# Sinon, l'utilisateur n'a pas accès à ce groupe |
|
| 785 |
else: |
|
| 786 |
return dict(groups = [], leaves = []) |
|
| 787 | 761 |
|
| 788 | 762 |
# On récupère la liste des groupes dont |
| 789 | 763 |
# l'identifiant du parent est passé en paramètre |
| 790 | 764 |
db_groups = DBSession.query( |
| 791 | 765 |
SupItemGroup |
| 792 |
).join( |
|
| 793 |
(GroupHierarchy, GroupHierarchy.idchild == \ |
|
| 794 |
SupItemGroup.idgroup), |
|
| 795 |
).filter(GroupHierarchy.hops == 1 |
|
| 796 |
).filter(GroupHierarchy.idparent == parent_id |
|
| 766 |
).filter(SupItemGroup.depth == parent.depth + 1 |
|
| 767 |
).filter(SupItemGroup.left > parent.left |
|
| 768 |
).filter(SupItemGroup.right < parent.right |
|
| 797 | 769 |
).order_by(SupItemGroup.name.asc()) |
| 798 |
if not is_manager and not direct_access: |
|
| 799 |
id_list = [ug for ug in user_groups.keys()] |
|
| 800 |
db_groups = db_groups.filter( |
|
| 801 |
SupItemGroup.idgroup.in_(id_list)) |
|
| 770 |
|
|
| 771 |
if not is_manager: |
|
| 772 |
user = get_current_user() |
|
| 773 |
user_groups = [g[0] for g in user.supitemgroups() if g[1]] |
|
| 774 |
db_groups = db_groups.filter(SupItemGroup.idgroup.in_(user_groups)) |
|
| 775 |
|
|
| 802 | 776 |
groups = [] |
| 803 | 777 |
for group in db_groups.all(): |
| 804 | 778 |
groups.append({
|
| ... | ... | |
| 817 | 791 |
@rtype : C{dict} of C{list} of C{dict} of C{mixed}
|
| 818 | 792 |
""" |
| 819 | 793 |
|
| 820 |
# On récupère tous les groupes qui ont un parent. |
|
| 821 |
children = DBSession.query( |
|
| 822 |
SupItemGroup, |
|
| 823 |
).distinct( |
|
| 824 |
).join( |
|
| 825 |
(GroupHierarchy, GroupHierarchy.idchild == SupItemGroup.idgroup) |
|
| 826 |
).filter(GroupHierarchy.hops > 0) |
|
| 827 |
|
|
| 828 |
# Ensuite on les exclut de la liste des groupes, |
|
| 829 |
# pour ne garder que ceux qui sont au sommet de |
|
| 830 |
# l'arbre et qui constituent nos "root groups". |
|
| 831 |
root_groups = DBSession.query( |
|
| 832 |
SupItemGroup, |
|
| 833 |
).except_(children |
|
| 834 |
).order_by(SupItemGroup.name) |
|
| 794 |
root_groups = SupItemGroup.get_top_groups() |
|
| 835 | 795 |
|
| 836 | 796 |
# On filtre ces groupes racines afin de ne |
| 837 | 797 |
# retourner que ceux auquels l'utilisateur a accès |
| 838 | 798 |
user = get_current_user() |
| 839 | 799 |
is_manager = in_group('managers').is_met(request.environ)
|
| 840 | 800 |
if not is_manager: |
| 841 |
user_groups = [ug[0] for ug in user.supitemgroups()] |
|
| 842 |
root_groups = root_groups.filter( |
|
| 843 |
SupItemGroup.idgroup.in_(user_groups)) |
|
| 801 |
user_groups = [sig[0] for sig in user.supitemgroups()] |
|
| 802 |
for root_group in root_groups: |
|
| 803 |
if root_group.idgroup not in user_groups: |
|
| 804 |
root_groups.remove(root_group) |
|
| 844 | 805 |
|
| 845 | 806 |
groups = [] |
| 846 |
for group in root_groups.all():
|
|
| 807 |
for group in root_groups: |
|
| 847 | 808 |
groups.append({
|
| 848 | 809 |
'id' : group.idgroup, |
| 849 | 810 |
'name' : group.name, |
Also available in: Unified diff