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

Revision 8cf9b2dd

     from astakos.im.notifications import build_notification, NotificationError
     from astakos.im.models import (
         AstakosUser, ProjectMembership, ProjectApplication, Project,
         sync_projects, PendingMembershipError, get_resource_names, new_chain)
         PendingMembershipError, get_resource_names, new_chain)
     from astakos.im.project_notif import (
         membership_change_notify,
         application_submit_notify, application_approve_notify,
-...
             raise PermissionDenied(m)
         membership.accept()
         sync_projects()
         membership_change_notify(project, membership.person, 'accepted')
-...
             raise PermissionDenied(m)
         membership.remove()
         sync_projects()
         membership_change_notify(project, membership.person, 'removed')
-...
             raise PermissionDenied(m)
         membership.accept()
         sync_projects()
         # TODO send proper notification
         return membership
-...
         leave_policy = project.application.member_leave_policy
         if leave_policy == AUTO_ACCEPT_POLICY:
             membership.remove()
             sync_projects()
         else:
             membership.leave_request_date = datetime.now()
             membership.save()
-...
         if (join_policy == AUTO_ACCEPT_POLICY and
             not project.violates_members_limit(adding=1)):
             membership.accept()
             sync_projects()
         return membership
     def submit_application(kw, request_user=None):
-...
             raise PermissionDenied(m)
         application.approve()
         sync_projects()
         application_approve_notify(application)
     def check_expiration(execute=False):
-...
         checkAlive(project)
         project.terminate()
         sync_projects()
         project_termination_notify(project)
-...
         checkAlive(project)
         project.suspend()
         sync_projects()
         project_suspension_notify(project)
-...
             raise PermissionDenied(m)
         project.resume()
         sync_projects()
     def get_by_chain_or_404(chain_id):
         try:

     from optparse import make_option
     from django.core.management.base import BaseCommand, CommandError
     from django.db import transaction
     from astakos.im.functions import check_expiration
     from astakos.im.project_xctx import project_transaction_context
     @transaction.commit_manually
     class Command(BaseCommand):
         help = "Perform administration checks on projects"
-...
         def handle(self, *args, **options):
             execute = options['execute']
             if options['expire']:
                 self.expire(execute=execute)
         @project_transaction_context(sync=True)
         def expire(self, execute=False, ctx=None):
             try:
                 if options['expire']:
                     projects = check_expiration(execute=execute)
                     self.print_expired(projects, execute)
                 projects = check_expiration(execute=execute)
                 self.print_expired(projects, execute)
             except BaseException as e:
                 transaction.rollback()
                 if ctx:
                     ctx.mark_rollback()
                 raise CommandError(e)
             else:
                 transaction.commit()

     from optparse import make_option
     from django.core.management.base import BaseCommand, CommandError
     from django.db import transaction
     from astakos.im.models import ProjectApplication
     from astakos.im.functions import approve_application
     from astakos.im.project_xctx import project_transaction_context
     class Command(BaseCommand):
         args = "<project application id>"
         help = "Update project state"
         help = "Approve project application"
         @transaction.commit_manually
         def handle(self, *args, **options):
             if len(args) < 1:
                 raise CommandError("Please provide a group identifier")
                 raise CommandError("Please provide an application id")
             try:
                 id = int(args[0])
             except ValueError:
-...
                     app = ProjectApplication.objects.get(id=id)
                 except ProjectApplication.DoesNotExist:
                     raise CommandError('Invalid id')
                 try:
                     approve_application(app)
                 except BaseException, e:
                     transaction.rollback()
                     raise CommandError(e)
                 else:
                     transaction.commit()
                 approve(app)
     @project_transaction_context(sync=True)
     def approve(app, ctx=None):
         try:
             approve_application(app)
         except BaseException as e:
             if ctx:
                 ctx.mark_rollback()
                 raise CommandError(e)

     from optparse import make_option
     from django.core.management.base import BaseCommand, CommandError
     from django.db import transaction
     from django.views.generic.create_update import lookup_object
     from django.http import Http404
     from astakos.im.models import (
         ProjectApplication, Project)
     from astakos.im.functions import terminate, suspend, resume
     from astakos.im.project_xctx import project_transaction_context
     @transaction.commit_manually
     class Command(BaseCommand):
         args = "<project id>"
         help = "Update project state"
-...
                         action='store_true',
                         dest='terminate',
                         default=False,
                         help="Terminate group"),
                         help="Terminate project"),
             make_option('--resume',
                         action='store_true',
                         dest='resume',
                         default=False,
                         help="Resume group"),
                         help="Resume project"),
             make_option('--suspend',
                         action='store_true',
                         dest='suspend',
                         default=False,
                         help="Suspend group")
                         help="Suspend project")
