from django.contrib import admin from main.models import Users, Recommendation, BusinessSubmission, Category, Comment from ratings.handlers import ratings, RatingHandler from ratings.forms import SliderVoteForm # Register your models here. class RecommendationAdmin(admin.ModelAdmin): list_display = ('name', ) search_fields = ('name', ) class CategoryAdmin(admin.ModelAdmin): list_display = ('name', ) search_fields = ('name', ) admin.site.register(Users) admin.site.register(BusinessSubmission) admin.site.register(Recommendation, RecommendationAdmin) admin.site.register(Category, CategoryAdmin) admin.site.register(Comment) # ratings.register(Recommendation) ratings.register(Recommendation, RatingHandler, score_range=(1, 5), score_step=0.5, can_delete_vote=False)
from wechat.models import * from django.http import HttpResponse, Http404, HttpResponseRedirect from django.core.context_processors import csrf from django.shortcuts import render_to_response, get_object_or_404 from django.contrib.auth.models import User from django.contrib.auth import logout, login, authenticate from django.template import RequestContext from django.utils import simplejson from ratings.handlers import ratings, RatingHandler from ratings.forms import StarVoteForm, SliderVoteForm from ratings.models import Vote from django.core.urlresolvers import reverse from blog.models import * ratings.register(Product, form_class=StarVoteForm) #pdb.set_trace() kwd = { 'main_menu' : "M", 'start' : "##", 'restart' : 'R', 'buy' : '0', 'sell' : '1', 'view' : '2', 'delete' : '3', 'reset' : '*', } note = { 'main_menu' : "To start pls input: \ [%s]Start to search products or to publish a sale\ [%s]Restart a buy or sell event\
from dramapp.models import UserForm, UserProfileForm, Whisky, Distillery, User from django.shortcuts import render_to_response from django.contrib.auth import authenticate, login, logout from django.contrib.auth.decorators import login_required from django.http import HttpResponseRedirect from django.db.models import Q from django.shortcuts import get_object_or_404 from django.views.generic.list_detail import object_list from django.contrib.comments.models import Comment from ratings.handlers import ratings from ratings.models import Score ratings.register(Whisky, ) def index(request): template = loader.get_template('dramapp/index.html') whisky_list = Whisky.objects.all() # add the cat_url data to each category for whisky in whisky_list: whisky_name = whisky.name whisky.url = encode_whisky(whisky_name) distillery_list = Distillery.objects.all() comment_list = Comment.objects.filter(is_public=True, is_removed=False).order_by('submit_date').reverse()[:5] rating_list = Score.objects.filter().order_by('average').reverse()[:5] context = RequestContext(request, {'distillery_list': distillery_list, 'whisky_list': whisky_list, 'comment_list': comment_list, 'rating_list': rating_list}) # render the template using the provided context and return as http response. return HttpResponse(template.render(context))
from django.views.generic.detail import DetailView from django.views.generic.list import ListView from django.shortcuts import render, get_object_or_404, redirect from django.utils import timezone from django_filters import FilterSet, CharFilter, NumberFilter # Create your views here. from .forms import VariationInventoryFormSet, ProductFilterForm from .mixins import StaffRequiredMixin from .models import Product, Variation, Category from ratings.handlers import ratings ratings.register(Product) class CategoryListView(ListView): model = Category queryset = Category.objects.all() template_name = "products/product_list.html" class CategoryDetailView(DetailView): model = Category def get_context_data(self, *args, **kwargs): context = super(CategoryDetailView, self).get_context_data(*args, **kwargs) obj = self.get_object() product_set = obj.product_set.all() default_products = obj.default_category.all()
class UserProfile(models.Model): user = models.OneToOneField(User) activation_key = models.CharField(max_length=40, blank=True) key_expires = models.DateTimeField(default=datetime.now) def __str__(self): return self.user.username class RequestAnime(models.Model): content = models.TextField() user = models.ForeignKey('Members', null=True, blank=True) anime = models.ForeignKey('Anime', null=True, blank=True) added = models.DateTimeField(auto_now=True, null=True, blank=True) class Meta: ordering = ['-added'] def __unicode__(self): return ('{}-{}'.format(self.user, self.added)) ratings.register(Anime, score_range=(1, 5), form_class=VoteForm) ratings.register(Manga, score_range=(1, 5), form_class=VoteForm) ratings.register(Character, score_range=(1, 5), form_class=VoteForm) ratings.register(CharacterManga, score_range=(1, 5), form_class=VoteForm) ratings.register(VoiceCharacter, score_range=(1, 5), form_class=VoteForm)
class TC_Membership(models.Model): """ This class specifies the association of a Task to a TaskCollection (needed for custom ordering of Tasks in TC) """ task = models.ForeignKey(Task) group = models.ForeignKey(TaskCollection) ordering = models.PositiveIntegerField() # register model classes for django-generic-ratings from ratings.handlers import ratings, RatingHandler from ratings.forms import StarVoteForm class CustomRatingHandler(RatingHandler): score_range = (0.5, 5) score_step = 0.5 can_delete_vote = False # default is True form_class = StarVoteForm allow_anonymous = True # default is False votes_per_ip_address = 0 # default is 0, meaning unlimited cookie_max_age = 2592000 # 30 days in seconds, default is 1 year def allow_key(self, request, instance, key): return key in ('difficulty', 'quality') ratings.register(Task, CustomRatingHandler)
description = models.CharField(max_length=200, default=None) requirements = models.CharField(max_length=200, default=None) rank = models.IntegerField(default=None) def __unicode__(self): return self.name class AwardMetric(models.Model): awardid = models.ForeignKey(Award) description = models.CharField(max_length=200) class AwardRating(models.Model): award = models.ForeignKey(Award) panel = models.ForeignKey(Panel) team = models.ForeignKey(Team) class MyHandler(RatingHandler): score_range = (1, 5) score_step = 1 can_delete_vote = False # def allow_key(self, request, instance, key): # return key in ('judge', 'panel') # def get_key(self, request, instance): # return 'judge' if instance.ratingtype == 'Judge' else 'panel' ratings.register(AwardRating, MyHandler)
return self.name class Restaurant(models.Model): """ Defines the state and behavior of a Restaurant object. Users will not be able to directly create a Restaurant object; they will only be able to select a Food object's restaurant on the food submit form. """ name = models.CharField(max_length=50) slug = models.SlugField() picture = models.FileField(upload_to='uploaded_files/restaurant_pics', blank=True, null=True) # Returns the Restaurant object's URL. def get_absolute_url(self): return '/food/restaurants/' + str(self.slug) + '/' # Define the unicode version of a Restaurant object. def __str__(self): return self.name def random_food(): """ Helper function that returns a random Food object from the database. """ return choice(Food.objects.all()) # Register the Food class in order to be used with the 'ratings' app. ratings.register(Food, score_range=(0.5, 5), score_step=0.5, form_class=StarVoteForm)
class OpenCourse(models.Model): link=models.URLField(max_length = 200) provider=models.CharField(max_length=120) language=models.CharField(max_length=50) rating=models.DecimalField(max_digits=2, decimal_places=1, default=0) panel_rating=models.IntegerField(default=0) category=models.ForeignKey(Category, default=1) tags=models.ManyToManyField(Tags) # author=models. title=models.CharField(max_length=200) description=models.TextField() pubDate = models.DateField() slug = models.SlugField() # class Meta: # ordering = ["-rating","-panel_rating","title"] def save(self, *args, **kwargs): if not self.id: # Newly created object, so set slug self.slug = slugify(self.title) super(OpenCourse, self).save(*args, **kwargs) def __unicode__(self): return (self.title) # ratings.register(OpenCourse, weight=2, form_class=SliderVoteForm) ratings.register(OpenCourse)
import time, datetime from django.http import HttpResponse, Http404, HttpResponseRedirect from django.core.context_processors import csrf from django.shortcuts import render_to_response, get_object_or_404 from django.contrib.auth.models import User from django.template import RequestContext from django.contrib.auth.decorators import login_required from django.utils import simplejson from django.core.urlresolvers import reverse from blog.forms import * from blog.models import * from ratings.handlers import ratings, RatingHandler from ratings.forms import StarVoteForm, SliderVoteForm from ratings.models import Vote import pdb ratings.register(BlogPost, form_class=StarVoteForm) pdb.set_trace() ##def blog(request): ## posts = BlogPost.objects.all() ## return render_to_response('archive.html', locals()) # def main_page(request): # return render_to_response('main_page.html', RequestContext(request)) def user_page(request, username): user = get_object_or_404(User, username=username) # blogposts = user.blogpost_set.order_by('-id') blogposts = user.blogpost_set.filter(status=BlogPost.LIVE_STATUS).order_by('-id') if request.user.is_authenticated(): is_following = Followingship.objects.filter( following=request.user,
#!/usr/bin/env python # -*- coding: utf-8 -*- # # Copyright 2010-2013 Código Sur Sociedad Civil # All rights reserved. # # This file is part of Cyclope. # # Cyclope is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # Cyclope is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from ratings.handlers import ratings from cyclope.apps.ratings.forms import LikeDislikeVoteForm from cyclope.apps import medialibrary from cyclope.apps.articles.models import Article ratings.register(Article, form_class=LikeDislikeVoteForm) for model in medialibrary.models.actual_models: ratings.register(model, form_class=LikeDislikeVoteForm)
IPs in the list are not allowed to use the boards. Only IPv4 addresses are supported, one per record. (patch with IPv6 and/or address range support welcome) ''' address = models.IPAddressField(unique=True, verbose_name=_('IP address'), help_text=_('A person\'s IP address may change and an IP address may be ' 'used by more than one person, or by different people over time. ' 'Be careful when using this.'), db_index=True) reason = models.CharField(max_length=255, verbose_name=_('reason'), help_text=_('This may be displayed to the people concerned by the ban.')) class Meta: verbose_name = _('banned IP address') verbose_name_plural = _('banned IP addresses') def __unicode__(self): return _('Banned IP: %s') % self.address @classmethod def update_cache(cls, **kwargs): c = connection.cursor() c.execute('SELECT address FROM %s;' % cls._meta.db_table) settings.SNAP_BANNED_IPS = set((x for (x,) in c.fetchall())) signals.post_save.connect(IPBan.update_cache, sender=IPBan) signals.post_delete.connect(IPBan.update_cache, sender=IPBan) ratings.register(UserProfile, score_range=(1, 3), form_class=StarVoteForm) # vim: ai ts=4 sts=4 et sw=4
if save: self.save() def get_name(self): """Return the name of this Product (provided for extensibility).""" return self.name def remove(self, save=True): """Set `removed` attribute instead of deleting the model.""" self.removed = True self.active = False if save: self.save() ratings.register(Product, RatingCacheHandler) class Offer(models.Model): """An (price) `Offer` assigned by a `Vendor` to a `Product`.""" UNIT_QUANTITIES = ( ('ks', _("units")), ('g', _("grams")), ('kg', _("kilograms")), ) name = models.CharField(max_length=255, verbose_name=_('Name')) slug = models.SlugField(verbose_name=_('Slug'), unique=True) active = models.BooleanField(default=False, verbose_name=_('Active'), db_index=True)