class Meta:
model = Jobform
fields = [
'title', 'description', 'category', 'jobtype', 'postdate',
'deadlinedate', 'posttime', 'deadlinetime', 'address',
'geolocation', 'salary_min', 'salary_max'
]
labels = {
'title': 'Title',
'decription': 'Description',
'category': 'Category',
'jobtype': 'Job Type',
'postdate': 'Post Date',
'deadlinedate': 'Deadline Date',
'posttime': 'Post Time',
'deadlinetime': 'Deadline Time'
}
widgets = {
'title':
forms.TextInput(attrs={
'size': 20,
'placeholder': 'e.g. Title'
}),
'description':
forms.Textarea(attrs={
'rows': 10,
'cols': 150
}),
'postdate':
DateInput(),
'posttime':
TimeInput(),
'deadlinedate':
DateInput(),
'deadlinetime':
TimeInput(),
'address':
map_widgets.GoogleMapsAddressWidget(
attrs={
'data-autocomplete-options':
json.dumps({
'types': ['geocode', 'establishment'],
'componentRestrictions': {
'country': 'us'
}
}),
'size':
50,
}),
'geolocation':
map_widgets.GoogleMapsAddressWidget(attrs={'hidden': True}),
}
class VendorAdmin(ImportMixin, admin.ModelAdmin):
list_filter = ["types", "subjects", GeolocationFilter]
list_display = ["title", "address", "email", "phone", "on_map"]
search_fields = ["title", "address", "email", "phone"]
filter_horizontal = ["subjects", "types"]
fields = [
"title",
"address",
"geolocation",
"phone",
"email",
"website",
"description",
"subjects",
"types",
]
formfield_overrides = {
map_fields.AddressField: {
"widget": map_widgets.GoogleMapsAddressWidget(
attrs={"data-map-type": "roadmap"}
),
},
}
resource_class = VendorResource
formats = (CustomCSV,)
def on_map(self, vendor):
return bool(vendor.geolocation)
on_map.boolean = True
on_map.short_description = "Added to map"
class DistribuidorAdmin(SimpleHistoryAdmin):
def get_form(self, request, obj=None, **kwargs):
self.exclude = []
if not request.user.is_superuser:
self.exclude.append('nombre_distribuidor')
self.exclude.append('horario')
self.exclude.append('estado')
self.exclude.append('direccion')
self.exclude.append('ciudad')
self.exclude.append('a_domicilio')
self.exclude.append('pago_con_tarjeta')
self.exclude.append('telefono')
self.exclude.append('whatsapp')
self.exclude.append('link_pagina')
self.exclude.append('address')
self.exclude.append('geolocation')
return super(DistribuidorAdmin, self).get_form(request, obj, **kwargs)
formfield_overrides = {
map_fields.AddressField: {
'widget':
map_widgets.GoogleMapsAddressWidget(
attrs={
'data-autocomplete-options':
json.dumps({
'types': ['geocode', 'establishment'],
'componentRestrictions': {
'country': 'mx'
}
})
})
},
}
class Meta:
model = Events
fields = ['organizer', 'name', 'comment', 'event_date', 'event_time', 'address', 'geolocation']
widgets = {
'address': map_widgets.GoogleMapsAddressWidget(attrs={'data-map-type': 'roadmap'}),
'geolocation': forms.HiddenInput(),
}
class ListingAdmin(admin.ModelAdmin):
list_display = ('id', 'title', 'is_published', 'price', 'list_date',
'realtor')
list_display_links = ('id', 'title')
list_filter = ('realtor', )
list_editable = ('is_published', )
search_fields = (
'title',
'description',
'address',
'city',
'state',
'zipcode',
'price',
)
formfield_overrides = {
map_fields.AddressField: {
'widget':
map_widgets.GoogleMapsAddressWidget(
attrs={
'data-autocomplete-options':
json.dumps({
'types': ['geocode', 'establishment'],
'componentRestrictions': {
'country': 'us'
}
})
})
},
}
class Meta:
model = Property
fields = [
'address', 'owned_since', 'geolocation', 'bought_for',
'estimated_value', 'property_type', 'insurance', 'property_taxes'
]
widgets = {
'address':
map_widgets.GoogleMapsAddressWidget(
attrs={
'data-map-type':
'roadmap',
'data-autocomplete-options':
json.dumps({'componentRestrictions': {
'country': 'us'
}})
}),
'geolocation':
forms.HiddenInput(),
'owned_since':
forms.DateInput(attrs={'placeholder': 'YYYY-MM-DD'}),
'bought_for':
CustomMoneyWidget(),
'estimated_value':
CustomMoneyWidget(),
'insurance':
CustomMoneyWidget(),
'property_taxes':
CustomMoneyWidget(),
}
class RentalAdmin(admin.ModelAdmin):
formfield_overrides = {
map_fields.AddressField: {
'widget':
map_widgets.GoogleMapsAddressWidget(
attrs={'data-map-type': 'roadmap'})
},
}
class OrderGeo(admin.ModelAdmin):
formfield_overrides = {
map_fields.AddressField: {'widget': map_widgets.GoogleMapsAddressWidget(attrs={
'data-map-type': 'roadmap',
'data-autocomplete-options': json.dumps({ 'types': ['geocode','establishment'],
'componentRestrictions': {'country': 'NZ'}
})
})},
}
class locationTrackAdmin(admin.ModelAdmin):
list_display = ['patient_id', 'address', 'date', 'time']
formfield_overrides = {
map_fields.AddressField: {
'widget':
map_widgets.GoogleMapsAddressWidget(
attrs={'data-map-type': 'roadmap'})
},
}
class SchoolCreationFormAdmin(forms.ModelForm):
address = forms.CharField(widget=map_widgets.GoogleMapsAddressWidget())
geolocation = forms.CharField(widget=forms.HiddenInput(), label='')
class Meta:
model = School
fields = ('name', 'email', 'website', 'file', 'type_school',
'telephone', 'fax')
def __init__(self, *args, **kwargs):
super(SchoolCreationFormAdmin, self).__init__(*args, **kwargs)
self.fields['telephone'].widget.attrs['placeholder'] = "+40735122139"
self.fields['fax'].widget.attrs['placeholder'] = "+40735122139"
def clean(self):
cleaned_data = super(SchoolCreationFormAdmin, self).clean()
try:
geoloc = cleaned_data['geolocation']
addr = cleaned_data['address']
if geoloc == "Invalid address or no results":
cleaned_data['geolocation'] = "0,0"
cleaned_data['address'] = ""
self.add_error("address",
forms.ValidationError("The address is invalid"))
if addr == "Invalid geolocation":
cleaned_data['geolocation'] = "0,0"
cleaned_data['address'] = ""
self.add_error(
"address",
forms.ValidationError("The geolocation is invalid"))
except:
cleaned_data['geolocation'] = "0,0"
cleaned_data['address'] = ""
self.add_error("address",
forms.ValidationError("The address is invalid"))
if self.errors.get("geolocation"):
del self.errors["geolocation"]
return cleaned_data
def clean_file(self):
uploaded_file = self.cleaned_data['file']
error = clean_file(uploaded_file, image=True)
if error:
raise forms.ValidationError(error)
return uploaded_file
def save(self, commit=True):
uploaded_file = super(SchoolCreationFormAdmin, self).save(commit=False)
uploaded_file.author = self.current_user
uploaded_file.address = self.cleaned_data['address']
uploaded_file.geolocation = self.cleaned_data['geolocation']
if commit:
uploaded_file.save()
return uploaded_file
class JoinPageInlineModel(PermissionInlineModel):
model = JoinPage
formfield_overrides = {
models.TextField: {
'widget': AdminMartorWidget
},
map_fields.AddressField: {
'widget':
map_widgets.GoogleMapsAddressWidget(
attrs={'data-map-type': 'roadmap'})
},
}
class HouseAdmin(OSMGeoAdmin):
formfield_overrides = {
map_fields.AddressField: {
'widget':
map_widgets.GoogleMapsAddressWidget(
attrs={'data-map-type': 'roadmap'})
},
}
list_display = [
'name', 'date_created', 'geom', 'landlord', 'get_categories'
]
inlines = [HouseInstanceInline]
class UserAdmin(admin.ModelAdmin):
list_display = ('email', 'first_name', 'last_name')
list_filter = ('is_staff', 'is_superuser')
formfield_overrides = {
map_fields.AddressField: { 'widget':
map_widgets.GoogleMapsAddressWidget(attrs={
'data-autocomplete-options': json.dumps({ 'types': ['geocode',
'establishment'], 'componentRestrictions': {
'country': 'us'
}
})
})
},
}
class Meta:
model = Condo
fields = ['name', 'description', 'number_of_floors', 'amenities', 'address', 'geolocation']
widgets = {
'name': TextInput(attrs={'class': 'form-control'}),
'description': Textarea(attrs={'class': "form-control"}),
'number_of_floors': NumberInput(attrs={'class': 'form-control'}),
# 'address': GoogleMapsAddressWidget,
'address': map_widgets.GoogleMapsAddressWidget(attrs={
'data-autocomplete-options': json.dumps({
'types': ['geocode', 'establishment'],
'componentRestrictions': {}
})
})
}
class DonationCenterAdmin(admin.ModelAdmin):
formfield_overrides = {
map_fields.AddressField: {
'widget':
map_widgets.GoogleMapsAddressWidget(
attrs={
'data-autocomplete-options':
json.dumps({
'types': ['geocode', 'establishment'],
'componentRestrictions': {
'country': 'ke'
}
})
})
}
}
list_display = ('id', 'name', 'email', 'is_approved')
list_display_links = ('id', 'name')
search_fields = ('name', )
list_filter = ('is_approved', )
list_per_page = 25
class PatientsAdmin(admin.ModelAdmin):
list_display = [
'firstName', 'lastName', 'email', 'photo', 'dob', 'address', 'contact',
'docor_name', 'disease_name', 'medicine_detail',
'emergency_contact_name', 'emergency_contact_no'
]
readonly_fields = ['patient_image']
formfield_overrides = {
map_fields.AddressField: {
'widget':
map_widgets.GoogleMapsAddressWidget(
attrs={'data-map-type': 'roadmap'})
},
}
def patient_image(self, obj):
return mark_safe(
'<img src="{url}" width="{width}" height={height} />'.format(
url=obj.photo.url,
width='400px',
height='400px',
))
class MapaAdmin(admin.ModelAdmin):
prepopulated_fields = {'slug': ('name',)}
formfield_overrides = {
map_fields.AddressField: {'widget': map_widgets.GoogleMapsAddressWidget(attrs={'data-map-type': 'roadmap'})},
}
class MyAdmin(TabbedTranslationAdmin):
class Media:
js = ('semantic/dist/semantic.min.js', 'js/wbcore.js')
formfield_overrides = {
models.TextField: {
'widget': AdminMartorWidget
},
map_fields.AddressField: {
'widget':
map_widgets.GoogleMapsAddressWidget(
attrs={'data-map-type': 'roadmap'})
},
}
def formfield_for_manytomany(self, db_field, request, **kwargs):
if request.user.is_super_admin:
return super().formfield_for_manytomany(db_field, request,
**kwargs)
if db_field.name == 'hosts':
if request.user.hosts.count() == 1:
# setting the user from the request object
kwargs['initial'] = request.user.hosts.all()
# making the field readonly
kwargs['disabled'] = True
kwargs["queryset"] = request.user.hosts
return super().formfield_for_manytomany(db_field, request, **kwargs)
def get_exclude(self, request, obj=None):
exclude = super().get_exclude(request, obj)
exclude = exclude if exclude else ()
if request.user.is_super_admin:
return exclude
if request.user.hosts.count() == 1:
exclude += ('hosts', 'host')
return exclude
def save_model(self, request, obj, form, change):
if request.user.is_super_admin:
super().save_model(request, obj, form, change)
return
if request.user.hosts.count() == 1:
super().save_model(request, obj, form, change)
if hasattr(obj, 'host'):
obj.host = request.user.hosts.all()[0]
elif hasattr(obj, 'hosts'):
obj.hosts.set(request.user.hosts.all())
super().save_model(request, obj, form, change)
def formfield_for_foreignkey(self, db_field, request, **kwargs):
if request.user.is_super_admin:
return super().formfield_for_foreignkey(db_field, request,
**kwargs)
if db_field.name == 'author':
# setting the user from the request object
kwargs['initial'] = request.user.pk
# making the field readonly
kwargs['disabled'] = True
elif db_field.name == 'location':
hosts = request.user.get_hosts_for_role(['admin', 'editor'])
event_locations = Location.objects.filter(event__host__in=hosts)
host_locations = Location.objects.filter(host__in=hosts)
project_locations = Location.objects.filter(
project__hosts__in=hosts)
blogpost_locations = Location.objects.filter(
blogpost__host__in=hosts)
kwargs["queryset"] = (event_locations | host_locations
| project_locations
| blogpost_locations).distinct()
elif db_field.name == 'host':
if request.user.hosts.count() == 1:
# setting the hosts the user belongs to from the request object
kwargs['initial'] = request.user.hosts.all()[0].pk
# making the field readonly
kwargs['disabled'] = True
else:
hosts = request.user.get_hosts_for_admin()
kwargs["queryset"] = Host.objects.filter(
pk__in=[host.pk for host in hosts])
elif db_field.name == 'project':
hosts = request.user.hosts.all()
kwargs["queryset"] = Project.objects.filter(hosts__in=hosts).all()
return super().formfield_for_foreignkey(db_field, request, **kwargs)
def get_queryset(self, request):
queryset = super(MyAdmin, self).get_queryset(request)
# super user can see everything
if request.user.is_super_admin:
return queryset
# if model is host display the users hosts
if queryset.model is Host:
return request.user.hosts.all()
# if many to many field hosts exists filter using it
try:
return queryset.filter(hosts__in=request.user.hosts.all())
except:
# if field host exists filter using it
try:
return queryset.filter(host__in=request.user.hosts.all())
except:
return queryset
def has_add_permission(self, request):
opts = self.opts
codename = get_permission_codename('add', opts)
return request.user.has_perm("%s.%s" % (opts.app_label, codename))
def has_change_permission(self, request, obj=None):
opts = self.opts
codename = get_permission_codename('change', opts)
ret = request.user.has_perm("%s.%s" % (opts.app_label, codename), obj)
return ret
def has_delete_permission(self, request, obj=None):
opts = self.opts
codename = get_permission_codename('delete', opts)
return request.user.has_perm("%s.%s" % (opts.app_label, codename), obj)
def has_view_permission(self, request, obj=None):
opts = self.opts
codename_view = get_permission_codename('view', opts)
codename_change = get_permission_codename('change', opts)
return (request.user.has_perm(
'%s.%s' % (opts.app_label, codename_view), obj)
or request.user.has_perm(
'%s.%s' % (opts.app_label, codename_change), obj))
def has_view_or_change_permission(self, request, obj=None):
return self.has_view_permission(
request, obj) or self.has_change_permission(request, obj)
def has_module_permission(self, request):
return request.user.has_module_perms(self.opts.app_label)
class EventCreationFormAdmin(forms.ModelForm):
text = forms.CharField(widget=AdminTinyMCE(
attrs={'cols': 80, 'rows': 30}), label='')
date = forms.SplitDateTimeField()
address = forms.CharField(widget=map_widgets.GoogleMapsAddressWidget())
geolocation = forms.CharField(widget=forms.HiddenInput(), label='')
show_files = True
show_preview = True
preview_url = "/preview_event/"
class Meta:
model = Event
fields = ('name', 'file',)
def clean(self):
cleaned_data = super(EventCreationFormAdmin, self).clean()
try:
geoloc = cleaned_data['geolocation']
addr = cleaned_data['address']
if geoloc == "Invalid address or no results":
cleaned_data['geolocation'] = "0,0"
cleaned_data['address'] = ""
self.add_error("address", forms.ValidationError(
"The address is invalid"))
if addr == "Invalid geolocation":
cleaned_data['geolocation'] = "0,0"
cleaned_data['address'] = ""
self.add_error("address", forms.ValidationError(
"The geolocation is invalid"))
except:
cleaned_data['geolocation'] = "0,0"
cleaned_data['address'] = ""
self.add_error("address", forms.ValidationError(
"The address is invalid"))
if self.errors.get("geolocation"):
del self.errors["geolocation"]
return cleaned_data
def clean_file(self):
uploaded_file = self.cleaned_data['file']
error = clean_file(uploaded_file, image=True)
if error:
raise forms.ValidationError(error)
return uploaded_file
def clean_date(self):
data = self.cleaned_data['date']
now = datetime.now()
data = data.replace(tzinfo=None)
if data < now:
raise forms.ValidationError(
"Data nu e valida.Nu puteti posta un eveniment in trecut!")
return data
def save(self, commit=True):
uploaded_file = super(EventCreationFormAdmin, self).save(commit=False)
uploaded_file.author = self.current_user
uploaded_file.text = self.cleaned_data['text']
uploaded_file.date = self.cleaned_data['date']
uploaded_file.address = self.cleaned_data['address']
uploaded_file.geolocation = self.cleaned_data['geolocation']
if commit:
uploaded_file.save()
return uploaded_file
