예제 #1
0
파일: control.py 프로젝트: labase/activnce
  def post(self, registry_id):               
      user = self.get_current_user()
      msg = ""
      if isUserOrOwner(user, registry_id):
          grupo = self.get_argument("grupo","")
          p = re.compile(VALID_LOGIN)
          if not grupo:
              msg = u"Grupo não preenchido."    
          elif not p.match(grupo):
              msg = u"Nome inválido. Deve ter no mínimo 3 caracteres, começando e terminando com letras ou números e utilizando apenas letras, números, '_' e '.' em sua composição. Não utilize acentuação!<br/>"                    
          else:
              user_data = _EMPTYCOMMUNITY()
              user_data.update(core.database.REGISTRY[registry_id])
              if grupo not in user_data["groups"]:
                  user_data["groups"][grupo] = []
                  core.database.REGISTRY[registry_id] = user_data     
                  msg = u"Grupo criado com sucesso."
              else:
                  msg = u"Grupo já existente."                    
 
      elif isACommunity(registry_id):
          msg=u"Somente administradores da comunidade podem criar grupos."  
      else:
          msg=u"Somente o próprio usuário pode criar grupos."
          
      self.render("popup_msg.html", MSG=msg, REGISTRY_ID=registry_id)                    
예제 #2
0
파일: control.py 프로젝트: labase/activnce
    def get(self, registry_id):
        user = self.get_current_user()
        page = int(self.get_argument("page","1"))
        log_data = []
        if isACommunity(registry_id) or user==registry_id:
            log_data = model.get_news_list(registry_id, date_time=True)
        else:
            log_data = model.get_log_list(registry_id, date_time=True, news=True)

        log_count = len(log_data)
        
        # obtem apenas a página que será exibida
        skip = (page-1)*NUM_MAX_NOVIDADES
        log_data = log_data[skip:skip+NUM_MAX_NOVIDADES]
        
        tabs = []
        if user==registry_id:
            tabs.append(("O que meus amigos tem feito no "+PLATAFORMA, ""))
            tabs.append(("O que eu tenho feito no "+PLATAFORMA, "/news"))
        
        model.log(user, u'acessou as novidades de', objeto=registry_id, tipo="news", news=False)        
        self.render("modules/log/news-list.html", NOMEPAG="novidades", REGISTRY_ID=registry_id, \
                                                  NEWS=log_data, NEWS_COUNT=log_count, \
                                                  PAGE=page, PAGESIZE=NUM_MAX_NOVIDADES, \
                                                  TABS=tabs, \
                                                  MSG="")
예제 #3
0
파일: notify.py 프로젝트: labase/activnce
 def email_notify(cls, user, sujeito, assunto, message="", link="", sendToMyself=False):
     # user -> quem deve ser avisado
     # sujeito -> quem realizou a ação
     # sendToMyself=True indica que a mensagem deve ser enviada para mim, mesmo que eu tenha realizado a ação. Ex: troca de senha.
     
     if (sendToMyself or user!=sujeito) and isAUser(sujeito):
         if isAUser(user):
             # usuário a ser avisado
             to_user_data = model._EMPTYMEMBER()
             to_user_data.update(database.REGISTRY[user])
             email = to_user_data["email"]
             notify = to_user_data["notify"]
             nome_destinatario = to_user_data["name"]
             
             # usuário que realizou a ação
             from_user_data = database.REGISTRY[sujeito]
             nome_completo = from_user_data["name"] + " " + from_user_data["lastname"]
             assunto = sendToMyself and assunto or nome_completo + " " + assunto
             
             if notify == "2":
                 # envia e-mail imediatamente
                 if not Notify.enviaEmail (email, assunto, nome_destinatario, message, link):
                     # erro no envio do e-mail: guarda mensagem em NOTIFICATIONERROR
                     notify_data = _EMPTYNOTIFICATIONERROR()
                     if user in log.database.NOTIFICATIONERROR:
                         notify_data.update(log.database.NOTIFICATIONERROR[user])
                     reg = dict(
                                sujeito= sujeito,
                                subject= assunto,
                                message= message,
                                data_inclusao= str(datetime.now())
                     )
                     notify_data["registros"].append(reg)
                     log.database.NOTIFICATIONERROR[user] = notify_data
                     #print "Erro no envio do email. Msg salva em NOTIFICATIONERROR"
                 else:
                     #print "Email enviado com sucesso para "+email
                     pass
                     
             elif notify == "1":
                 # guarda mensagem no banco para depois enviar resumo semanal
                 notify_data = _EMPTYNOTIFICATION()
                 if user in log.database.NOTIFICATION:
                     notify_data.update(log.database.NOTIFICATION[user])
                 reg = dict(
                            sujeito= sujeito,
                            subject= assunto,
                            message= message,
                            data_inclusao= str(datetime.now())
                 )
                 notify_data["registros"].append(reg)
                 log.database.NOTIFICATION[user] = notify_data
                 #print "Email salvo em NOTIFICATION"
             else:
                 #print "Usuário não deseja ser notificado"
                 pass
                 
         elif isACommunity(user):
             for participante in database.REGISTRY[user]["participantes"]:
                 Notify.email_notify(participante, sujeito, assunto, message, link)
