/ - Diff - Synnefo - Greek Research and Technology Network's projects

                                                         resource.name)
                         d = model_to_dict(resource)
                         if uplimit:
                             d.update(dict(resource=prefix, uplimit=uplimit))
                             d.update(dict(resource=prefix, uplimit=long(uplimit)))
                         else:
                             d.update(dict(resource=prefix, uplimit=None))
                         append(d)
-...
             return policies
         def cleaned_resource_policies(self):
             return [(d['name'], d['uplimit']) for d in self.resource_policies]
             policies = {}
             for d in self.resource_policies:
                 policies[d["name"]] = {
                     "project_capacity": None,
                     "member_capacity": d["uplimit"]
+                }
             return policies
         def save(self, commit=True):
             data = dict(self.cleaned_data)
             is_new = self.instance.id is None
             data['project_id'] = self.instance.chain.id if not is_new else None
             data['owner'] = self.user if is_new else self.instance.owner
             data['resource_policies'] = self.cleaned_resource_policies()
             data['resources'] = self.cleaned_resource_policies()
             data['request_user'] = self.user
             submit_application(**data)

     from synnefo.lib import join_urls
     from astakos.im.models import AstakosUser, Invitation, ProjectMembership, \
         ProjectApplication, Project, new_chain
         ProjectApplication, Project, new_chain, Resource
     from astakos.im.quotas import qh_sync_user, get_pending_app_quota, \
         register_pending_apps, qh_sync_project, qh_sync_locked_users, \
         get_users_for_update, members_to_sync
-...
                            member_leave_policy=None,
                            limit_on_members_number=None,
                            comments=None,
                            resource_policies=None,
                            resources=None,
                            request_user=None):
         project = None
-...
                 m = _(astakos_messages.NOT_ALLOWED)
                 raise PermissionDenied(m)
         policies = validate_resource_policies(resources)
         force = request_user.is_project_admin()
         ok, limit = qh_add_pending_app(owner, project, force)
         if not ok:
-...
                 app.state = ProjectApplication.REPLACED
                 app.save()
         if resource_policies is not None:
             application.set_resource_policies(resource_policies)
         if policies is not None:
             set_resource_policies(application, policies)
         logger.info("User %s submitted %s." %
                     (request_user.log_display, application.log_display))
         application_submit_notify(application)
         return application
     def validate_resource_policies(policies):
         if not isinstance(policies, dict):
             raise ProjectBadRequest("Malformed resource policies")
         resource_names = policies.keys()
         resources = Resource.objects.filter(name__in=resource_names)
         resource_d = {}
         for resource in resources:
             resource_d[resource.name] = resource
         found = resource_d.keys()
         nonex = [name for name in resource_names if name not in found]
         if nonex:
             raise ValueError("Malformed resource policies")
         pols = []
         for resource_name, specs in policies.iteritems():
             p_capacity = specs.get("project_capacity")
             m_capacity = specs.get("member_capacity")
             if p_capacity is not None and not isinstance(p_capacity, (int, long)):
                 raise ValueError("Malformed resource policies")
             if not isinstance(m_capacity, (int, long)):
                 raise ValueError("Malformed resource policies")
             pols.append((resource_d[resource_name], m_capacity, p_capacity))
         return pols
     def set_resource_policies(application, policies):
         for resource, m_capacity, p_capacity in policies:
             g = application.projectresourcegrant_set
             g.create(resource=resource,
                      member_capacity=m_capacity,
                      project_capacity=p_capacity)
     def cancel_application(application_id, request_user=None, reason=""):
         get_project_of_application_for_update(application_id)
         application = get_application(application_id)

         def state_display(self):
             return self.APPLICATION_STATE_DISPLAY.get(self.state, _('Unknown'))
         def add_resource_policy(self, resource, uplimit):
             """Raises ObjectDoesNotExist, IntegrityError"""
             q = self.projectresourcegrant_set
             resource = Resource.objects.get(name=resource)
             q.create(resource=resource, member_capacity=uplimit)
         @property
         def grants(self):
             return self.projectresourcegrant_set.values('member_capacity',
-...
         def resource_policies(self):
             return [str(rp) for rp in self.projectresourcegrant_set.all()]
         def set_resource_policies(self, policies):
             for resource, uplimit in policies:
                 self.add_resource_policy(resource, uplimit)
         def is_modification(self):
             # if self.state != self.PENDING:
             #     return False

Synnefo

Revision b2369828