+        )
         def handle(self, *args, **options):
             if len(args) < 1:
                 raise CommandError("Please provide a group identifier")
                 raise CommandError("Please provide a project id")
             try:
                 id = int(args[0])
             except ValueError:
                 raise CommandError('Invalid id')
             else:
                 try:
                     if options['terminate']:
                         terminate(id)
                     elif options['resume']:
                         resume(id)
                     elif options['suspend']:
                         suspend(id)
                 except BaseException, e:
                     transaction.rollback()
                     raise CommandError(e)
                 else:
                     transaction.commit()
                 if options['terminate']:
                     run_command(terminate, id)
                 elif options['resume']:
                     run_command(resume, id)
                 elif options['suspend']:
                     run_command(suspend, id)
     @project_transaction_context(sync=True)
     def run_command(func, id, ctx=None):
         try:
             func(id)
         except BaseException as e:
             if ctx:
                 ctx.mark_rollback()
             raise CommandError(e)

     # Copyright 2013 GRNET S.A. All rights reserved.
+    #
     # Redistribution and use in source and binary forms, with or
     # without modification, are permitted provided that the following
     # conditions are met:
+    #
     #   1. Redistributions of source code must retain the above
     #      copyright notice, this list of conditions and the following
     #      disclaimer.
+    #
     #   2. Redistributions in binary form must reproduce the above
     #      copyright notice, this list of conditions and the following
     #      disclaimer in the documentation and/or other materials
     #      provided with the distribution.
+    #
     # THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
     # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
     # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
     # USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
     # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
     # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     # POSSIBILITY OF SUCH DAMAGE.
+    #
     # The views and conclusions contained in the software and
     # documentation are those of the authors and should not be
     # interpreted as representing official policies, either expressed
     # or implied, of GRNET S.A.
     from synnefo.lib.db.xctx import TransactionContext, TransactionHandler
     from astakos.im.notifications import Notification
     # USAGE
     # =====
     # @notification_transaction_context(notify=False)
     # def a_view(args, ctx=None):
     #     ...
     #     if ctx:
     #         ctx.mark_rollback()
     #     ...
     #     return http response
+    #
     # OR
+    #
     # def a_view(args):
     #     with notification_transaction_context(notify=False) as ctx:
     #         ...
     #         ctx.mark_rollback()
     #         ...
     #         return http response
     def notification_transaction_context(**kwargs):
         return TransactionHandler(ctx=NotificationTransactionContext, **kwargs)
     class NotificationTransactionContext(TransactionContext):
         def __init__(self, notify=True, **kwargs):
             self._notifications = []
             self._messages      = []
             self._notify        = notify
             TransactionContext.__init__(self, **kwargs)
         def register(self, o):
             if isinstance(o, dict):
                 msg = o.get('msg', None)
                 if msg is not None and request is not None:
                     if isinstance(msg, basestring):
                         self.queue_message(msg)
                 notif = o.get('notif', None)
                 fst, snd = o
                 if isinstance(snd, Notification):
                     self.queue_notification(snd)
                     return fst
             return o
         def queue_message(m):
             self._messages.append(m)
         def queue_notification(self, n):
             self._notifications.append(n)
         def _send_notifications(self):
             if self._notifications is None:
                 return
             # send mail
         def postprocess(self):
             if self._notify:
                 self._send_notifications()
             TransactionContext.postprocess(self)

     # Copyright 2013 GRNET S.A. All rights reserved.
+    #
     # Redistribution and use in source and binary forms, with or
     # without modification, are permitted provided that the following
     # conditions are met:
+    #
     #   1. Redistributions of source code must retain the above
     #      copyright notice, this list of conditions and the following
     #      disclaimer.
+    #
     #   2. Redistributions in binary form must reproduce the above
     #      copyright notice, this list of conditions and the following
     #      disclaimer in the documentation and/or other materials
     #      provided with the distribution.
+    #
     # THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
     # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
     # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
     # USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
     # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
     # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     # POSSIBILITY OF SUCH DAMAGE.
+    #
     # The views and conclusions contained in the software and
     # documentation are those of the authors and should not be
     # interpreted as representing official policies, either expressed
     # or implied, of GRNET S.A.
     from synnefo.lib.db.xctx import TransactionHandler
     from astakos.im.notification_xctx import NotificationTransactionContext
     from astakos.im.models import sync_projects
     # USAGE
     # =====
     # @project_transaction_context(sync=True)
     # def a_view(args, ctx=None):
     #     ...
     #     if ctx:
     #         ctx.mark_rollback()
     #     ...
     #     return http response
