コード例 #1
0
def index(request, slugs=None):
    # TODO This function is perfect for a request context processors reused
    # in gallery pages...
    parent_slug, current_category = process_category_thread(request, slugs, 'daguerro')
    categories = Gallery.objects.filter(parent__title_slug=parent_slug)

    if current_category:
        photos = current_category.photos.all()
        if current_category.photos_ordering:
            photos = photos.custom_order_by(current_category.photos_ordering)
    else:
        photos = Photo.objects.orphans()

    user_groups = request.user.groups.all().values_list("name", flat=True)
    if 'Editor' in user_groups and len(user_groups) == 1:
        return HttpResponseRedirect(reverse("daguerro-pages-index"))

    page_no = int(request.GET.get('page', 1))
    paginator = DiggPaginator(photos, django_settings.get('DAG_RESULTS_PER_PAGE'))
    context = {'categories': categories,
               'current_category': current_category,
               'photos_page': paginator.page(page_no),
               'add_photo_in_root': django_settings.get('DAG_ALLOW_PHOTOS_IN_ROOT_GALLERY'),
               'no_image_thumb_url': os.path.join(settings.STATIC_URL,
                                                  settings.DAG_NO_IMAGE[settings.DAG_GALLERY_THUMB_SIZE_KEY]),
               'search_options_form': SearchOptionsForm(),
               }
    return render_to_response('daguerro/gallery.html', context,
                              context_instance=RequestContext(request))
コード例 #2
0
def _send_request_emails(subject, message, sender_email, photo_items):
    try:
        t = get_template('website/request_photos_mail.html')
        photos = Photo.objects.filter(pk__in=photo_items)
        no_image_thumb_url = os.path.join(settings.STATIC_URL,
                                          settings.DAG_NO_IMAGE[settings.DAG_GALLERY_THUMB_SIZE_KEY])
        body = t.render(Context({'photos': photos, 
                                 'sender_email': sender_email,
                                 'message': message, 
                                 'no_image_thumb_url': no_image_thumb_url}
                                ))
        _send_html_mail(EmailMultiAlternatives(subject,
                                               body,
                                               django_settings.get('DAG_SMTP_HOST'),
                                               [django_settings.get('DAG_SMTP_HOST_USER')],
                                               headers = {'Reply-To': sender_email})
                        )
        confirmation_body = settings.DAGUERRO_EMAIL_BODY % {'email': 
                                                            django_settings.get("DAG_SALES_EMAIL")}
        _send_html_mail(EmailMultiAlternatives(django_settings.get('DAG_CONFIRMATION_MAIL_SUBJECT'), 
                                               confirmation_body,
                                               django_settings.get('DAG_SMTP_HOST_USER'),
                                               [sender_email],)
                        )
    except BadHeaderError:
        return HttpResponse('Invalid header found.')
コード例 #3
0
ファイル: paytrail.py プロジェクト: jrutila/stables.fi
def createPayment(order, amount, transaction_id, urls):
    data = {
        "orderNumber": transaction_id,
        "currency": "EUR",
        "locale": "fi_FI",
        "urlSet": urls,
        "price": str(order.order_total)
    }
    """
    VAT = getattr(settings, 'SHOP_VAT', Decimal('0.24'))
    for o in order.items.all():
        data['orderDetails']['products'].append(
            {
                "title": o.product_name,
                "code": str(o.product.id),
                "amount": str(o.quantity),
                "price": str((o.line_total*(1+VAT)).quantize(Decimal('0.01'))),
                "vat": str(VAT*100),
                "discount": "0.00",
                "type": "1"
            }
        )
    """
    AUTH_HELP = (getattr(settings, 'MERCHANT_ID',
                         django_settings.get('merchant_id', default=None)),
                 getattr(settings, 'MERCHANT_PASS',
                         django_settings.get('merchant_pass', default=None)))
    r = requests.post(SERVICE_URL,
                      headers=headers,
                      auth=AUTH_HELP,
                      data=json.dumps(data))
    r.raise_for_status()
    return r.json()['url']
