def delete(self, request, name=None):
if name:
try:
apikey = MyAPIKey.objects.get(name=name)
apikey.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
except MyAPIKey.DoesNotExist:
raise NotFound(status=404, detail='API key not found')
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, username=None):
if username:
try:
user = CustUser.objects.get(username=username)
user.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
except CustUser.DoesNotExist:
raise (NotFound(status=404, detail='User not found'))
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, apiid=None):
if apiid:
try:
ThresholdsProfiles.objects.get(apiid=apiid).delete()
return Response(status=status.HTTP_204_NO_CONTENT)
except ThresholdsProfiles.DoesNotExist:
raise NotFound(status=404,
detail='Thresholds profile not found.')
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request, username=None):
if username:
if request.user.is_superuser or (
not request.user.is_superuser and
request.user.username == username
):
users = CustUser.objects.filter(username=username)
if users.count() == 0:
raise NotFound(status=404, detail='User does not exist.')
else:
return error_response(
status_code=status.HTTP_403_FORBIDDEN,
detail='You do not have permission to fetch users other '
'than yourself.'
)
else:
if request.user.is_superuser:
users = CustUser.objects.all()
else:
users = CustUser.objects.filter(username=request.user.username)
results = []
for user in users:
if user.last_login:
last_login = datetime.datetime.strftime(
user.last_login, '%Y-%m-%d %H:%M:%S'
)
else:
last_login = ''
results.append(dict(
pk=user.pk,
username=user.username,
first_name=user.first_name,
last_name=user.last_name,
is_active=user.is_active,
is_superuser=user.is_superuser,
email=user.email,
date_joined=datetime.datetime.strftime(
user.date_joined, '%Y-%m-%d %H:%M:%S'
),
last_login=last_login
))
results = sorted(results, key=lambda k: k['username'])
if username:
return Response(results[0])
else:
return Response(results)
def get(self, request, name=None):
if name:
metrics = poem_models.Metric.objects.filter(name=name)
if metrics.count() == 0:
raise NotFound(status=404, detail='Metric not found')
else:
metrics = poem_models.Metric.objects.all()
results = []
for metric in metrics:
config = two_value_inline(metric.config)
parent = one_value_inline(metric.parent)
probeexecutable = one_value_inline(metric.probeexecutable)
attribute = two_value_inline(metric.attribute)
dependancy = two_value_inline(metric.dependancy)
flags = two_value_inline(metric.flags)
files = two_value_inline(metric.files)
parameter = two_value_inline(metric.parameter)
fileparameter = two_value_inline(metric.fileparameter)
if metric.probekey:
probeversion = metric.probekey.__str__()
else:
probeversion = ''
if metric.group:
group = metric.group.name
else:
group = ''
results.append(
dict(id=metric.id,
name=metric.name,
mtype=metric.mtype.name,
probeversion=probeversion,
group=group,
parent=parent,
probeexecutable=probeexecutable,
config=config,
attribute=attribute,
dependancy=dependancy,
flags=flags,
files=files,
parameter=parameter,
fileparameter=fileparameter))
results = sorted(results, key=lambda k: k['name'])
if name:
return Response(results[0])
else:
return Response(results)
def delete(self, request, group=None):
if group:
try:
group = poem_models.GroupOfMetrics.objects.get(name=group)
group.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
except poem_models.GroupOfMetrics.DoesNotExist:
raise (NotFound(status=404,
detail='Group of metrics not found'))
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request):
try:
apikey = MyAPIKey.objects.get(name='WEB-API-RO')
api_format = dict(id=apikey.id,
name=apikey.name,
token=apikey.token,
created=datetime.datetime.strftime(
apikey.created, '%Y-%m-%d %H:%M:%S'),
revoked=apikey.revoked)
except MyAPIKey.DoesNotExist:
raise NotFound(status=404, detail='API key not found')
return Response(api_format)
def delete(self, request, profile_name=None):
if profile_name:
try:
userprofile = poem_models.UserProfile.objects.get(
user=request.user)
usergroups = \
userprofile.groupsofmetricprofiles.all().values_list(
'name', flat=True
)
if not request.user.is_superuser and len(usergroups) == 0:
return error_response(
status_code=status.HTTP_401_UNAUTHORIZED,
detail='You do not have permission to delete metric '
'profiles.')
else:
try:
profile = poem_models.MetricProfiles.objects.get(
apiid=profile_name)
user_perm = request.user.is_superuser or \
profile.groupname in usergroups
if user_perm:
poem_models.TenantHistory.objects.filter(
object_id=profile.id,
content_type=ContentType.objects.get_for_model(
profile)).delete()
profile.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
else:
return error_response(
status_code=status.HTTP_401_UNAUTHORIZED,
detail='You do not have permission to delete '
'metric profiles assigned to this group.')
except poem_models.MetricProfiles.DoesNotExist:
raise NotFound(status=404,
detail='Metric profile not found')
except poem_models.UserProfile.DoesNotExist:
return error_response(
detail='No user profile for authenticated user.',
status_code=status.HTTP_404_NOT_FOUND)
else:
return Response({'detail': 'Metric profile not specified!'},
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, name=None):
if name:
try:
probe = admin_models.Probe.objects.get(name=name)
if probe.datetime:
probe_datetime = datetime.datetime.strftime(
probe.datetime, '%Y-%m-%dT%H:%M:%S.%f')
else:
probe_datetime = ''
result = dict(id=probe.id,
name=probe.name,
version=probe.package.version,
package=probe.package.__str__(),
docurl=probe.docurl,
description=probe.description,
comment=probe.comment,
repository=probe.repository,
user=probe.user,
datetime=probe_datetime)
return Response(result)
except admin_models.Probe.DoesNotExist:
raise NotFound(status=404, detail='Probe not found')
else:
probes = admin_models.Probe.objects.all()
results = []
for probe in probes:
# number of probe revisions
nv = admin_models.ProbeHistory.objects.filter(
object_id=probe).count()
results.append(
dict(name=probe.name,
version=probe.package.version,
package=probe.package.__str__(),
docurl=probe.docurl,
description=probe.description,
comment=probe.comment,
repository=probe.repository,
nv=nv))
results = sorted(results, key=lambda k: k['name'].lower())
return Response(results)
def get(self, request, username=None):
if username:
try:
user = CustUser.objects.get(username=username)
except CustUser.DoesNotExist:
raise NotFound(status=404, detail='User not found')
else:
results = get_groups_for_user(user)
else:
results = get_all_groups()
return Response({'result': results})
def put(self, request):
try:
names = MyAPIKey.objects.all().values_list('name', flat=True)
if request.data['name'] not in names:
obj = MyAPIKey.objects.get(id=request.data['id'])
obj.name = request.data['name']
obj.revoked = request.data['revoked']
obj.save()
else:
return Response(status=status.HTTP_403_FORBIDDEN)
return Response(status=status.HTTP_201_CREATED)
except MyAPIKey.DoesNotExist:
raise NotFound(status=404, detail='API key not found')
def delete(self, request, name=None, tag=None):
if name and tag:
if tag == 'centos6':
ostag = admin_models.OSTag.objects.get(name='CentOS 6')
else:
ostag = admin_models.OSTag.objects.get(name='CentOS 7')
try:
admin_models.YumRepo.objects.get(name=name, tag=ostag).delete()
return Response(status=status.HTTP_204_NO_CONTENT)
except admin_models.YumRepo.DoesNotExist:
raise NotFound(status=404, detail='YUM repo not found.')
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, name=None):
if name:
try:
metric = poem_models.Metric.objects.get(name=name)
poem_models.TenantHistory.objects.filter(
object_id=metric.id,
content_type=ContentType.objects.get_for_model(
poem_models.Metric)).delete()
metric.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
except poem_models.Metric.DoesNotExist:
raise NotFound(status=404, detail='Metric not found')
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, aggregation_name):
if aggregation_name:
try:
aggregation = poem_models.Aggregation.objects.get(
apiid=aggregation_name)
poem_models.TenantHistory.objects.filter(
object_id=aggregation.id,
content_type=ContentType.objects.get_for_model(
aggregation)).delete()
aggregation.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
except poem_models.Aggregation.DoesNotExist:
raise NotFound(status=404, detail='Aggregation not found')
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request, group=None):
if group:
gr = poem_models.GroupOfMetrics.objects.filter(name__exact=group)
if len(gr) > 0:
metrics = poem_models.Metric.objects.filter(
group__name__exact=group)
else:
raise NotFound(status=404, detail='Group not found')
else:
metrics = poem_models.Metric.objects.filter(group=None)
results = []
for item in metrics:
results.append({'id': item.id, 'name': item.name})
results = sorted(results, key=lambda k: k['name'])
return Response({'result': results})
def delete(self, request, nameversion):
package_name, package_version = get_package_version(nameversion)
try:
admin_models.Package.objects.get(name=package_name,
version=package_version).delete()
return Response(status=status.HTTP_204_NO_CONTENT)
except admin_models.Package.DoesNotExist:
raise NotFound(status=404, detail='Package not found.')
except ProtectedError:
return Response(
{
'detail':
'You cannot delete package with associated probes!'
},
status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, aggregation_name=None):
if aggregation_name:
try:
aggregation = poem_models.Aggregation.objects.get(
apiid=aggregation_name)
groupname = None
if aggregation.groupname:
try:
groupname = poem_models.GroupOfAggregations.objects.get(
name=aggregation.groupname)
except poem_models.GroupOfAggregations.DoesNotExist:
pass
userprofile = poem_models.UserProfile.objects.get(
user=request.user)
if (groupname and groupname
in userprofile.groupsofaggregations.all()
) or request.user.is_superuser:
poem_models.TenantHistory.objects.filter(
object_id=aggregation.id,
content_type=ContentType.objects.get_for_model(
aggregation)).delete()
aggregation.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
else:
return error_response(
detail='You do not have group permission to delete this'
' aggregation profile.',
status_code=status.HTTP_401_UNAUTHORIZED)
except poem_models.Aggregation.DoesNotExist:
raise NotFound(status=404, detail='Aggregation not found')
except poem_models.UserProfile.DoesNotExist:
return error_response(
detail='No user profile for authenticated user.',
status_code=status.HTTP_404_NOT_FOUND)
else:
return error_response(detail='Aggregation profile not specified!',
status_code=status.HTTP_400_BAD_REQUEST)
def delete(self, request, group=None):
if group:
try:
gr = poem_models.GroupOfAggregations.objects.get(name=group)
gr.delete()
for aggr in poem_models.Aggregation.objects.filter(
groupname=group):
aggr.groupname = ''
aggr.save()
return Response(status=status.HTTP_204_NO_CONTENT)
except poem_models.GroupOfAggregations.DoesNotExist:
raise NotFound(status=404,
detail='Group of aggregations not found')
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request, profile_name=None):
sync_webapi(settings.WEBAPI_METRIC, poem_models.MetricProfiles)
if profile_name:
try:
profile = poem_models.MetricProfiles.objects.get(
name=profile_name)
serializer = serializers.MetricProfileSerializer(profile)
return Response(serializer.data)
except poem_models.MetricProfiles.DoesNotExist:
raise NotFound(status=404, detail='Metric profile not found')
else:
profiles = poem_models.MetricProfiles.objects.all().order_by(
'name')
serializer = serializers.MetricProfileSerializer(profiles,
many=True)
return Response(serializer.data)
def delete(self, request, group=None):
if group:
try:
gr = poem_models.GroupOfMetricProfiles.objects.get(name=group)
gr.delete()
for mp in poem_models.MetricProfiles.objects.filter(
groupname=group):
mp.groupname = ''
mp.save()
return Response(status=status.HTTP_204_NO_CONTENT)
except poem_models.GroupOfMetricProfiles.DoesNotExist:
raise NotFound(status=404,
detail='Group of metric profiles not found')
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request, nameversion=None):
if nameversion:
try:
package_name, package_version = get_package_version(
nameversion)
package = admin_models.Package.objects.get(
name=package_name, version=package_version)
repos = []
for repo in package.repos.all():
repos.append('{} ({})'.format(repo.name, repo.tag.name))
result = {
'id': package.id,
'name': package.name,
'version': package.version,
'use_present_version': package.use_present_version,
'repos': repos
}
return Response(result)
except admin_models.Package.DoesNotExist:
raise NotFound(status=404, detail='Package not found.')
else:
packages = admin_models.Package.objects.all()
results = []
for package in packages:
repos = []
for repo in package.repos.all():
repos.append('{} ({})'.format(repo.name, repo.tag.name))
results.append({
'name': package.name,
'version': package.version,
'use_present_version': package.use_present_version,
'repos': repos
})
results = sorted(results, key=lambda k: k['name'].lower())
return Response(results)
def get(self, request, name=None):
sync_webapi(settings.WEBAPI_THRESHOLDS, poem_models.ThresholdsProfiles)
if name:
try:
profile = poem_models.ThresholdsProfiles.objects.get(name=name)
serializer = serializers.ThresholdsProfileSerializer(profile)
return Response(serializer.data)
except poem_models.ThresholdsProfiles.DoesNotExist:
raise NotFound(status=404,
detail='Thresholds profile does not exist.')
else:
profiles = poem_models.ThresholdsProfiles.objects.all().order_by(
'name')
serializer = serializers.ThresholdsProfileSerializer(profiles,
many=True)
return Response(serializer.data)
def get(self, request, report_name=None):
sync_webapi(settings.WEBAPI_REPORTS, poem_models.Reports)
if report_name:
try:
report = poem_models.Reports.objects.get(
name=report_name
)
serializer = serializers.ReportsSerializer(report)
return Response(serializer.data)
except poem_models.Reports.DoesNotExist:
raise NotFound(status=404,
detail='Report not found')
else:
reports = poem_models.Reports.objects.all().order_by('name')
serializer = serializers.ReportsSerializer(reports, many=True)
return Response(serializer.data)
def delete(self, request, name=None):
if request.user.is_superuser:
if name:
try:
apikey = MyAPIKey.objects.get(name=name)
apikey.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
except MyAPIKey.DoesNotExist:
raise NotFound(status=404, detail='API key not found')
else:
return error_response(detail='API key name must be defined',
status_code=status.HTTP_400_BAD_REQUEST)
else:
return error_response(
detail='You do not have permission to delete API keys.',
status_code=status.HTTP_401_UNAUTHORIZED)
def get(self, request, username=None):
if username:
try:
user = CustUser.objects.get(username=username)
serializer = serializers.UsersSerializer(user)
return Response(serializer.data)
except CustUser.DoesNotExist:
raise NotFound(status=404, detail='User not found')
else:
if request.user.is_superuser:
users = CustUser.objects.all()
else:
users = CustUser.objects.filter(username=request.user.username)
serializer = serializers.UsersSerializer(users, many=True)
data = sorted(serializer.data, key=lambda k: k['username'].lower())
return Response(data)
def get(self, request, aggregation_name=None):
sync_webapi(settings.WEBAPI_AGGREGATION, poem_models.Aggregation)
if aggregation_name:
try:
aggregation = poem_models.Aggregation.objects.get(
name=aggregation_name)
serializer = serializers.AggregationProfileSerializer(
aggregation)
return Response(serializer.data)
except poem_models.Aggregation.DoesNotExist:
raise NotFound(status=404, detail='Aggregation not found')
else:
aggregations = poem_models.Aggregation.objects.all().order_by(
'name')
serializer = serializers.AggregationProfileSerializer(aggregations,
many=True)
return Response(serializer.data)
def delete(self, request, group=None):
if request.user.is_superuser:
if group:
try:
group = poem_models.GroupOfMetrics.objects.get(name=group)
group.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
except poem_models.GroupOfMetrics.DoesNotExist:
raise NotFound(
status=404, detail='Group of metrics not found'
)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
else:
return error_response(
status_code=status.HTTP_401_UNAUTHORIZED,
detail='You do not have permission to delete groups of metrics.'
)
def delete(self, request, name=None):
if name:
try:
userprofile = poem_models.UserProfile.objects.get(
user=request.user)
if not request.user.is_superuser and \
userprofile.groupsofmetrics.all().count() == 0:
return error_response(
status_code=status.HTTP_401_UNAUTHORIZED,
detail='You do not have permission to delete metrics.')
else:
metric = poem_models.Metric.objects.get(name=name)
if request.user.is_superuser or \
metric.group in userprofile.groupsofmetrics.all():
poem_models.TenantHistory.objects.filter(
object_id=metric.id,
content_type=ContentType.objects.get_for_model(
poem_models.Metric)).delete()
metric.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
else:
return error_response(
status_code=status.HTTP_401_UNAUTHORIZED,
detail='You do not have permission to delete '
'metrics in this group.')
except poem_models.UserProfile.DoesNotExist:
return error_response(
status_code=status.HTTP_404_NOT_FOUND,
detail='No user profile for authenticated user.')
except poem_models.Metric.DoesNotExist:
raise NotFound(status=404, detail='Metric not found')
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, name=None):
schemas = list(Tenant.objects.all().values_list('schema_name',
flat=True))
schemas.remove(get_public_schema_name())
if request.tenant.schema_name == get_public_schema_name() and \
request.user.is_superuser:
if name:
try:
probe = admin_models.Probe.objects.get(name=name)
mt = admin_models.MetricTemplate.objects.filter(
probekey=admin_models.ProbeHistory.objects.get(
name=probe.name,
package__version=probe.package.version))
if len(mt) == 0:
for schema in schemas:
# need to iterate through schemas because of foreign
# key in Metric model
with schema_context(schema):
admin_models.ProbeHistory.objects.filter(
object_id=probe).delete()
probe.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
else:
return error_response(
status_code=status.HTTP_400_BAD_REQUEST,
detail='You cannot delete probe that is associated '
'to metric templates.')
except admin_models.Probe.DoesNotExist:
raise NotFound(status=404, detail='Probe does not exist.')
else:
return error_response(status_code=status.HTTP_400_BAD_REQUEST,
detail='Probe name not specified.')
else:
return error_response(
status_code=status.HTTP_401_UNAUTHORIZED,
detail='You do not have permission to delete probes.')
def put(self, request):
try:
if request.user.username == request.data['username']:
user = CustUser.objects.get(username=request.data['username'])
user.set_password(request.data['new_password'])
user.save()
return Response(status=status.HTTP_201_CREATED)
except CustUser.DoesNotExist:
raise NotFound(status=404, detail='User does not exist.')
except KeyError as e:
return error_response(
status_code=status.HTTP_400_BAD_REQUEST,
detail='Missing data key: {}'.format(e.args[0])
)
else:
return error_response(
status_code=status.HTTP_401_UNAUTHORIZED,
detail='You do not have permission to change password for '
'another user.'
)