예제 #4
0
파일: control.py 프로젝트: labase/activnce
    def post(self, registry_id):               
        user = self.get_current_user()
        if isUserOrOwner(user, registry_id):
            part = self.get_argument("part","")
            group = self.get_argument("group","")

            if isACommunity(registry_id):
                user_data = _EMPTYCOMMUNITY()
            else:
                user_data = _EMPTYMEMBER()
            user_data.update(core.database.REGISTRY[registry_id])
            
            if part:
                for group in user_data["groups"].keys():
                    checkbox_value = self.get_argument(group,"")
                    if checkbox_value=="S" and part not in user_data["groups"][group]:
                        user_data["groups"][group].append(part)
                    elif checkbox_value<>"S" and part in user_data["groups"][group]:
                        while part in user_data["groups"][group]:
                            user_data["groups"][group].remove(part)
                core.database.REGISTRY[registry_id] = user_data
                     
                self.render("popup_msg.html", MSG=u"Grupos alterados com sucesso.", REGISTRY_ID=registry_id)
                
            elif group:
                pessoas = user_data["participantes"] if isACommunity(registry_id) else user_data["amigos"]
                for part in pessoas:
                    checkbox_value = self.get_argument(part,"")
                    if checkbox_value=="S" and part not in user_data["groups"][group]:
                        user_data["groups"][group].append(part)
                    elif checkbox_value<>"S" and part in user_data["groups"][group]:
                        while part in user_data["groups"][group]:
                            user_data["groups"][group].remove(part)
                core.database.REGISTRY[registry_id] = user_data
                     
                self.render("popup_msg.html", MSG=u"Participantes alterados com sucesso.", REGISTRY_ID=registry_id)               

            else:
                self.render("popup_msg.html", MSG=u"Chamada inválida.")                    
             
        else:
            if isACommunity(registry_id):
                self.render("popup_msg.html", MSG=u"Somente administradores da comunidade podem agrupar participantes.", REGISTRY_ID=registry_id)  
            else:                
                self.render("popup_msg.html", MSG=u"Somente o próprio usuário pode agrupar seus amigos.", REGISTRY_ID=registry_id)                    
예제 #5
0
파일: control.py 프로젝트: labase/activnce
 def get(self, community_id):
     if not isACommunity(community_id):
         raise HTTPError(404)
         return
                 
     # Para evitar esse teste, manter a wiki sempre habilitada.
     if "wiki" in core.database.REGISTRY[community_id]['services']:
         self.redirect ("/wiki/%s/home" % community_id)
     else:
         self.redirect ("/profile/%s" % community_id)
