def user_add(request):
"""
Add new GTS_User instance
(!) В данный момент не используется.
Пользователи заводятся в админ-части Джанго-сайта.
"""
error_message = ""
if request.method == "POST":
UserForm = form_for_model(GTS_User)
user_form = UserForm(request.POST)
if user_form.is_valid():
user_form.save()
return HttpResponseRedirect('/users/')
else:
error_message = "Form contain errors!" # % account_form.errors
else:
UserForm = form_for_model(GTS_User)
user_form = UserForm()
content = {"user_form" : user_form,
"error_message" : error_message,
}
return render_to_response("user_detail.html", content)
def device_add(request):
"Add new Device instance"
account = request.user.gts_user.account
error_message = ""
if request.method == "POST":
DeviceForm = form_for_model(Device)
device_form = DeviceForm(request.POST)
if device_form.is_valid():
new_device = device_form.save(False)
new_device.account = account
new_device.save()
return HttpResponseRedirect('/devices/')
else:
error_message = "Form contain errors!" # % account_form.errors
else:
DeviceForm = form_for_model(Device)
device_form = DeviceForm()
content = {"device_form" : device_form,
"error_message" : error_message,
}
return render_to_response("device_detail.html", content)
def add(request):
if request.method == 'GET':
form = forms.form_for_model(dw.MRProj)()
elif request.method == 'POST':
form = forms.form_for_model(dw.MRProj)(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 add(request):
if request.method == "GET":
form = forms.form_for_model(dw.MROrg)()
elif request.method == "POST":
form = forms.form_for_model(dw.MROrg)(request.POST)
if form.is_valid():
try:
form.save()
return HttpResponseRedirect("/org/")
except Exception, e:
logging.debug(unicode(e))
request.add_message(unicode(e))
def new_term(request, class_name):
Class = models.get_model('tm', class_name)
if request.method == 'GET':
new_term_form = forms.form_for_model(Class)()
else:
new_term_form = forms.form_for_model(Class)(request.POST)
if new_term_form.is_valid():
try:
new_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 add_condition(request, mark_id):
mark = km.Mark.objects.get(id=mark_id)
fields = ['name_cn', 'name_en', 'description', 'condition_field',
'judgetype', 'judgevalue', 'calculate_method']
if request.method == "GET":
forms.form_for_model(km.Condition, fields=fields)()
elif request.method == "POST":
forms.form_for_model(km.Condition, fields=fields)(request.POST)
if form.is_valid():
try:
condition = form.save(commit=False)
condition.mark = mark
condition.save()
except Exception, e:
logging.debug(unicode(e))
request.add_message(unicode(e))
def new_atm_doc(request):
"Creates a new ATM Document"
DocForm = form_for_model(AtmDocument)
if request.method == "POST":
doc_form = DocForm(request.POST)
if doc_form.is_valid():
# сохраняем новый документ
doc = doc_form.save(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]
# сохраняем карточку
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()
return default_renderer(request, "atm_doc", {'doc_form':doc_form})
def create(self, request):
"""
Creates a resource with attributes given by POST, then
redirects to the resource URI.
"""
# Create form filled with POST data
ResourceForm = forms.form_for_model(self.queryset.model,
form=self.form_class)
data = self.receiver.get_post_data(request)
form = ResourceForm(data)
# If the data contains no errors, save the model,
# return a "201 Created" response with the model's
# URI in the location header and a representation
# of the model in the response body.
if form.is_valid():
new_model = form.save()
model_entry = self.entry_class(self, new_model)
response = model_entry.read(request)
response.status_code = 201
response['Location'] = model_entry.get_url()
return response
# Otherwise return a 400 Bad Request error.
raise InvalidModelData(form.errors)
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 dane_z_pliku(request,klasa_id):
if not request.user.is_authenticated():return HttpResponseRedirect('/')
DaneForm = form_for_model(DaneUczniow)
form = DaneForm()
if request.POST or request.method == "POST":
new_data = request.POST.copy()
new_data.update(request.FILES)
form = DaneForm(new_data)
if form.is_valid() and new_data['plik']['filename'].split('.')[-1] == 'xls':
dirname = settings.MEDIA_ROOT+'files/lista uczniow/'
for f in os.listdir(dirname):
if new_data['plik']['filename']==f:
os.remove(dirname+f)
t = DaneUczniow()
t.opis = new_data['opis']
t.save_plik_file(new_data['plik']['filename'],new_data['plik']['content'])
Uczniowie_tmp.objects.filter(klasa=klasa_id).delete()
xlsfile=PyXLReader()
try:
xlsfile.read(dirname+new_data['plik']['filename'])
l = []
for sheetnumber, sheetdata in xlsfile.sheets.items()[:1]:
for row,cols in sheetdata['cells'].items():
numer = cols[1]
imie = cols[2]
nazwisko = cols[3]
grupa = Grupy_jezykowe.objects.get(nazwa=cols[4]).id
u = Uczniowie_tmp(numer=numer,imie=imie,nazwisko=nazwisko,klasa_id=klasa_id,grupa_id=grupa)
u.save()
return HttpResponseRedirect('/'+klasa_id+'/Lista uczniow/')
except:
return HttpResponse('Niepoprawny format pliku')
else: return render_to_response('dane_uczniow2.html',{'f':form},context_instance=RequestContext(request))
else: return render_to_response('dane_uczniow2.html',{'f':form},context_instance=RequestContext(request))
def upload_document(request, slug):
event = get_object_or_404(Event, slug=slug)
attendants = Attendant.objects.filter(event=event.id, user=request.user.id)
user_id_list = [a.user_id for a in attendants]
if not request.user.id in user_id_list:
staff_list = event.staff.all()
if not [a.id for a in staff_list if request.user.id == a.id]:
request.user.message_set.create(
message=_(u'Only Attendant or Staff can add document.'))
return HttpResponseRedirect(
reverse('event_detail', kwargs=dict(slug=slug)))
EventFileForm = forms.form_for_model(EventFile)
if request.method == "POST":
new_data = request.POST.copy()
print request.FILES
new_data.update({'event': event.id, 'user': request.user.id})
form = EventFileForm(new_data, request.FILES)
if form.is_valid():
form.save()
request.user.message_set.create(
message=_(u'Document upload successfully.'))
return HttpResponseRedirect(event.get_absolute_url())
else:
del EventFileForm.base_fields['user']
del EventFileForm.base_fields['event']
form = EventFileForm()
return render_to_response('event/upload_document.html',
context_instance=RequestContext(
request, {
'object': event,
'form': form
}))
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 add_pattern(request):
#fields = ('length', 'instruments', 'selector', 'crossover', 'mutators')
PatternForm = forms.form_for_model(Pattern)
if request.method == "POST":
data = request.POST
else:
data = None
form = PatternForm(data)
if form.is_valid():
pattern = Pattern(length=form.cleaned_data['length'],
selector=form.cleaned_data['selector'],
crossover=form.cleaned_data['crossover'],
author=request.user)
pattern.save()
pattern.instruments = form.cleaned_data['instruments']
pattern.mutators = form.cleaned_data['mutators']
pattern.save()
#mutators=form.cleaned_data['mutators'],
return HttpResponseRedirect(pattern.get_absolute_url())
title = heading = "Add Pattern"
context = {'title': title, 'heading': heading, 'form': form}
return render_to_response('fitbeats/edit_pattern.html',
context,
context_instance=RequestContext(request))
def story_comment(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)
if not story.allow_comments:
return HttpResponseForbidden("NO COMMENTS")
CommentForm = newforms.form_for_model(Comment)
if request.POST:
form = CommentForm(request.POST)
if form.is_valid():
new_comment = form.save(commit=False)
new_comment.creator = request.user
new_comment.story = story
new_comment.save()
return HttpResponseRedirect(new_comment.get_absolute_url())
form = CommentForm()
return render_to_response('blog/story/comment.html', {'form': form,
'story': story,
'blog': blog,
'title': 'Add Comment: %s - %s' % (story.title, blog.title)})
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 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 claim(request, slug):
event = get_object_or_404(Event, slug=slug)
attendants = Attendant.objects.filter(event=event.id)
user_id_list = [a.user_id for a in attendants]
AttendantForm = forms.form_for_model(Attendant)
if not event.is_claimable():
return HttpResponseRedirect(event.get_absolute_url())
if not request.user.id in user_id_list:
if request.method == "POST":
new_data = request.POST.copy()
new_data.update({
'user': request.user.id,
'event': event.id,
'cancel': False
})
form = AttendantForm(new_data)
if form.is_valid():
#attendant = Attendant()
#attendant.user = requeset.user
#attendant.event = event
#attendant.cancel = False
#attendant.pos_paper =
#attendant.cache_html = ""
#attendant.save()
form.save()
request.user.message_set.create(message=_(
u'You made a reservation to %(event_name)s . Check your status.'
) % {'event_name': event.name})
if event.max_people <= len(attendants):
request.user.message_set.create(message=_(
u'You are put on a waiting list for cancellation'))
return HttpResponseRedirect(event.get_absolute_url())
else:
del AttendantForm.base_fields['user']
del AttendantForm.base_fields['event']
del AttendantForm.base_fields['canceled']
AttendantForm.base_fields['pos_paper'].widget = forms.Textarea(
attrs={'cols': '80'})
AttendantForm.base_fields['pos_paper'].label = ''
form = AttendantForm(initial={'pos_paper': event.pos_paper})
if event.max_people <= len(attendants):
request.user.message_set.create(message=_(
u'Capacity is full already. You are going to putting on a waiting list for cancellation'
) % {'event_name': event.name})
request.user.message_set.create(
message=_(u'Will you attend %(event_name)s ?') %
{'event_name': event.name})
else:
request.user.message_set.create(
message=_('You already joined event "%(event_name)s".') %
{'event_name': event.name})
return HttpResponseRedirect(event.get_absolute_url())
return render_to_response('event/claim.html',
context_instance=RequestContext(
request, {
'object': event,
'form': form
}))
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 requisition(request):
RequisitionForm = forms.form_for_model(Requisition)
form = RequisitionForm()
title = 'Requisition'
return render_to_response(
'warehouse/requisition.html',
{'form': form,
'title': title},
context_instance=RequestContext(request)
)
def add_topic(request, forum_id):
if not request.user.is_authenticated():return HttpResponseRedirect('/')
"""
add topic
* forum_id - ID of a Forum entry
"""
k=form_for_model(Topic)
if request.POST:
page_data = request.POST.copy()
page_data['topic_author'] = str(request.user.get_full_name())
tags = findall( r'(?xs)\[code\](.*?)\[/code\]''', page_data['text'])
for i in tags:
page_data['text'] = page_data['text'].replace(u'[code]'+i+u'[/code]', u'[code]'+base64.encodestring(i)+u'[/code]')
page_data['text'] = html2safehtml(page_data['text'] ,valid_tags=settings.VALID_TAGS)
tags = findall( r'(?xs)\[code\](.*?)\[/code\]''', page_data['text'])
for i in tags:
page_data['text'] = page_data['text'].replace(u'[code]'+i+u'[/code]', u'[code]'+base64.decodestring(i)+u'[/code]')
text = page_data['text']
del page_data['text']
page_data['topic_name'] = html2safehtml(page_data['topic_name'] ,valid_tags=())
page_data['topic_forum'] = forum_id
page_data['topic_posts'] = 1
page_data['topic_lastpost'] = str(request.user.get_full_name())+'<br />' + str(datetime.today())[:-10]
page_data['topic_last_pagination_page'] = 1
page_data['topic_modification_date'] = datetime.now()
#form = AddTopicForm(page_data)
form = k(page_data)
if form.is_valid():
new_place = form.save()
post = Post(post_topic = new_place, post_text = text, post_author = str(request.user.get_full_name()), post_ip = request.META['REMOTE_ADDR'])
post.save()
forum = Forum.objects.get(id=forum_id)
forum.forum_topics = forum.forum_topics +1
forum.forum_posts = forum.forum_posts +1
forum.forum_lastpost = str(request.user.get_full_name())+'<br />' + str(datetime.today())[:-10] + '<br /><a href="/forum/topic/1/' + str(new_place.id) + '/">' + new_place.topic_name + '</a>'
forum.save()
#mail_admins('Temat Dodany', "Dodano Temat: http://www." + settings.SITE_KEY + "/forum/forum/" + forum_id +"/", fail_silently=True)
return HttpResponseRedirect("/forum/forum/" + forum_id +"/")
else:
return render_to_response(
'myghtyboard/add_topic.html',
{'form': form,'header':header, 'perms': list_perms(request)},
context_instance=RequestContext(request))
form = k()
return render_to_response(
'myghtyboard/add_topic.html',
{'form': form,'header':header, 'perms': list_perms(request)},
context_instance=RequestContext(request))
def create_form(self, request, queryset, form_class):
"""
Render form for creation of new collection entry.
"""
ResourceForm = forms.form_for_model(queryset.model, form=form_class)
if request.POST:
form = ResourceForm(request.POST)
else:
form = ResourceForm()
template_name = '%s/%s_form.html' % (self.template_dir, queryset.model._meta.module_name)
return render_to_response(template_name, {'form':form})
def new_stuff_item(request, model_name):
"New Organization"
ItemForm = form_for_model(eval(model_name))
new_item = None
if request.method == "POST":
item_form = ItemForm(request.POST)
if item_form.is_valid():
new_item = item_form.save(True)
return HttpResponseRedirect("/stuff/%s/list/" % model_name)
def account_add(request):
"Add new Account instance"
error_message = ""
if request.method == "POST":
AccountForm = form_for_model(Account)
account_form = AccountForm(request.POST)
if account_form.is_valid():
account_form.save()
return HttpResponseRedirect('/gts_accounts/')
else:
error_message = "Form contain errors!" # % account_form.errors
else:
AccountForm = form_for_model(Account)
account_form = AccountForm()
content = {"account_form" : account_form,
"error_message" : error_message,
}
return render_to_response("account_detail.html", content)
def create_form(self, request, queryset, form_class):
"""
Render form for creation of new collection entry.
"""
ResourceForm = forms.form_for_model(queryset.model, form=form_class)
if request.POST:
form = ResourceForm(request.POST)
else:
form = ResourceForm()
template_name = '%s/%s_form.html' % (self.template_dir,
queryset.model._meta.module_name)
return render_to_response(template_name, {'form': form})
def story_add(request, blogname):
blog = get_object_or_404(Blog, alias__exact=blogname)
allow = False
if request.user.is_authenticated():
try:
role = Role.objects.get(user__pk=request.user.id, blog__pk=blog.id)
if role.role in "AMC":
allow = True
except Role.DoesNotExist:
pass
if allow == False: # XXX redirect to login-page with next=/stories/add
error_message = "You must not create a story in this blog"
return HttpResponseRedirect('/members/login/')
StoryForm = newforms.form_for_model(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)
form = StoryForm(data)
if form.is_valid():
new_story = form.save(commit=False)
new_story.blog_id = blog.id
new_story.creator_id = request.user.id
new_story.save()
for tag in form.cleaned_data['tags']:
new_story.tags.add(tag)
return HttpResponseRedirect(new_story.get_absolute_url())
StoryForm.base_fields['tags'].widget = newforms.widgets.TextInput()
StoryForm.base_fields['tags'].help_text = ''
form = StoryForm()
print form.fields
form.fields['allow_comments'].initial = 1
form.fields['is_public'].initial = 1
return render_to_response('blog/story/add.html', {'form': form,
'title': 'Add Story: %s' % (blog.title),
'blog': blog},
context_instance=template.RequestContext(request))
def add_pro(request):
redirect_url = "/project/"
if request.method == "POST":
Form = form_for_model(OrgProj, fields=filter_fields(OrgProj))
form = Form(request.POST)
if form.is_valid():
obj = form.save(commit=False)
obj.create_time = datetime.date.today()
obj.update_time = datetime.date.today()
obj.create_by = request.user
obj.update_by = request.user
obj.save()
request.user.message_set.create(message=u"新增项目成功！")
return HttpResponseRedirect(redirect_url)
else:
context_data = {"form":form, "action_url":"/project/add/", "submit":u"保 存", "title":u"新建项目"}
return render_to_response("client/project/project_form.html", context_data,
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 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 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 create(request, model, decorator = lambda x:x,
post_save_redirect='', template_name=''):
"""
Generic view for object creation. Automatically
adds the current account to object.account, and
the current user to object.created_by.
Uses a newforms form generated from the model.
`decorator` is called on the form class to allow
customization.
"""
FormClass = decorator(
forms.form_for_model(
model,
fields = get_allowed_fields(request, model),
),
request,
)
template_name = template_name or _make_template_name(model, 'form')
if request.method == 'POST':
form = FormClass(request.POST)
if form.is_valid():
record = form.save(commit = False)
record.account = request.account
record.created_by = request.person
record.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 message_send(request,klasa_id,header,error=False):
"""Wysylanie wiadomosci za pomoca modelu Message oraz newforms(form_for_model)"""
if request.user.is_authenticated() :
if request.user.has_perm('e_dziennik.add_wiadomosci'):
MessageForm = form_for_model(Wiadomosci)
form = MessageForm()
form.fields['user'] = forms.GroupedChoiceField(choices=get_odbiorcy(klasa_id,'msg'))
if request.method == 'POST':
new_data = request.POST.copy()
new_data['user']= new_data['user'].strip('[]').split(',')[0]
new_data['sender']=request.user.get_full_name()
form = MessageForm(new_data)
if form.is_valid():
if new_data.has_key('sms'):
#wyslanie sms-a
import sms_orangembox
from sms_orangembox import *
phones=[]
for e in request.POST['user'].strip('[]').split(','):
u = User.objects.get(id = e)
if u.mobile_phone != None:phones.append(u.mobile_phone)
if len(phones)==0:error=True
else:
for n in phones:sendsms(new_data['sender'],str(n),new_data['message'])
else:
#wyslanie wiadomosci
new_msg=form.save(commit=False)
new_msg.multi_msg(request.POST['user'].strip('[]').split(','))
return render_to_response('msg/message_send_done.html',{'path':request.path,'error':error},
context_instance=RequestContext(request))
else:
form.fields['user'] = forms.GroupedChoiceField(choices=get_odbiorcy(klasa_id,'msg'))
return render_to_response('msg/message_send_form.html',
{'f':form},context_instance=RequestContext(request))
else:
return render_to_response('msg/message_send_form.html',{'f':form,'header':header},
context_instance=RequestContext(request))
else:
#raise Http404
return HttpResponseRedirect('/perm/wiadomosci/')
else: return HttpResponseRedirect("/")
def dodaj_uwage(request,uczen_id):
if not request.user.is_authenticated():return HttpResponseRedirect('/')
if not request.user.has_perm('e_dziennik.add_uwagi'): return HttpResponse(perm_denied(request,klasa_id,model='Uwagi'))
uczen = Uczniowie_tmp.objects.get(id=uczen_id)
UwagaForm = form_for_model(Uwagi)
form = UwagaForm()
if request.POST:
new_data = request.POST.copy()
new_data['uczen']=uczen_id
new_data['wystawil']=request.user.id
form = UwagaForm(new_data)
if form.is_valid():
new_msg=form.save()
return HttpResponseRedirect('/'+uczen_id+'/sprawdz/uwagi/')
else:
form.fields['typ']=forms.ChoiceField(choices=TYPES,widget=forms.RadioSelect)
return render_to_response('uwagi_form.html',{'f':form,'uczen':uczen},context_instance=RequestContext(request))
else:
form.fields['typ']=forms.ChoiceField(choices=TYPES,widget=forms.RadioSelect)
return render_to_response('uwagi_form.html',{'f':form,'uczen':uczen},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 create(request,
model,
decorator=lambda x: x,
post_save_redirect='',
template_name=''):
"""
Generic view for object creation. Automatically
adds the current account to object.account, and
the current user to object.created_by.
Uses a newforms form generated from the model.
`decorator` is called on the form class to allow
customization.
"""
FormClass = decorator(
forms.form_for_model(
model,
fields=get_allowed_fields(request, model),
),
request,
)
template_name = template_name or _make_template_name(model, 'form')
if request.method == 'POST':
form = FormClass(request.POST)
if form.is_valid():
record = form.save(commit=False)
record.account = request.account
record.created_by = request.person
record.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 add_trajectory(request, pattern_id, trajectory_type):
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
functions = FitnessFunction.objects.filter(trajectory_type=trajectory_type)
functions = tuple([(function.id, str(function)) for function in functions])
TrajectoryForm = forms.form_for_model(FitnessTrajectory)
TrajectoryForm.base_fields['function'].widget = forms.widgets.Select(choices=functions)
TrajectoryValueForm = eval("forms.form_for_model(FitnessTrajectory%s)" % trajectory_type.capitalize())
if trajectory_type == "coordinate":
form_count = 4
for i in xrange(0, form_count):
TrajectoryValueForm.base_fields['sequence_number'].widget = TextHiddenInput(attrs={'value': i,
'display': COORDINATE_TRAJECTORY_NAMES[i]})
value_forms.append(TrajectoryValueForm(data, prefix=str(i)))
else:
value_id = 1
for instrument in pattern.instruments.all().order_by('sequence_number'):
TrajectoryValueForm.base_fields['instrument'].widget = TextHiddenInput(attrs={'value': instrument.id,
'display': instrument.name})
value_forms.append(TrajectoryValueForm(data, prefix=str(value_id)))
value_id += 1
form = TrajectoryForm(data)
if form.is_valid():
# Add trajectory
trajectory = FitnessTrajectory(pattern=pattern,
function=form.cleaned_data['function'],
trajectory_type=trajectory_type)
trajectory.save()
# Add values
errors = []
valid_value_forms_count = 0
for f in value_forms:
if f.is_valid():
valid_value_forms_count += 1
value = f.save()
value.trajectory = trajectory
value.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()
trajectory_types = dict(TRAJECTORY_TYPES)
title = heading = "Add %s Trajectory" % trajectory_types[trajectory_type]
context = {'title': title,
'heading': heading,
'pattern': pattern,
'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))
"""
Apply views.
"""
__revision__ = "$Rev$"
__date__ = "$Date$"
__author__ = "$Author$"
from django.http import HttpResponseRedirect
from django.template import RequestContext
from django.shortcuts import render_to_response
from django.contrib.auth.decorators import login_required
from django import newforms as forms
from shotserver04.apply.models import Applicant
ApplicantForm = forms.form_for_model(Applicant)
@login_required
def apply(http_request):
"""
Partner application form.
"""
form_title = "Want to join Browsershots?"
form_action = '/apply/'
form = ApplicantForm(http_request.POST or None)
form_submit = "submit"
form_extra_before = '<p class="admonition warning">%s<p>' % ' '.join((
"This page is only a mock-up.",
"Your info will not be saved.",
"Please try again later.",
from django.db import models
from django import newforms as forms
from django.newforms import form_for_model
from xbaydnsweb.web.models import ViewMatch
class SmartModel(models.Model):
"""SmartModel"""
now_viewmatch = models.ManyToManyField(ViewMatch,
filter_interface=models.HORIZONTAL)
def __str__(self):
return "SmartModel"
SmartForm = form_for_model(SmartModel)
#class SmartForm(forms.Form):
# vm=forms.ModelMultipleChoiceField(queryset=ViewMatch.objects.all())
def consorcio_detail(request, consorcio_id):
"""muestra el detalle del consorcio y sus balances"""
consorcio = Consorcio.objects.get(id=consorcio_id)
deptos = Depto.objects.filter(consorcio=consorcio_id)
balances = Balance.objects.filter(
consorcio=consorcio_id).order_by("-fecha_vencimiento")
return render_to_response('balance/consorcio_detail.html', {
'consorcio': consorcio,
'deptos': deptos,
'balances': balances
})
FormBalanceNew = forms.form_for_model(Balance,
fields=('fecha_vencimiento',
'observacion'))
def balance_new(request, consorcio_id):
"""vista de formulario para generar un nuevo balance para el consorcio."""
consorcio = Consorcio.objects.get(id=consorcio_id)
if request.method == 'POST':
#procesado de Formularios.
form_nuevo_balance = FormBalanceNew(request.POST)
if form_nuevo_balance.is_valid():
#TODO verificar que no exista un balance para el mismo mes/año
instance = form_nuevo_balance.save(
commit=False) #hago un save falso para guardar los demas datos
instance.consorcio = consorcio
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'))
CommentForm = forms.form_for_model(EventComment)
def add_comment(request, slug):
event = get_object_or_404(Event, slug=slug)
attendants = Attendant.objects.filter(event=event.id)
user_id_list = [a.user_id for a in attendants]
if not request.user.id in user_id_list:
staff_list = event.staff.all()
if not [a.id for a in staff_list if request.user.id == a.id]:
request.user.message_set.create(
message=_(u'Only Attendant or Staff can add comment.'))
return HttpResponseRedirect(
reverse('event_detail', kwargs=dict(slug=slug)))
if request.method == "POST":
new_data = request.POST.copy()