+    #
     # OR
+    #
     # def a_view(args):
     #     with project_transaction_context(sync=True) as ctx:
     #         ...
     #         ctx.mark_rollback()
     #         ...
     #         return http response
     def project_transaction_context(**kwargs):
         return TransactionHandler(ctx=ProjectTransactionContext, **kwargs)
     class ProjectTransactionContext(NotificationTransactionContext):
         def __init__(self, sync=False, **kwargs):
             self._sync = sync
             NotificationTransactionContext.__init__(self, **kwargs)
         def postprocess(self):
             if self._sync:
                 sync_projects()
             NotificationTransactionContext.postprocess(self)

     from astakos.im import settings as astakos_settings
     from astakos.im.api.callpoint import AstakosCallpoint
     from astakos.im import auth_providers
     from astakos.im.project_xctx import project_transaction_context
     logger = logging.getLogger(__name__)
-...
             'im/how_it_works.html',
             context_instance=get_context(request))
     @transaction.commit_manually
     @project_transaction_context()
     def _create_object(request, model=None, template_name=None,
             template_loader=template_loader, extra_context=None, post_save_redirect=None,
             login_required=False, context_processors=None, form_class=None,
             msg=None):
             msg=None, ctx=None):
         """
         Based of django.views.generic.create_update.create_object which displays a
         summary page before creating the object.
         """
         rollback = False
         response = None
         if extra_context is None: extra_context = {}
-...
         except BaseException, e:
             logger.exception(e)
             messages.error(request, _(astakos_messages.GENERIC_ERROR))
             rollback = True
             if ctx:
                 ctx.mark_rollback()
         finally:
             if rollback:
                 transaction.rollback()
             else:
                 transaction.commit()
             if response == None:
                 # Create the template, context, response
                 if not template_name:
-...
                 response = HttpResponse(t.render(c))
             return response
     @transaction.commit_manually
     @project_transaction_context()
     def _update_object(request, model=None, object_id=None, slug=None,
             slug_field='slug', template_name=None, template_loader=template_loader,
             extra_context=None, post_save_redirect=None, login_required=False,
             context_processors=None, template_object_name='object',
             form_class=None, msg=None):
             form_class=None, msg=None, ctx=None):
         """
         Based of django.views.generic.create_update.update_object which displays a
         summary page before updating the object.
         """
         rollback = False
         response = None
         if extra_context is None: extra_context = {}
-...
         except BaseException, e:
             logger.exception(e)
             messages.error(request, _(astakos_messages.GENERIC_ERROR))
             rollback = True
             ctx.mark_rollback()
         finally:
             if rollback:
                 transaction.rollback()
             else:
                 transaction.commit()
             if response == None:
                 if not template_name:
                     template_name = "%s/%s_form.html" %\