예제 #6
0
파일: control.py 프로젝트: labase/activnce
    def post(self):
        user = self.get_current_user()
        msg = ""
            
        #Email agora é um array
        emails = self.get_argument("email", "")
        email_array = list(set(emails.split()))
        
        msg += self._validate_emails(email_array)
        
        user_keys = core.database.REGISTRY[user]['mykeys']
        lista_invited = [ model.MAGKEYS[key]["email"] for key in user_keys]
            
        invited_before = self._already_invited(email_array,lista_invited)
        
        if invited_before:
            for mail in invited_before:
                msg += u"Você já convidou o e-mail: %s<br/>" %mail
        
        for email in email_array:
            if emailExists(email):
                msg += u"Já existe um usuário cadastrado com o email: %s<br/>" % email
        
        # Comunidades é uma lista das comunidades default do usuário
        # que vai se cadastrar com esta chave
        comunidades = []
        for comu in list(set(self.get_argument("comunidades", "").split())):
            if isACommunity(comu):
                if isOwner(user, comu) or isMember(user, PRIV_GLOBAL_ADMIN):
                    comunidades.append(comu)
                else:
                    msg += u"Você deve ser dono ou administrador da comunidade %s.<br/>" % comu
                    
            else:
                msg += u"Comunidade %s não existente.<br/>" % comu
        
        if not msg:
            [self._send_invites(mail, user, comunidades) for mail in email_array]

            request_id = self.get_argument("request_id", "")
            if request_id != "":
                request_data = _EMPTYREQUESTINVITE()
                request_data.update(model.REQUESTINVITE[request_id])
                request_data["estado"] = "aprovado"
                model.REQUESTINVITE[request_id] = request_data
        else:
            msg += u"Os convites não foram enviados.<br/>"

        if msg:
            showInvitesPage(self, user, msg, email_list=emails, community_list=self.get_argument("comunidades", ""))
        else:
            showInvitesPage(self, user, u"Convites enviados com sucesso.<br/>")
예제 #7
0
파일: model.py 프로젝트: labase/activnce
def channel_name(user, registry_id):
    if isACommunity(registry_id):
        if isMember(user, registry_id):   
            return registry_id
        else:
            return None
            
    else:
        if isFriend(user, registry_id):
            channel = [user, registry_id]   
            channel.sort()
            return ":".join(channel)
        else:
            return None
예제 #8
0
파일: control.py 프로젝트: labase/activnce
 def get (self, registry_id, id):
     user = self.get_current_user()
     _atividade = model.Activity().retrieve(id)
     
     members = []
     if isACommunity(registry_id):
         _community = core.model.Registry().retrieve(registry_id)
         (num_members, members) = _community.getMembersList()
     
     if _atividade:
         self.render("modules/activity/activity-edit.html",  NOMEPAG=u"atividades",  MEMBERS=members, \
                     ATIVIDADE=_atividade, REGISTRY_ID=registry_id, MSG="")
     else:        
           raise HTTPError(404)
예제 #9
0
파일: control.py 프로젝트: labase/activnce
    def get(self, registry_id):               
        user = self.get_current_user()
        grupo = self.get_argument("group","")
        if isUserOrOwner(user, registry_id):
            user_data = _EMPTYCOMMUNITY()
            user_data.update(core.database.REGISTRY[registry_id])
            if grupo in user_data["groups"]:
                del user_data["groups"][grupo]
                core.database.REGISTRY[registry_id] = user_data     
                if isACommunity(registry_id):
                    self.redirect ("/members/"+registry_id)
                else:
                    self.redirect ("/friends/"+registry_id)
                return
                    
            else:
                msg = u"Grupo não existente."   
        elif isACommunity(registry_id):
            msg = u"Somente administradores da comunidade podem excluir grupos."
        else:
            msg = u"Somente o próprio usuário pode excluir grupos."

        self.render("popup_msg.html", MSG=msg, REGISTRY_ID=registry_id)  
예제 #10
0
파일: control.py 프로젝트: labase/activnce
 def get(self, registry_id):               
     user = self.get_current_user()
     if isUserOrOwner(user, registry_id):
         user_data = _EMPTYCOMMUNITY()
         user_data.update(core.database.REGISTRY[registry_id])
         groups = user_data["groups"].keys()
         
         self.render("modules/community/create-group.html", NOMEPAG='comunidades', \
                     GROUPS=groups, \
                     REGISTRY_ID=registry_id, MSG="")   
     elif isACommunity(registry_id):
         self.render("home.html", MSG=u"Somente administradores da comunidade podem criar grupos.", NOMEPAG='comunidades')  
     else:
         self.render("home.html", MSG=u"Somente o próprio usuário pode criar grupos.", NOMEPAG='amigos')  
