def editBookmark(self, user, newtitle, newdesc, newtags):
# preserva tags anteriores
old_tags = self.tags
self.title = newtitle
self.description = newdesc
self.tags = newtags
self.alterado_por = user
self.data_alt = str(datetime.now())
self.save()
# compara as tags anteriores com as modificadas, atualizando a lista de tags no BD
data_tag = str(datetime.now())
if self.title:
nome = self.title
else:
url = self.url
url = remove_special_chars(remove_diacritics(url.replace(" ","_")))
nome = url
for tag in self.tags:
if tag not in old_tags:
addTag(tag, self.registry_id, user, "bookmarks", self.id, nome, data_tag)
for tag in old_tags:
if tag not in self.tags:
removeTag(remove_diacritics(tag.lower()), "bookmarks", self.id)
def post(self, registry_id):
user = self.get_current_user()
type = self.get_argument("type","")
_group = model.Group()
msg = ""
_group.titulo = self.get_argument("titulo","")
if _group.titulo == "":
msg += u"O nome do grupo não pode ser vazio.<br/>"
else:
_group.name_id = remove_special_chars(remove_diacritics(_group.titulo.replace(" ","_")))
if _group.name_id == "":
msg += u"Nome do grupo inválido<br/>"
if msg:
self.render("modules/activity/newgroup-form.html", NOMEPAG=u"atividades", \
GRUPO=_group, \
REGISTRY_ID=registry_id, MSG=msg)
return
doc_id = uuid4().hex
_group.data_cri = str(datetime.now())
_group.service="activity"
_group.type="group"
_group.registry_id = registry_id
_group.owner = user
_group.save(id=doc_id)
log.model.log(user, u'criou um grupo de atividades em', objeto=registry_id, tipo="activity", link="/activity/%s"%registry_id)
self.render("modules/activity/newgroup-form.html", NOMEPAG=u"atividades", \
GRUPO=model.Group(), \
REGISTRY_ID=registry_id, MSG="O grupo foi criado com sucesso")
def post(self):
user = self.get_current_user()
formdata = _EMPTYREQUESTINVITEFORM()
erros = 0
msg = ""
for key in _REQUESTINVITEFORM:
if self.get_argument(key, "") != "" :
formdata[key] = self.get_argument(key)
else:
erros += 1
if erros > 0:
msg += u"Há %d campos obrigatórios não preenchidos!<br/>" % erros
if formdata["titulo"]!="":
formdata["nome"] = remove_special_chars(remove_diacritics(formdata["titulo"].replace(" ","_")))
if formdata["nome"]=="":
msg += u"Título do formulário inválido.<br/>"
if msg:
self.render("modules/invites/create-form-invite.html", REGISTRY_ID=user, \
FORMDATA=formdata, \
MSG=msg,\
NOMEPAG="convites")
else:
formdata["owner"] = user
formdata["data_cri"] = str(datetime.now())
formdata["data_alt"] = formdata["data_cri"]
id = "%s/%s" % (user, formdata["nome"])
model.REQUESTINVITEFORM[id] = formdata
showInvitesPage(self, user, "")
def post(self, registry_id):
user = self.get_current_user()
self._blog = model.Blog()
msg = ""
self._blog.titulo = self.get_argument("titulo","")
if self._blog.titulo == "":
msg += u"O título do Post não pode ser vazio.<br/>"
else:
self._blog.post_id = remove_special_chars(remove_diacritics(self._blog.titulo.replace(" ","_")))
if self._blog.post_id == "":
msg += u"Título do Post inválido<br/>"
self._blog.tags = splitTags(self.get_argument("tags",""))
self._blog.conteudo = self.get_argument("conteudo","")
if self._blog.conteudo == "":
msg += u"O conteúdo do Post não pode ser vazio.<br/>"
if msg:
self.render("modules/blog/blog-form.html", NOMEPAG="blog", REGISTRY_ID=registry_id, BLOGDATA=self._blog, MSG=msg)
return
else:
self._blog.data_cri = str(datetime.now())
self._blog.data_alt = self._blog.data_cri
# A chave _id do documento no couchdb é nome/pagina
doc_id = '/'.join([registry_id,self._blog.post_id])
self._blog.registry_id = registry_id
self._blog.owner = user
historico_inicial = dict()
historico_inicial["data_alt"] = self._blog.data_alt
historico_inicial["alterado_por"] = user
historico_inicial["conteudo"] = self._blog.conteudo
self._blog.historico.append(historico_inicial)
try:
self._blog.save(id=doc_id)
except Exception as detail:
self.render("modules/blog/blog-form.html", NOMEPAG="blog", REGISTRY_ID=registry_id, BLOGDATA=self._blog, \
MSG=u"Já existe um post com este título.")
return
data_tag = str(datetime.now())
for tag in self._blog.tags:
addTag(tag, registry_id, user, "blog", doc_id, self._blog.titulo, data_tag)
log.model.log(user, u'escreveu no blog', objeto=doc_id, tipo="blog")
self.redirect("/blog/%s" % doc_id)
def post(self, registry_id):
user = self.get_current_user()
msg = ""
_topic = model.Topic()
_topic.titulo = self.get_argument("titulo","")
if _topic.titulo == "":
msg += u"O título do tópico não pode ser vazio.<br/>"
else:
_topic.name_id = remove_special_chars(remove_diacritics(_topic.titulo.replace(" ","_")))
if _topic.name_id == "":
msg += u"Título do tópico inválido<br/>"
if model.Topic.exists(registry_id, _topic.name_id):
msg += u"Já existe um tópico com este nome"
_topic.tags = splitTags(self.get_argument("tags",""))
_topic.conteudo = self.get_argument("conteudo","")
if _topic.conteudo == "":
msg += u"O conteúdo do tópico não pode ser vazio.<br/>"
if msg:
self.render("modules/forum/forum-form.html", NOMEPAG="forum", REGISTRY_ID=registry_id, TOPICO=_topic, MSG=msg)
return
else:
_topic.receber_email = self.get_argument("receber_email", "N")
_topic.data_cri = str(datetime.now())
_topic.data_alt = _topic.data_cri
_topic.service = "forum"
_topic.type = "topic"
doc_id = uuid4().hex
_topic.registry_id = registry_id
_topic.owner = user
_topic.alterado_por = user
try:
_topic.save(id=doc_id)
except Exception as detail:
self.render("modules/forum/forum-form.html", NOMEPAG="forum", REGISTRY_ID=registry_id, TOPICO=_topic, \
MSG=u"Já existe um tópico neste forum com este título.")
return
data_tag = str(datetime.now())
for tag in _topic.tags:
addTag(tag, registry_id, user, "forum", registry_id+"/"+_topic.name_id, _topic.titulo, data_tag)
log.model.log(user, u'criou um tópico no forum', objeto=registry_id, tipo="forum")
self.redirect("/forum/%s" % registry_id)
def saveBookmark(self, id=None):
self.save(id=id)
# atualiza tabela de tags
# vai para o tags.model
data_tag = str(datetime.now())
for tag in self.tags:
if self.title:
nome = self.title
else:
url = self.url
url = remove_special_chars(remove_diacritics(url.replace(" ","_")))
nome = url
addTag(tag, self.registry_id, self.owner, "bookmarks", self.id, nome, data_tag)
def post(self, registry_id):
user = self.get_current_user()
_atividade = model.Activity()
msg = ""
_atividade.titulo = self.get_argument("titulo","")
if _atividade.titulo == "":
msg += u"O nome da atividade não pode ser vazio.<br/>"
else:
_atividade.name_id = remove_special_chars(remove_diacritics(_atividade.titulo.replace(" ","_")))
if _atividade.name_id == "":
msg += u"Título da atividade inválido<br/>"
_atividade.group_id = self.get_argument("id","")
if _atividade.group_id == "":
msg += u"O grupo da atividade não foi informado.<br/>"
if msg:
self.render("modules/activity/activity-form.html", NOMEPAG=u"atividades", \
ATIVIDADE=_atividade, \
GROUP=_atividade.group_id, \
REGISTRY_ID=registry_id, MSG=msg)
return
#verifica se o registry é usuário ou comunidade
if registry_id == user:
_atividade.subtype="user"
else:
_atividade.subtype="comunity"
doc_id = uuid4().hex
#_atividade.observacao = self.get_argument("observacao",'')
_atividade.data_cri = str(datetime.now())
_atividade.data_start = short_datetime(_atividade.data_cri, include_separator=" ")
_atividade.data_end = ""
_atividade.encarregados.append(user)
_atividade.prioritario = self.get_argument("prioritario",'N')
_atividade.status = u"pendente"
_atividade.service="activity"
_atividade.type="activity"
_atividade.registry_id = registry_id
_atividade.owner = user
log.model.log(user, u'criou uma atividade em', objeto=registry_id, tipo="activity",link="/activity/%s"%registry_id)
_atividade.save(id=doc_id)
self.render("modules/activity/activity-form.html", NOMEPAG=u"atividades", \
ATIVIDADE=model.Activity(), \
GROUP=_atividade.group_id, \
REGISTRY_ID=registry_id, MSG="A atividade foi criada com sucesso")
def post(self, registry_id):
user = self.get_current_user()
_va = model.Videoaula()
msg = ""
_va.titulo = self.get_argument("name","")
if _va.titulo == "":
msg += u"Nome da videoaula não preenchido.<br/>"
_va.arqvideo = self.get_argument("arqvideo","")
if _va.arqvideo == "":
msg += u"Arquivo de vídeo não preenchido.<br/>"
_va.tags = splitTags(self.get_argument("tags",""))
_va.service = "videoaula"
_va.type = "videoaula"
_va.registry_id = registry_id
_va.name_id = remove_special_chars(remove_diacritics(_va.titulo.replace(" ","_")))
if model.Videoaula.exists(_va.registry_id, _va.name_id):
msg += u"Já existe uma videoaula com este nome"
if msg:
self.render("modules/videoaula/videoaula-form.html", NOMEPAG="videoaulas", VIDEODATA=_va, \
FOLDERS = files.model.Files.listFolders(user, registry_id, "files/all_data"), \
REGISTRY_ID=registry_id, MSG=msg)
return
else:
doc_id = uuid4().hex
_va.owner = user
#_va.alterado_por = user
_va.data_cri = str(datetime.now())
_va.data_alt = _va.data_cri
_va.save(id=doc_id)
# Adiciona tags da videoaula ao banco de tags.
data_tag = str(datetime.now())
for tag in _va.tags:
addTag(tag, registry_id, user, "videoaula", registry_id+"/"+_va.name_id, str_limit(remove_html_tags(_va.titulo), 50), data_tag)
log.model.log(user, u'criou videoaula em', objeto=registry_id, tipo="videoaula",link="/videoaula/%s/%s"%(registry_id,_va.name_id))
self.redirect("/videoaula/edit/%s/%s" % (registry_id,_va.name_id))
def post(self, registry_id):
user = self.get_current_user()
if not isUserOrMember(user, registry_id):
self.render("home.html", MSG=u"Você não tem permissão para criar termos neste glossário.", \
NOMEPAG=NOME_PAG_CLOSSARIO, REGISTRY_ID=registry_id)
return
MSG = ""
glossary_term = self.get_argument("term","")
if not glossary_term:
MSG += u"Termo não pode ser vazio."
glossary_definition = self.get_argument("definition","")
if not glossary_definition:
MSG += u"%sA definição do termo não pode estar vazia." % ("" if not MSG else "<br/>")
if not MSG:
glossary_item_id = remove_special_chars(remove_diacritics(glossary_term.replace(" ","_")))
if model.Glossary.searchItemByRegistryIdAndItemId(user, registry_id, glossary_item_id, False):
MSG += u"Termo já definido neste glossário."
if MSG:
self.render("modules/glossary/new_glossary_item-form.html", \
NOMEPAG=NOME_PAG_CLOSSARIO, DEFINITION=glossary_definition, REGISTRY_ID=registry_id, MSG=MSG)
return
else:
self._glossary = model.Glossary()
self._glossary.id = '/'.join([registry_id,glossary_item_id])
self._glossary.registry_id = registry_id
self._glossary.owner = user
self._glossary.item_id = glossary_item_id
self._glossary.term = self.get_argument("term","")
self._glossary.definition = glossary_definition
self._glossary.tags = splitTags(self.get_argument("tags",""))
self._glossary.data_cri = self._glossary.data_alt = str(datetime.now())
self._glossary.alterado_por = user
self._glossary.saveGlossaryItem(glossary_item_id)
log.model.log(user, u'criou um termo no glossário de', objeto=registry_id, tipo="glossary")
self.redirect("/glossary/%s" % registry_id)
def post(self, registry_id):
user = self.get_current_user()
if self.request.files:
# este split é para resolver o problema do IE, que manda o caminho completo.
filename = self.request.files["arquivo"][0]["filename"].split("\\")[-1]
#filename = remove_diacritics(filename)
#filename = filename.replace(" ", "_")
filename = remove_special_chars(remove_diacritics(filename.replace(" ","_")))
if filename=="":
self.write (dict(status=1, msg=u"Nome do arquivo inválido."))
return
if filename[0]=="_":
self.write (dict(status=1, msg=u"Nome do arquivo não pode iniciar com sublinhado (_)."))
return
if "." not in filename or filename.split(".")[-1].lower() not in ["gif", "jpg", "jpeg", "png"]:
self.write (dict(status=1, msg=u"Utilize somente arquivos com extensão: gif, jpg, jpeg ou png."))
return
if registry_id in core.database.REGISTRY:
if not isUserOrMember(user, registry_id):
self.write (dict(status=1, MSG=u"Você não tem permissão para carregar arquivos aqui."))
return
# A chave _id do documento no couchdb é nome/arquivo
file_id = '/'.join([registry_id,filename])
self._file = model.Studio().retrieve(file_id)
if self._file:
self.write (dict(status=1, MSG=u"Já existe um arquivo com este mesmo nome (%s). Remova-o antes de subir com uma nova versão." % file_id))
return
else:
self._file = model.Studio(file_id=file_id)
if self.get_argument("type","")=="":
self.write (dict(status=1, MSG=u"Escolha a fase onde a imagem deve ser armazenada."))
return
self._file.type = int(self.get_argument("type",""))
self._file.description = self.get_argument("description","")
self._file.url = self.get_argument("url","")
self._file.tags = splitTags(self.get_argument("tags",""))
self._file.owner = self._file.alterado_por = user
self._file.registry_id = registry_id
self._file.data_upload = self._file.data_alt = str(datetime.now())
self._file.filename = filename
if not self._file.saveFile(file_id, self.request.files):
self.write (dict(status=1, MSG=u"Erro na leitura do arquivo de imagem. (%s)" %file_id))
return
log.model.log(user, u'criou o arquivo', objeto=file_id, tipo="file")
self.write (dict(status=0, redirect="/studio/%s" % (registry_id)))
else:
self.write (dict(status=1, msg=u"Usuário ou comunidade inexistentes."))
else:
self.write (dict(status=1, msg=u"Erro: Arquivo inexistente!"))
def post(self, registry_id, tipo):
user = self.get_current_user()
msg = ""
if isOwner(user, registry_id):
self._aval = model.Evaluation()
self._aval.nome = self.get_argument("nome","")
if not self._aval.nome:
msg += u"Nome da avaliação não informado.<br/>"
else:
self._aval.nome = remove_special_chars(remove_diacritics(self._aval.nome.replace(" ","_")))
if self._aval.nome == "":
msg += u"Nome da avaliação inválido.<br/>"
self._aval.descricao = self.get_argument("descricao", "")
if tipo=="member":
self._aval.tipo = "participantes"
self._comu = core.model.Community().retrieve(registry_id)
avaliados = self._comu.participantes
grupos = self._comu.groups
groupnames = {}
for grupo in grupos:
groupnames[grupo] = grupo
else: # tipo =="wiki"
self._aval.tipo = u"páginas"
avaliados = [row.key[1].split("/")[1] for row in wiki.database.WIKI.view('wiki/partial_data',startkey=[registry_id],endkey=[registry_id, {}]) if row.value["is_folder"]!="S" and not row.value["removido"]]
(grupos, groupnames) = wiki.model.Wiki.listWikiFolderItens(registry_id)
# qdo colocamos as views passou a dar erro de encoding
# avaliados = [x.encode("UTF-8") for x in avaliados]
for item in avaliados:
if self.get_argument(item,"") == "S":
self._aval.avaliados.append(item)
if not self._aval.avaliados:
msg += u"Selecione pelo menos um item para ser avaliado.<br/>"
pontuacao = self.get_argument("pontuacao","").strip()
if pontuacao:
self._aval.pontuacao = pontuacao.split(",")
else:
msg += u"O campo 'Pontuação' não foi preenchido.<br/>"
self._aval.owner = user
self._aval.data_cri = str(datetime.now())
self._aval.data_inicio = self.get_argument("data_start","")
if not self._aval.data_inicio:
msg += u"O campo 'Data/hora de início' não foi preenchido.<br/>"
self._aval.data_encerramento = self.get_argument("data_end","")
if not self._aval.data_encerramento:
msg += u"O campo 'Data/hora de encerramento' não foi preenchido.<br/>"
if msg:
self.render("modules/evaluation/newevaluation-form.html", MSG=msg, EVALUATIONDATA=self._aval, \
AVALIADOS=avaliados, REGISTRY_ID=registry_id, \
GROUPS=grupos, \
GROUPNAMES=groupnames, \
NOMEPAG=u"Avaliações")
else:
aval_id = "%s/%s" % (registry_id, self._aval.nome)
try:
self._aval.save(id=aval_id)
except Exception as detail:
self.render("modules/evaluation/newevaluation-form.html", MSG=u"Já existe uma avaliação com este nome", EVALUATIONDATA=self._aval, \
AVALIADOS=avaliados, REGISTRY_ID=registry_id, \
GROUPS=grupos, \
GROUPNAMES=groupnames, \
NOMEPAG=u"Avaliações")
return
log.model.log(user, u'criou a avaliação', objeto=aval_id, tipo="evaluation")
self.redirect("/evaluation/%s" % registry_id)
else:
self.render("home.html", MSG=u"Você não pode criar avaliação nesta comunidade.", REGISTRY_ID=ifExists(registry_id, user), \
NOMEPAG="comunidades")
def post(self, registry_id):
user = self.get_current_user()
subtype = self.get_argument ("subtype","")
if subtype == "":
raise HTTPError (400)
return
_quiz = model.Quiz()
_quiz.titulo = self.get_argument("titulo","")
_quiz.questions = self.get_arguments("questions")
_quiz.descricao = self.get_argument("descricao","")
_quiz.data_inicio = self.get_argument("data_start","")
_quiz.data_fim = self.get_argument("data_end","")
_quiz.exibicao = self.get_argument("exibicao", "")
msg = ""
if _quiz.titulo == "":
msg += u"Título do quiz não preenchido.<br/>"
else:
quiz_id = remove_special_chars(remove_diacritics(_quiz.titulo.replace(" ","_")))
if quiz_id == "":
msg += u"Título do quiz inválido<br/>"
if not _quiz.descricao:
msg += u"Descrição do quiz não preenchida.<br/>"
if not _quiz.questions:
msg += u"Selecione pelo menos uma questão para fazer parte do quiz.<br/>"
if not _quiz.data_inicio:
msg += u"O quiz deve possuir uma data de início.<br/>"
if not _quiz.data_fim:
msg += u"O quiz deve possuir uma data de encerramento.<br/>"
if not msg and not maiorData(_quiz.data_fim, _quiz.data_inicio, short=True):
msg += u"A Data/hora de encerramento não pode ser anterior à Data/hora de início.<br/>"
if msg:
self.render("modules/quiz/quiz-form.html", NOMEPAG=u"Quiz", QUIZ=_quiz, REGISTRY_ID=registry_id, \
MSG=msg, \
QUESTIONS=self.prepareQuestionList(question.model.Question.listObjectsBySubtype(subtype, registry_id)), \
TITLE=u"Criar Quiz ("+TIPO_QUIZ[subtype]+")", \
LINKS=[], SUBTYPE=subtype )
return
else:
_quiz.data_cri = str(datetime.now())
_quiz.data_alt = _quiz.data_cri
_quiz.service = "quiz"
_quiz.type = "quiz"
_quiz.subtype = subtype
doc_id = uuid4().hex
_quiz.registry_id = registry_id
_quiz.owner = user
try:
_quiz.save(id=doc_id)
except Exception as detail:
self.render("modules/quiz/quiz-form.html", NOMEPAG=u"Questionário", QUIZDATA=_quiz, REGISTRY_ID=registry_id, \
QUESTIONS=self.prepareQuestionList(question.model.Question.listObjectsBySubtype(subtype, registry_id)), \
SUBTYPE=subtype,\
TITLE=u"Criar Quiz ("+TIPO_QUIZ[subtype]+")", \
LINKS=[], \
MSG=u"Já existe um quiz com este título.")
return
log.model.log(user, u'criou quiz em', objeto=registry_id, tipo="quiz",link="/quiz/%s"%quiz_id)
self.redirect("/quiz/%s" % registry_id)
def post(self, registry_id):
msg = ""
user = self.get_current_user()
folder = self.get_argument("parent_folder","")
if folder:
folder_id = registry_id+"/"+folder
self._pai = model.Wiki().retrieve(folder_id)
parent_name = self._pai.nomepag
else:
parent_name = registry_id+"/"
nomepag = self.get_argument("nomepag","")
if nomepag=="":
msg += u"* Nome da página não preenchido<br/>"
nomepag_id = remove_special_chars(remove_diacritics(nomepag.replace(" ","_")))
if nomepag_id=="":
msg += u"* Nome da página inválido<br/>"
doc_id = '/'.join([registry_id,nomepag_id])
if model.Wiki.nomepagExists(registry_id, nomepag) or model.Wiki().retrieve(doc_id):
msg += u"* Já existe uma página ou pasta com este nome<br/>"
self._wiki = model.Wiki()
conteudo = self.get_argument("conteudo","")
if conteudo=="": msg += u"* Conteúdo não preenchido<br/>"
historico = dict(
conteudo=conteudo,
data_alt=str(datetime.now()),
alterado_por = user
)
self._wiki.historico.append(historico)
self._wiki.tags = splitTags(self.get_argument("tags",""))
self._wiki.parent_folder = self.get_argument("parent_folder","")
if self._wiki.parent_folder!="":
parent_id = '/'.join([registry_id,self._wiki.parent_folder])
test_parent_folder = model.Wiki().retrieve(parent_id)
if not test_parent_folder:
msg += u"* Impossível criar página dentro de uma pasta inexistente (%s)<br/>" % parent_id
elif not isAllowedToWriteObject(user, "wiki", registry_id, self._wiki.parent_folder):
msg += u"* Você não tem permissão para criar páginas nesta pasta."
if msg:
self.write (dict(status=1, msg=msg))
else:
self._wiki.nomepag = nomepag
self._wiki.nomepag_id = nomepag_id
self._wiki.user = user
self._wiki.owner = user
self._wiki.registry_id = registry_id
self._wiki.data_cri = self._wiki.historico[-1]["data_alt"]
self._wiki.saveWiki(id=doc_id)
# inclui a página recem criada na lista de filhos do parent_folder
if self._wiki.parent_folder:
parent = model.Wiki().retrieve(registry_id+"/"+self._wiki.parent_folder)
parent.addItemToParent(user, self._wiki.nomepag_id)
log.model.log(user, u'criou a página', objeto=doc_id, tipo="wiki")
self.redirect("/wiki/%s" % doc_id)