sla/slicetabsla.py

   1 # this somehow is not used anymore - should it not be ?
   2 from django.template import RequestContext
   3 from django.shortcuts import render_to_response
   4 from django.shortcuts import render
   5 from django import forms
   6
   7 from unfold.loginrequired import FreeAccessView
   8 from unfold.page import Page
   9 from sla.slaclient import restclient
  10 from sla.slaclient import wsag_model
  11 import wsag_helper
  12 from myslice.theme import ThemeView
  13 # from sla import SLAPlugin
  14 from django.core.urlresolvers import reverse
  15 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
  16
  17 import slaclient.service.fed4fire.fed4fireservice as fed4fireservice
  18 from rest_framework.views import APIView
  19 from django.http import HttpResponse
  20
  21 import json
  22 import traceback
  23
  24
  25 class Rol:
  26     CONSUMER = "CONSUMER"
  27     PROVIDER = "PROVIDER"
  28
  29
  30 class AgreementsFilter(object):
  31     def __init__(self, status=None, provider=None, consumer=None):
  32         self.status = status
  33         self.provider = provider
  34         self.consumer = consumer
  35
  36     def __repr__(self):
  37         return "<AgreementsFilter(status={}, provider={}, consumer={})>".format(
  38             self.status, self.provider, self.consumer
  39         )
  40
  41     @staticmethod
  42     def _check(expectedvalue, actualvalue):
  43         if expectedvalue is None or expectedvalue == '':
  44             return True
  45         else:
  46             return actualvalue == expectedvalue
  47
  48     def check(self, agreement):
  49         """Check if this agreement satisfy the filter.
  50
  51         The agreement must be previously annotated
  52         """
  53         guaranteestatus = agreement.guaranteestatus
  54         provider = agreement.context.provider
  55         consumer = agreement.context.consumer
  56         return (
  57             AgreementsFilter._check(self.status, guaranteestatus) and
  58             AgreementsFilter._check(self.provider, provider) and
  59             AgreementsFilter._check(self.consumer, consumer)
  60         )
  61
  62
  63 class FilterForm(forms.Form):
  64     _attrs = {'class': 'form-control'}
  65     exclude = ()
  66     status = forms.ChoiceField(
  67         choices=[
  68             ('', 'All'),
  69             (wsag_model.AgreementStatus.StatusEnum.FULFILLED, 'Fulfilled'),
  70             (wsag_model.AgreementStatus.StatusEnum.VIOLATED, 'Violated'),
  71             (wsag_model.AgreementStatus.StatusEnum.NON_DETERMINED, 'Non determined')],
  72         widget=forms.Select(attrs=_attrs),
  73         required=False
  74     )
  75     provider = forms.CharField(
  76         widget=forms.TextInput(attrs=_attrs),
  77         required=False
  78     )
  79     consumer = forms.CharField(
  80         widget=forms.TextInput(attrs=_attrs),
  81         required=False
  82     )
  83
  84
  85 class SLAView (FreeAccessView, ThemeView):
  86     template_name = 'slice-tab-sla.html'
  87
  88     def get (self, request, slicename, state=None):
  89
  90         page=Page(request)
  91
  92         consumer_id = None
  93         agreement_id = None
  94         enforcements = {}
  95
  96         filter_ = None
  97         form = FilterForm(request.GET)
  98         if form.is_valid():
  99              print "IS VALID"
 100              filter_ = _get_filter_from_form(form)
 101
 102         consumer_id = _get_consumer_id(request)
 103
 104         agreements = _get_agreements(agreement_id, consumer_id=consumer_id, filter_=filter_)
 105
 106         for agreement in agreements:
 107             enf = _get_enforcement(agreement.agreement_id)
 108             enforcements[agreement.agreement_id] = enf.enabled
 109
 110         for key, value in enforcements.items():
 111             print key + ": " + value
 112
 113         template_env = {}
 114        # write something of our own instead
 115        # more general variables expected in the template
 116         template_env['title'] = 'SLA Agreements'
 117         template_env['agreements'] = agreements
 118         template_env['username'] = request.user
 119         template_env['slicename'] = slicename
 120         template_env['enforcements'] = enforcements
 121
 122        # the prelude object in page contains a summary of the requirements() for all plugins
 123        # define {js,css}_{files,chunks}
 124         prelude_env = page.prelude_env()
 125         template_env.update(prelude_env)
 126
 127         return render_to_response (self.template_name, template_env, context_instance=RequestContext(request))
 128
 129
 130 class AgreementsFilter(object):
 131     def __init__(self, status=None, provider=None, consumer=None):
 132         self.status = status
 133         self.provider = provider
 134         self.consumer = consumer
 135
 136     def __repr__(self):
 137         return "<AgreementsFilter(status={}, provider={}, consumer={})>".format(
 138             self.status, self.provider, self.consumer
 139         )
 140
 141     @staticmethod
 142     def _check(expectedvalue, actualvalue):
 143         if expectedvalue is None or expectedvalue == '':
 144             return True
 145         else:
 146             return actualvalue == expectedvalue
 147
 148     def check(self, agreement):
 149         """Check if this agreement satisfy the filter.
 150
 151         The agreement must be previously annotated
 152         """
 153         guaranteestatus = agreement.guaranteestatus
 154         provider = agreement.context.provider
 155         consumer = agreement.context.consumer
 156         return (
 157             AgreementsFilter._check(self.status, guaranteestatus) and
 158             AgreementsFilter._check(self.provider, provider) and
 159             AgreementsFilter._check(self.consumer, consumer)
 160         )
 161
 162
 163 class ContactForm(forms.Form):
 164     subject = forms.CharField(max_length=100)
 165     message = forms.CharField()
 166     sender = forms.EmailField()
 167     cc_myself = forms.BooleanField(required=False)
 168
 169
 170 def _get_agreements_client():
 171     return restclient.Factory.agreements()
 172
 173
 174 def _get_violations_client():
 175     return restclient.Factory.violations()
 176
 177 def _get_enforcements_client():
 178     return restclient.Factory.enforcements()
 179
 180 def _get_consumer_id(request):
 181     return request.user
 182
 183
 184 def _get_agreement(agreement_id):
 185
 186     agreements_client = _get_agreements_client()
 187     agreement, response = agreements_client.getbyid(agreement_id)
 188     return agreement
 189
 190 def _get_enforcement(agreement_id):
 191
 192     enforcements_client = _get_enforcements_client()
 193     enforcement, response = enforcements_client.getbyagreement(agreement_id)
 194     return enforcement
 195
 196 def _get_filter_from_form(form):
 197
 198     data = form.cleaned_data
 199     result = AgreementsFilter(
 200         data["status"], data["provider"], data["consumer"])
 201     return result
 202
 203 def agreement_term_violations(request, agreement_id, guarantee_name):
 204
 205     page = Page(request)
 206     prelude_env = page.prelude_env()
 207
 208     annotator = wsag_helper.AgreementAnnotator()
 209     agreement = _get_agreement(agreement_id)
 210     violations = _get_agreement_violations(agreement_id, guarantee_name)
 211     annotator.annotate_agreement(agreement)
 212
 213     slicename = request.POST.get('slicename')
 214
 215     paginator = Paginator(violations, 25) # Show 25 violations per page
 216     page_num = request.GET.get('page')
 217
 218     try:
 219         violation_page = paginator.page(page_num)
 220     except PageNotAnInteger:
 221         # If page is not an integer, deliver first page.
 222         violation_page = paginator.page(1)
 223     except EmptyPage:
 224         # If page is out of range (e.g. 9999), deliver first page.
 225         violation_page = paginator.page(1)
 226
 227     context = {
 228         'agreement_id': agreement_id,
 229         'guarantee_term': agreement.guaranteeterms[guarantee_name],
 230         'violations': violation_page,
 231         'agreement': agreement,
 232         'slicename': slicename,
 233     }
 234
 235     context.update(prelude_env)
 236
 237     return render_to_response ('violations_template.html', context, context_instance=RequestContext(request))
 238 #     return render(request, 'violations_template.html', context)
 239
 240 def agreement_details(request, agreement_id):
 241
 242     page = Page(request)
 243     prelude_env = page.prelude_env()
 244
 245     annotator = wsag_helper.AgreementAnnotator()
 246     agreement = _get_agreement(agreement_id)
 247     violations = _get_agreement_violations(agreement_id)
 248     status = _get_agreement_status(agreement_id)
 249     annotator.annotate_agreement(agreement, status, violations)
 250
 251     violations_by_date = wsag_helper.get_violations_bydate(violations)
 252     context = {
 253         'agreement_id': agreement_id,
 254         'agreement': agreement,
 255         'status': status,
 256         'violations_by_date': violations_by_date
 257     }
 258
 259     context.update(prelude_env)
 260
 261     return render_to_response ('violations_template.html', context, context_instance=RequestContext(request))
 262     #return render(request, 'agreement_detail.html', context)
 263
 264
 265 def _get_agreements_client():
 266     return restclient.Factory.agreements()
 267
 268
 269 def _get_agreement(agreement_id):
 270
 271     agreements_client = _get_agreements_client()
 272     agreement, response = agreements_client.getbyid(agreement_id)
 273     return agreement
 274
 275 def _get_agreements(agreement_id, provider_id=None, consumer_id=None, filter_=None):
 276
 277     agreements_client = _get_agreements_client()
 278     if agreement_id is None:
 279         if consumer_id is not None:
 280             agreements, response = agreements_client.getbyconsumer(consumer_id)
 281         elif provider_id is not None:
 282             agreements, response = agreements_client.getbyprovider(provider_id)
 283         else:
 284             raise ValueError(
 285                 "Invalid values: consumer_id and provider_id are None")
 286     else:
 287         agreement, response = agreements_client.getbyid(agreement_id)
 288         agreements = [agreement]
 289
 290     annotator = wsag_helper.AgreementAnnotator()
 291     for agreement in agreements:
 292         id_ = agreement.agreement_id
 293         status = _get_agreement_status(id_)
 294         annotator.annotate_agreement(agreement, status)
 295
 296     if filter_ is not None:
 297         print "FILTERING ", repr(filter_)
 298         agreements = filter(filter_.check, agreements);
 299     else:
 300         print "NOT FILTERING"
 301     return agreements
 302
 303
 304 def _get_agreements_by_consumer(consumer_id):
 305
 306     agreements_client = _get_agreements_client()
 307     agreements, response = agreements_client.getbyconsumer(consumer_id)
 308     return agreements
 309
 310 def _get_agreement_status(agreement_id):
 311
 312     agreements_client = _get_agreements_client()
 313     status, response = agreements_client.getstatus(agreement_id)
 314     return status
 315
 316 def _get_agreement_violations(agreement_id, term=None):
 317
 318     violations_client = _get_violations_client()
 319     violations, response = violations_client.getbyagreement(agreement_id, term)
 320     return violations
 321
 322
 323 class AgreementSimple(APIView):
 324     def build_response(self, code, text):
 325         response = HttpResponse(text, content_type="text/plain", status=code)
 326         return response
 327
 328     def post( self, request, **kwargs):
 329         #import pdb; pdb.set_trace()
 330         print "------------------------------------------------1"
 331         data = {}
 332         for key, value in request.DATA.items():
 333             new_key = key
 334             data[new_key] = value
 335
 336         try:
 337             template_id = data['template_id']
 338         except:
 339             return self.build_response(400, 'Invalid template_id')
 340
 341         try:
 342             user = data['user']
 343         except:
 344             return self.build_response(400, 'Invalid user')
 345
 346         try:
 347             print "Calling createagreementsimplified with template_id:",template_id,"and user:",user
 348             result = fed4fireservice.createagreementsimplified(template_id, user)
 349             print result
 350         except Exception, e:
 351             print traceback.format_exc()
 352             print '%s (%s)' % (e, type(e))
 353
 354             return self.build_response(400, 'Problem creating agreement')
 355
 356         return self.build_response(200, result)