예제 #11
0
파일: control.py 프로젝트: labase/activnce
    def get(self, registry_id):               
        user = self.get_current_user()
        if isACommunity(registry_id):
            if isUserOrOwner(user, registry_id):
                part = self.get_argument("part","")
                group = self.get_argument("group","")
    
                user_data = _EMPTYCOMMUNITY()
                user_data.update(core.database.REGISTRY[registry_id])
                if part:
                    groups = [(group, part in user_data["groups"][group]) for group in user_data["groups"].keys()]
                    
                    self.render("modules/community/update-groups.html", NOMEPAG='comunidades', \
                                PART=part, GROUPS=groups, \
                                REGISTRY_ID=registry_id, MSG="")   
                elif group:
                    parts = [(part, part in user_data["groups"][group]) for part in user_data["participantes"] if isAUser(part)]
                    self.render("modules/community/update-parts.html", NOMEPAG='comunidades', \
                                PARTS=parts, GROUP=group, \
                                REGISTRY_ID=registry_id, MSG="")                   
                else:
                    self.render("home.html", MSG=u"Chamada inválida.", NOMEPAG='comunidades')                    
            else:
                    self.render("home.html", MSG=u"Somente administradores da comunidade podem agrupar participantes.", NOMEPAG='comunidades')  

        else:
            if isUserOrOwner(user, registry_id):
                part = self.get_argument("part","")
                group = self.get_argument("group","")
    
                user_data = _EMPTYMEMBER()
                user_data.update(core.database.REGISTRY[registry_id])
                if part:
                    groups = [(group, part in user_data["groups"][group]) for group in user_data["groups"].keys()]
                    
                    self.render("modules/community/update-groups.html", NOMEPAG='amigos', \
                                PART=part, GROUPS=groups, \
                                REGISTRY_ID=registry_id, MSG="")   
                elif group:
                    parts = [(part, part in user_data["groups"][group]) for part in user_data["amigos"]]
                    self.render("modules/community/update-parts.html", NOMEPAG='amigos', \
                                PARTS=parts, GROUP=group, \
                                REGISTRY_ID=registry_id, MSG="")                   
                else:
                    self.render("home.html", MSG=u"Chamada inválida.", NOMEPAG='amigos')                    
            else:
                    self.render("home.html", MSG=u"Somente o próprio usuário pode agrupar seus amigos.", NOMEPAG='amigos')                              
예제 #12
0
파일: control.py 프로젝트: labase/activnce
def autocomplete_mblog (user, registry_id):
    permission = False
    autocomplete = dict()    
    if isUserOrMember(user, registry_id):
        permission = True
        
        _member = core.model.Member().retrieve(user)
        autocomplete_list = []
        autocomplete_list.extend(_member.getFriendsList()[1])
        autocomplete_list.extend(_member.getCommunitiesList())
        if isACommunity(registry_id):
            _member = core.model.Community().retrieve(registry_id)
            autocomplete_list.extend(_member.getMembersList()[1])
        
        for item in autocomplete_list:
            autocomplete[item[0].encode('iso-8859-1', 'ignore')] = item[1].encode('iso-8859-1', 'ignore')
            
    return (permission, autocomplete)