コード例 #4
0
def gallery(request, slugs=None):
    parent_slug, current_gallery = process_category_thread(request, slugs)
    no_image_thumb_url = os.path.join(settings.STATIC_URL, 
                                          settings.DAG_NO_IMAGE[settings.DAG_GALLERY_THUMB_SIZE_KEY])
    
    # TODO Find a better way to do this (parent by default for a category, i.e. root)
    if current_gallery:
        children_galleries = current_gallery.get_children().filter(is_public=True)
        brother_galleries = current_gallery.get_siblings(include_self=True).filter(is_public=True)
        photos = current_gallery.photos.public()
        if current_gallery.photos_ordering:
            photos = photos.custom_order_by(current_gallery.photos_ordering)
    else:
        brother_galleries = None
        children_galleries = None
        photos = Photo.objects.public().orphans()
    
    page_no = int(request.GET.get('page', 1))
    paginator = DiggPaginator(photos, django_settings.get('DAG_RESULTS_PER_PAGE'))
    template = 'website/gallery.html' if slugs else 'website/index.html'  
    return render_to_response(template, {'gallery': current_gallery, 
                                         'brother_galleries': brother_galleries, 
                                         'children_galleries': children_galleries,
                                         'search_options_form': SearchOptionsForm(),
                                         'no_image_thumb_url': no_image_thumb_url,
                                         'photos_page': paginator.page(page_no),
                                         }, context_instance=RequestContext(request)
                              )
コード例 #5
0
def page(request, action, id=None):
    if action == 'edit':
        current_action_title = _("Edit Page")
        page = get_object_or_404(DaguerroFlatPage, pk=id)
    elif action == 'add':
        current_action_title = _("Add Page")
        page = DaguerroFlatPage(registration_required=True)

    request.breadcrumbs((
            (_("Pages"), reverse("daguerro-pages-index")),
            (current_action_title, None),
    ))

    if request.method == 'POST':
        form = FlatPageForm(request.POST, instance=page)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse("daguerro-pages-index"))
    else:
        form = FlatPageForm(instance=page, initial={
                'registration_required': not django_settings.get('DAG_PUBLISH_BY_DEFAULT',
                                                                 default=True)
                })

    return render_to_response('daguerro/page_form.html',
                              {'form': form,
                               'current_action_title': current_action_title,
                               'current_action': action,
                               },
                              context_instance=RequestContext(request))
コード例 #6
0
ファイル: paytrail.py プロジェクト: jrutila/stables.fi
def calcAuthCode(order_number, timestamp, paid, method):
    auth = order_number + "|" + timestamp
    if paid: auth += "|" + paid
    if method: auth += "|" + method
    auth += "|" + getattr(settings, 'MERCHANT_PASS',
                          django_settings.get('merchant_pass', default=None))
    return hashlib.md5(auth).hexdigest()
コード例 #7
0
 def get_billing_and_shipping_selection_form(self):
     form = super(NoShippingAddressCheckoutSelectionView,
                  self).get_billing_and_shipping_selection_form()
     form.fields['shipping_method'].widget.attrs['class'] = "hidden"
     form.fields['shipping_method'].label = ""
     choices = self.get_billing_backends_choices()
     tpl = []
     for c in choices:
         if c[0] == 'paytrail-payment' \
                 and django_settings.get('merchant_id') != "":
             tpl.append(c)
         #and django_settings.exists['payment_account_number']\
         if c[0] == 'advance-payment' \
                 and django_settings.get('payment_account_number') != "":
             tpl.append(c)
     form.fields['payment_method'] = forms.ChoiceField(
         choices=tpl, label=_('Payment method'))
     form.helper = DefaultHelper()
     return form
