def test_resource_users_for_any_perm(self, db_session):
self.maxDiff = 99999
self.set_up_user_group_and_perms(db_session)
perms = ResourceService.users_for_perm(
self.resource, "__any_permission__", db_session=db_session
)
second = [
PermissionTuple(
self.user, "group_perm", "group", self.group, self.resource, False, True
),
PermissionTuple(
self.user, "test_perm2", "user", None, self.resource, False, True
),
PermissionTuple(
self.user, "foo_perm", "user", None, self.resource, False, True
),
PermissionTuple(
self.user4,
"group_perm",
"group",
self.group2,
self.resource,
False,
True,
),
]
check_one_in_other(perms, second)
def test_resource_users_for_any_perm_excluding_group_perms(self, db_session):
self.maxDiff = 99999
self.set_up_user_group_and_perms(db_session)
user6 = add_user(db_session, 6, "user 6")
user7 = add_user(db_session, 7, "user 7")
perm2 = GroupResourcePermission(
perm_name="group_perm2", resource_id=self.resource.resource_id
)
self.group.resource_permissions.append(perm2)
self.group.users.append(user6)
self.group.users.append(user7)
perms = ResourceService.users_for_perm(
self.resource,
"__any_permission__",
limit_group_permissions=True,
skip_group_perms=True,
db_session=db_session,
)
second = [
PermissionTuple(
self.user, "test_perm2", "user", None, self.resource, False, True
),
PermissionTuple(
self.user, "foo_perm", "user", None, self.resource, False, True
),
]
check_one_in_other(perms, second)
def send_alerts(self, request=None, resource=None, db_session=None):
"""" Sends alerts to applicable channels """
db_session = get_db_session(db_session)
db_session.flush()
if not resource:
resource = ResourceService.by_resource_id(self.resource_id)
if not request:
request = get_current_request()
if not resource:
return
users = set(
[p.user for p in ResourceService.users_for_perm(resource, "view")])
for user in users:
for channel in user.alert_channels:
matches_resource = not channel.resources or resource in [
r.resource_id for r in channel.resources
]
if (not channel.channel_validated or not channel.send_alerts
or not matches_resource):
continue
else:
try:
channel.notify_alert(resource=resource,
event=self,
user=user,
request=request)
except IntegrationException as e:
log.warning("%s" % e)
def test_resource_users_for_any_perm(self, db_session):
self.maxDiff = 99999
self.set_up_user_group_and_perms(db_session)
perms = ResourceService.users_for_perm(self.resource,
"__any_permission__",
db_session=db_session)
second = [
PermissionTuple(self.user, "group_perm", "group", self.group,
self.resource, False, True),
PermissionTuple(self.user, "test_perm2", "user", None,
self.resource, False, True),
PermissionTuple(self.user, "foo_perm", "user", None, self.resource,
False, True),
PermissionTuple(
self.user4,
"group_perm",
"group",
self.group2,
self.resource,
False,
True,
),
]
check_one_in_other(perms, second)
def test_resource_users_limited_group_ownage(self, db_session):
self.maxDiff = 9999
self.set_up_user_group_and_perms(db_session)
resource = ResourceTestobjB(resource_id=99,
resource_name="other",
owner_user_id=self.user2.id)
group3 = add_group(db_session, "group 3")
user2_permission = UserResourcePermission(perm_name="foo_perm",
user_id=self.user2.id)
group3_permission = GroupResourcePermission(perm_name="group_perm",
group_id=group3.id)
resource.group_permissions.append(group3_permission)
resource.user_permissions.append(user2_permission)
group3.users.append(self.user3)
self.user.resources.append(resource)
self.group2.resources.append(resource)
db_session.flush()
perms = ResourceService.users_for_perm(resource,
"__any_permission__",
db_session=db_session)
second = [
PermissionTuple(self.user2, "foo_perm", "user", None, resource,
False, True),
PermissionTuple(self.user, ALL_PERMISSIONS, "user", None, resource,
True, True),
PermissionTuple(self.user4, ALL_PERMISSIONS, "group", self.group2,
resource, True, True),
PermissionTuple(self.user3, "group_perm", "group", group3,
resource, False, True),
]
check_one_in_other(perms, second)
def test_resource_users_for_any_perm_excluding_group_perms(
self, db_session):
self.maxDiff = 99999
self.set_up_user_group_and_perms(db_session)
user6 = add_user(db_session, 6, "user 6")
user7 = add_user(db_session, 7, "user 7")
perm2 = GroupResourcePermission(perm_name="group_perm2",
resource_id=self.resource.resource_id)
self.group.resource_permissions.append(perm2)
self.group.users.append(user6)
self.group.users.append(user7)
perms = ResourceService.users_for_perm(
self.resource,
"__any_permission__",
limit_group_permissions=True,
skip_group_perms=True,
db_session=db_session,
)
second = [
PermissionTuple(self.user, "test_perm2", "user", None,
self.resource, False, True),
PermissionTuple(self.user, "foo_perm", "user", None, self.resource,
False, True),
]
check_one_in_other(perms, second)
def check_user_report_notifications(resource_id):
since_when = datetime.utcnow()
try:
request = get_current_request()
application = ApplicationService.by_id(resource_id)
if not application:
return
error_key = REDIS_KEYS["reports_to_notify_per_type_per_app"].format(
ReportType.error, resource_id)
slow_key = REDIS_KEYS["reports_to_notify_per_type_per_app"].format(
ReportType.slow, resource_id)
error_group_ids = Datastores.redis.smembers(error_key)
slow_group_ids = Datastores.redis.smembers(slow_key)
Datastores.redis.delete(error_key)
Datastores.redis.delete(slow_key)
err_gids = [int(g_id) for g_id in error_group_ids]
slow_gids = [int(g_id) for g_id in list(slow_group_ids)]
group_ids = err_gids + slow_gids
occurence_dict = {}
for g_id in group_ids:
key = REDIS_KEYS["counters"]["report_group_occurences"].format(
g_id)
val = Datastores.redis.get(key)
Datastores.redis.delete(key)
if val:
occurence_dict[g_id] = int(val)
else:
occurence_dict[g_id] = 1
report_groups = ReportGroupService.by_ids(group_ids)
report_groups.options(sa.orm.joinedload(ReportGroup.last_report_ref))
ApplicationService.check_for_groups_alert(
application,
"alert",
report_groups=report_groups,
occurence_dict=occurence_dict,
)
users = set([
p.user
for p in ResourceService.users_for_perm(application, "view")
])
report_groups = report_groups.all()
for user in users:
UserService.report_notify(
user,
request,
application,
report_groups=report_groups,
occurence_dict=occurence_dict,
)
for group in report_groups:
# marks report_groups as notified
if not group.notified:
group.notified = True
except Exception as exc:
print_traceback(log)
raise
def test_resource_users_for_perm(self, db_session):
self.set_up_user_group_and_perms(db_session)
perms = ResourceService.users_for_perm(self.resource,
"foo_perm",
db_session=db_session)
second = [
PermissionTuple(self.user, "foo_perm", "user", None, self.resource,
False, True)
]
check_one_in_other(perms, second)
def test_resource_users_for_perm(self, db_session):
self.set_up_user_group_and_perms(db_session)
perms = ResourceService.users_for_perm(
self.resource, "foo_perm", db_session=db_session
)
second = [
PermissionTuple(
self.user, "foo_perm", "user", None, self.resource, False, True
)
]
check_one_in_other(perms, second)
def comment_create(request):
"""
Creates user comments for report group, sends email notifications
of said comments
"""
report_group = request.context.report_group
application = request.context.resource
form = forms.CommentForm(MultiDict(request.unsafe_json_body),
csrf_context=request)
if request.method == "POST" and form.validate():
comment = ReportComment(owner_id=request.user.id,
report_time=report_group.first_timestamp)
form.populate_obj(comment)
report_group.comments.append(comment)
perm_list = ResourceService.users_for_perm(application, "view")
uids_to_notify = []
users_to_notify = []
for perm in perm_list:
user = perm.user
if ("@{}".format(user.user_name) in comment.body
and user.id not in uids_to_notify):
uids_to_notify.append(user.id)
users_to_notify.append(user)
commenters = ReportGroupService.users_commenting(
report_group, exclude_user_id=request.user.id)
for user in commenters:
if user.id not in uids_to_notify:
uids_to_notify.append(user.id)
users_to_notify.append(user)
for user in users_to_notify:
email_vars = {
"user": user,
"commenting_user": request.user,
"request": request,
"application": application,
"report_group": report_group,
"comment": comment,
"email_title": "AppEnlight :: New comment",
}
UserService.send_email(
request,
recipients=[user.email],
variables=email_vars,
template="/email_templates/new_comment_report.jinja2",
)
request.session.flash(_("Your comment was created"))
return comment.get_dict()
else:
return form.errors
def test_resource_users_limited_group_other_user_3(self, db_session):
self.maxDiff = 9999
self.set_up_user_group_and_perms(db_session)
perms = ResourceService.users_for_perm(
self.resource2,
"__any_permission__",
user_ids=[self.user3.id],
db_session=db_session,
)
second = [
PermissionTuple(self.user3, "test_perm", "user", None,
self.resource2, False, True)
]
check_one_in_other(perms, second)
def test_resource_users_limited_group_other_user_3(self, db_session):
self.maxDiff = 9999
self.set_up_user_group_and_perms(db_session)
perms = ResourceService.users_for_perm(
self.resource2,
"__any_permission__",
user_ids=[self.user3.id],
db_session=db_session,
)
second = [
PermissionTuple(
self.user3, "test_perm", "user", None, self.resource2, False, True
)
]
check_one_in_other(perms, second)
def users_for_perm(self, perm_name, user_ids=None, group_ids=None,
limit_group_permissions=False, skip_group_perms=False,
db_session=None):
"""
.. deprecated:: 0.8
:param perm_name:
:param user_ids:
:param group_ids:
:param limit_group_permissions:
:param skip_group_perms:
:param db_session:
:return:
"""
db_session = get_db_session(db_session, self)
return ResourceService.users_for_perm(
self, perm_name, user_ids=user_ids, group_ids=group_ids,
limit_group_permissions=limit_group_permissions,
skip_group_perms=skip_group_perms, db_session=db_session)
def assigned_users(request):
"""
Returns list of users a specific report group is assigned for review
"""
report_group = request.context.report_group
application = request.context.resource
users = set(
[p.user for p in ResourceService.users_for_perm(application, "view")])
currently_assigned = [u.user_name for u in report_group.assigned_users]
user_status = {"assigned": [], "unassigned": []}
# handle users
for user in users:
user_dict = {
"user_name": user.user_name,
"gravatar_url": UserService.gravatar_url(user),
"name": "%s %s" % (user.first_name, user.last_name),
}
if user.user_name in currently_assigned:
user_status["assigned"].append(user_dict)
elif user_dict not in user_status["unassigned"]:
user_status["unassigned"].append(user_dict)
return user_status
def test_resource_users_limited_group_ownage(self, db_session):
self.maxDiff = 9999
self.set_up_user_group_and_perms(db_session)
resource = TestResourceB(
resource_id=99, resource_name="other", owner_user_id=self.user2.id
)
group3 = add_group(db_session, "group 3")
user2_permission = UserResourcePermission(
perm_name="foo_perm", user_id=self.user2.id
)
group3_permission = GroupResourcePermission(
perm_name="group_perm", group_id=group3.id
)
resource.group_permissions.append(group3_permission)
resource.user_permissions.append(user2_permission)
group3.users.append(self.user3)
self.user.resources.append(resource)
self.group2.resources.append(resource)
db_session.flush()
perms = ResourceService.users_for_perm(
resource, "__any_permission__", db_session=db_session
)
second = [
PermissionTuple(
self.user2, "foo_perm", "user", None, resource, False, True
),
PermissionTuple(
self.user, ALL_PERMISSIONS, "user", None, resource, True, True
),
PermissionTuple(
self.user4, ALL_PERMISSIONS, "group", self.group2, resource, True, True
),
PermissionTuple(
self.user3, "group_perm", "group", group3, resource, False, True
),
]
check_one_in_other(perms, second)
def daily_digest():
"""
Sends daily digest with top 50 error reports
"""
request = get_current_request()
apps = Datastores.redis.smembers(REDIS_KEYS["apps_that_had_reports"])
Datastores.redis.delete(REDIS_KEYS["apps_that_had_reports"])
since_when = datetime.utcnow() - timedelta(hours=8)
log.warning("Generating daily digests")
for resource_id in apps:
resource_id = resource_id.decode("utf8")
end_date = datetime.utcnow().replace(microsecond=0, second=0)
filter_settings = {
"resource": [resource_id],
"tags": [{
"name": "type",
"value": ["error"],
"op": None
}],
"type": "error",
"start_date": since_when,
"end_date": end_date,
}
reports = ReportGroupService.get_trending(
request, filter_settings=filter_settings, limit=50)
application = ApplicationService.by_id(resource_id)
if application:
users = set([
p.user
for p in ResourceService.users_for_perm(application, "view")
])
for user in users:
user.send_digest(request,
application,
reports=reports,
since_when=since_when)
def test_resource_users_limited_group_other_user_4(self, db_session):
self.maxDiff = 9999
self.set_up_user_group_and_perms(db_session)
perms = ResourceService.users_for_perm(
self.resource,
"__any_permission__",
user_ids=[self.user4.id],
group_ids=[self.group2.id],
db_session=db_session,
)
second = [
PermissionTuple(
self.user4,
"group_perm",
"group",
self.group2,
self.resource,
False,
True,
)
]
check_one_in_other(perms, second)
def test_resource_users_limited_group_other_user_4(self, db_session):
self.maxDiff = 9999
self.set_up_user_group_and_perms(db_session)
perms = ResourceService.users_for_perm(
self.resource,
"__any_permission__",
user_ids=[self.user4.id],
group_ids=[self.group2.id],
db_session=db_session,
)
second = [
PermissionTuple(
self.user4,
"group_perm",
"group",
self.group2,
self.resource,
False,
True,
)
]
check_one_in_other(perms, second)
def get_patch(self):
request = self.request
resource = self.request.context.resource
breadcrumbs = tree_service.path_upper(
resource.resource_id, db_session=self.request.dbsession)
user_permission_form = UserResourcePermissionForm(
request.POST, context={'request': request})
group_permission_form = GroupResourcePermissionForm(
request.POST, context={'request': request})
groups = GroupService.base_query(db_session=request.dbsession)
group_permission_form.group_id.choices = [(g.id, g.group_name)
for g in groups]
choices = [(p, p) for p in resource.__possible_permissions__]
user_permission_form.perm_name.choices = choices
group_permission_form.perm_name.choices = choices
permissions = ResourceService.users_for_perm(
resource, perm_name=ANY_PERMISSION, limit_group_permissions=True)
user_permissions = sorted([p for p in permissions if p.type == 'user'],
key=lambda x: x.user.user_name)
group_permissions = sorted(
[p for p in permissions if p.type == 'group'],
key=lambda x: x.group.group_name)
user_permissions_grid = ResourceUserPermissionsGrid(user_permissions,
request=request)
group_permissions_grid = ResourceGroupPermissionsGrid(
group_permissions, request=request)
parent_id_choices = get_possible_parents(self.request)
resource_form = EntryCreateForm(request.POST,
obj=resource,
context={
'request': request,
'modified_obj': resource
})
resource_form.parent_id.choices = parent_id_choices
if request.method == "POST" and resource_form.validate():
parent_id = resource_form.data.get('parent_id', noop)
position = resource_form.data.get('ordering', noop)
# we need to not change_parent_id or order of element
# to not confuse tree manager
self.shared.populate_instance(
resource,
resource_form.data,
exclude_keys=['parent_id', 'ordering'])
into_new_parent = parent_id != resource.parent_id and \
parent_id is not noop
if position is not noop or into_new_parent:
if not position and into_new_parent:
position = tree_service.count_children(
parent_id, db_session=self.request.dbsession) + 1
tree_service.move_to_position(
resource_id=resource.resource_id,
new_parent_id=parent_id,
to_position=position,
db_session=self.request.dbsession)
return {
'breadcrumbs': breadcrumbs,
'resource': resource,
'resource_form': resource_form,
'user_permission_form': user_permission_form,
'group_permission_form': group_permission_form,
'group_permissions_grid': group_permissions_grid,
'user_permissions_grid': user_permissions_grid
}
def user_permissions_list(self):
return [
permission_tuple_to_dict(perm)
for perm in ResourceService.users_for_perm(
self, "__any_permission__", limit_group_permissions=True)
]