def new_model_field_form(request, field_type, model_id):
if field_type not in FIELD_FORMS:
raise Http404
model = get_object_or_404(Model,
application__project__owner=request.user,
pk=model_id)
context = {}
prefix = "%s_%d" % (field_type, model.id)
if request.method == 'POST':
form = FIELD_FORMS[field_type](model, request.POST, prefix=prefix)
if form.is_valid():
new_field = form.save()
model_field = model.model_fields.create(object=new_field)
prefix = "%s_%d" % (field_type, model_field.id)
form = FIELD_FORMS[field_type](model,
instance=new_field,
prefix=prefix)
context = {'field_form': form, 'model_field': model_field}
return render_response(request, 'field_form.html', context)
else:
form = FIELD_FORMS[field_type](model, prefix=prefix)
context = {
'new_field_form': form,
'model': model,
'field_type': field_type
}
return render_response(request, 'new_field_form.html', context)
def project_view(request, project_id):
"""
- return project corresponding to project_id
- handle project modification form submition
- raise 404 if project is not found or project doesn't belong to the current user
"""
if request.user.is_superuser:
project = get_object_or_404(Project, pk=project_id)
else:
project = get_object_or_404(Project, owner=request.user, pk=project_id)
if request.method == "POST":
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
form.save()
else:
form = ProjectForm(instance=project)
context = {
'project':
project,
'new_application_form':
NewApplicationForm({'project_id': project.id},
prefix='new_application'),
'project_form':
form
}
return render_response(request, 'project/project_view.html', context)
def picture_view(request, picture_id):
"""
Show the picture # picture_id if is_visible is True, overwise raise HTTP404 exception.
"""
picture = get_object_or_404(Picture, pk=picture_id, is_visible=True)
context = {"picture": picture, "current": "photos"}
return render_response(request, "picture/picture_view.html", context)
def model_form_view(request, model_form_id):
model_form = get_object_or_404(
ModelForm,
model__application__project__owner=request.user,
pk=model_form_id)
return render_response(request, 'model_form_view.html',
{'model_form': model_form})
def contact_requests_view(request):
"""
show a list of request
"""
context = {'current':'contacts',
'contact_requests': request.user.contact_requests_received.all() }
return render_response(request, 'contact/contact_requests.html', context)
def product_list_view(request):
filter ={}
url_parameters = []
if request.GET:
if request.GET.get('category'):
filter['category__ref__iexact'] = request.GET['category']
url_parameters.append('category=%s' % request.GET['category'])
if request.GET.get('filter'):
filter['item_number__icontains'] = request.GET.get('filter','').strip()
url_parameters.append('filter=%s' % request.GET['filter'])
products = Product.objects.filter(**filter)
# if only one result, display the detail page directly
if len(products) == 1:
return HttpResponseRedirect(reverse('view_product', args=[products[0].item_number]))
results = products.count()
products = paginate(products, request)
categories = Category.objects.all()
context = {'products': products,
'filter': request.GET.get('filter',''),
'category': request.GET.get('category',''),
'url_parameters': '&'.join(url_parameters),
'results': results,
'categories': categories}
context.update(filter)
return render_response(request,'product/products.html', context)
def model_form_form(request, model_form_id):
"""
Allow update of a given ModelForm.
Current user must own the destination model.
"""
model_form = get_object_or_404(
ModelForm,
pk=model_form_id,
model__application__project__owner=request.user)
context = {}
prefix = "modelform_%d" % model_form.id
if request.method == 'POST':
form = ModelFormForm(model_form.model,
request.POST,
instance=model_form,
prefix=prefix)
if form.is_valid():
model_form = form.save()
form = ModelFormForm(model_form.model,
request.POST,
instance=model_form,
prefix=prefix)
context['saved'] = True
else:
form = ModelFormForm(model_form.model,
instance=model_form,
prefix=prefix)
context.update({'model_form_form': form, 'model_form': model_form})
return render_response(request, 'model_form_form.html', context)
def login_view(request, template_name="profile/login.html", redirect_field_name=REDIRECT_FIELD_NAME):
context = {}
redirect_to = request.REQUEST.get(redirect_field_name, "")
if request.user.is_authenticated():
return HttpResponseRedirect("/")
if request.method == "POST":
form = LoginForm(data=request.POST)
if form.is_valid():
# Light security check -- make sure redirect_to isn't garbage.
if not redirect_to or "//" in redirect_to or " " in redirect_to:
redirect_to = settings.LOGIN_REDIRECT_URL
login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
return HttpResponseRedirect(redirect_to)
else:
form = LoginForm(request)
request.session.set_test_cookie()
if Site._meta.installed:
current_site = Site.objects.get_current()
else:
current_site = RequestSite(request)
return render_response(
request,
template_name,
{
"login_form": form,
"register_form": RegisterForm(),
redirect_field_name: redirect_to,
"site": current_site,
"site_name": current_site.name,
},
)
def register_view(request, template_name='registration.html'):
"""
Form that send registration email to user
"""
context = {}
if request.method == "POST":
form = RegisterForm(request.POST)
if form.is_valid():
registration = form.save()
context['registration'] = registration
context['email_to'] = registration.email
text_content = render_string(request,
'email/registration.txt',
context)
send_mail('Your Registration is done',
text_content,
DEFAULT_EMAIL_FROM,
[registration.email, ])
return HttpResponseRedirect(reverse('registration_sent'))
else:
# form is invalid
context['register_form'] = form
else:
# no post, user just arrived
context['register_form'] = RegisterForm()
return render_response(request, template_name, context)
def new_model_form_form(request, model_id):
"""
Create a new ModelForm if the form is valid, otherwise display the
initial form.
Current user must own the destination model.
If a new ModelForm is created, the template will use ajax to render it
and append it to the FormList.
"""
model = get_object_or_404(Model, pk=model_id, application__project__owner=request.user)
context = {}
prefix = "new_modelform_%d" % model.id
if request.method == 'POST':
form = NewModelFormForm(model, request.POST, prefix=prefix)
if form.is_valid():
model_form = form.save(commit=False)
model_form.model = model
model_form.save()
form = NewModelFormForm(model, prefix=prefix)
context.update({'created': True,
'model_form': model_form})
else:
form = NewModelFormForm(model, request.POST, prefix=prefix)
context.update({ 'new_model_form_form': form,
'model': model})
return render_response(request, 'new_model_form_form.html', context)
def new_model_form_form(request, model_id):
"""
Create a new ModelForm if the form is valid, otherwise display the
initial form.
Current user must own the destination model.
If a new ModelForm is created, the template will use ajax to render it
and append it to the FormList.
"""
model = get_object_or_404(Model,
pk=model_id,
application__project__owner=request.user)
context = {}
prefix = "new_modelform_%d" % model.id
if request.method == 'POST':
form = NewModelFormForm(model, request.POST, prefix=prefix)
if form.is_valid():
model_form = form.save(commit=False)
model_form.model = model
model_form.save()
form = NewModelFormForm(model, prefix=prefix)
context.update({'created': True, 'model_form': model_form})
else:
form = NewModelFormForm(model, request.POST, prefix=prefix)
context.update({'new_model_form_form': form, 'model': model})
return render_response(request, 'new_model_form_form.html', context)
def new_model_form(request, application_id):
"""
Create a new model inside an application.
return 404 if
"""
application = get_object_or_404(Application,
project__owner=request.user,
pk=application_id)
context = {}
if request.method == 'POST':
form = NewModelForm(request.POST,
application=application,
prefix="new_model_%d" % application.id)
if form.is_valid():
context['created'] = True
new_model = form.save(commit=False)
new_model.application = application
new_model.save()
context['model'] = new_model
form = NewModelForm(application=application,
prefix="new_model_%d" % application.id)
else:
form = NewModelForm(application=application,
prefix="new_model_%d" % application.id)
context.update({'new_model_form': form, 'application': application})
return render_response(request, 'new_model_form.html', context)
def project_detail_view(request,id):
context = {'current':'projects'}
user = request.user
project = Project.objects.get_for_user(user=request.user, id=int(id))
if request.POST:
form = ProjectForm(instance=project, data=request.POST)
if form.is_valid():
form.save()
context['project_saved'] = True
context['form'] = form
else:
context['form'] = ProjectForm(instance=project)
context['project'] = project
context['spectators'] = project.spectators.all().select_related()
context['owners'] = project.owners.all().select_related()
context['collaborators'] = project.collaborators.all().select_related()
context['new_spectators'] = User.objects.filter(profile__contacts__user=request.user).exclude(projects_as_spectator = project).select_related()
context['new_collaborators'] = User.objects.filter(profile__contacts__user=request.user).exclude(projects_as_collaborator = project).select_related()
context['is_creator'] = project.is_creator(request.user)
context['is_admin'] = project.is_admin(request.user)
context['new_owners'] = User.objects.filter(profile__contacts__user=request.user).exclude(owned_projects = project).select_related()
context['new_task_form'] = NewTaskForm()
context['goal_form'] = GoalForm()
return render_response(request, 'project/project_detail_view.html', context)
def owner_form(request, project_id):
project = Project.objects.get_for_user(user=request.user, id=int(project_id))
if project.is_creator(request.user):
context = {'project': project}
context['owners'] = project.owners.all().select_related()
context['new_owners'] = User.objects.filter(profile__contacts__user=request.user).exclude(owned_projects = project).select_related()
return render_response(request, 'project/owner_form.html', context)
raise Http404
def last_week_time_records_view(request):
kw_filter = {'start_date__gte': date.today() - timedelta(days=7)}
time_records = paginate(TimeRecord.objects.get_time_records(request).filter(**kw_filter),
int(request.GET.get('page', '1')))
context = {'current':'times',
'content_title': _('Last week times records'),
'time_records': time_records}
return render_response(request,'timer/time_records.html', context)
def collaborator_form(request, project_id):
project = Project.objects.get_for_user(user=request.user, id=int(project_id))
if project.is_admin(request.user):
context = {'project': project}
context['collaborators'] = project.collaborators.all().select_related()
context['new_collaborators'] = User.objects.filter(profile__contacts__user=request.user).exclude(projects_as_collaborator = project).select_related()
return render_response(request, 'project/collaborator_form.html', context)
raise Http404
def pictures_view(request):
"""
show a list of picture
"""
pictures = Picture.objects.filter(is_visible=True).order_by("-creation_date")
pictures = paginate(pictures, request)
context = {"pictures": pictures, "current": "photos"}
return render_response(request, "picture/pictures_view.html", context)
def time_records_view(request):
time_records = paginate(TimeRecord.objects.get_time_records(request),
int(request.GET.get('page', '1')))
context = {'current':'times',
'content_title': _('All times records'),
'time_records': time_records}
return render_response(request,'timer/time_records.html', context)
def tips_view(request):
"""
show a list of picture
"""
tips = Tip.objects.filter(is_visible=True).order_by("-creation_date")
tips = paginate(tips, request, 3)
context = {'tips': tips,
'current':'tips'}
return render_response(request, 'tip/tips_view.html', context)
def login_view(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
if user is not None:
if user.is_active:
login(request, user)
return redirect('/tracker')
else:
return render_response(request, 'core/login.html', {'form' : form, 'error' : 'Account not active'})
else:
return render_response(request, 'core/login.html', {'form' : form, 'error' : 'Username or password was incorrect'})
else:
return render_response(request, 'core/login.html', {'form' : form, 'error' : 'Form not valid'})
else:
form = LoginForm()
return render_response(request, 'core/login.html', {'form' : form})
def public_project_list(request):
"""
return public projects list
The result list is paginated
"""
context = {}
projects = Project.objects.filter(public=True).order_by("-creation_date")
context['projects'] = paginate(projects, request)
return render_response(request, 'project/public_project_list.html', context)
def register_confirm(request, key, template_name='create_account.html'):
"""
Account creation from email link.
if the key is wrong the user is redirected to the login view.
"""
registration = Registration.objects.filter(key=key)
if not registration:
return HttpResponseRedirect(reverse('login_view'))
if request.user.is_authenticated():
logout(request)
registration = registration[0]
# check that user does not already exist with this email
if User.objects.filter(email__iexact=registration.email):
Registration.objects.filter(email__iexact=registration.email).delete()
return HttpResponseRedirect(reverse('login_view'))
context = {'registration': registration}
if request.method == "POST":
form = SetPasswordFormWithAgreementCopyTimeRecord(request.POST)
if form.is_valid():
time_records = TimeRecord.objects.get_time_records(request)
password = form.cleaned_data['password2']
user = User.objects.create_user(sha_constructor(str(registration.email)).hexdigest()[:30],
registration.email,
password)
profile = Profile.objects.create(user=user)
user = authenticate(username=user.username, password=password)
if form.cleaned_data['backup_time_records']:
for time_record in time_records:
time_record.user = user
time_record.save()
login(request, user)
context['email_to'] = registration.email
context['password'] = password
text_content = render_string(request,
'email/welcome.txt',
context)
send_mail('Welcome',
text_content,
DEFAULT_EMAIL_FROM,
[user.email, ])
Registration.objects.filter(email__iexact=registration.email).delete()
request.session['first_login'] = True
return HttpResponseRedirect(reverse('thank_you_for_registering'))
else:
context['password_form'] = form
else:
context['password_form'] = SetPasswordFormWithAgreementCopyTimeRecord()
return render_response(request, template_name, context)
def public_project_list(request):
"""
return public projects list
The result list is paginated
"""
context = {}
projects = Project.objects.filter(public=True).order_by("-creation_date")
context['projects'] = paginate(projects, request)
return render_response(request, 'project/public_project_list.html',
context)
def public_project_view(request, project_id):
"""
- return project corresponding to project_id
- raise 404 if project is not found or is not public
"""
if request.user.is_superuser:
project = get_object_or_404(Project, pk=project_id)
else:
project = get_object_or_404(Project, public=True, pk=project_id)
context = {'project': project}
return render_response(request, 'project/public_project_view.html', context)
def new_model_field_form(request, field_type, model_id):
if field_type not in FIELD_FORMS:
raise Http404
model = get_object_or_404(Model, application__project__owner=request.user, pk=model_id)
context = {}
prefix = "%s_%d" % (field_type,model.id)
if request.method == 'POST':
form = FIELD_FORMS[field_type](model, request.POST, prefix=prefix)
if form.is_valid():
new_field = form.save()
model_field = model.model_fields.create(object=new_field)
form = FIELD_FORMS[field_type](model, instance=new_field, prefix=prefix)
context = { 'field_form':form,
'model_field': model_field}
return render_response(request, 'field_form.html', context)
else:
form = FIELD_FORMS[field_type](model, prefix=prefix)
context = { 'new_field_form':form,
'model':model,
'field_type':field_type }
return render_response(request, 'new_field_form.html', context)
def contact_detail(request, contact_id):
if int(contact_id) == request.user.get_profile().id:
contact = request.user.get_profile()
else:
if request.user.is_staff:
contact = get_object_or_404(Profile, id=contact_id)
else:
contact = get_object_or_404(Profile, id=contact_id, contacts__user=request.user)
context = {'current':'contacts',
'time_records': contact.user.time_records.order_by('-stop_date')[:5],
'projects': Project.objects.for_user(contact.user),
'contact': contact }
return render_response(request, 'contact/contact_detail.html', context)
def tip_view(request, tip_id):
"""
show a list of picture
"""
kwargs = {'pk': tip_id}
# does not allow visitor to see not visible tip
# this trick allow staff to preview tips they wrote
if not request.user.is_staff:
kwargs['is_visible'] = True
tip = get_object_or_404(Tip,**kwargs)
context = {'tip': tip,
'current':'tips'}
return render_response(request, 'tip/tip_view.html', context)
def model_form(request, model_id):
model = get_object_or_404(Model, application__project__owner=request.user, pk=model_id)
context = {}
if request.method == 'POST':
model_form = ModelForm(request.POST, instance=model, prefix="model_%d_" % model.id)
if model_form.is_valid():
model = model_form.save()
context['saved'] = True
model_form = ModelForm(instance=model, prefix="model_%d_" % model.id)
context.update({'model_form': model_form,
'model': model})
return render_response(request, 'model_form.html', context)
raise Http404
def public_project_view(request, project_id):
"""
- return project corresponding to project_id
- raise 404 if project is not found or is not public
"""
if request.user.is_superuser:
project = get_object_or_404(Project, pk=project_id)
else:
project = get_object_or_404(Project, public=True, pk=project_id)
context = {'project': project}
return render_response(request, 'project/public_project_view.html',
context)
def homepage(request):
"""
Display some featured articles, most recent article
and some tips.
"""
featured = FeaturedArticle.objects.filter(is_visible=True).order_by('?')
if len(featured):
featured = featured[0]
articles = Article.objects.filter(is_visible=True).select_related().order_by('-creation_date')[:4]
context = {'current': 'home',
'featured': featured,
'articles': articles}
return render_response(request, 'homepage.html', context)
def application_form(request, application_id):
application = get_object_or_404(Application, project__owner=request.user, pk=application_id)
context = {}
if request.method == "POST":
form = ApplicationForm(application.project, request.POST, instance=application, prefix='app_%d_' % application.id)
if form.is_valid():
application = form.save()
context['saved'] = True
form = ApplicationForm(application.project, instance=application, prefix='app_%d_' % application.id)
else:
form = ApplicationForm(application.project, instance=application, prefix='app_%d_' % application.id)
context.update({'application_form': form,
'application': application})
return render_response(request, 'application_form.html', context)
def register_confirm(request, key):
"""
Account creation from email link.
"""
registration = Registration.objects.filter(key=key)
if not registration:
return HttpResponseRedirect(reverse("login_view"))
if request.user.is_authenticated():
logout(request)
registration = registration[0]
# check that user does not already exist with this email
if User.objects.filter(email__iexact=registration.email):
Registration.objects.filter(email__iexact=registration.email).delete()
return HttpResponseRedirect(reverse("login_view"))
context = {"registration": registration}
if request.method == "POST":
form = SetPasswordFormWithAgreementCopyTimeRecord(request.POST)
if form.is_valid():
time_records = TimeRecord.objects.get_time_records(request)
password = form.cleaned_data["password2"]
user = User.objects.create_user(
sha_constructor(str(registration.email)).hexdigest()[:30], registration.email, password
)
profile = Profile.objects.create(user=user)
user = authenticate(username=user.username, password=password)
if form.cleaned_data["backup_time_records"]:
for time_record in time_records:
time_record.user = user
time_record.save()
login(request, user)
context["email_to"] = registration.email
context["password"] = password
text_content = render_string(request, "email/welcome.txt", context)
send_mail("Welcome to kaaloo", text_content, settings.DEFAULT_EMAIL_FROM, [user.email])
Registration.objects.filter(email__iexact=registration.email).delete()
return HttpResponseRedirect(reverse("thank_you_for_registering"))
else:
context["password_form"] = form
else:
context["password_form"] = SetPasswordFormWithAgreementCopyTimeRecord()
return render_response(request, "profile/create_account.html", context)
def model_field_form(request, field_type, model_field_id):
model_field = get_object_or_404(ModelField, model__application__project__owner=request.user, pk=model_field_id)
context = {}
prefix = "%s_%d" % (model_field.object.field_type,model_field.id)
if request.method == 'POST':
form = FIELD_FORMS[model_field.object.field_type](model_field.model, request.POST, prefix=prefix, instance=model_field.object)
if form.is_valid():
field = form.save()
form = FIELD_FORMS[model_field.object.field_type](model_field.model, instance=model_field.object, prefix=prefix)
context['saved'] = True
else:
form = FIELD_FORMS[model_field.object.field_type](model_field.model, instance=model_field.object, prefix=prefix)
context.update({'field_form':form,
'model_field':model_field})
return render_response(request, 'field_form.html', context)
def add_project_view(request):
context = {'current':'projects'}
if request.method == "POST":
form = NewProjectForm(data=request.POST)
if form.is_valid():
project = form.save(commit=False)
project.creator = request.user
project.save()
project.owners = [request.user]
return HttpResponseRedirect(reverse('project_detail_view', args=[project.id]))
else:
context['form'] = form
else:
context['form'] = NewProjectForm()
return render_response(request, 'project/add_project.html', context)
def buy_sucess(request, presentation_id, zone_id):
presentation = get_object_or_404(Presentation, id=presentation_id)
zone = get_object_or_404(Zone, id=zone_id)
extra_context = {
'event': presentation.event,
'presentation': presentation,
'zone': zone,
}
return render_response(
request,
'ticket/buy_sucess.html',
extra_context
)
def password_view(request):
"""
Allow user to change his password by entering his old one
"""
profile = request.user.get_profile()
context = {"current": "account"}
if request.method == "POST":
password_form = PasswordChangeForm(user=request.user, data=request.POST)
if password_form.is_valid():
password_form.save()
context["password_saved"] = True
else:
password_form = PasswordChangeForm(user=request.user)
context.update({"password_form": password_form})
return render_response(request, "profile/password.html", context)
def invite_confirm_view(request, key):
"""
Create an account for the user.
"""
"""
Account creation from email link.
"""
invites = InviteRequest.objects.filter(key=key)
if not invites:
return HttpResponseRedirect(reverse('login_view'))
invite = invites[0]
# check that user does not already exist with this email
if User.objects.filter(email__iexact=invite.to_email):
return HttpResponseRedirect(reverse('login_view'))
context = {}
if request.method == "POST":
form = SetPasswordForm(request.POST)
if form.is_valid():
password = form.cleaned_data['password2']
user = User.objects.create_user(sha_constructor(str(invite.to_email)).hexdigest()[:30], invite.to_email, password)
profile = Profile.objects.create(user=user)
user = authenticate(username=user.username, password=password)
login(request, user)
context['email_to'] = user.email
context['password'] = password
text_content = render_string(request,
'email/welcome.txt',
context)
send_mail('Welcome to kaaloo',
text_content,
settings.DEFAULT_EMAIL_FROM,
[user.email, ])
# transform all invites in friend request
invites = InviteRequest.objects.filter(to_email__iexact = user.email)
for invite in invites:
ContactRequest.objects.create(from_user=invite.from_user, to_user=user)
invites.delete()
return HttpResponseRedirect(reverse('contact_requests_view'))
else:
context['password_form'] = form
else:
context['password_form'] = SetPasswordForm()
return render_response(request, 'profile/create_account.html', context)
def new_application_form(request, project_id):
project = get_object_or_404(Project, owner=request.user, pk=project_id)
context = {}
if request.method == 'POST':
form = NewApplicationForm(project, request.POST, prefix="new_application_")
if form.is_valid():
context['created'] = True
new_application = form.save(commit=False)
new_application.project = project
new_application.save()
context['application'] = new_application
form = NewApplicationForm(project, prefix="new_application_")
else:
form = NewApplicationForm(project, prefix="new_application_")
context.update({'new_application_form': form, 'project': project})
return render_response(request, 'new_application_form.html', context)
def model_form(request, model_id):
model = get_object_or_404(Model,
application__project__owner=request.user,
pk=model_id)
context = {}
if request.method == 'POST':
model_form = ModelForm(request.POST,
instance=model,
prefix="model_%d_" % model.id)
if model_form.is_valid():
model = model_form.save()
context['saved'] = True
model_form = ModelForm(instance=model,
prefix="model_%d_" % model.id)
context.update({'model_form': model_form, 'model': model})
return render_response(request, 'model_form.html', context)
raise Http404
def new_application_form(request, project_id):
project = get_object_or_404(Project, owner=request.user, pk=project_id)
context = {}
if request.method == 'POST':
form = NewApplicationForm(project,
request.POST,
prefix="new_application_")
if form.is_valid():
context['created'] = True
new_application = form.save(commit=False)
new_application.project = project
new_application.save()
context['application'] = new_application
form = NewApplicationForm(project, prefix="new_application_")
else:
form = NewApplicationForm(project, prefix="new_application_")
context.update({'new_application_form': form, 'project': project})
return render_response(request, 'new_application_form.html', context)
def project_list(request):
"""
return projects own by the current user.
The result list is paginated
"""
context = {}
projects = Project.objects.filter(
owner=request.user).order_by("-creation_date")
if request.method == "POST":
form = NewProjectForm(request.POST, owner=request.user)
if form.is_valid():
new_project = form.save(commit=False)
new_project.owner = request.user
new_project.save()
else:
form = NewProjectForm(owner=request.user)
context['projects'] = paginate(projects, request)
context['new_project_form'] = form
return render_response(request, 'project/project_list.html', context)
def application_form(request, application_id):
application = get_object_or_404(Application,
project__owner=request.user,
pk=application_id)
context = {}
if request.method == "POST":
form = ApplicationForm(application.project,
request.POST,
instance=application,
prefix='app_%d_' % application.id)
if form.is_valid():
application = form.save()
context['saved'] = True
form = ApplicationForm(application.project,
instance=application,
prefix='app_%d_' % application.id)
else:
form = ApplicationForm(application.project,
instance=application,
prefix='app_%d_' % application.id)
context.update({'application_form': form, 'application': application})
return render_response(request, 'application_form.html', context)
def model_field_form(request, field_type, model_field_id):
model_field = get_object_or_404(
ModelField,
model__application__project__owner=request.user,
pk=model_field_id)
context = {}
prefix = "%s_%d" % (model_field.object.field_type, model_field.id)
if request.method == 'POST':
form = FIELD_FORMS[model_field.object.field_type](
model_field.model,
request.POST,
prefix=prefix,
instance=model_field.object)
if form.is_valid():
field = form.save()
form = FIELD_FORMS[model_field.object.field_type](
model_field.model, instance=model_field.object, prefix=prefix)
context['saved'] = True
else:
form = FIELD_FORMS[model_field.object.field_type](
model_field.model, instance=model_field.object, prefix=prefix)
context.update({'field_form': form, 'model_field': model_field})
return render_response(request, 'field_form.html', context)
def model_view(request, model_id):
model = get_object_or_404(Model,
application__project__owner=request.user,
pk=model_id)
return render_response(request, 'model_view.html', {'model': model})
def application_view(request, application_id):
application = get_object_or_404(Application,
project__owner=request.user,
pk=application_id)
context = {'application': application}
return render_response(request, 'application_view.html', context)