コード例 #8
0
    def get_context_data(self, member_id):
        ctx = super().get_context_data()
        member = get_object_or_404(Member, token=member_id)
        ctx["season"] = Season.objects.current_season()
        ctx["member"] = member
        transactions = Transaction.objects.filter(owner=member)
        saldo = transactions.aggregate(Sum('amount'))['amount__sum']
        # Limit transactions to only show the latest
        ctx["transactions"] = []
        sld = 0
        if saldo != None and saldo < 0:
            for tr in list(transactions.order_by('created_at')):
                sld = sld + tr.amount
                if sld >= Decimal('0.00'):
                    ctx["transactions"] = []
                if sld != Decimal('0.00'):
                    ctx["transactions"].append(tr)
        else:
            season_type = ContentType.objects.get_for_model(ctx["season"])
            act_type = ContentType.objects.get_for_model(Activity)
            acts = Activity.objects.filter(season=ctx["season"]).values_list(
                'id', flat=True)
            ctx["transactions"] = transactions.filter(
                Q(source_type=season_type.id, source_id=ctx["season"].id)
                | Q(source_type=act_type.id, source_id__in=acts))

        ctx['acts'] = ActivityParticipation.objects.filter_canceable(
            member=member)
        for a in ctx['acts']:
            tr = [x for x in ctx['transactions'] if x.source == a.activity]
            if tr:
                tr[0].cancel = CancelForm({
                    'actpartid': a.id,
                    'member': member.token
                })
        ctx["saldo"] = saldo
        ctx["last_check"] = Transaction.objects.filter(
            source_type=ContentType.objects.get_for_model(
                ReferenceNumber)).aggregate(
                    Max('created_at'))['created_at__max']
        if saldo and member.reference_numbers:
            barcode = "4"
            barcode = barcode + re.sub(r"[A-Za-z\s]+", "",
                                       django_settings.get('bank_account'))
            intpart, decimalpart = int(saldo), int((saldo - int(saldo)) * 100)
            barcode = barcode + str(1000000 - intpart)[1:]
            barcode = barcode + str(100 - decimalpart)[1:]
            barcode = barcode + '000'
            barcode = barcode + str(
                member.reference_numbers.first().number).zfill(20)
            barcode = barcode + timezone.now().strftime("%Y%m%d")
            ctx['barcode'] = barcode
        return ctx
コード例 #9
0
ファイル: views.py プロジェクト: SLOBYYYY/vetco
def about_us(request):
    try:
        about_us_text = django_settings.get('rolunk')
    except:
        about_us_text = ''
    return render(
        request,
        'about_us.html',
        {
            'about_us_text': about_us_text
        }
    )
コード例 #10
0
def settings(parser, token):
    var_name = None
    try:
        tag_name, arg = token.contents.split(None, 1)
    except ValueError:
        raise template.TemplateSyntaxError(
            "%r tag requires arguments" % token.contents.split()[0])
    m = re.search(r'(.*?) as (\w+)', arg)
    if m:
        arg, var_name = m.groups()
    if not (arg[0] == arg[-1] and arg[0] in ('"', "'")):
        raise template.TemplateSyntaxError(
            "%r tag's argument should be in quotes" % tag_name)
    return ContextNode(django_settings.get(arg[1:-1]), var_name)
コード例 #11
0
ファイル: views.py プロジェクト: SLOBYYYY/vetco
def price_list(request):
    products = Product.objects.all()
    try:
        price_list_text = django_settings.get('arlista_szovegalairas')
    except:
        price_list_text = ''
    return render(
        request,
        'price_list.html',
        {
            'products': products,
            'price_list_text': price_list_text
        }
    )
コード例 #12
0
    def test_setting_value_few_times(self):
        typename = "MyString"
        django_settings.set(typename, 'test_string', 'data1')
        self.assert_equal(django_settings.exists('test_string'), True)
        self.assert_equal(django_settings.get("test_string"), "data1")

        django_settings.set(typename, 'test_string', 'data2')
        self.assert_equal(django_settings.data.get("test_string"), "data2")

        django_settings.set(typename, 'test_string', 'data3')
        self.assert_equal(django_settings.data.get("test_string"), "data3")

        django_settings.set(typename, 'test_string', 'data4')
        self.assert_equal(django_settings.data.get("test_string"), "data4")
コード例 #13
0
ファイル: test_api.py プロジェクト: Rakuli/django-settings
    def test_setting_value_few_times(self):
        typename = "MyString"
        django_settings.set(typename, 'test_string', 'data1')
        n.assert_equal(django_settings.exists('test_string'), True)
        n.assert_equal(django_settings.get("test_string"), "data1")

        django_settings.set(typename, 'test_string', 'data2')
        n.assert_equal(django_settings.data.get("test_string"), "data2")

        django_settings.set(typename, 'test_string', 'data3')
        n.assert_equal(django_settings.data.get("test_string"), "data3")

        django_settings.set(typename, 'test_string', 'data4')
        n.assert_equal(django_settings.data.get("test_string"), "data4")
