def edit(request, id):
obj = dw.MRProj.objects.get(pk=id)
if request.method == 'GET':
form = forms.form_for_instance(obj)()
elif request.method == 'POST':
form = forms.form_for_instance(obj)(request.POST)
if form.is_valid():
try:
form.save()
return HttpResponseRedirect('/proj/')
except Exception, e:
logging.debug(unicode(e))
request.add_message(unicode(e))
def edit(request, id):
obj = km.Mark.objects.get(pk=id)
if request.method == "GET":
form = forms.form_for_instance(obj)()
elif request.method == "POST":
form = forms.form_for_instance(obj)(request.POST)
if form.is_valid():
try:
form.save()
return http.HttpResponseRedirect("/mark/")
except Exception, e:
logging.debug(unicode(e))
request.add_message(unicode(e))
def order(request, order_id=0):
OrderForm = forms.form_for_model(Order)
# supplier_id = 0
order = None
items = None
title = 'Add order'
if order_id:
order = get_object_or_404(Order, pk=order_id)
items = order.item_set.select_related()
OrderForm = forms.form_for_instance(order)
# supplier_id = order.supplier.id
title = 'Editing order'
if request.method == 'POST':
form = OrderForm(request.POST.copy())
if form.is_valid():
o = form.save()
return HttpResponseRedirect('%s/%i/'%('/purchase/order', o.id))
else:
form = OrderForm()
return render_to_response(
'purchase/order.html',
{'form': form,
'order': order,
'items': items,
'title': title},
context_instance=RequestContext(request)
)
def device_detail(request, device_id):
"Show/edit/save Device instance"
account = request.user.gts_user.account
error_message = ""
device = Device.objects.get(pk=device_id)
if request.method == "POST":
DeviceForm = form_for_model(Device)
device_form = DeviceForm(request.POST)
if device_form.is_valid():
save_instance(device_form, device, True)
# new_device = save_instance(device_form, device, False)
# new_device.account = account
# new_device.save()
return HttpResponseRedirect('/devices/')
else:
error_message = "Form contain errors!" # % account_form.errors
else:
DeviceForm = form_for_instance(device)
device_form = DeviceForm()
content = {"device" : device,
"device_form" : device_form,
"error_message" : error_message,
}
return render_to_response("device_detail.html", content)
def user_detail(request, user_id):
"""
Show/edit/save GTS_User instance
(!) В данный момент не используется.
Пользователи редактируюся в админ-части Джанго-сайта.
"""
error_message = ""
user = GTS_User.objects.get(pk=user_id)
if request.method == "POST":
UserForm = form_for_model(GTS_User)
user_form = UserForm(request.POST)
if user_form.is_valid():
save_instance(user_form, user, True)
return HttpResponseRedirect('/users/')
else:
error_message = "Form contain errors!" # % account_form.errors
else:
UserForm = form_for_instance(user)
user_form = UserForm()
content = {"user" : user,
"user_form" : user_form,
"error_message" : error_message,
}
return render_to_response("user_detail.html", content)
def account_detail(request, account_id=0):
"""
Отображает информацию о текущем Аккаунте.
Ее можно изменить и сохранить.
Аккаунт берется из request, при залогиневшеся юзере там появляется переменная user.
"""
error_message = ""
#if account_id == 0:
account = request.user.gts_user.account
#else:
# account = Account.objects.get(pk=account_id)
if request.method == "POST":
AccountForm = form_for_model(Account)
account_form = AccountForm(request.POST)
if account_form.is_valid():
account_form.clean_data['id'] = account.id
save_instance(account_form, account, True)
return HttpResponseRedirect('/gts_accounts/')
else:
error_message = "Form contain errors!" # % account_form.errors
else:
AccountForm = form_for_instance(account)
account_form = AccountForm()
content = {"account" : account,
"account_form" : account_form,
"error_message" : error_message,
}
return render_to_response("account_detail.html", content)
def article_form(request, object_id=''):
print "article_form POST data:\n", request.POST
if object_id:
object = get_object_or_404(Article, pk=object_id)
Form = form_for_instance(object)
else:
Form = form_for_model(Article)
if request.method == 'POST':
form = Form(request.POST)
if form.is_valid(): form.save()
else:
errors = form.errors
print "article_form errors:\n", errors
return render_to_response('errors.html', {'errors': errors})
return HttpResponseRedirect('/test/article/%s/' %
(object_id and object_id or 'new'))
else:
form = Form()
params = {
'form': form,
'object_id': object_id,
}
template_name = 'tags/article_form.html'
return render_to_response(template_name,
params,
context_instance=RequestContext(request))
def update(self, request):
"""
Changes the attributes of the resource identified by 'ident'
and redirects to the resource URI. Usually called by a HTTP
request to the resource URI with method PUT.
"""
# Create a form from the model/PUT data
ResourceForm = forms.form_for_instance(self.model,
form=self.collection.form_class)
data = self.collection.receiver.get_put_data(request)
form = ResourceForm(data)
# If the data contains no errors, save the model,
# return a "200 Ok" response with the model's
# URI in the location header and a representation
# of the model in the response body.
if form.is_valid():
form.save()
response = self.read(request)
response.status_code = 200
response['Location'] = self.get_url()
return response
# Otherwise return a 400 Bad Request error.
raise InvalidModelData(form.errors)
def edit_term(request, class_name, id):
Class = models.get_model('tm', class_name)
obj = Class.objects.get(id=id)
if request.method == 'GET':
edit_term_form = forms.form_for_instance(obj)()
else:
edit_term_form = forms.form_for_instance(obj)(request.POST)
if edit_term_form.is_valid():
try:
edit_term_form.save()
return http.HttpResponseRedirect(
h.reverse(manage, args=[class_name])
)
except Exception, e:
logging.debug(unicode(e))
request.add_message(unicode(e))
def file_manage(request):
if request.method == "GET":
c = RequestContext(request)
return render_to_response("client/project/file_list.html", c)
elif request.method == "POST":
if "query" in request.POST:
orgproj_id = request.POST.getlist("selected_orgproj")[0]
orgproj = get_object_or_404(OrgProj, pk=orgproj_id)
proj_docs = orgproj.mrdocs.filter(is_active=True)
context_data = {"proj_docs":proj_docs}
c = RequestContext(request, context_data)
return render_to_response("client/project/file_list.html", c)
if "add" in request.POST:
orgproj_id = request.POST.getlist("selected_orgproj")[0]
if orgproj_id == "0":
request.user.message_set.create(message=u"请选择一个项目！")
return HttpResponseRedirect("/file/")
else:
action_url = "/file/add/?pro=%s" % orgproj_id
Form = form_for_model(Doc, fields=filter_fields(Doc))
form = Form()
form.fields.insert(1, "file", forms.FileField())
form.fields["file"].label = u"选择csv文件"
context_data = {"form":form, "action_url":action_url, "submit":u"保 存",
"title":u"添加文件"}
return render_to_response("client/project/file_form.html", context_data,
context_instance=RequestContext(request))
if "edit" in request.POST:
if "selected" in request.POST:
file_id = request.POST.getlist("selected")[0]
action_url = "/file/%s/edit/" % file_id
file = get_object_or_404(Doc, pk=file_id)
Form = form_for_instance(file, fields=filter_fields(Doc))
form = Form()
form.fields["name"].widget.attrs.update({"readonly":True, "title":u"不能修改文件名称"})
form.fields.insert(1, "file", forms.FileField())
form.fields["file"].label = u"选择csv文件"
context_data = {"form":form, "action_url":action_url, "submit":u"修 改",
"project":file.org_proj, "title":u"编辑文件"}
return render_to_response("client/project/file_form.html", context_data,
context_instance=RequestContext(request))
else:
request.user.message_set.create(message=u"请选择一个文件！")
return HttpResponseRedirect("/file/")
if "delete" in request.POST:
if "selected" in request.POST:
file_id = request.POST.getlist("selected")[0]
file = get_object_or_404(Doc, pk=file_id)
conn = sqlite3.connect(DATABASE_NAME)
cursor = conn.cursor()
try:
cursor.execute('drop table %s_%s' % (file.org_proj.name, file.name))
except:
pass
conn.commit()
conn.close()
file.delete()
request.user.message_set.create(message=u"删除文件成功！")
return HttpResponseRedirect("/file/")
def story_edit(request, blogname, story_id):
blog = get_object_or_404(Blog, alias__exact=blogname)
story = get_object_or_404(Story, pk=story_id, blog__pk=blog.id)
allow = False
if request.user.is_authenticated():
if story.creator == request.user:
allow = True
else:
try:
role = Role.objects.get(user__pk=request.user.id, blog__pk=blog.id)
if role.role in "AM":
allow = True
except Role.DoesNotExist:
pass
if allow == False: # XXX redirect to login-page with next=/stories/add
error_message = "You must not edit this story"
return HttpResponseRedirect('/members/login/')
StoryForm = newforms.form_for_instance(story)
if request.POST:
data = request.POST.copy()
tags = request.POST.get('tags', '').split(' ')
taglist = [ str(Tag.objects.get_or_create(name=tag, blog=blog)[0].id) for tag in tags if tag ]
data.setlist('tags', taglist)
old_tag_set = set([ str(tag.id) for tag in story.tags.all() ])
new_tag_set = set(taglist)
form = StoryForm(data)
if form.is_valid():
story = form.save(commit=False)
for tag in old_tag_set - new_tag_set:
story.tags.remove(tag)
for tag in new_tag_set - old_tag_set:
story.tags.add(tag)
story.save()
return HttpResponseRedirect(story.get_absolute_url())
tags = " ".join([ tag.name for tag in story.tags.all() ])
StoryForm.base_fields['tags'].widget = newforms.widgets.TextInput()
StoryForm.base_fields['tags'].help_text = ''
StoryForm.base_fields['tags'].initial = tags
form = StoryForm()
return render_to_response('blog/story/add.html', {'form': form,
'title': 'Edit Story: %s' % (blog.title),
'blog': blog},
context_instance=template.RequestContext(request))
def language_update(request, language_code = None, template_name = 'lanpro/language/form.html'):
""" Create a new language definition or update an existing one """
# Check if this is a new language or not
if language_code:
# Check permissions
if not request.user.has_perm('lanpro.change_language'):
return page_forbidden(request, _('You are not allowed to change languages.'))
# We know the language id, so this is an update
language = get_object_or_404(Language, code = language_code)
# Create the form
LanguageFormClass = forms.form_for_instance(language, form = BaseForm)
url = language.get_absolute_url()
else:
# Check permissions
if not request.user.has_perm('lanpro.add_language'):
return page_forbidden(request, _('You are not allowed to add languages.'))
# This is a new one
LanguageFormClass = forms.form_for_model(Language, form = BaseForm)
url = Language.objects.get_absolute_url()
# Customize the css class
for item in ['code', 'name', 'description', 'plurals', 'equation']:
LanguageFormClass.base_fields[item].widget.attrs['class'] = 'textbox'
# Check the request
if request.POST:
# Posting data
if 'submit' in request.POST:
# Fill the form with posted data
form = LanguageFormClass(request.POST)
# Check the data validity
if form.is_valid():
# Save the form and, implicit, the model
form.save()
# Redirect to language page
return HttpResponseRedirect(url)
elif 'cancel' in request.POST:
# No data, redirect to language page
return HttpResponseRedirect(url)
else:
# No data, just display the form
form = LanguageFormClass()
# The absolute url to add a new language
url_add = Language.objects.get_absolute_add_url()
# Return the response
return render_to_response(
template_name,
{
'form': form,
'url_add': url_add,
},
context_instance = RequestContext(request)
)
def edit_doc(request, doc_id):
"Edit document"
doc = Document.objects.get(pk=doc_id)
DocForm = form_for_instance(doc)
if request.method == "POST":
doc_form = DocForm(request.POST)
if doc_form.is_valid():
# сохраняем новый документ
doc = doc_form.save(True)
save_instance(doc_form, doc, True)
# теперь распарсим строки документа
i = 1
while True:
if request.has_key("card_name%i" % i):
card_name = request.POST["card_name%i" % i]
if card_name=="":
break
card_number = request.POST["card_number%i" % i]
card_credit = request.POST["card_credit%i" % i]
card_note = request.POST["card_note%i" % i]
have_pin = False
if request.has_key("have_pin%i" % i):
have_pin = True
if request.has_key("card_id%i" % i):
card_id = request.POST["card_id%i" % i]
item = CardItem.objects.get(pk=card_id)
item.name = card_name
item.number = card_number
item.credit_number = card_credit
item.have_pin = have_pin
item.note=card_note
item.save()
else:
# сохраняем новую карточку
new_item = CardItem(name=card_name, number=card_number, credit_number=card_credit, have_pin=have_pin, note=card_note, doc=doc)
new_item.save()
# индекс следующей строки
i=i+1
return HttpResponseRedirect("/edit_docs/%s/" % doc.id)
else:
doc_form = DocForm()
items = CardItem.objects.filter(doc=doc).order_by("id")
content = {
"doc": doc,
"doc_form": doc_form,
"items": items,
}
return default_renderer(request, "card_edit", content)
def edit_atm_doc(request, doc_id):
"Edit ATM Document"
doc = AtmDocument.objects.get(pk=doc_id)
DocForm = form_for_instance(doc)
if request.method == "POST":
doc_form = DocForm(request.POST)
if doc_form.is_valid():
# сохраняем новый документ
doc = doc_form.save(True)
save_instance(doc_form, doc, True)
# теперь распарсим строки документа
i = 1
while True:
if request.has_key("card_name%i" % i):
card_name = request.POST["card_name%i" % i]
if card_name=="":
break
card_number = request.POST["card_number%i" % i]
arrival_date = request.POST["arrival_date%i" % i]
delivery_date = request.POST["delivery_date%i" % i]
card_note = request.POST["card_note%i" % i]
if request.has_key("card_id%i" % i):
card_id = request.POST["card_id%i" % i]
item = AtmCardItem.objects.get(pk=card_id)
item.name = card_name
item.number = card_number
item.arrival_date = arrival_date
item.delivery_date = delivery_date
item.note=card_note
item.save()
else:
# сохраняем новую карточку
new_item = AtmCardItem(name=card_name, number=card_number, delivery_date=delivery_date, arrival_date=arrival_date, note=card_note, doc=doc)
new_item.save()
# индекс следующей строки
i=i+1
return HttpResponseRedirect("/edit_docs_atm/%s/" % doc.id)
else:
doc_form = DocForm()
items = AtmCardItem.objects.filter(doc=doc).order_by("id")
content = {
"doc": doc,
"doc_form": doc_form,
"items": items,
}
return default_renderer(request, "atm_edit", content)
def edit_parameters(request, pattern_id):
pattern = get_object_or_404(Pattern, pk=pattern_id, author__pk=request.user.id)
if request.method == "POST":
data = request.POST
else:
data = None
parameters = pattern.parameters.all().order_by('name')
parameter_forms = []
value_id = 1
errors = []
valid_form_count = 0
for parameter in parameters:
# population_max_generations -> Population Max Generations
label_name = " ".join([s.capitalize() for s in parameter.name.split("_")])
ParameterForm = forms.form_for_instance(parameter)
ParameterForm.base_fields['value'].label = label_name
f = ParameterForm(data, prefix=str(value_id))
parameter_forms.append(f)
value_id += 1
if data is not None:
if f.is_valid():
valid_form_count += 1
value = f.save()
else:
errors.append(f.errors)
if data is not None:
# Only commit changes if at least one of the value forms validated
if valid_form_count > 0:
transaction.commit()
return HttpResponseRedirect("%sparameters/" % pattern.get_absolute_url())
else:
transaction.rollback()
raise Exception("Could not save all parameters: %s" % ", ".join(errors))
title = heading = "Edit Parameters"
context = {'title': title,
'heading': heading,
'pattern': pattern,
'parameter_forms': parameter_forms,
}
return render_to_response('fitbeats/edit_parameters.html',
context,
context_instance=RequestContext(request))
def update_form(self, request, pk, queryset, form_class):
"""
Render edit form for single entry.
"""
# Remove queryset cache by cloning the queryset
queryset = queryset._clone()
elem = queryset.get(**{queryset.model._meta.pk.name : pk})
ResourceForm = forms.form_for_instance(elem, form=form_class)
if request.PUT:
form = ResourceForm(request.PUT)
else:
form = ResourceForm()
template_name = '%s/%s_form.html' % (self.template_dir, elem._meta.module_name)
return render_to_response(template_name,
{'form':form, 'update':True, self.template_object_name:elem})
def upload_icon(request, username):
thumb_icon_width = 64
large_icon_width = 128
user = request.user
profile = user.get_profile()
ProfileEdit = forms.form_for_instance(profile)
del ProfileEdit.base_fields['user']
del ProfileEdit.base_fields['nickname']
del ProfileEdit.base_fields['twitter_name']
del ProfileEdit.base_fields['pownce_name']
del ProfileEdit.base_fields['blog_url']
#ProfileEdit.base_fields['icon'].widget = forms.FileInput()
#ProfileEdit.base_fields['icon'].clean = new.instancemethod(clean_icon,
# ProfileEdit.base_fields['icon'],
# ProfileEdit.base_fields['icon'].__class__)
if request.method == 'POST':
if 'icon' in request.FILES:
thumb_path = 'icon/%s.png' % user.username
large_path = 'icon/%s_large.png' % user.username
new_data = request.POST.copy()
file_data = request.FILES.copy()
try:
file_data['icon']['filename'] = '%s.png' % user.username
profile_form = ProfileEdit(new_data, file_data)
if profile_form.is_valid():
if 'icon' in ProfileEdit.base_fields:
from StringIO import StringIO
from PIL import Image
icon = Image.open(
StringIO(request.FILES['icon']['content']))
icon = icon.convert("RGB")
x, y = icon.size
thumb_im = resize_image(icon, x, y, thumb_icon_width)
large_im = resize_image(icon, x, y, large_icon_width)
thumb_icon_path = '%s/%s' % (settings.MEDIR_DIR,
thumb_path)
large_icon_path = '%s/%s' % (settings.MEDIR_DIR,
large_path)
thumb_im.save(thumb_icon_path, 'png')
large_im.save(large_icon_path, 'png')
#profile_form.cleaned_data['icon'] = thumb_path
profile_form.save()
request.user.message_set.create(
message=_('Profile image update successfully.'))
except:
pass
return HttpResponseRedirect(reverse('user_home'))
def user_home(request):
user = request.user
profile = user.get_profile()
ProfileEdit = forms.form_for_instance(profile)
del ProfileEdit.base_fields['user']
del ProfileEdit.base_fields['icon']
if request.method == 'POST':
new_data = request.POST.copy()
profile_form = ProfileEdit(new_data)
if profile_form.is_valid():
profile_form.save()
request.user.message_set.create(
message=_('Profile update successfully.'))
return HttpResponseRedirect(reverse('user_home'))
else:
profile_form = ProfileEdit()
return render_to_response('auth/user_home.html',
context_instance=RequestContext(
request, {'profile_form': profile_form}))
def edit(request, id, model, decorator = lambda x:x,
post_save_redirect='', template_name=''):
"""
Generic view for object editing. Will only edit
objects belonging to current account.
Uses a newforms form generated from the model.
`decorator` is called on the form class to allow
customization.
"""
record = get_or_404(request, model, id)
FormClass = decorator(
forms.form_for_instance(
record,
fields = get_allowed_fields(request, model),
),
request,
instance = record
)
template_name = template_name or _make_template_name(model, 'form')
#import pdb; pdb.set_trace()
if request.method == 'POST':
form = FormClass(request.POST)
if form.is_valid():
record = form.save()
return HttpResponseRedirect(
post_save_redirect or record.get_absolute_url()
)
else:
form = FormClass()
return render_to_response(
template_name,
context_instance = RequestContext(
request,
{
'form': form,
}
)
)
def edit_pro(request, pro_id):
redirect_url = "/project/"
project = get_object_or_404(OrgProj, pk=pro_id)
if request.method == "POST":
Form = form_for_instance(project, fields=filter_fields(OrgProj))
form = Form(request.POST)
if form.is_valid():
obj = form.save(commit=False)
obj.update_time = datetime.date.today()
obj.update_by = request.user
obj.save()
request.user.message_set.create(message=u"修改项目成功！")
return HttpResponseRedirect(redirect_url)
else:
action_url = "/project/%s/edit/" % pro_id
context_dict = {"form":form, "action_url":action_url,
"submit":u"修 改", "title":u"编辑项目"}
return render_to_response("client/project/project_form.html", context_dict,
context_instance=RequestContext(request))
def edit_file(request, file_id):
file = get_object_or_404(Doc, pk=file_id)
if request.method == "POST":
Form = form_for_instance(file, fields=filter_fields(Doc))
form = Form(request.POST)
if form.is_valid():
obj = form.save(commit=False)
obj.update_time = datetime.date.today()
obj.update_by = request.user
obj.save()
import_file(request, obj)
request.user.message_set.create(message=u"修改文件成功！")
return HttpResponseRedirect("/file/")
else:
action_url = "/file/%s/edit/" % file_id
context_data = {"form":form, "action_url":action_url, "submit":u"修 改",
"title":u"编辑文件"}
return render_to_response("client/project/file_form.html", context_data,
context_instance=RequestContext(request))
def update_form(self, request, pk, queryset, form_class):
"""
Render edit form for single entry.
"""
# Remove queryset cache by cloning the queryset
queryset = queryset._clone()
elem = queryset.get(**{queryset.model._meta.pk.name: pk})
ResourceForm = forms.form_for_instance(elem, form=form_class)
if request.PUT:
form = ResourceForm(request.PUT)
else:
form = ResourceForm()
template_name = '%s/%s_form.html' % (self.template_dir,
elem._meta.module_name)
return render_to_response(template_name, {
'form': form,
'update': True,
self.template_object_name: elem
})
def product(request, product_id=0):
ProductForm = forms.form_for_model(Product)
title = 'Add product'
if product_id:
product = get_object_or_404(Product, pk=product_id)
ProductForm = forms.form_for_instance(product)
title = 'Editing product'
if request.method == 'POST':
form = ProductForm(request.POST.copy())
if form.is_valid():
p = form.save()
return HttpResponseRedirect('%s/%i/'%('/warehouse/product', p.id))
else:
form = ProductForm()
return render_to_response(
'warehouse/product.html',
{'form': form,
'title': title},
context_instance=RequestContext(request)
)
def category(request, category_id=0):
CategoryForm = forms.form_for_model(Category)
title = 'Add category'
if category_id:
category = Category.objects.get(pk=category_id)
CategoryForm = forms.form_for_instance(category)
title = 'Editing category'
if request.method == 'POST':
form = CategoryForm(request.POST.copy())
if form.is_valid():
c = form.save()
return HttpResponseRedirect('%s/%i/'%('/warehouse/category', c.id))
else:
form = CategoryForm()
return render_to_response(
'warehouse/category.html',
{'form': form,
'title': title},
context_instance=RequestContext(request)
)
def supplier(request, supplier_id=0):
SupplierForm = forms.form_for_model(Supplier)
title = 'Add supplier'
if supplier_id:
supplier = Supplier.objects.get(pk=supplier_id)
SupplierForm = forms.form_for_instance(supplier)
title = 'Editing supplier'
if request.method == 'POST':
form = SupplierForm(request.POST.copy())
if form.is_valid():
s = form.save()
return HttpResponseRedirect('%s/%i/'%('/purchase/supplier', s.id))
else:
form = SupplierForm()
return render_to_response(
'purchase/supplier.html',
{'form': form,
'title': title},
context_instance=RequestContext(request)
)
def article_form(request, object_id=""):
print "article_form POST data:\n", request.POST
if object_id:
object = get_object_or_404(Article, pk=object_id)
Form = form_for_instance(object)
else:
Form = form_for_model(Article)
if request.method == "POST":
form = Form(request.POST)
if form.is_valid():
form.save()
else:
errors = form.errors
print "article_form errors:\n", errors
return render_to_response("errors.html", {"errors": errors})
return HttpResponseRedirect("/test/article/%s/" % (object_id and object_id or "new"))
else:
form = Form()
params = {"form": form, "object_id": object_id}
template_name = "tags/article_form.html"
return render_to_response(template_name, params, context_instance=RequestContext(request))
def pro_manage(request):
redirect_url = "/project/"
if "add" in request.POST:
action_url = "/project/add/"
Form = form_for_model(OrgProj, fields=filter_fields(OrgProj))
form = Form()
context_data = {"form":form, "action_url":action_url,
"submit":u"保 存", "title":u"新建项目"}
return render_to_response("client/project/project_form.html", context_data,
context_instance=RequestContext(request))
if "edit" in request.POST:
if "selected" in request.POST:
pro_id = request.POST.getlist("selected")[0]
action_url = "/project/%s/edit/" % pro_id
project = get_object_or_404(OrgProj, pk=pro_id)
Form = form_for_instance(project, fields=filter_fields(OrgProj))
form = Form()
form.fields["name"].widget.attrs.update({"readonly":True, "title":u"不能修改项目名称"})
context_data = {"form":form, "action_url":action_url, "submit":u"修 改", "title":u"编辑项目"}
return render_to_response("client/project/project_form.html", context_data,
context_instance=RequestContext(request))
else:
request.user.message_set.create(message=u"请选择一个项目！")
return HttpResponseRedirect(redirect_url)
if "delete" in request.POST:
if "selected" in request.POST:
pro_id = request.POST.getlist("selected")[0]
project = get_object_or_404(OrgProj, pk=pro_id)
if project.mrdocs.all():
request.user.message_set.create(message=u"删除失败，该项目下仍有文件存在！")
else:
project.delete()
request.user.message_set.create(message=u"删除项目成功！")
return HttpResponseRedirect(redirect_url)
else:
request.user.message_set.create(message=u"请选择一个项目！")
return HttpResponseRedirect(redirect_url)
if "back" in request.POST:
return HttpResponseRedirect("/")
def edit_pattern(request, id):
fields = ('length', 'instruments', 'selector', 'crossover', 'mutators')
pattern = get_object_or_404(Pattern, pk=id, author__pk=request.user.id)
PatternForm = forms.form_for_instance(pattern)
if request.method == "POST":
form = PatternForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(pattern.get_absolute_url())
else:
form = PatternForm()
title = heading = "Edit Pattern"
context = {'title': title,
'heading': heading,
'form': form,
'pattern': pattern}
return render_to_response('fitbeats/edit_pattern.html',
context,
context_instance=RequestContext(request))
def edit(request,
id,
model,
decorator=lambda x: x,
post_save_redirect='',
template_name=''):
"""
Generic view for object editing. Will only edit
objects belonging to current account.
Uses a newforms form generated from the model.
`decorator` is called on the form class to allow
customization.
"""
record = get_or_404(request, model, id)
FormClass = decorator(forms.form_for_instance(
record,
fields=get_allowed_fields(request, model),
),
request,
instance=record)
template_name = template_name or _make_template_name(model, 'form')
#import pdb; pdb.set_trace()
if request.method == 'POST':
form = FormClass(request.POST)
if form.is_valid():
record = form.save()
return HttpResponseRedirect(post_save_redirect
or record.get_absolute_url())
else:
form = FormClass()
return render_to_response(template_name,
context_instance=RequestContext(
request, {
'form': form,
}))
def agent_create(request, id = None):
recaptcha_failure = False
if id:
form_object = get_object_or_404(models.Agent, pk=id)
AgentForm = forms.form_for_instance(form_object)
else:
AgentForm = forms.form_for_model(models.Agent)
if request.POST:
check_captcha = captcha.submit( request.POST['recaptcha_challenge_field'],
request.POST['recaptcha_response_field'],
settings.RECAPTCHA_PRIVATE_KEY,
request.META['REMOTE_ADDR'])
f = AgentForm(request.POST)
if check_captcha.is_valid:
if f.is_valid():
datasource = f.save()
return HttpResponseRedirect("/")
else:
recaptcha_failure = True
else:
f = AgentForm()
return render_to_response("create_form.tmpl", {'form': f, 'type':'Agent', 'recaptcha_failure':recaptcha_failure})
def datarecord_create(request, id = None):
recaptcha_failure = False
if id:
form_object = get_object_or_404(models.DataRecord, pk=id)
DataRecordForm = forms.form_for_instance(form_object)
else:
DataRecordForm = forms.form_for_model(models.DataRecord)
if request.POST:
check_captcha = captcha.submit( request.POST['recaptcha_challenge_field'],
request.POST['recaptcha_response_field'],
settings.RECAPTCHA_PRIVATE_KEY,
request.META['REMOTE_ADDR'])
if check_captcha.is_valid:
f = DataRecordForm(request.POST)
if f.is_valid():
datarecord = f.save()
return HttpResponseRedirect("/datasource/%s/" % datarecord.datasource.id)
else:
recaptcha_failure = True
else:
f = DataRecordForm()
return render_to_response("create_form.tmpl", {'form': f, 'type':'DataRecord', 'recaptcha_failure':recaptcha_failure})
def update(self, request):
"""
Changes the attributes of the resource identified by 'ident'
and redirects to the resource URI. Usually called by a HTTP
request to the resource URI with method PUT.
"""
# Create a form from the model/PUT data
ResourceForm = forms.form_for_instance(self.model, form=self.collection.form_class)
data = self.collection.receiver.get_put_data(request)
form = ResourceForm(data)
# If the data contains no errors, save the model,
# return a "200 Ok" response with the model's
# URI in the location header and a representation
# of the model in the response body.
if form.is_valid():
form.save()
response = self.read(request)
response.status_code = 200
response.headers['Location'] = self.get_url()
return response
# Otherwise return a 400 Bad Request error.
raise InvalidModelData(form.errors)
def edit_position_paper(request, slug):
event = get_object_or_404(Event, slug=slug)
attendants = Attendant.objects.filter(event=event.id, user=request.user.id)
if len(attendants) == 0:
raise Http404()
PaperEdit = forms.form_for_instance(attendants[0])
del PaperEdit.base_fields['user']
del PaperEdit.base_fields['event']
del PaperEdit.base_fields['canceled']
if request.method == "POST":
form = PaperEdit(request.POST.copy())
if form.is_valid():
form.save()
request.user.message_set.create(
message=_(u'Your Position Paper successfully updated.'))
return HttpResponseRedirect(event.get_absolute_url())
else:
form = PaperEdit()
return render_to_response('event/edit_position_paper.html',
context_instance=RequestContext(
request, {
'object': event,
'form': form
}))
def manage(request, **kwargs):
def linereturn(line, linereturns):
if linereturns == "":
linereturns = linereturns + line
else:
linereturns = linereturns + u'\n' + line
return linereturns
group = kwargs.get("group", False)
if group:
g = Group.objects.get(acronym=group)
css = g.defaultcss
logo = g.get_logo_url()
person = request.user.person
permtest = group and (person == g.project_leader or person == g.editor or request.user.is_superuser)
if not permtest:
return error (request, "you do not have permission to change the options for this group")
ManageForm = forms.form_for_instance(g, fields=('name','subtitle','acronym','preferred_name','project_leader','editor','logo','description','keywords','friends','defaultcss','forum'))
if request.method == 'POST':
new_data=request.POST.copy()
if new_data['submit']=='save':
mform = ManageForm(request.POST, request.FILES)
if mform.is_valid():
mform.save()
return HttpResponseRedirect('../')
else:
pform = PersonForm()
mbform = MemberForm()
elif new_data['submit']=='add':
mbform = MemberForm(request.POST)
r = Role.objects.get(role="")
if mbform.is_valid():
memberlist = mbform.cleaned_data['people']
for email in memberlist:
p = Person.objects.get(email=email)
if Membership.objects.filter(person=p, group=g).count() > 0:
pass
else:
m = Membership(person=p,group=g,role=r)
m.save()
return HttpResponseRedirect('../people/')
else:
pform = PersonForm()
mform = MemberForm()
elif new_data['submit']=='subscribe':
pform = PersonForm(request.POST)
personlist = new_data['people']
personlist = personlist.split('\n')
errorlist=[]
linereturns = u""
r = Role.objects.get(role="")
for line in personlist:
items=line.split(',')
if not len(items) == 2:
erroritem= items[0] + u': Line not formatted correctly'
errorlist.append(erroritem)
linereturns = linereturn(line,linereturns)
elif not len(items[1].split('@')) == 2:
erroritem= items [0] + u': Invalid email address'
errorlist.append(erroritem)
linereturns = linereturn(line,linereturns)
else:
firstname = items[0].split()[0]
lastname = ' '.join(items[0].split()[1:])
email = items[1].strip()
emailclash = Person.objects.filter(email=email).count() > 0
if emailclash:
erroritem = items[0] + u': Email already exists on the \
database. Find the user in the Existing Users \
form (above) and subscribe them that way'
errorlist.append(erroritem)
linereturns = linereturn(line,linereturns)
else:
p = Person(first_name=firstname,last_name=lastname, email=email)
p.save()
m = Membership(person=p,group=g,role=r)
m.save()
if not errorlist == []:
erroroutput = [u"The following people were not added, for the \
reasons stated:"]
for erroritem in errorlist:
erroroutput.append(erroritem)
pform._errors={"people": erroroutput}
formdata = {'people': linereturns}
if pform.is_valid():
return HttpResponseRedirect('../people/')
else:
mform=ManageForm()
mbform=MemberForm()
pform = PersonForm(formdata)
pform._errors={"people": erroroutput}
else:
pform = PersonForm()
mform = ManageForm()
mbform = MemberForm()
return render_to_response('groups/group_form.html',{"logo": logo, "group":g,
"css":css, "manageform":mform, "pform":pform, "mbform":mbform})
def edit_publication(request, **kwargs):
from esmg.people.models import Person
membership = False
group = kwargs.get("group", False)
if group:
g = Group.objects.get(acronym=group)
person = request.user.person
ms = person.membership_set.all()
pubinstance = kwargs.get("object_id", False)
PublicationForm = form_for_model(Publication)
if pubinstance:
try:
pub = Publication.objects.get(id=pubinstance)
except:
return error(request,u"Publication not found")
PubInstanceForm = form_for_instance(pub)
gss = Groupship.objects.filter(publication=pub)
if gss.count() > 0:
currentgroupships = gss
else:
currentgroupships = False
add = False
else:
add = True
currentgroupships = False
if request.method == 'POST':
uselessvar = kwargs.pop('ms', False)
if pubinstance:
pubform = PubInstanceForm(request.POST, request.FILES)
else:
pubform = PublicationForm(request.POST, request.FILES)
groupform = GroupshipForm(request.POST)
authorship_forms = AuthorshipForm.get_forms(request)
authorship_data = [authorship_form.render_js('from_template') for authorship_form in authorship_forms]
if authorship_forms.are_valid() and groupform.is_valid() and pubform.is_valid():
#if authorship_forms.are_valid() and pubform.is_valid():
publication = pubform.save()
if not groupform.cleaned_data['group_1'] == 'none':
grp = Group.objects.get(id=groupform.cleaned_data['group_1'])
gs = Groupship(group=grp,publication=publication)
gs.save()
if not groupform.cleaned_data['group_2'] == 'none':
grp = Group.objects.get(id=groupform.cleaned_data['group_2'])
gs = Groupship(group=grp,publication=publication)
gs.save()
if not groupform.cleaned_data['group_3'] == 'none':
grp = Group.objects.get(id=groupform.cleaned_data['group_3'])
gs = Groupship(group=grp,publication=publication)
gs.save()
for auth in Authorship.objects.filter(publication=publication):
auth.delete()
#out=[('keys',request.POST.keys())]
for form in authorship_forms:
#out.append(('form',form.postfix,form.id,form.cleaned_data['author'],form.cleaned_data['last_name']))
if not form.cleaned_data['author'] == 'no':
email = form.cleaned_data['author']
try:
p = Person.objects.get(email=email)
except:
return error(request,u'Something has gone wrong with \
the email addresses stored for authors the \
ResearcPages database. Please go back and try \
again. If this doesn\'t work please contact \
[email protected]')
a = Author.objects.get(person=p)
as = Authorship(author=a,publication=publication)
as.save()
elif not form.cleaned_data['last_name'] == '':
if (not form.cleaned_data['email'] == '') and Person.objects.filter(email=form.cleaned_data['email']).count() >0:
a = Author.objects.get(person=Person.objects.get(email=form.cleaned_data['email']))
else:
a, created = Author.objects.get_or_create(first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
email=form.cleaned_data['email'])
as = Authorship(author=a,publication=publication)
as.save()
else:
pass
if pubinstance:
return HttpResponseRedirect('../../' + str(publication.id))
else:
return HttpResponseRedirect('../' + str(publication.id))
else:
if pubinstance:
pubform = PubInstanceForm()
authorship_data = [AuthorshipForm(initial={'author':
authorship.author.get_form_author(),'first_name':authorship.author.first_name,'last_name':authorship.author.last_name,'email':authorship.author.email},
id=authorship.id).render_js('from_template') for authorship in
Authorship.objects.filter(publication=pub)]
else:
pubform = PublicationForm()
authorship_data = [AuthorshipForm(initial={'author': 'no'}).render_js('from_template')]
groupform = GroupshipForm(request.POST, ms)
if group:
css = g.defaultcss
logo = g.get_logo_url()
else:
css = settings.DEFAULT_CSS
logo = settings.DEFAULT_LOGO
return render_to_response('publications/publication_form.html',
{
'pubform': pubform,
'groupform': groupform,
'add': add,
'currentgroupships': currentgroupships,
'css':css, 'logo':logo, 'membership':membership,
'authorship_data': authorship_data,
'authorship_template':AuthorshipForm(initial={'author':
'no'}).render_js('from_template')},
RequestContext(request))
def editwiki(request, **kwargs):
wikipagecontent=False
#is this a group wiki?
group=kwargs.get("group", False)
if not group:
#if we want non-group wikis (i.e. top level) put stuff jere
raise Http404
try:
g = Group.objects.get(acronym=group)
except:
return error(request, "Couldn't find a group called " + group +". Please check the group name.")
slug = kwargs.get("slug", False)
groupwikihome = False
if not slug:
slug = ""
groupwikihome = True
try:
wikipage = WikiPage.objects.get(group=g, slug=slug)
create = False
try:
wikipagecontent = wikipage.wpcontent.latest()
except:
pass
except:
#we're creating a page
create = True
wikipage = None
if create:
WikiForm = form_for_model(WikiPage)
ContentForm = form_for_model(WikiPageContent)
else:
WikiForm = form_for_instance(wikipage)
if wikipagecontent:
ContentForm = form_for_instance(wikipagecontent)
else:
ContentForm = form_for_model(WikiPageContent)
if request.method == 'POST':
wform = WikiForm(request.POST)
wikipage = wform.save(commit=False)
if not wikipage.id:
#we're creating not editing
wikipage.groupwikihome = groupwikihome
wikipage.slug=slug
wikipage.group=g
wikipage.disabled=False
wikipage.locked_time=0
wikipage.locked_by=request.user.person
wikipage.save()
cform = ContentForm(request.POST)
content = cform.save(commit=False)
if content.version:
new_version = WikiPageContent(page=wikipage)
new_version.title = content.title
new_version.body = content.body
new_version.version = content.version+1
new_version.last_editor = request.user.person
new_version.page = wikipage
new_version.save()
else:
content.last_editor = request.user.person
content.page = wikipage
content.save()
return HttpResponseRedirect('../')
else:
if not create:
if not wikipage.locked_by or time() - float(wikipage.locked_time) > 200 or (wikipage.locked_by and wikipage.locked_by == request.user.person):
wikipage.locked_by = request.user.person
wikipage.locked_time = int(time())
wikipage.save()
else:
return error(request,"This wiki page is currently being edited by"
+ smart_unicode(wikipage.locked_by) + ". Please try again \
in a few minutes")
wform = WikiForm()
cform = ContentForm()
return render_to_response('wiki/wiki_form.html',
{
"create": create,
"wform": wform,
"cform": cform,
"group":g,
"wikipage":wikipage,
"logo":g.get_logo_url(),
})
def edit_trajectory(request, pattern_id, id):
pattern = get_object_or_404(Pattern, pk=pattern_id, author__pk=request.user.id)
value_forms = []
if request.method == "POST":
data = request.POST
else:
data = None
trajectory = get_object_or_404(FitnessTrajectory, pk=id, pattern__pk=pattern_id)
trajectory_type = trajectory.trajectory_type
functions = FitnessFunction.objects.filter(trajectory_type=trajectory_type)
functions = tuple([(function.id, str(function)) for function in functions])
TrajectoryForm = forms.form_for_instance(trajectory)
TrajectoryForm.base_fields['function'].widget = forms.widgets.Select(choices=functions)
#trajectory_values = eval("trajectory.fitnesstrajectory%s_set.all()" % trajectory_type)
trajectory_values = trajectory.trajectory_set
value_id = 1
for v in trajectory_values:
TrajectoryValueForm = forms.form_for_instance(v)
if trajectory_type == "coordinate":
TrajectoryValueForm.base_fields['sequence_number'].widget = TextHiddenInput(attrs={'value': v.sequence_number,
'display': COORDINATE_TRAJECTORY_NAMES[v.sequence_number]})
else:
TrajectoryValueForm.base_fields['instrument'].widget = TextHiddenInput(attrs={'value': v.instrument.id,
'display': v.instrument.name})
value_forms.append(TrajectoryValueForm(data, prefix=str(value_id)))
value_id += 1
form = TrajectoryForm(data)
if form.is_valid():
# Update trajectory
form.save()
# Update values
errors = []
valid_value_forms_count = 0
for f in value_forms:
if f.is_valid():
valid_value_forms_count += 1
value = f.save()
else:
errors.append(f.errors)
# Only commit changes if at least one of the value forms validated
if valid_value_forms_count > 0:
transaction.commit()
return HttpResponseRedirect(trajectory.get_absolute_url())
else:
transaction.rollback()
raise Exception(errors)
trajectory_types = dict(TRAJECTORY_TYPES)
title = heading = "Edit %s Trajectory" % trajectory_types[trajectory_type]
context = {'title': title,
'heading': heading,
'pattern': pattern,
'trajectory': trajectory,
'trajectory_type': trajectory_type,
'trajectory_types': TRAJECTORY_TYPES,
'form': form,
'value_forms': value_forms,
}
return render_to_response('fitbeats/edit_trajectory.html',
context,
context_instance=RequestContext(request))
def form(self):
return forms.form_for_instance(self.picture)