예제 #13
0
파일: control.py 프로젝트: labase/activnce
    def post(self, registry_id, id):
        user = self.get_current_user()
        _atividade = model.Activity().retrieve(id)
        
        members = []
        if isACommunity(registry_id):
            _community = core.model.Registry().retrieve(registry_id)
            (num_members, members) = _community.getMembersList()
        
        msg = ""
        titulo = self.get_argument("titulo","")
        if not titulo:
            msg = u"A atividade precisa ter um titulo.<br/>"
            
        if _atividade.subtype== "comunity":
            _atividade.encarregados = self.get_arguments("encarregados")
        
        _atividade.titulo = titulo
        _atividade.observacao = self.get_argument("observacao",'')
        _atividade.data_start = self.get_argument("data_start",'')
        _atividade.data_end = self.get_argument("data_end",'')
        _atividade.data_conclusion = self.get_argument("data_conclusion",'')
        _atividade.prioritario = self.get_argument("prioritario",'N')
        _atividade.status = self.get_argument("status","")

        if _atividade.data_end and _atividade.data_start and not maiorData(_atividade.data_end, _atividade.data_start, short=True):
            msg += u"A Data de encerramento não pode ser anterior à Data de início.<br/>"
        
        if msg: 
            self.render("modules/activity/activity-edit.html",  NOMEPAG=u"atividades", ATIVIDADE=_atividade, MEMBERS=members, \
                                                                REGISTRY_ID=registry_id, MSG=msg)  
            return       
        
        doc_id = id
        _atividade.data_alt = str(datetime.now())
        _atividade.type="activity"
        _atividade.registry_id = registry_id
        _atividade.alterado_por = user
        _atividade.save(id=doc_id)
        
        log.model.log(user, u'alterou uma atividade em', objeto=registry_id, tipo="activity", link="/activity/%s"%registry_id)
        self.render("modules/activity/activity-edit.html",  NOMEPAG=u"atividades", MEMBERS=members, ATIVIDADE=_atividade, \
                    REGISTRY_ID=registry_id, MSG=u"Alteração realizada com sucesso")  
예제 #14
0
파일: control.py 프로젝트: labase/activnce
    def post(self):
        user = self.get_current_user()
        tipo = self.get_argument("tipo","")
        str_busca = self.get_argument("str_busca","")
        
        if str_busca:
            if tipo == "T": # busca por tags
                tags = remove_diacritics(str_busca.lower())
                if tags:
                    resultados_busca = {}
                    for tag in list(set(tags.split(","))):
                        temp_busca = findTag(tag.strip())
                        for item in temp_busca:
                            for tupla in temp_busca[item]:
                                registry_id = tupla[2]
                                # se este item ainda não foi encontrado e ele
                                # não faz parte de uma comunidade privada...
                                #if self.isAllowedToAccess(user, registry_id, display_error=False) and \
                                if core.model.isAllowedToAccess(user, registry_id)==0:
                                    if item not in resultados_busca:
                                        resultados_busca[item] = [tupla]
                                    elif tupla not in resultados_busca[item]:
                                        resultados_busca[item].append(tupla)
        
                    for item in resultados_busca:
                        # ordena pela data não formatada
                        resultados_busca[item].sort(key=itemgetter(4), reverse=True)
                        # limita o número de itens exibidos
                        resultados_busca[item] = resultados_busca[item][:_MAX_RESULTADOS_POR_ITEM]
        
                    totais = [len(resultados_busca[key]) for key in resultados_busca]
                    
                    self.render("modules/search/search-results.html", REGISTRY_ID=user, \
                                           NOMEPAG='busca', \
                                           RESULTADOS=resultados_busca, LEGENDA=URL_TO_PAGETITLE, \
                                           NUM_RESULT=sum(totais), \
                                           TAGS_PROCURADAS=str_busca)
                    return
                
            elif tipo == "P": # busca por usuários
                #registry_id = self.get_argument("registry_id","")
                registry_id = str_busca.split(":")[0]
                
                if isAUser(registry_id):
                    self.redirect ("/user/%s"%registry_id)
                    return
                else:
                    #msg = u'Usuário não encontrado.'   
                    msg = 121
                       
            elif tipo == "C": # busca por comunidades
                #registry_id = self.get_argument("registry_id","")
                registry_id = str_busca.split(":")[0]
                
                if isACommunity(registry_id):
                    self.redirect ("/community/%s"%registry_id)
                    return
                else:
                    #msg = u'Comunidade não encontrada.'    
                    msg = 122                   
            else:
                #msg = u'Tipo de busca incorreto.'
                msg = 123

        else:
            #msg = u'Termos de busca não preenchidos.'
            msg = 124
 
        #self.render("popup_msg.html", MSG=msg)
        self.redirect ("/profile/%s?msg=%s" % (user,msg))