コード例 #14
0
def photo(request, action='add', slugs=None, slug=None):
    # TODO This function is perfect for a request context processor reused in gallery pages...
    parent_slug, current_category = process_category_thread(request, slugs, 'daguerro')

    if slug:
        current_action_title = _("Edit photography")
        extra_context = {'current_action': 'edit'}
        photo = get_object_or_404(Photo, title_slug=slug)
        initial_galleries = photo.galleries.all().values_list('id', flat=True)
    else:
        current_action_title = _("Add photography")
        extra_context = {'current_action': 'add'}
        photo = Photo()
        try:
            initial_galleries = [Gallery.objects.get(title_slug=parent_slug).id]
        except Gallery.DoesNotExist:
            initial_galleries = None

    request.breadcrumbs(current_action_title, None)

    if request.method == 'POST':
        # Force slugify, otherwise I need to fix photologue model or need client-side filling.
        request.POST['title_slug'] = slugify(request.POST['title'])
        form = PhotoForm(request.POST, request.FILES, instance=photo)
        if form.is_valid():
            form.save()
            return redirect_to_gallery(slugs, page=request.GET.get("page", None))
    else:
        form = PhotoForm(instance=photo, initial={
                'galleries': initial_galleries,
                'is_public': django_settings.get('DAG_PUBLISH_BY_DEFAULT', default=False)
                })

    return render_to_response('daguerro/photo.html',
                              {'form': form,
                               'photo': photo,
                               'extra_context': extra_context,
                               'current_category': current_category,
                               'current_action_title': current_action_title,
                               'current_action': action,
                               'no_image_thumb_url': os.path.join(settings.STATIC_URL,
                                                     settings.DAG_NO_IMAGE[settings.DAG_PHOTO_THUMB_SIZE_KEY]),
                               },
                              context_instance=RequestContext(request))
コード例 #15
0
def gallery(request, action='add', slugs=""):
    # TODO This function is perfect for a request context processors reused in gallery pages...
    parent_slug, current_category = process_category_thread(request, slugs, 'daguerro', action)

    if action == 'edit':
        current_action_title = _("Edit Gallery")
        parent_gallery = current_category.parent.id if current_category.parent else None
        gallery = get_object_or_404(Gallery, title_slug=current_category.title_slug)
    elif action == 'add':
        current_action_title = _("Add Gallery")
        parent_gallery = current_category.id if current_category else None
        gallery = Gallery()

    request.breadcrumbs(current_action_title, None)

    if request.method == 'POST':
        # Force slugify, otherwise I need to fix photologue model or need client-side filling.
        request.POST['title_slug'] = slugify(request.POST['title'])
        form = GalleryForm(request.POST, request.FILES, instance=gallery)
        if form.is_valid():
            form.save()
            return redirect_to_gallery(slugs, gallery, action)
    else:
        form = GalleryForm(instance=gallery, initial={
                'parent': parent_gallery,
                'is_public': django_settings.get('DAG_PUBLISH_BY_DEFAULT', default=False)
                })

    return render_to_response('daguerro/gallery_form.html',
                              {'form': form,
                               'current_category': current_category,
                               'current_action_title': current_action_title,
                               'current_action': action,
                               'no_image_thumb_url': os.path.join(settings.STATIC_URL,
                                                                  settings.DAG_NO_IMAGE['gallery']),
                               'search_options_form': SearchOptionsForm(),
                               },
                              context_instance=RequestContext(request))
コード例 #16
0
ファイル: views.py プロジェクト: jrutila/dancing
    def get_context_data(self, member_id):
        ctx = super().get_context_data()
        member = get_object_or_404(Member, token=member_id)
        ctx["season"] = Season.objects.current_season()
        ctx["member"] = member
        transactions = Transaction.objects.filter(owner=member)
        saldo = transactions.aggregate(Sum('amount'))['amount__sum']
        # Limit transactions to only show the latest
        ctx["transactions"] = []
        sld = 0
        for tr in list(transactions.order_by('created_at')):
            sld = sld + tr.amount
            if sld >= Decimal('0.00'):
                ctx["transactions"] = []
            if sld != Decimal('0.00'):
                ctx["transactions"].append(tr)

        ctx['acts'] = ActivityParticipation.objects.filter_canceable(member=member)
        for a in ctx['acts']:
            tr = [x for x in ctx['transactions'] if x.source == a.activity]
            if tr:
                tr[0].cancel = CancelForm({ 'actpartid': a.id, 'member': member.token })
        ctx["saldo"] = saldo
        ctx["last_check"] = Transaction.objects.filter(
            source_type=ContentType.objects.get_for_model(ReferenceNumber)).aggregate(
                Max('created_at'))['created_at__max']
        if saldo and member.reference_numbers:
            barcode = "4"
            barcode = barcode + re.sub(r"[A-Za-z\s]+", "", django_settings.get('bank_account'))
            intpart,decimalpart = int(saldo),int((saldo-int(saldo))*100)
            barcode = barcode + str(1000000 - intpart)[1:]
            barcode = barcode + str(100 - decimalpart)[1:]
            barcode = barcode + '000'
            barcode = barcode + str(member.reference_numbers.first().number).zfill(20)
            barcode = barcode + timezone.now().strftime("%Y%m%d")
            ctx['barcode'] = barcode
        return ctx
