def add_attachment(request,
app_label,
module_name,
pk,
template_name='attachments/add.html',
extra_context={}):
next = request.POST.get('next', '/')
model = get_model(app_label, module_name)
if model is None:
return HttpResponseRedirect(next)
obj = get_object_or_404(model, pk=pk)
form = AttachmentForm(request.POST, request.FILES)
if form.is_valid():
form.save(request, obj)
messages.add_message(request, messages.INFO,
_('Your attachment was uploaded.'))
return HttpResponseRedirect(next)
else:
template_context = {
'form': form,
'form_url': add_url_for_obj(obj),
'next': next,
}
template_context.update(extra_context)
return render_to_response(template_name, template_context,
RequestContext(request))
def new(request):
if request.method == 'GET':
form = AttachmentForm()
content_type = request.GET['content_type']
object_id = request.GET['object_id']
next = request.GET['next']
elif request.method == 'POST':
data = request.POST
next = data['next']
form = AttachmentForm(data = data, files = request.FILES)
if form.is_valid():
form.save()
info_msg(request, u"Pièce jointe ajoutée avec succès.")
return redirect(next)
else:
content_type = data['content_type']
object_id = data['object_id']
return render(request, "attachments/form.html", {
'form': form,
'content_type': content_type,
'object_id': object_id,
'next': next
})
def add_attachment(request, app_label, module_name, pk,
template_name='attachments/add.html', extra_context={}):
ajax = request.is_ajax
next = request.POST.get('next', '/')
model = get_model(app_label, module_name)
if model is None:
return HttpResponseRedirect(next)
obj = get_object_or_404(model, pk=pk)
form = AttachmentForm(request.POST, request.FILES)
if form.is_valid():
form.save(request, obj)
message = _('Your attachement was uploaded.')
if ajax:
return _json_response(request, _("Success"), message)
messages.add_message(request, messages.SUCCESS, message)
return HttpResponseRedirect(next)
else:
template_context = {
'form': form,
'form_url': add_url_for_obj(obj),
'next': next,
}
template_context.update(extra_context)
if ajax:
json_context = {
'form_html': render_to_string(template_name, template_context)
}
return _json_response(request, _("Error"), _("Please correct the form errors."), json_context)
return render_to_response(template_name, template_context,
RequestContext(request))
def add_attachment(request, app_label, module_name, pk,
template_name='attachments/add.html', extra_context={}):
next = request.POST.get('next', '/')
model = get_model(app_label, module_name)
if model is None:
return HttpResponseRedirect(next)
obj = get_object_or_404(model, pk=pk)
form = AttachmentForm(request.POST, request.FILES)
if form.is_valid():
if form.cleaned_data['tag']:
a = Attachment.objects.filter(tag = form.cleaned_data['tag'], object_id = obj.id, content_type = ContentType.objects.get_for_model(obj))
for old_item in a:
old_item.delete()
form.save(request, obj)
request.user.message_set.create(message=ugettext('Your attachment was uploaded.'))
return HttpResponseRedirect(next)
else:
template_context = {
'form': form,
'form_url': add_url_for_obj(obj),
'next': next,
}
template_context.update(extra_context)
return render_to_response(template_name, template_context,
RequestContext(request))
def add_attachment(request,
app_label,
model_name,
pk,
template_name='attachments/add.html',
extra_context={}):
next = request.POST.get('next', '/')
model = get_model(app_label, model_name)
if model is None:
return HttpResponseRedirect(next)
obj = get_object_or_404(model, pk=pk)
form = AttachmentForm(request.POST, request.FILES)
if form.is_valid():
file = request.FILES['attachment_file']
try:
validate_file_type(file)
except ValidationError, e:
messages.error(request, ('; '.join(e.messages)))
return HttpResponseRedirect(next)
form.save(request, obj)
messages.success(request, ugettext('Your attachment was uploaded.'))
return HttpResponseRedirect(next)
def add(request, app_label, module_name, pk, template_name="attachments/add_form.html", perm_callback=PERMS["add"]):
# TODO: check for proper applabel/modelname
model = get_model(app_label, module_name)
obj = get_object_or_404(model, pk=pk)
# TODO: check for valid next attribute
next = request.REQUEST.get("next") or "/"
if not perm_callback(request, obj):
return HttpResponseForbidden("Did't allowed upload attachments for this item")
if request.method == "POST":
form = AttachmentForm(request.POST, request.FILES)
else:
form = AttachmentForm()
if form.is_valid():
form.save(request, obj)
request.user.message_set.create(message=ugettext("Your attachment was uploaded."))
return HttpResponseRedirect(next)
else:
return render_to_response(
template_name, {"form": form, "form_url": add_url_for_obj(obj), "next": next}, RequestContext(request)
)
def add_attachment(request, app_label, model_name, pk,
template_name='attachments/add.html', extra_context={}):
model = apps.get_model(app_label, model_name)
if model is None:
return HttpResponseRedirect(next)
obj = get_object_or_404(model, pk=pk)
next = request.POST.get('next', obj.get_absolute_url())
if not request.POST:
form = AttachmentForm()
else:
form = AttachmentForm(request.POST, request.FILES)
if form.is_valid():
form.save(request, obj)
messages.success(request, ugettext('Your attachment was uploaded.'))
return HttpResponseRedirect(next)
else:
template_context = {
'form': form,
'form_url': add_url_for_obj(obj),
'next': next,
}
template_context.update(extra_context)
return render(request, template_name, template_context)
def get_form(self, context):
obj = self.get_object(context)
if obj:
f = AttachmentForm()
f.form_url = add_url_for_obj(obj)
return f
else:
return None
def upload_file(request):
if request.method == 'POST':
form = AttachmentForm(request.POST, request.FILES)
if form.is_valid():
attach = form.save()
return JsonResponse({'success': attach.id})
return JsonResponse({'errors': form.errors}, status=400)
return HttpResponseNotAllowed(['POST'])
def create(request):
form = AttachmentForm(request.POST)
if form.is_valid():
attachment = form.save()
return JsonResponse({
'success': True,
'attachment ID': attachment.id
})
return JsonResponse({'errors': form.errors}, status=400)
def attachments_create(request):
if request.POST:
form = AttachmentForm(request.POST, request.FILES)
if form.is_valid():
attachment = form.save(commit=False)
attachment.save()
return redirect(attachment)
else:
form = AttachmentForm()
return render_to_response('attachments/create.html', RequestContext(request, {
'form': form,
'subtitle': 'Upload attachments'
}))
def new(request):
if request.method == 'GET':
form = AttachmentForm()
content_type = request.GET['content_type']
object_id = request.GET['object_id']
next = request.GET['next']
elif request.method == 'POST':
data = request.POST
next = data['next']
form = AttachmentForm(data=data, files=request.FILES)
if form.is_valid():
form.save()
info_msg(request, u"Pièce jointe ajoutée avec succès.")
return redirect(next)
else:
content_type = data['content_type']
object_id = data['object_id']
return render(
request, "attachments/form.html", {
'form': form,
'content_type': content_type,
'object_id': object_id,
'next': next
})
def get_form(self, context):
obj = self.get_object(context)
if obj and context['user'].has_perm('attachments.add_attachment'):
if 'form' in context:
return context['form']
else:
return AttachmentForm()
else:
return None
def attachments_edit(request, id):
attachment = get_object_or_404(Attachment, pk=id)
if not attachment.can_edit(request.user):
return HttpResponseForbidden()
if request.POST:
form = AttachmentForm(request.POST, request.FILES, instance=attachment)
if form.is_valid():
attachment = form.save(commit=False)
attachment.save()
return redirect(attachment)
else:
form = AttachmentForm(instance=attachment)
return render_to_response('attachments/edit.html', RequestContext(request, {
'form': form,
'subtitle': 'Edit attachments'
}))
def add_attachment(request,
app_label,
module_name,
pk,
template_name='attachments/add.html',
extra_context={}):
ajax = request.is_ajax
next = request.POST.get('next', '/')
model = get_model(app_label, module_name)
if model is None:
return HttpResponseRedirect(next)
obj = get_object_or_404(model, pk=pk)
form = AttachmentForm(request.POST, request.FILES)
if form.is_valid():
form.save(request, obj)
message = _('Your attachement was uploaded.')
if ajax:
return _json_response(request, _("Success"), message)
messages.add_message(request, messages.SUCCESS, message)
return HttpResponseRedirect(next)
else:
template_context = {
'form': form,
'form_url': add_url_for_obj(obj),
'next': next,
}
template_context.update(extra_context)
if ajax:
json_context = {
'form_html': render_to_string(template_name, template_context)
}
return _json_response(request, _("Error"),
_("Please correct the form errors."),
json_context)
return render_to_response(template_name, template_context,
RequestContext(request))
def new_attachment(request, content_type, object_id):
object_type = get_object_or_404(ContentType, id = int(content_type))
try:
object = object_type.get_object_for_this_type(pk=int(object_id))
except object_type.DoesNotExist:
raise Http404
if request.method == "POST":
attachment_form = AttachmentForm(request.POST, request.FILES)
if attachment_form.is_valid():
attachment = attachment_form.save(commit=False)
attachment.content_type = object_type
attachment.object_id = object_id
attachment.attached_by = request.user
attachment.save()
return HttpResponseRedirect(object.get_absolute_url())
else:
attachment_form = AttachmentForm()
return render_to_response("attachments/new_attachment.html", {
"attachment_form": attachment_form,
"object": object
}, context_instance=RequestContext(request))
def add_attachment(request, app_label, model_name, pk,
template_name='attachments/add.html', extra_context={}):
# when using jquery.forms some browsers must use an iFrame to submit the form data
# when using this frame HTTP_X_REQUESTED_WITH is not set correctly
# adding isajaxrequest to your jquery.form options can get around this.
# var options = {'data': { isajaxrequest: 'true' } };
ajax = request.is_ajax() or 'isajaxrequest' in request.POST
next = request.POST.get('next', '/')
model = apps.get_model(app_label, model_name)
if model is None:
return HttpResponseRedirect(next)
obj = get_object_or_404(model, pk=pk)
form = AttachmentForm(request.POST, request.FILES)
if form.is_valid():
form.save(request, obj)
message = _('Your attachement was uploaded.')
if ajax:
return _json_response(request, _("Success"), message)
messages.add_message(request, messages.SUCCESS, message)
return HttpResponseRedirect(next)
else:
template_context = {
'form': form,
'form_url': add_url_for_obj(obj),
'next': next,
}
template_context.update(extra_context)
if ajax:
json_context = {
'form_html': render_to_string(template_name, template_context)
}
return _json_response(request, _("Error"), _("Please correct the form errors."), json_context)
return render_to_response(template_name, template_context,
RequestContext(request))
def add_attachment(request, app_label, module_name, pk,
template_name='attachments/add.html', extra_context={}):
next = request.POST.get('next', '/')
model = get_model(app_label, module_name)
if model is None:
return HttpResponseRedirect(next)
obj = get_object_or_404(model, pk=pk)
form = AttachmentForm(request.POST, request.FILES)
if form.is_valid():
form.save(request, obj)
request.user.message_set.create(message=ugettext('Your attachment was uploaded.'))
return HttpResponseRedirect(next)
else:
template_context = {
'form': form,
'form_url': add_url_for_obj(obj),
'next': next,
}
template_context.update(extra_context)
return render_to_response(template_name, template_context,
RequestContext(request))
def attachment_form(context, obj):
"""
Renders a "upload attachment" form.
The user must own ``attachments.add_attachment permission`` to add
attachments.
"""
if context['user'].has_perm('attachments.add_attachment'):
return {
'form': AttachmentForm(),
'form_url': add_url_for_obj(obj),
'next': context['request'].build_absolute_uri(),
}
else:
return {
'form': None,
}
def attachment_form(context, obj, category=''):
"""
Renders a "upload attachment" form.
The user must own ``attachments.add_attachment permission`` to add
attachments.
"""
if context['user'].has_perm('attachments.add_attachment'):
if category in categories:
category = categories[category]
else:
category = Attachment.DEFAULT
return {
'form': AttachmentForm(initial={'category': category}),
'form_url': add_url_for_obj(obj),
'next': context.request.build_absolute_uri(),
}
else:
return {
'form': None,
}
def new_attachment(request, content_type, object_id):
object_type = get_object_or_404(ContentType, id=int(content_type))
try:
object = object_type.get_object_for_this_type(pk=int(object_id))
except object_type.DoesNotExist:
raise Http404
if request.method == "POST":
attachment_form = AttachmentForm(request.POST, request.FILES)
if attachment_form.is_valid():
attachment = attachment_form.save(commit=False)
attachment.content_type = object_type
attachment.object_id = object_id
attachment.attached_by = request.user
attachment.save()
return HttpResponseRedirect(object.get_absolute_url())
else:
attachment_form = AttachmentForm()
return render_to_response("attachments/new_attachment.html", {
"attachment_form": attachment_form,
"object": object
},
context_instance=RequestContext(request))
def add_project(request):
if request.method == 'POST':
form1 = CreateProjectForm(request.POST)
input_data = request.POST.copy()
if form1.is_valid():
obj1 = sql_util.save_entry_to_db(form1, input_data)
pk = obj1.id
app_label = 'pages'
model_name = 'Project'
if request.user.has_perm("attachments.add_attachment"):
model = apps.get_model(app_label, model_name)
obj = get_object_or_404(model, pk=pk)
files = request.FILES.getlist('attachment_file')
images = request.FILES.getlist('attachment_image')
if len(files) > 0:
for f in files:
test = MultiValueDict({'attachment_file': [f]})
form = AttachmentForm(request.POST, test)
if form.is_valid():
form.save(request, obj)
if len(images) > 0:
for i in images:
test = MultiValueDict({'attachment_image': [i]})
form = ImageForm(request.POST, test)
if form.is_valid():
form.save(request, obj)
if 'undertaking' in input_data:
form2 = CreateReferenceProjectForm(request.POST)
if form2.is_valid():
obj2 = sql_util.save_ref_to_db(form2, obj1)
return HttpResponseRedirect(reverse('success'))
else:
input_data = request.POST.copy()
attachment_model = Attachment(pk=1) # tää on viel kyssäri
image_model = Image(pk=1)
context = {
'form1':
CreateProjectForm(request.POST),
'form2':
CreateReferenceProjectForm(request.POST),
'attachment':
attachment_model,
'image':
image_model,
'filters':
sql_util.get_filters(),
'selected_filters':
parse_util.filters_qs_to_dict(
parse_util.parse_input_filters(input_data)),
'is_reference':
'undertaking' in input_data
}
return render(request, 'add_project.html', context)
elif request.method == 'GET':
form1 = CreateProjectForm()
form2 = CreateReferenceProjectForm()
attachment_model = Attachment(pk=1) # tää on viel kyssäri
image_model = Image(pk=1)
context = {
'form1': form1,
'form2': form2,
'attachment': attachment_model,
'image': image_model,
'filters': sql_util.get_filters(),
}
return render(request, 'add_project.html', context)
def new_topic(request, group_slug=None, bridge=None):
is_member = False
group = None
if group_slug is None:
group_slug = "ewb"
group = get_object_or_404(BaseGroup, slug=group_slug)
is_member = group.user_is_member(request.user, admin_override=True)
if not group.is_visible(request.user):
return HttpResponseForbidden()
attach_count = 0
if request.method == "POST":
if not request.user.is_authenticated():
return HttpResponseForbidden()
try:
attach_count = int(request.POST.get("attach_count", 0))
except ValueError:
attach_count = 0
if group.slug == "ewb" or is_member:
# has been previewed. mark it as good to go!
if request.POST.get("previewed", None) and request.POST.get(
"postid", None):
topic = GroupTopic.objects.get(id=request.POST['postid'],
creator=request.user)
if topic.pending:
topic.pending = False
topic.save()
# extra security check that sender isn't forged.
# can't hurt...
sender_valid = False
if group.user_is_admin(request.user) and request.POST.get(
'sender', None):
if request.POST['sender'] == group.from_email:
sender_valid = True
sender = '"%s" <%s>' % (group.from_name,
group.from_email)
elif get_object_or_none(
EmailAddress, email=request.POST['sender']
) in request.user.get_profile().email_addresses():
sender_valid = True
sender = '"%s %s" <%s>' % (
request.user.get_profile().first_name,
request.user.get_profile().last_name,
request.POST['sender'])
elif request.user.is_staff and request.POST[
'sender'] == "*****@*****.**":
sender_valid = True
sender = '"EWB-ISF Canada" <*****@*****.**>'
if topic.send_as_email:
if sender_valid:
request.user.message_set.create(
message=escape("Sent as %s" % sender))
topic.send_email(sender=sender)
else:
request.user.message_set.create(
message="Unable to send email.")
# redirect out.
request.user.message_set.create(
message=_("You have started the topic %(topic_title)s")
% {"topic_title": topic.title})
else:
# probably double-clicked the submit button and this is the dupe request...
pass
return HttpResponseRedirect(topic.get_absolute_url())
# confirmation was cancelled, so delete the temp post and bump back to edit screen
topic = None
if request.POST.get("goback", None) and request.POST.get(
"postid", None):
topic = get_object_or_none(GroupTopic,
id=request.POST['postid'],
pending=True,
creator=request.user)
if topic:
topic_form = GroupTopicForm(instance=topic,
user=request.user,
group=group)
attach_forms = []
topic.delete()
# validate form and show preview...
else:
topic_form = GroupTopicForm(request.POST,
user=request.user,
group=group)
attach_forms = [
AttachmentForm(request.POST,
request.FILES,
prefix=str(x),
instance=Attachment())
for x in range(0, attach_count)
]
# do not take blank attachment forms into account
for af in attach_forms:
if not af.is_valid() and not af['attachment_file'].data:
attach_forms.remove(af)
attach_count = attach_count - 1
# all good. save it!
if topic_form.is_valid() and all([
af.is_valid() for af in attach_forms
]) and not request.POST.get("goback", None):
# save the post but mark it as "pending".... and display a confirmation.
topic = topic_form.save(commit=False)
if group:
group.associate(topic, commit=False)
topic.creator = request.user
topic.pending = True
topic.save()
# save the attachments.
# We need the "Topic" object in order to retrieve attachments properly
# since other functions only get the Topic object
base_topic = GroupTopic.objects.get(id=topic.id)
attachments = []
for af in attach_forms:
attachment = af.save(request, base_topic)
attachments.append(
af.cleaned_data['attachment_file'].name)
sender = None
if topic_form.cleaned_data.get('send_as_email', None):
sender = topic_form.cleaned_data.get('sender', None)
is_large_group = False
if group.members.count() > 50:
is_large_group = True
return render_to_response(
"topics/preview.html", {
"group": group,
"topic": topic,
"is_member": is_member,
"sender": sender,
"attachments": attachments,
"is_large_group": is_large_group,
},
context_instance=RequestContext(request))
else:
# if they can't start a topic, why are we still loading up a form?
request.user.message_set.create(message=_(
"You are not a member and so cannot start a new topic"))
topic_form = GroupTopicForm(instance=GroupTopic())
attach_forms = [
AttachmentForm(prefix=str(x), instance=Attachment())
for x in range(0, attach_count)
]
else:
topic_form = GroupTopicForm(instance=GroupTopic(),
user=request.user,
group=group)
attach_forms = []
return render_to_response("topics/new_topic.html", {
"group": group,
"topic_form": topic_form,
"attach_forms": attach_forms,
"attach_count": attach_count,
"is_member": is_member,
},
context_instance=RequestContext(request))
def edit_project(request, id):
project = models.Project.project_db.get(id=id)
if request.method == 'POST':
form1 = CreateProjectForm(request.POST)
if form1.is_valid():
input_data = request.POST.copy()
sql_util.edit_entry_in_db(project, form1, input_data)
app_label = 'pages'
model_name = 'Project'
if request.user.has_perm("attachments.add_attachment"):
model = apps.get_model(app_label, model_name)
obj = get_object_or_404(model, pk=id)
files = request.FILES.getlist('attachment_file')
images = request.FILES.getlist('attachment_image')
if len(files) > 0:
for f in files:
test = MultiValueDict({'attachment_file': [f]})
form = AttachmentForm(request.POST, test)
if form.is_valid():
form.save(request, obj)
#else invalid
if len(images) > 0:
existing_images = Image.objects.attachments_for_object(id)
for image in existing_images:
delete_image(request, image.pk)
for i in images:
test = MultiValueDict({'attachment_image': [i]})
form = ImageForm(request.POST, test)
if form.is_valid():
form.save(request, obj)
#else invalid
print(input_data)
if 'undertaking' in input_data:
form2 = CreateReferenceProjectForm(request.POST)
print(form2.is_valid())
if form2.is_valid():
sql_util.edit_ref_in_db(project.referenceproject, form2)
#else invalid - look at what happens when form1 is not valid
return HttpResponseRedirect(reverse(success))
else:
input_data = request.POST.copy()
attachment_model = Attachment(pk=1) # tää on viel kyssäri
image_model = Image(pk=1)
context = {
'form1':
CreateProjectForm(request.POST),
'form2':
CreateReferenceProjectForm(request.POST),
'attachment':
attachment_model,
'image':
image_model,
'id':
id,
'filters':
sql_util.get_filters(),
'selected_filters':
parse_util.filters_qs_to_dict(
parse_util.parse_input_filters(input_data))
}
return render(request, 'edit_project.html', context)
elif request.method == 'GET':
f1, f2, f3, f4, f5 = sql_util.get_filters()
filters_qset = project.filters.all()
filters_dict = parse_util.filters_qs_to_dict(filters_qset)
form1 = CreateProjectForm(
initial={
'project_name':
project.project_name,
'destination_name':
'' if project.destination_name ==
'—' else project.destination_name,
'start_date':
parse_util.format_time(project.start_date),
'end_date':
parse_util.format_time(project.end_date),
'keywords':
'' if project.keywords == '—' else project.keywords,
'project_description':
project.project_description,
'documentation_path':
'' if project.documentation_path ==
'—' else project.documentation_path,
'project_manager':
'' if project.project_manager ==
'—' else project.project_manager,
})
try:
form2 = CreateReferenceProjectForm(
initial={
'undertaking':
project.referenceproject.undertaking,
'client':
project.referenceproject.client,
'area':
project.referenceproject.area,
'construction_cost':
project.referenceproject.construction_cost,
'project_accepted':
parse_util.format_time(
project.referenceproject.project_accepted),
'construction_permit_granted':
parse_util.format_time(
project.referenceproject.construction_permit_granted),
})
except ObjectDoesNotExist:
form2 = False
attachment_model = Attachment(pk=1)
image_model = Image(pk=1)
context = {
'form1':
form1,
'form2':
form2,
'attachment':
attachment_model,
'image':
image_model,
'id':
id,
'filters':
sql_util.get_filters(),
'selected_filters':
parse_util.filters_qs_to_dict(project.filters.all())
}
return render(request, 'edit_project.html', context)
def edit_article(request, title,
group_slug=None, bridge=None,
article_qs=ALL_WHITEBOARDS,
ArticleClass=Whiteboard, # to get the DoesNotExist exception
ArticleFormClass=WhiteboardForm,
template_name='edit_whiteboard.html',
template_dir='whiteboard',
extra_context=None,
check_membership=False,
is_member=None,
is_private=None,
*args, **kw):
if group_slug is not None:
try:
group = bridge.get_group(group_slug)
except ObjectDoesNotExist:
raise Http404
# permissions check
if not group.user_is_member(request.user, admin_override=True):
return HttpResponseForbidden()
try:
article = article_qs.get_by(title, group)
except ArticleClass.DoesNotExist:
article = None
attach_forms = []
if request.method == 'POST':
try:
attach_count = int(request.POST.get("attach_count", 0))
except ValueError:
attach_count = 0
form = ArticleFormClass(request.POST, instance=article)
attach_forms = [AttachmentForm(request.POST, request.FILES, prefix=str(x), instance=Attachment()) for x in range(0,attach_count)]
# do not take blank attachment forms into account
for af in attach_forms:
if not af.is_valid() and not af['attachment_file'].data:
attach_forms.remove(af)
attach_count = attach_count - 1
if form.is_valid() and all([af.is_valid() for af in attach_forms]):
if request.user.is_authenticated():
form.editor = request.user
if article is None:
user_message = u"Whiteboard was created successfully."
else:
user_message = u"Whiteboard was edited successfully."
request.user.message_set.create(message=user_message)
if ((article is None) and (group_slug is not None)):
form.group = group
new_article, changeset = form.save()
for af in attach_forms:
attachment = af.save(request, new_article)
# FIXME: is there a more efficient way of finding the parent
# than running these count() queries?
if new_article.topic.count():
url = new_article.topic.all()[0].get_absolute_url()
elif new_article.event.count():
url = new_article.event.all()[0].get_absolute_url()
else:
url = group.get_absolute_url() + "#group-whiteboard"
return redirect_to(request, url)
elif request.method == 'GET':
user_ip = get_real_ip(request)
lock = cache.get(title, None)
if lock is None:
lock = ArticleEditLock(title, request)
lock.create_message(request)
initial = {'user_ip': user_ip}
if group_slug is not None:
# @@@ wikiapp currently handles the group filtering, but we will
# eventually want to handle that via the bridge.
initial.update({'content_type': get_ct(group).id,
'object_id': group.id})
if article is None:
initial.update({'title': title,
'action': 'create'})
form = ArticleFormClass(initial=initial)
else:
initial['action'] = 'edit'
form = ArticleFormClass(instance=article,
initial=initial)
template_params = {'form': form}
template_params['attach_forms'] = attach_forms
template_params['group'] = group
if extra_context is not None:
template_params.update(extra_context)
return render_to_response(os.path.join(template_dir, template_name),
template_params,
context_instance=RequestContext(request))
