def QuestAnswerAdd(request, name):
context = RequestContext(request)
n = name
add = 0
answer_form = AnswerForm()
er = []
quest = get_object_or_404(Question, id=n)
if request.method == 'POST':
answer_form = AnswerForm(data=request.POST)
if answer_form.is_valid():
answer = answer_form.save(commit=False)
answer._setAdd(request.user)
#quest._setActiveFalse()
answer._setLink(quest.link)
answer._setActiveTrue()
answer._setQuest(quest)
answer.save()
add = 1
else:
er.append(answer_form.errors)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'answer_form': answer_form,
'er': er,
'add': add,
'quest': quest
}
return render_to_response((template() + '/questsions/addAnswer.html'),
dict, context)
def QuestCategoryAdd(request):
context = RequestContext(request)
add = 0
category_form = CategoryForm()
er = []
if request.method == 'POST':
category_form = CategoryForm(data=request.POST)
if category_form.is_valid():
cat = category_form.save(commit=False)
cat._setAdd(request.user)
cat._setLink(cat.name)
cat.save()
add = 1
else:
er.append(category_form.errors)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'quest_form': category_form,
'er': er,
'add': add
}
return render_to_response((template() + '/questsions/addCategory.html'),
dict, context)
def EditMessage(request, name):
context = RequestContext(request)
dict = {'template': template(), 'footer_dc' : footer_dc()}
return render_to_response(( template() + '/conf/addMessage.html'), dict, context)
def ConfMessage(request):
context = RequestContext(request)
pag = pagination_message(request)
dict = {'template': template(), 'footer_dc' : footer_dc(), 'pag' : pag }
return render_to_response(( template() + '/conf/confMessage.html'), dict, context)
def ConfRegister(request):
context = RequestContext(request)
conf_dc = get_list_or_404(RegisterConfig_dc_items)
dict = {'template': template(), 'footer_dc' : footer_dc(), 'conf_dc' : conf_dc }
return render_to_response(( template() + '/conf/confRegister.html'), dict, context)
def QuestCategoryConf(request):
context = RequestContext(request)
pag = pagination_quest_category_conf(request)
dict = {'template': template(), 'footer_dc': footer_dc(), 'pag': pag}
return render_to_response((template() + '/questsions/confCategory.html'),
dict, context)
def ConfPubPublications(request):
context = RequestContext(request)
pag = pagination_pub_conf_publications(request)
dict = {'template': template(), 'footer_dc': footer_dc(), 'pag': pag}
return render_to_response(
(template() + '/publications/confPublications.html'), dict, context)
def PubPublicationsEdit(request, name):
context = RequestContext(request)
cat = getCategoryItems()
edit = get_object_or_404(PubPublications, link=name)
ed = 0
pub_form = PubPublicationsForms()
er = []
if request.method == 'POST':
pub_form = PubCategoryForms(data=request.POST)
if pub_form.is_valid():
#edit = category_form.save(commit=False)
edit.name = request.POST['name']
edit.descriptions = request.POST['descriptions']
edit._setMod(request.user)
edit._setLink(request.POST['name'])
if 'category' in request.POST:
edit.category = get_object_or_404(PubCategory,
id=request.POST['category'])
if 'active' in request.POST:
edit._setActiveTrue()
else:
edit._setActiveFalse()
if 'temporary' in request.POST:
edit._setTemporaryTrue()
edit.start_date = request.POST['start_date'] #datetime.now()
edit.end_date = request.POST['end_date'] #datetime.now()
else:
edit._setTemporaryFalse()
edit.start_date = None
edit.end_date = None
edit.save()
ed = 1
else:
er.append(pub_form.errors)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'pub_form': pub_form,
'er': er,
'ed': ed,
'edit': edit,
'cat': cat
}
return render_to_response(
(template() + '/publications/editPublications.html'), dict, context)
def PubPublicationsItem(request, name):
context = RequestContext(request)
pubs = get_object_or_404(PubPublications, link=name)
att = PubAttachments.objects.filter(pub=pubs.id, deleted=0, active=1)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'pub': pubs,
'att': att
}
return render_to_response((template() + '/publications/publications.html'),
dict, context)
def PubAttatchemntsConf(request, name):
context = RequestContext(request)
edit = get_object_or_404(PubPublications, link=name)
pag = pagination_pub_conf_Attatchemnts(request, name)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'pag': pag,
'edit': edit
}
return render_to_response(
(template() + '/publications/confAttatchemnts.html'), dict, context)
def QuestionsCategory(request):
context = RequestContext(request)
cat = getCategoryItems()
quest = getCategoryItemsCountQuest(cat)
pag = pagination_quest_category(request)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'pag': pag,
'quest': quest
}
return render_to_response((template() + '/questsions/category.html'), dict,
context)
def answerForQuest(request, name):
context = RequestContext(request)
n = name
answer = get_object_or_404(QuestAnswer, link=n)
quest = get_object_or_404(Question, id=answer.quest.id)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'answer': answer,
'quest': quest
}
return render_to_response((template() + '/questsions/answerForQuest.html'),
dict, context)
def AddPubAttatchments(request, name):
context = RequestContext(request)
edit = get_object_or_404(PubPublications, link=name)
types = get_list_or_404(PubTypesAttachments, active=1)
add = 0
atta_form = PubAttatchemntsForms()
er = []
if request.method == 'POST':
atta_form = PubAttatchemntsForms(data=request.POST)
if atta_form.is_valid():
atta = atta_form.save(commit=False)
#_types = get_object_or_404(PubTypesAttachments, name = request.POST['types'])
atta.types = get_object_or_404(PubTypesAttachments,
id=request.POST['types'])
atta.pub = edit
if 'active' in request.POST:
atta._setActiveTrue()
else:
atta._setActiveFalse()
if 'files' in request.FILES:
atta.files = request.FILES['files']
atta._setAdd(request.user)
atta._setLink(atta.name)
atta.save()
add = 1
else:
er.append(atta_form.errors)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'atta_form': atta_form,
'er': er,
'add': add,
'edit': edit,
'types': types
}
return render_to_response(
(template() + '/publications/AddPubAttatchments.html'), dict, context)
def PubForCategory(request, name):
context = RequestContext(request)
pag = pagination_pub_for_category(request, name)
cat = get_object_or_404(PubCategory, link=name)
att = getAttatchmentsItemsCountPublications(pag)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'pag': pag,
'cat': cat,
'att': att
}
return render_to_response(
(template() + '/publications/publicationsForCategory.html'), dict,
context)
def QuestCategoryEdit(request, name):
context = RequestContext(request)
edit = get_object_or_404(QuestCategory, link=name)
ed = 0
category_form = CategoryForm()
er = []
if request.method == 'POST':
category_form = CategoryForm(data=request.POST)
if category_form.is_valid():
#edit = category_form.save(commit=False)
edit.name = request.POST['name']
edit.descriptions = request.POST['descriptions']
edit.status = request.POST['status']
edit._setAdd(request.user)
edit._setLink(request.POST['name'])
if 'active' in request.POST:
edit._setActiveTrue()
else:
edit._setActiveFalse()
edit.save()
ed = 1
else:
er.append(category_form.errors)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'quest_form': category_form,
'er': er,
'ed': ed,
'edit': edit
}
return render_to_response((template() + '/questsions/editCategory.html'),
dict, context)
def AddPubPublications(request):
context = RequestContext(request)
cat = getCategoryItems()
add = 0
pub_form = PubPublicationsForms()
er = []
if request.method == 'POST':
pub_form = PubPublicationsForms(data=request.POST)
if pub_form.is_valid():
pub = pub_form.save(commit=False)
pub._setAdd(request.user)
pub._setLink(pub.name)
if 'active' in request.POST:
pub._setActiveTrue()
else:
pub._setActiveFalse()
if 'temporary' in request.POST:
pub._setTemporaryTrue()
pub.start_date = request.POST['start_date'] #datetime.now()
pub.end_date = request.POST['end_date'] #datetime.now()
pub.save()
add = 1
else:
er.append(pub_form.errors)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'pub_form': pub_form,
'er': er,
'add': add,
'cat': cat
}
return render_to_response(
(template() + '/publications/addPublications.html'), dict, context)
def QuestionsForCat(request, name):
context = RequestContext(request)
cat = get_object_or_404(QuestCategory, link=name)
answer_items = []
if request.user.id is None:
quest_items = Question.objects.filter(active=1,
deleted=0,
category=cat)
else:
if request.user.is_authenticated and request.user.userprofile.status.id == 1:
quest_items = Question.objects.filter(deleted=0, category=cat)
for e in quest_items:
k = {}
k['quest_id'] = e.id
k['answer'] = QuestAnswer.objects.filter(deleted=0, quest=e.id)
answer_items.append(k)
#getAnswerForQuest_items(quest_items)
else:
quest_items = Question.objects.filter(active=1,
deleted=0,
category=cat)
for e in quest_items:
k = {}
k['quest_id'] = e.id
k['answer'] = QuestAnswer.objects.filter(deleted=0, quest=e.id)
answer_items.append(k)
pag = pagination_quest_for_category(request, quest_items)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'cat': cat,
'pag': pag,
'answer_items': answer_items
}
return render_to_response(
(template() + '/questsions/questionsForCat.html'), dict, context)
def AddMessage(request):
context = RequestContext(request)
#conf_dc = get_list_or_404(MessageConfig_dc_items)
add = 0
message_form = MessageForm()
er = []
if request.method == 'POST':
message_form = MessageForm(data=request.POST)
if message_form.is_valid():
message = message_form.save(commit=False)
message._setAdd(request.user)
message.save()
add = 1
else:
er.append(message_form.errors)
dict = {'template': template(), 'footer_dc' : footer_dc(), 'message_form' : message_form, 'er' : er, 'add' : add }
return render_to_response(( template() + '/conf/addMessage.html'), dict, context)
def QuestAdd(request, name):
context = RequestContext(request)
add = 0
quest_form = QuestForm()
#captcha_form = CaptchaForm()
er = []
cat = get_object_or_404(QuestCategory, link=name)
if request.method == 'POST':
quest_form = QuestForm(data=request.POST)
if quest_form.is_valid():
quest = quest_form.save(commit=False)
#quest._setAdd(request.user)
quest._setAdd()
quest._setCategory(cat)
#quest._setActiveFalse()
quest._setLink(quest.category)
quest._setActiveTrue()
quest.save()
add = 1
else:
er.append(quest_form.errors)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'quest_form': quest_form,
'er': er,
'add': add,
'cat': cat
}
return render_to_response((template() + '/questsions/addQuest.html'), dict,
context)
def AddPubCategory(request):
context = RequestContext(request)
add = 0
category_form = PubCategoryForms()
er = []
if request.method == 'POST':
category_form = PubCategoryForms(data=request.POST)
if category_form.is_valid():
cat = category_form.save(commit=False)
cat._setAdd(request.user)
cat._setLink(cat.name)
if 'active' in request.POST:
cat._setActiveTrue()
else:
cat._setActiveFalse()
if 'temporary' in request.POST:
cat.start_date = request.POST['start_date'] #datetime.now()
cat.end_date = request.POST['end_date'] #datetime.now()
cat.save()
add = 1
else:
er.append(category_form.errors)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'category_form': category_form,
'er': er,
'add': add
}
return render_to_response((template() + '/publications/addCategory.html'),
dict, context)