コード例 #17
0
def search_photo(request, format):
    term = request.GET.get('term', '')
    photos = Photo.objects.filter(title__icontains=term).order_by("title")
    if format == 'json':
        label = '<a><img src="%s"/><p>%s</p></a>'
        response = HttpResponse(simplejson.dumps([{
                        'label': label % (p.get_thumbnail_url(), p.title),
                        'value': p.title,
                        'image': p.get_gallery_url(),
                        'id': p.id} for p in photos]))
    else:
        no_image_thumb_url = os.path.join(settings.STATIC_URL, settings.DAG_NO_IMAGE[settings.DAG_GALLERY_THUMB_SIZE_KEY])
        num_results = len(photos)
        response = render_to_response(
            'daguerro/gallery.html', {
                'categories': {},
                'current_category': None,
                'photos': photos,
                'term': term,
                'num_results': num_results,
                'add_photo_in_root': django_settings.get('DAG_ALLOW_PHOTOS_IN_ROOT_GALLERY'),
                'no_image_thumb_url': no_image_thumb_url,},
            context_instance=RequestContext(request))
    return response
コード例 #18
0
ファイル: test_api.py プロジェクト: Rakuli/django-settings
 def test_get_should_accept_default_param(self):
     result = django_settings.get('unexisting_value', default="DefaultValue")
     n.assert_equal(result, "DefaultValue")
コード例 #19
0
ファイル: test_api.py プロジェクト: Rakuli/django-settings
    def test_should_set_properly(self):
        n.assert_true(hasattr(django_settings.models, 'MyString'))

        assert not django_settings.exists('admin_email')
        django_settings.set('MyString', 'admin_email', '*****@*****.**')
        assert django_settings.get('admin_email') == '*****@*****.**'
コード例 #20
0
 def test_get_should_raise_DoesNotExist_if_theres_no_such_setting(self):
     self.assert_raises(
         django_settings.db.Setting.DoesNotExist,
         lambda: django_settings.get('unexisting_value'),
     )
コード例 #21
0
 def get_context_data(self, **kwargs):
     context = super(InfoView, self).get_context_data(**kwargs)
     context['content'] = django_settings.get('shop_info')
     return context
コード例 #22
0
ファイル: views.py プロジェクト: alifanov/artlounge
 def post(self, request, *args, **kwargs):
     if request.POST:
         form = OrderForm(request.POST)
         if form.is_valid():
             order = form.save()
             msg = u'E-mail: {}\nКомментарий: {}'.format(order.email, order.comment)
             send_mail(u'Заполнение формы на сайте art-lounge.ru',msg, '*****@*****.**', [django_settings.get('admin_email'),])
     return HttpResponse('OK')
