from builtins import object

import hashlib

from django.conf import settings

from django.template import RequestContext

# This is backwards compatibilty support for a custom function we wrote

# ourselves that is no longer necessary in modern Django.

from django.shortcuts import render as render_template_with_context

class ParameterValidator(object):

    def __init__(self, given_hash_or_params, params_hash_key=None):

from django.db import models

from django.conf import settings

from conservancy import bsoup

from conservancy.apps.staff.models import Person

from datetime import datetime, timedelta

class EntryTag(models.Model):

    """Tagging for blog entries"""

    label = models.CharField(max_length=100)

    slug = models.SlugField()

    # Ping google blogs and technorati.  Taken from

    # http://blog.foozia.com/blog/2007/apr/21/ping-technorati-your-django-blog-using-xml-rpc/

    def save(self):

        if settings.CONSERVANCY_DEVEL or True: # "or True" means it is disabled always

            super(Entry, self).save()

            return

        blog_name = 'Software Freedom Conservancy Blog'

        blog_url =  'http://www.sfconservancy.org/blog/'

        post_url = ('http://www.sfconservancy.org'

                    + self.get_absolute_url())

        # Ping Technorati

        reply = j.weblogUpdates.ping(blog_name, blog_url)

        # Ping Google Blog Search

        reply = j.weblogUpdates.ping(blog_name, blog_url, post_url)

        # Call any superclass's method

        super(Entry, self).save()

    * event (event object)

    * date (date object for most recently posted media from event)

    * media_list (a string of the available media types)

    """

    media_by_event = {}

    for media in eventmedia_queryset:

        media_by_event.setdefault(media.event.id, []).append(media)

    mbe = [{'event': x[0].event,

            'date': max(y.date_created for y in x),

            'media_list': ', '.join(set(y.get_format_display() for y in x))}

    mbe.sort(key=(lambda x: x['date']), reverse=True) # sort by date

    return mbe

from builtins import object

import random

from django.db import models

class FundraisingGoal(models.Model):

    """Conservancy fundraiser Goal"""

    fundraiser_code_name = models.CharField(max_length=200, blank=False, unique=True)

    fundraiser_goal_amount = models.DecimalField(max_digits=10, decimal_places=2)

    fundraiser_so_far_amount = models.DecimalField(max_digits=10, decimal_places=2)

    fundraiser_donation_count = models.IntegerField()

    fundraiser_donation_count_disclose_threshold = models.IntegerField()

    fundraiser_endtime = models.DateTimeField(null=True)

    def __unicode__(self):

        return self.fundraiser_code_name

    def percentage_there(self):

    class Meta(object):

        ordering = ('fundraiser_code_name',)

    def providers(self):

        return GoalProvider.objects.filter(fundraising_goal=self)

    def random_providers(self, k=None):

        providers = self.providers()

        if not providers.exists():

            return None

        elif k is None:

from builtins import object

from django.db import models

from django.conf import settings

from conservancy import bsoup

from conservancy.apps.staff.models import Person

from conservancy.apps.events.models import Event

from django.contrib.sites.models import Site

from datetime import datetime, timedelta

class PressRelease(models.Model, bsoup.SoupModelMixin):

    """News release model"""

        return self.pub_date > (datetime.now() - timedelta(days=30))

    def save(self):

        if settings.CONSERVANCY_DEVEL or True:

            super(PressRelease, self).save()

            return

        blog_name = 'Software Freedom Conservancy News'

        blog_url =  'https://www.sfconservancy.org/news/'

        post_url = ('https://www.sfconservancy.org'

                    + self.get_absolute_url())

        # Ping Technorati

        reply = j.weblogUpdates.ping(blog_name, blog_url)

        # Ping Google Blog Search

        reply = j.weblogUpdates.ping(blog_name, blog_url, post_url)

        # Call any superclass's method

        super(PressRelease, self).save()

class ExternalArticleTag(models.Model):

    """A way to tag external articles"""

    label = models.CharField(max_length=100)

    date_created = models.DateField(auto_now_add=True)

from django import template

register = template.Library()

@register.filter(name='fill_url')

def fill_url(given_url, base_url):

    """"Fill out" missing pieces of one URL from another.

    This function parses the given URL, and if it's missing any pieces

    (scheme, netloc, etc.), it fills those in from the base URL.

    Typical usage is "/URL/path"|fill_url:"https://hostname/"

    to generate "https://hostname/URL/path".

    """

        given_part or base_part for given_part, base_part in zip(given_parts, base_parts)

    )

# -*- encoding: utf-8 -*-

from builtins import object

import io

import itertools

import re

import bs4

import bs4.element

class BeautifulSoup(bs4.BeautifulSoup):

    """A wrapper of the original BeautifulSoup class, with convenience methods added."""

    IMAGE_ATTRS = {

            except (KeyError, ValueError):

                sort_key = fallback

            elem[attr_name] = sort_key

            return sort_key

        return elem_sort_key

    def _elem_pred(self, attr_name=OG_PREVIEW_ATTR, test=lambda n: n > 0):

        def elem_pred(elem):

            return test(elem[attr_name])

        return elem_pred

    def _sort_and_slice_elems(self, elem_seq, elem_key, pred, *slice_args):

        if slice_args:

            return itertools.islice(seq, *slice_args)

        else:

            return seq

    def get_description(self):

        """Return a string with a brief excerpt of body text from the HTML."""

        return u''.join(self._get_soup().some_body_text())

    def get_image_urls(self, *slice_args):

        """Return an iterator of source URL strings of all images in the HTML.

        # we have no object!  do something

        return None

def sitefundraiser(request):

    return {

        'datetime_now': DateTime.now(),

        'sitefundgoal': fundgoal_lookup(SITE_FUNDGOAL),

    }

if conservancy.settings.FORCE_CANONICAL_HOSTNAME:

    _HOST_URL_VAR = {'host_url': 'https://' + conservancy.settings.FORCE_CANONICAL_HOSTNAME}

    def host_url(request):

else:

    def host_url(request):

import mimetypes

import os.path

from django.http import HttpResponse

from django.template.response import TemplateResponse

from conservancy.local_context_processors import fundgoal_lookup

STATIC_ROOT = os.path.abspath(os.path.dirname(__file__))

FILESYSTEM_ENCODING = 'utf-8'

def handler(request, errorcode):

    path = os.path.join('error', str(errorcode), 'index.html')

from mod_python import apache

# 404 should do NOTHING so apache can handle it.  This view is referenced

# in sflc.urls

def view404(request):

    from django.http import HttpResponseNotFound

    return HttpResponseNotFound("")

def outputfilter(filter):

    # set appropriate cache timeout

    filter.req.headers_out["Cache-Control"] = "max-age=600"

                for middleware_method in self._response_middleware:

                    response = middleware_method(request, response)

                response = self.apply_response_fixes(request, response)

        finally:

            signals.request_finished.send(sender=self.__class__) 

        # SFLC: decline so apache can serve a static file

        if response.status_code == 404:

            return apache.DECLINED

        # Convert our custom HttpResponse object back into the mod_python req.

        req.content_type = response['Content-Type']

            if key != 'content-type':

                req.headers_out[str(key)] = str(value)

            req.headers_out.add('Set-Cookie', c.output(header=''))

        req.status = response.status_code

        try:

            for chunk in response:

                req.write(chunk)

        finally:

            response.close()

        return apache.DONE # skip all remaining phases (sf[l]c customization)

def postreadrequesthandler(req):

    # mod_python hooks into this function.