class Meta:
model = Team
fields = ('name', 'description', 'allow_requests', 'image')
widgets = {
'description':
TinyMCE(attrs={'class': 'team-editor-description'},
mce_attrs={
"theme": "advanced",
"cleanup_on_startup": True,
"theme_advanced_toolbar_location": "top",
"gecko_spellcheck": True,
"width": "100%"
})
}
class PostAdmin(admin.ModelAdmin):
#prepopulated_fields = {"slug": ("title",)}
formfield_overrides = {
HTMLField: {'widget': TinyMCE(
attrs={'cols':50, 'rows':30},
mce_attrs={'width':"655px"}
)}
}
list_filter = ('status',)
def get_form(self, request, obj=None, **kwargs):
self.exclude = []
if not request.user.has_perm('feeds.add_feed'):
self.exclude.append('on_front')
self.exclude.append('featured')
return super(PostAdmin, self).get_form(request, obj, **kwargs)
def queryset(self, request):
qs = Post.objects.all()
if request.user.has_perm('feeds.add_feed'):
return qs
return qs.filter(feed__authors=request.user)
def formfield_for_foreignkey(self, db_field, request, **kwargs):
if db_field.name == 'feed':
qs = Feed.objects.all()
if request.user.has_perm('feeds.add_feed'):
kwargs['queryset'] = qs
else:
kwargs['queryset'] = qs.filter(authors=request.user)
return super(PostAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)
def formfield_for_choice_field(self, db_field, request, **kwargs):
if db_field.name == 'status':
LIVE_STATUS = 1
SUBMITTED_STATUS = 2
DRAFT_STATUS = 3
if request.user.has_perm('feeds.add_post'):
kwargs['choices'] = (
(LIVE_STATUS, 'Live'),
(DRAFT_STATUS, 'Draft'),)
else:
kwargs['choices'] = (
(SUBMITTED_STATUS, 'Submitted'),
(DRAFT_STATUS, 'Draft'),)
return super(PostAdmin, self).formfield_for_choice_field(db_field, request, **kwargs)
class ProfileForm(forms.ModelForm):
email = forms.EmailField()
confirm_email = forms.CharField(required=False)
date_of_birth = forms.DateField(
input_formats=['%Y-%m-%d', '%m/%d/%Y', '%m/%d/%y'],
widget=forms.DateInput(format='%Y-%m-%d'))
short_bio = forms.CharField(widget=TinyMCE(attrs={'rows': 10}),
min_length=10)
avatar = forms.ImageField(required=False)
class Meta:
model = models.UserProfile
fields = [
'first_name',
'last_name',
'email',
'confirm_email',
'date_of_birth',
'short_bio',
'avatar',
'city',
'state',
'country',
'favorite_animal',
'hobby',
]
def clean(self):
cleaned_data = super(ProfileForm, self).clean()
# Check date is in the Past
date_of_birth = cleaned_data.get("date_of_birth")
if date_of_birth.year > 2020:
adjusted_date = date_of_birth - timedelta(days=36524.25)
cleaned_data["date_of_birth"] = adjusted_date
# Work around formatted text length
short_bio = cleaned_data.get("short_bio")
if short_bio is None or len(removetags(short_bio)) < 10:
raise forms.ValidationError("Your Bio must be at least 10 " +
"characters long.")
# Check email match
email = cleaned_data.get("email")
confirm_email = cleaned_data.get("confirm_email")
if email != confirm_email:
raise forms.ValidationError("email and confirm email do not match")
return cleaned_data
class VideoForm(TendenciBaseForm):
description = forms.CharField(required=False,
widget=TinyMCE(attrs={'style':'width:100%'},
mce_attrs={'storme_app_label':Video._meta.app_label,
'storme_model':Video._meta.module_name.lower()}))
status_detail = forms.ChoiceField(choices=(('active','Active'),('pending','Pending')))
clear_image = forms.BooleanField(required=False)
class Meta:
model = Video
fields = (
'title',
'slug',
'category',
'image',
'video_url',
'tags',
'description',
'allow_anonymous_view',
'user_perms',
'group_perms',
'member_perms',
'status',
'status_detail',
)
def __init__(self, *args, **kwargs):
super(VideoForm, self).__init__(*args, **kwargs)
if self.instance.pk:
self.fields['description'].widget.mce_attrs['app_instance_id'] = self.instance.pk
else:
self.fields['description'].widget.mce_attrs['app_instance_id'] = 0
def clean_video_url(self):
value = self.cleaned_data.get('video_url')
if not value:
return value
if not is_pattern_match(value):
raise forms.ValidationError('This url is not supported by embed.ly')
return value
def save(self, *args, **kwargs):
video = super(VideoForm, self).save(*args, **kwargs)
if self.cleaned_data['clear_image']:
video.image.delete()
return video
class CommentsEditForm(forms.ModelForm):
comment = forms.CharField(
max_length=3000,
label='Kommentar',
widget=TinyMCE(
attrs={
'rows': 2,
'placeholder': 'Geben Sie hier das neue Kommentar ein...'
}),
required=False)
class Meta:
model = Comments
fields = ['comment']
class ProfileEditForm(forms.ModelForm):
biography = forms.CharField(
max_length=3000,
label='Biographie',
widget=TinyMCE(attrs={
'cols': 80,
'placeholder': 'Erzählen Sie etwas über sich hier...'
}),
required=False)
picture = forms.ImageField(label='Profilbild', required=False)
class Meta:
model = Profile
fields = ['biography', 'picture']
class AssignmentForm(forms.ModelForm):
description = forms.CharField(widget=TinyMCE(attrs={
'cols': 80,
'rows': 40
}))
deadline_date = forms.DateTimeField(
widget=DateTimeWidget(usel10n=True, bootstrap_version=3))
#samping_private=forms.IntegerField(label='1-100')
class Meta:
model = Assignment
fields = ('name', 'description', 'ground_truth', 'deadline_date',
'test_data', 'train_data', 'format_example',
'num_subs_per_day', 'hidden_status', 'scoring_method',
'sampling_private', 'class_name')
class CharacterAdmin(admin.ModelAdmin):
fieldsets = [
("Introduction", {
"fields": ["name", "anime"]
}),
("slug", {
"fields": ["slug"]
}),
("Characteristics and Story", {
"fields": ["skill", "power", "description"]
}),
]
formfield_overrides = {models.TextField: {'widget': TinyMCE()}}
class Meta:
model = Cooking
content = forms.CharField(widget=TinyMCE(attrs={
'cols': 80,
'rows': 30
}))
fields = [
'title',
'course',
'meat',
'URL_link',
'ingredients',
'instructions',
'tinymce_test',
]
class SimpleAdForm(forms.ModelForm):
body = forms.CharField(widget=TinyMCE(attrs={'cols': 80, 'rows': 30}), label='Treść ogłoszenia')
def __init__(self, user, *args, **kwargs):
self.user = user
super(SimpleAdForm, self).__init__(*args, **kwargs)
class Meta:
model = SimpleAd
fields = ('title', 'body', 'price', 'image',)
labels = {
'title': 'Tytuł',
'price': 'Cena w zł',
'image': 'Zdjęcie'
}
class tutorialAdmin(admin.ModelAdmin):
# fields= ["tutorial_title",
# "tutorial_published",
# "tutorial_content"]
prepopulated_fields = {"tutorial_slug": ("tutorial_title", )}
fieldsets = [("Title/date", {
"fields": ["tutorial_title", "tutorial_published"]
}), ("content", {
"fields": ["tutorial_content"]
}), ("URL", {
"fields": ["tutorial_slug"]
}), ("series", {
"fields": ["tutorial_series"]
})]
formfield_overrides = {models.TextField: {'widget': TinyMCE()}}
class ChapterCreateForm(forms.ModelForm):
book = forms.ModelChoiceField(queryset=Book.objects.none())
content = forms.CharField(widget=TinyMCE(attrs={'cols': 80, 'rows': 30}))
class Meta:
model = Chapter
fields = ['name', 'content', 'book', 'next_release']
widgets = {
'next_release': DateInput(),
}
def __init__(self, *args, **kwargs):
user = kwargs.pop('user', None)
super(ChapterCreateForm, self).__init__(*args, **kwargs)
self.fields['book'].queryset = Book.objects.filter(author=user)
class ProductAdmin(admin.ModelAdmin):
list_display = ('id', 'category', 'brand', 'title', 'price')
list_filter = ['category', 'brand', 'available']
prepopulated_fields = {'slug': ('title', )}
fieldsets = [('Title/slug', {
'fields': ['title', 'slug']
}), ('General Info', {
'fields': ['category', 'brand', 'price']
}), ('Content', {
'fields': ['description', 'image']
}), ('Available', {
'fields': ['available']
})]
formfield_overrides = {models.TextField: {'widget': TinyMCE()}}
class BlogForm(forms.ModelForm):
content = forms.CharField(
widget=TinyMCE(attrs={
'required' : False,
'cols' : 30,
'rows' : 10,
}))
class Meta:
model = models.Blog
fields = ['content']
def __init__(self, *args, **kwargs):
super(BlogForm, self).__init__(*args, **kwargs)
self.fields['content'].label = ''
class ProfileForm(forms.Form):
mugshot = forms.FileField(label='Profile image',
required=False,
widget=ShortNameClearableFileInput)
resume = forms.FileField(label='Resume',
required=False,
widget=ShortNameClearableFileInput)
biography = forms.CharField(widget=TinyMCE(attrs={'cols': 80, 'rows': 30}))
def save(self, profile):
profile.mugshot = self.cleaned_data['mugshot']
profile.resume = self.cleaned_data['resume']
profile.data['biography'] = self.cleaned_data['biography']
profile.save()
class TutorialAdmin(admin.ModelAdmin):
fieldsets = [("Title/Date", {
"fields": ["tutorial_title", "tutorial_published"]
}), ("URL", {
"fields": ["tutorial_slug"]
}), ("Courses", {
"fields": ["tutorial_course"]
}), ("Thumbnail", {
"fields": ["tutorial_pic"]
}), ("Content", {
"fields": ["tutorial_content"]
})]
formfield_overrides = {models.TextField: {'widget': TinyMCE()}}
class PostAdmin(admin.ModelAdmin):
fieldsets = [
('Title/date', {
'fields': ['post_title', 'post_published']
}),
('Content', {
'fields': ['post_content']
}),
]
formfield_overrides = {
models.TextField: {
'widget': TinyMCE()
},
}
class PostForm(forms.Form):
category_id = forms.ChoiceField(
label="Category",
widget=forms.Select(attrs={'class': 'input-field'}),
choices=generate_category_choices(['id', 'name']))
title = forms.CharField(label="Title")
content = forms.CharField(label="Content", widget=TinyMCE())
publish = forms.BooleanField(required=False, label="Publish")
def __init__(self, *args, **kwargs):
super(PostForm, self).__init__(*args, **kwargs)
self.fields['category_id'] = forms.ChoiceField(
label="Category",
widget=forms.Select(attrs={'class': 'input-field'}),
choices=generate_category_choices(['id', 'name']))
class ForumForm(forms.ModelForm):
categories = Category.objects.all()
title = forms.CharField()
category = CategoryModelChoiceField(queryset=categories,
to_field_name="id",
empty_label="Select Category")
description = forms.CharField(widget=TinyMCE(attrs={
'cols': 10,
'rows': 10
}))
class Meta:
model = forum
fields = ('title', 'category', 'description')
class PostForm(forms.ModelForm):
content = forms.CharField(widget=TinyMCE())
class Meta():
model = BlogPost
fields = ('author', 'title', 'content')
widgets = {
'title':
forms.TextInput(attrs={'class': 'textinputclass'}),
'content':
forms.Textarea(
attrs={'class': 'editable medium-editor-textarea postcontent'
}),
}
class TestEmailForm(forms.Form):
texto = forms.CharField(label="Texto", widget=TinyMCE())
destinatario = forms.EmailField(
label="", widget=forms.EmailInput(attrs={'placeholder': 'Destino'}))
def __init__(self, request, *args, **kwargs):
self.request = request
super(TestEmailForm, self).__init__(*args, **kwargs)
def clean(self):
cleaned_data = self.cleaned_data
texto = cleaned_data.get('texto')
destinatario = cleaned_data.get("testinatario")
return cleaned_data
class CommentForm(FileFormMixin, betterforms.BetterForm):
body = forms.CharField(label="body",
widget=TinyMCE(attrs={
'cols': 80,
'rows': 10
}),
required=False)
class Meta:
fieldsets = [
('comment', {
'fields': ['body'],
'legend': 'text-area'
}),
]
class MassiveEmailForm(forms.ModelForm):
subject = forms.CharField(widget=forms.TextInput(attrs={
'class': 'span10',
'maxlength': 100,
}),
label=_('Subject'))
message = forms.CharField(widget=TinyMCE(attrs={
'class': 'span10',
}),
label=_('Message'))
class Meta:
model = MassiveEmail
exclude = ('course', 'datetime')
class PostAdmin(admin.ModelAdmin):
list_display = ('title', 'slug', 'series', 'author', 'published_date',
'status')
list_filter = ('status', 'created', 'published_date', 'author')
search_fields = ('title', 'content', 'series__name')
prepopulated_fields = {'slug': ('title', )}
raw_id_fields = ('author', )
date_hierarchy = 'published_date'
ordering = ('status', 'published_date')
formfield_overrides = {
models.TextField: {
'widget': TinyMCE()
},
}
class progAdmin(admin.ModelAdmin):
fieldsets = [('Lecture URL', {
'fields': ['lecture_slug']
}), ('programming Language', {
'fields': ['Programming']
}), ('Title and Date', {
'fields': ['title', 'date']
}), ('Content Block', {
'fields': ['explain']
})]
formfield_overrides = {
models.TextField: {
'widget': TinyMCE()
},
}
class PlayAdmin(admin.ModelAdmin):
actions_on_bottom = True
save_on_top = True
list_display = ('title', 'playwright')
search_fields = ['title', 'playwright']
formfield_overrides = {
models.TextField: {
'widget': TinyMCE(attrs={
'cols': 80,
'rows': 30
})
},
}
class NewsAdmin(admin.ModelAdmin):
"""
class that is used to present our tutorial model in admin panel
we are overwritting the default model structure to display
fields in the manner defined by us
"""
# dividing fields into fieldsets
fieldsets = [("Title/date", {
"fields": ["title", "published"]
}), ("Content", {
"fields": ["content", "author"]
})]
# overridding form field to include tinyMCE widget
formfield_overrides = {models.TextField: {'widget': TinyMCE()}}
class PostAdminForm(forms.ModelForm):
uid = forms.CharField()
slug = forms.CharField()
title = forms.CharField()
teaser = forms.CharField(widget=TinyMCE(attrs={
'cols': 80,
'rows': 30
},
mce_attrs={
'height': 400,
'width': 1200
}))
content = forms.CharField(widget=TinyMCE(attrs={
'cols': 80,
'rows': 30
},
mce_attrs={
'height': 800,
'width': 1200
}))
class Meta:
model = Post
fields = '__all__'
class PostAdmin(admin.ModelAdmin):
fieldsets = [("Title/Date", {
"fields": ["post_title", "post_published"]
}), ("URL", {
"fields": ["post_slug"]
}), ("Series", {
"fields": ["post_series"]
}), ("Content", {
"fields": ["post_text"]
})]
formfield_overrides = {
models.TextField: {
'widget': TinyMCE()
},
}
class TutorialAdmin(admin.ModelAdmin):
# fields = ['tutorial_title',
# 'tutorial_published',
# 'tutorial_content']
fieldsets = [
('Title/date', {'fields': ['tutorial_title', 'tutorial_published']}),
('URL', {'fields': ['tutorial_slug']}),
('Series', {'fields': ['tutorial_series']}),
('Content', {'fields': ['tutorial_content']})
]
formfield_overrides = {
models.TextField: {'widget': TinyMCE()}
}
