Synnefo

from astakos.im.tasks import request_billing

from astakos.im.api.callpoint import AstakosCallpoint

logger = logging.getLogger(__name__)

                    email = form.cleaned_data.get('username')

                    realname = form.cleaned_data.get('realname')

                    inviter.invite(email, realname)

                    messages.success(request, message)

                except SendMailError, e:

                    message = e.message

                    messages.error(request, message)

                    transaction.rollback()

                except BaseException, e:

                    messages.error(request, message)

                    logger.exception(e)

                    transaction.rollback()

                else:

                    transaction.commit()

        else:

            messages.error(request, message)

    sent = [{'email': inv.username,

                next = request.POST.get('next')

                if next:

                    return redirect(next)

                messages.success(request, msg)

            except ValueError, ve:

                messages.success(request, ve)

                messages.error(request, message)

                transaction.rollback()

            except BaseException, e:

                messages.error(request, message)

                logger.exception(e)

                transaction.rollback()

            except SendMailError, e:

                messages.error(request, message)

            else:

                messages.success(request, message)

    return render_response(template_name,

                           feedback_form=form,

        response['Location'] = LOGOUT_NEXT

        response.status_code = 301

        return response

    context = get_context(request, extra_context)

    response.write(

        template_loader.render_to_string(template, context_instance=context))

    try:

        user = AstakosUser.objects.get(auth_token=token)

    except AstakosUser.DoesNotExist:

    if user.is_active:

        messages.error(request, message)

        return index(request)

            transaction.rollback()

            return index(request)

        except BaseException, e:

            messages.error(request, message)

            logger.exception(e)

            transaction.rollback()

            transaction.rollback()

            return index(request)

        except BaseException, e:

            messages.error(request, message)

            logger.exception(e)

            transaction.rollback()

            pass

    if not term:

        return HttpResponseRedirect(reverse('index'))

    f = open(term.location, 'r')

    terms = f.read()

        try:

            user = EmailChange.objects.change_email(activation_key)

            if request.user.is_authenticated() and request.user == user:

                messages.success(request, msg)

                auth_logout(request)

                response = prepare_response(request, user)

            messages.error(request, msg)

            transaction.rollback()

        except IntegrityError, e:

            messages.error(request, msg)

        else:

            messages.success(request, msg)

            transaction.commit()

    return render_response(form_template_name,

    try:

        kind = GroupKind.objects.get(name=kind_name)

    except:

        result = callpoint.create_groups((d,)).next()

        if result.is_success:

            new_object = result.data[0]

                {"verbose_name": model._meta.verbose_name}

            messages.success(request, msg, fail_silently=True)

            post_save_redirect = '/im/group/%(id)s/'

            return HttpResponseRedirect(post_save_redirect % new_object)

        else:

                {"verbose_name": model._meta.verbose_name,

                 "reason":result.reason}

            messages.error(request, msg, fail_silently=True)

        return HttpResponseRedirect(post_save_redirect)

    except IntegrityError, e:

        logger.exception(e)

        messages.error(request, msg)

        return group_search(request)

            group__id=group_id,

            person=request.user)

    except Membership.DoesNotExist:

    if request.user in m.group.owner.all():

    return delete_object(

        request,

        model=Membership,

                group__id=group_id,

                person__id=user_id)

        except Membership.DoesNotExist:

        else:

            if request.user not in m.group.owner.all():

            func(request, m)

            return group_detail(request, group_id)

    return wrapper

    try:

        membership.approve()

        realname = membership.person.realname

        messages.success(request, msg)

    except BaseException, e:

        logger.exception(e)

        realname = membership.person.realname

        messages.error(request, msg)

    try:

        membership.disapprove()

        realname = membership.person.realname

        messages.success(request, msg)

    except BaseException, e:

        logger.exception(e)

        messages.error(request, msg)

        status, data = r.result

        data = _clear_billing_data(data)

        if status != 200:

    except:

        messages.error(request, r.result)