コード例 #23
0
    def handle(self, *args, **options):
        '''For each Team object check their sponsorship
        page and update their record in the database
        '''
        # connect to the API
        if not settings.TWITTER_CONSUMER_KEY:
            raise Exception("There are no Twitter user credentials")

        api = TwitterAPI(
            settings.TWITTER_CONSUMER_KEY,
            settings.TWITTER_CONSUMER_SECRET,
            settings.TWITTER_ACCESS_TOKEN_KEY,
            settings.TWITTER_ACCESS_TOKEN_SECRET
        )

        streams = TwitterStream.objects.all().filter(
            Q(type=TwitterStream.TWITTER) | Q(type=TwitterStream.TWITTER_LIST)
        )

        for stream in streams:
            logging.debug("Now working on %s" % stream)

            # look up the settings in the database to see where 
            # were we the last time we asked for tweets from Twitter
            since_id = django_settings.get('TWITTER_SINCE_ID_%s' % stream.stream_id, default=1)
            new_since_id = since_id

            # make APiI request and check HTTP response
            r = api.request('lists/statuses', 
                    {
                        'list_id': stream.stream_id, 
                        'include_rts': stream.include_rts,
                        'since_id': since_id,
                        'count': 25
                    }
                )
            if r.status_code != 200:
                logging.exception("API Call Failed")
                raise Exception("API Call Failed")

            # prcoess tweets
            for tweet in r.get_iterator():

                try:
                    try:
                        tweet['retweeted_status'] # this key is only set on retweets
                        # this is a retweet by our accounts
                        # we care about the original tweet maker not ourselves
                        tweet = tweet['retweeted_status']

                    except KeyError:
                        pass

                    # extract out the media from the entities
                    try:
                        media_url = tweet['entities']['media'][0]['media_url']
                    except:
                        media_url = None

                    # strip the timezone off the timestamp
                    time_tz = dateutil.parser.parse(tweet['created_at'])
                    time = datetime.datetime(time_tz.year, time_tz.month, time_tz.day, time_tz.hour, time_tz.minute, time_tz.second)

                    if not Tweet.objects.all().filter(tweet_id=tweet['id']).exists():
                        new_tweet = Tweet.objects.create(
                                tweet_id=tweet['id'],
                                media_url=media_url,
                                message=_html_for_tweet(tweet),
                                time=time,
                                in_reply_to_user_name=tweet['in_reply_to_screen_name'],
                                retweeted=True,
                                user_id=tweet['user']['id'],
                                user_name=tweet['user']['screen_name'],
                                user_photo=tweet['user']['profile_image_url'],
                                team=None
                            )

                        # update the since id so we don't get the same
                        # tweets mutliple times from twitter
                        if new_tweet.tweet_id < new_since_id:
                            new_since_id = new_tweet.tweet_id

                        logging.debug("Created tweet %i" % new_tweet.tweet_id)
                    else:
                        logging.debug("Tweet %s has already been added to the database" % tweet['id'])
                        new_tweet = None

                except Exception as e:
                    logging.exception("Failed to process tweet %d" % tweet['id'])

            # update settings datastore with highest tweet id
            django_settings.set('Integer', 'TWITTER_SINCE_ID_%s' % stream.stream_id, new_since_id)
コード例 #24
0
from autobahn.twisted.websocket import listenWS
from laptimer.server import APIServerFactory
from twisted.internet import reactor
from twisted.web.server import Site
from twisted.web.static import File
import django_settings
import logging

logger = logging.getLogger('laptimer')

if __name__ == '__main__':
    # TODO: Get server and port from settings
    debug = django_settings.get('debug_app')
    factory = APIServerFactory('ws://localhost:9000',
                               debug=debug,
                               debugCodePaths=debug)
    listenWS(factory)
    webdir = File('.')
    web = Site(webdir)
    reactor.run()
コード例 #25
0
def average_speed_per_hour(start, finish, distance):
    unit = django_settings.get('unit_of_measurement', default=settings.METRIC)
    if (unit == settings.METRIC):
        return average_kilometres_per_hour(start, finish, distance)
    else:
        return average_miles_per_hour(start, finish, distance)
コード例 #26
0
 def test_gpio_app_defaults_to_11(self):
     self.assertTrue(django_settings.exists('gpio_app'))
     self.assertEqual(15, django_settings.get('gpio_app'))