-...
     @require_http_methods(["GET", "POST"])
     @signed_terms_required
     @login_required
     @transaction.commit_on_success
     def project_app(request, application_id):
         return common_detail(request, application_id, is_chain=False)
     @require_http_methods(["GET", "POST"])
     @signed_terms_required
     @login_required
     @transaction.commit_on_success
     def project_detail(request, chain_id):
         return common_detail(request, chain_id)
     def addmembers(request, chain_id):
     @project_transaction_context(sync=True)
     def addmembers(request, chain_id, ctx=None):
         addmembers_form = AddProjectMembersForm(
             request.POST,
             chain_id=int(chain_id),
             request_user=request.user)
         if addmembers_form.is_valid():
             try:
                 rollback = False
                 chain_id = int(chain_id)
                 map(lambda u: enroll_member(
                         chain_id,
-...
             except (IOError, PermissionDenied), e:
                 messages.error(request, e)
             except BaseException, e:
                 rollback = True
                 if ctx:
                     ctx.mark_rollback()
                 messages.error(request, e)
             finally:
                 if rollback == True:
                     transaction.rollback()
                 else:
                     transaction.commit()
     def common_detail(request, chain_or_app_id, is_chain=True):
         if is_chain:
-...
     @require_http_methods(["POST", "GET"])
     @signed_terms_required
     @login_required
     @transaction.commit_manually
     def project_join(request, chain_id):
     @project_transaction_context(sync=True)
     def project_join(request, chain_id, ctx=None):
         next = request.GET.get('next')
         if not next:
             next = reverse('astakos.im.views.project_detail',
                            args=(chain_id,))
         rollback = False
         try:
             chain_id = int(chain_id)
             join_project(chain_id, request.user)
-...
         except BaseException, e:
             logger.exception(e)
             messages.error(request, _(astakos_messages.GENERIC_ERROR))
             rollback = True
         finally:
             if rollback:
                 transaction.rollback()
             else:
                 transaction.commit()
             if ctx:
                 ctx.mark_rollback()
         next = restrict_next(next, domain=COOKIE_DOMAIN)
         return redirect(next)
     @require_http_methods(["POST"])
     @signed_terms_required
     @login_required
     @transaction.commit_manually
     def project_leave(request, chain_id):
     @project_transaction_context(sync=True)
     def project_leave(request, chain_id, ctx=None):
         next = request.GET.get('next')
         if not next:
             next = reverse('astakos.im.views.project_list')
         rollback = False
         try:
             chain_id = int(chain_id)
             leave_project(chain_id, request.user)
-...
         except BaseException, e:
             logger.exception(e)
             messages.error(request, _(astakos_messages.GENERIC_ERROR))
             rollback = True
         finally:
             if rollback:
                 transaction.rollback()
             else:
                 transaction.commit()
             if ctx:
                 ctx.mark_rollback()
         next = restrict_next(next, domain=COOKIE_DOMAIN)
         return redirect(next)
     @require_http_methods(["POST"])
     @signed_terms_required
     @login_required
     @transaction.commit_manually
     def project_cancel(request, chain_id):
     @project_transaction_context()
     def project_cancel(request, chain_id, ctx=None):
         next = request.GET.get('next')
         if not next:
             next = reverse('astakos.im.views.project_list')
         rollback = False
         try:
             chain_id = int(chain_id)
             cancel_membership(chain_id, request.user)
-...
         except BaseException, e:
             logger.exception(e)
             messages.error(request, _(astakos_messages.GENERIC_ERROR))
             rollback = True
         finally:
             if rollback:
                 transaction.rollback()
             else:
                 transaction.commit()
             if ctx:
                 ctx.mark_rollback()
         next = restrict_next(next, domain=COOKIE_DOMAIN)
         return redirect(next)
-...
     @require_http_methods(["POST"])
     @signed_terms_required
     @login_required
     @transaction.commit_manually
     def project_accept_member(request, chain_id, user_id):
         rollback = False
     @project_transaction_context(sync=True)
     def project_accept_member(request, chain_id, user_id, ctx=None):
         try:
             chain_id = int(chain_id)
             user_id = int(user_id)
-...
         except BaseException, e:
             logger.exception(e)
             messages.error(request, _(astakos_messages.GENERIC_ERROR))
             rollback = True
             if ctx:
                 ctx.mark_rollback()
         else:
             realname = m.person.realname
             msg = _(astakos_messages.USER_JOINED_PROJECT) % locals()
             messages.success(request, msg)
         finally:
             if rollback:
                 transaction.rollback()
             else:
                 transaction.commit()
         return redirect(reverse('project_detail', args=(chain_id,)))
     @require_http_methods(["POST"])
     @signed_terms_required
     @login_required
     @transaction.commit_manually
     def project_remove_member(request, chain_id, user_id):
         rollback = False
     @project_transaction_context(sync=True)
     def project_remove_member(request, chain_id, user_id, ctx=None):
         try:
             chain_id = int(chain_id)
             user_id = int(user_id)
-...
         except BaseException, e:
             logger.exception(e)
             messages.error(request, _(astakos_messages.GENERIC_ERROR))
             rollback = True
             if ctx:
                 ctx.mark_rollback()
         else:
             realname = m.person.realname
             msg = _(astakos_messages.USER_LEFT_PROJECT) % locals()
             messages.success(request, msg)
         finally:
             if rollback:
                 transaction.rollback()
             else:
                 transaction.commit()
         return redirect(reverse('project_detail', args=(chain_id,)))
     @require_http_methods(["POST"])
     @signed_terms_required
     @login_required
     @transaction.commit_manually
     def project_reject_member(request, chain_id, user_id):
         rollback = False
     @project_transaction_context()
     def project_reject_member(request, chain_id, user_id, ctx=None):
         try:
             chain_id = int(chain_id)
             user_id = int(user_id)
-...
         except BaseException, e:
             logger.exception(e)
             messages.error(request, _(astakos_messages.GENERIC_ERROR))
             rollback = True
             if ctx:
                 ctx.mark_rollback()
         else:
             realname = m.person.realname
             msg = _(astakos_messages.USER_LEFT_PROJECT) % locals()
             messages.success(request, msg)
         finally:
             if rollback:
                 transaction.rollback()
             else:
                 transaction.commit()
         return redirect(reverse('project_detail', args=(chain_id,)))
     def landing(request):

Also available in: Unified diff