コード例 #27
0
ファイル: gpio.py プロジェクト: movermeyer/pi-time
class PiTimeGPIO:
    ''''
    Class used to work with Raspberry Pi GPIO when triggering sensor events,
    as well as displaying information relating to application and lap status.
    '''
    # TODO: Decouple gpio pins from django settings, instead add properties
    # for track and sensor. When these are not initialised, use the laptimer
    # API to define the track, sensor and gpio pins (in a separate class).
    # Needs some sort of registration process, since as soon as you have more
    # than one sensor (RPi), or if the sensor is on separate hardware from the
    # laptimer server, configuration can't be shared from django settings, so
    # it probably requires a separate db for the rpi app, and some client code
    # to talk to the laptimer app server.

    gpio_app = django_settings.get('gpio_app')
    '''GPIO pin which indicates whether application server is active.'''

    gpio_lap = django_settings.get('gpio_lap')
    '''GPIO pin which indicates whether a lap is currently active.'''

    gpio_sensor = django_settings.get('gpio_sensor')
    '''GPIO pin which indicates when a sensor event has been triggered.'''
    def __init__(self):
        GPIO.setmode(GPIO.BOARD)
        GPIO.setup(self.gpio_app, GPIO.OUT, initial=GPIO.LOW)
        GPIO.setup(self.gpio_lap, GPIO.OUT, initial=GPIO.LOW)
        GPIO.setup(self.gpio_sensor,
                   GPIO.IN,
                   initial=GPIO.LOW,
                   pull_up_down=GPIO.PUD_DOWN)
        GPIO.add_event_detect(self.gpio_sensor,
                              GPIO.RISING,
                              callback=_sensor_event,
                              bouncetime=1000)
        logging.debug(
            'GPIO channels configured as app: %i lap: %i sensor: %i' %
            (self.gpio_app, self.gpio_lap, self.gpio_sensor))

    def appOpen(self):
        logging.debug('App open')
        _strobe_led(self.gpio_app, GPIO.HIGH)

    def appClose(self):
        logging.debug('App close')
        _strobe_led(self.gpio_app, GPIO.LOW)

    def cleanup(self):
        logging.debug('Cleaning up')
        GPIO.output(self.gpio_app, GPIO.LOW)
        GPIO.output(self.gpio_lap, GPIO.LOW)
        GPIO.remove_event_detect(self.gpio_sensor)
        GPIO.cleanup()

    def _sensor_event(self, channel):
        time = timezone.now()
        logging.debug('Sensor event')
        _strobe_led(self.gpio_lap, GPIO.LOW)
        # TODO: trigger event to call api.end_lap

    def _strobe_led(self, channel, final_state):
        on = not GPIO.input(channel)
        strobe_count = 10  # TODO: settings?
        strobe_sleep = 0.1  #
        for index in xrange(1, strobe_count):
            GPIO.output(channel, on)
            time.sleep(strobe_sleep)
            on = not on
        GPIO.output(channel, final_state)
コード例 #28
0
 def test_get_should_accept_default_param(self):
     result = django_settings.get('unexisting_value',
                                  default="DefaultValue")
     self.assert_equal(result, "DefaultValue")
コード例 #29
0
 def test_gpio_sensor_defaults_to_18(self):
     self.assertTrue(django_settings.exists('gpio_sensor'))
     self.assertEqual(18, django_settings.get('gpio_sensor'))
コード例 #30
0
ファイル: test_api.py プロジェクト: Rakuli/django-settings
 def test_get_should_raise_DoesNotExist_if_theres_no_such_setting(self):
     n.assert_raises(
         django_settings.db.Setting.DoesNotExist,
         lambda: django_settings.get('unexisting_value'),
     )
コード例 #31
0
ファイル: settings.py プロジェクト: ygneo/daguerro
from django.conf import settings
import django_settings


try:
    dag_results_per_page = django_settings.get('DAG_RESULTS_PER_PAGE', default=20)
    settings.HAYSTACK_SEARCH_RESULTS_PER_PAGE = dag_results_per_page
except:
    pass
コード例 #32
0
ファイル: server.py プロジェクト: si618/pi-time
from autobahn.twisted.websocket import listenWS
from laptimer.server import APIServerFactory
from twisted.internet import reactor
from twisted.web.server import Site
from twisted.web.static import File
import django_settings
import logging


logger = logging.getLogger('laptimer')

if __name__ == '__main__':
    # TODO: Get server and port from settings
    debug=django_settings.get('debug_app')
    factory = APIServerFactory('ws://localhost:9000', debug=debug, debugCodePaths=debug)
    listenWS(factory)
    webdir = File('.')
    web = Site(webdir)
    reactor.run()
コード例 #33
0
 def test_gpio_lap_defaults_to_13(self):
     self.assertTrue(django_settings.exists('gpio_lap'))
     self.assertEqual(16, django_settings.get('gpio_lap'))
コード例 #34
0
ファイル: compute.py プロジェクト: si618/pi-time
def average_speed_per_hour(start, finish, distance):
    unit = django_settings.get('unit_of_measurement', default=settings.METRIC)
    if (unit == settings.METRIC):
        return average_kilometres_per_hour(start, finish, distance)
    else:
        return average_miles_per_hour(start, finish, distance)
コード例 #35
0
 def test_unit_of_measurement_defaults_to_metric(self):
     self.assertTrue(django_settings.exists('unit_of_measurement'))
     self.assertEqual(settings.METRIC,
         django_settings.get('unit_of_measurement'))
コード例 #36
0
    def test_should_set_properly(self):
        self.assert_true(hasattr(django_settings.models, 'MyString'))

        assert not django_settings.exists('admin_email')
        django_settings.set('MyString', 'admin_email', '*****@*****.**')
        assert django_settings.get('admin_email') == '*****@*****.**'