Trabalhando com grupos no LotusScript

Este artigo descreve como é possível trabalhar com grupos no LotusScript, usando a classe integrada NotesAdministrationProcess e duas classes customizadas do LotusScript.

Andre Guirard, EI Product Developer, IBM

Andre Guirard é membro da equipe de desenvolvimento do Notes Client e Domino Designer. Desenvolvedor do Notes há muito tempo, Andre agora se concentra na ativação de desenvolvedores. Ele frequentemente ministra palestras na Lotusphere e outras conferências IBM, e seus artigos já apareceram no developerWorks: Lotus (LDD), na revista The View e em outros lugares. Em seu tempo livre, ele ajuda sua esposa nos projetos de jardinagem.


nível de autor Contribuidor do
        developerWorks

03/Nov/2011

Um grupo é um tipo de documento do Notes encontrado no diretório Domino. O documento Grupo pode ser manipulado usando a classe NotesDocument. O problema é saber os significados dos valores nos diferentes campos e lidar com as complexidades dos grupos que contêm outros grupos (grupos aninhados) ou que precisam exceder o limite de tamanho da lista de membros.

Neste artigo, nós discutimos duas maneiras de trabalhar com grupos. Primeiro, a classe integrada NotesAdministrationProcess do LotusScript, disponível no Notes/Domino 6.0 e superior, será examinada. Essa classe pode incluir membros em grupos, renomeá-los e excluí-los (bem como várias outras funções que não são relacionadas a grupos). Não há função para remover usuários de um grupo. No entanto, se o processo de administração (AdminP) for usado para remover totalmente um usuário, ele também será removido dos grupos. Para mais informações sobre a classe NotesAdministrationProcess, consulte o artigo "LotusScript: The NotesAdministrationProcess Class in Notes/Domino 6."

Também serão apresentadas duas classes LotusScript customizadas que suportam um conjunto maior de operações em grupos. O código foi criado para Lotus Notes/Domino 6.0 e superior. Para usá-lo no release 5 são necessárias algumas pequenas mudanças. O artigo contém alguns agentes de amostra que explicam como usar essas classes para diferentes tarefas. As classes não podem ser usadas a partir de COM, porque elas usam internamente o tipo de dados List, que o Visual Basic não suporta.

O código real das classes, todos os agentes de amostra e a documentação completa de todas as propriedades e métodos listados neste artigo estão disponíveis no banco de dados de amostra, e o download pode ser feito na LotusScript Gold Collection em OpenNTF.org. (No banco de dados de amostra, use a ação de ajude GMan ou pressione F1 em qualquer visualização para consultar a documentação completa das classes customizadas.) As classes customizadas são chamadas NotesGroupManager e NotesGroup. Para usá-las, copie a biblioteca de scripts GroupManager do LotusScript do banco de dados de amostra para seus próprios aplicativos e a inclua em seu script com a instrução Use. As classes contêm funções para:

  • Localizar todas as listas de endereços.
  • Procurar documentos de Grupo em todas as listas de endereços ou em subconjunto especificado.
  • Criar e excluir grupos.
  • Incluir e remover membros.
  • Classificar a lista de membros.
  • Lidar com grupos que contêm outros grupos.
  • Determinar se alguém é ou não membro de um grupo, ou obter uma lista de todos os membros de um grupo, incluindo de grupos aninhados.
  • Gerenciar grupos que têm mais membros do que o número suportado em um único documento de Grupo, dividindo-os em diversos documentos.

O banco de dados de exemplo contém alguns elementos de design, copiados do modelo de lista pública de endereços (pubnames.ntf), para que você possa usar a ferramenta nos dados no banco de dados de amostra e evitar alterar grupos em seu diretório Domino. O código pode ser usado em qualquer aplicativo.

Este artigo considera que o leitor seja um desenvolvedor LotusScript experiente.

Métodos de grupo da classe NotesAdministrationProcess

Como mencionado na introdução, a classe NotesAdministrationProcess permite algumas operações simples de grupo (bem como várias outras funções não relacionadas a grupos). Os métodos relevantes são listados nas seções a seguir.

Cada um desses métodos funciona criando um documento de solicitação no banco de dados de solicitações à administração do Notes (admin4.nsf). Quando AdminP executa no servidor, ele percebe a solicitação e realiza a operação. Algumas solicitações podem precisar de aprovação de outra pessoa, e outras podem ser enviadas para processamento em diferentes domínios Notes.

As vantagens de usar essa classe são:

  • Permite emitir uma solicitação mesmo quando não se tem acesso imediato ao servidor que irá realizá-la.
  • Se um usuário estiver esperando que seu script conclua, isso permite que você finalize mais rápido, pois o trabalho real está sendo feito pelo servidor.
  • AdminP realiza um trabalho mais completo ao remover e renomear grupos. Ele não apenas exclui ou altera o registro do grupo, como também rastreia referências ao nome antigo do grupo e as atualiza.

As desvantagens são:

  • Apenas algumas operações podem ser feitas dessa maneira.
  • A solicitação não é necessariamente realizada de imediato.
  • Não suporta a inclusão de usuários em um grupo que tenha muitos membros e que, portanto, não caiba em um único documento Grupo.

A maioria dos métodos dessa classe retorna o ID da nota do novo documento de solicitação no banco de dados de solicitações à administração. Se a solicitação não puder ser criada (por exemplo, porque o usuário atual não tem autorização), ela retorna uma cadeia de caracteres vazia ("") ou causa uma condição de erro, dependendo do motivo da falha.

A ideia de retornar o ID da nota é que, se você quiser, pode monitorar o documento para ver quando a solicitação foi concluída. AdminP cria um documento de resposta para mostrar quando a tarefa foi concluída. Dependendo da configuração do servidor, o AdminP pode executar em um servidor diferente daquele no qual a solicitação é postada, o que resulta em uma longa demora na replicação de e para o servidor de administração. O usuário não pode usar AdminP para realizar uma atividade para a qual ele não tenha acesso. O AdminP apenas automatiza a atividade.

Não iremos descrever a sintaxe completa desses métodos aqui, mas indicaremos ao leitor a ajuda do Domino Designer. Aqui nós fornecemos um resumo e pequenas informações úteis não encontradas na documentação.

Método AddGroupMembers

Determinando o nome de um grupo (cadeia de caractere) e um array de nomes de usuários, este método inclui estes nomes no grupo. Isso pode significar a procura por diversos diretórios para localizar o grupo. Se não houver um grupo com esse nome, ele é criado e recebe o tipo de propósito geral, o que significa que pode ser usado para e-mail ou controle de acesso. Nomes já contidos no grupo não são incluídos.

OBSERVAÇÃO: A documentação do Domino Designer diz que o argumento members pode ser uma cadeia de caracteres contendo um único nome de usuário, mas isso parece não estar funcionando no Lotus Notes/Domino 6.5.4. Use um array de um único elemento para incluir apenas um nome de usuário.

Exemplo 1: Assinatura automática em lista de e-mails

O agente a seguir (AdminP\Process Subscription Requests) está configurado para executar em documentos Memo novos e alterados em um banco de dados de correio. Ele verifica se a linha de assunto contém a palavra subscribe e, se contiver, inclui o usuário no grupo:

Option PublicOption Declare ' always use Option Declare

Sub Initialize
	Dim session As New NotesSession
	Dim adminp As NotesAdministrationProcess
	Dim db As NotesDatabase
	Dim coll As NotesDocumentCollection
	Dim docRequest As NotesDocument
	Dim strID As String
	Dim strNewMembersArray( ) As String
	Dim intNewMemberCount As Integer
	
	Set db = session.CurrentDatabase
	Set coll = db.UnprocessedDocuments
	Set docRequest = coll.GetFirstDocument( )
	Do Until docRequest Is Nothing
		If docRequest.Subject(0) = "subscribe" Then
			Redim Preserve strNewMembersArray(0 To intNewMemberCount) 
			  strNewMembersArray(intNewMemberCount) = 
			  docRequest.GetItemValue("From")(0)
			intNewMemberCount = intNewMemberCount + 1
		End If
		session.UpdateProcessedDoc docRequest
		Set docRequest = coll.GetNextDocument(docRequest)
	Loop
	If intNewMemberCount  > 0 Then ' There are some members to add
		Set adminp = session.CreateAdministrationProcess("bobbity")
		strID = adminp.AddGroupMembers("Hazardous Joke 
		  Mailing List", strNewMembersArray)
		If strID = "" Then ' Probable insufficient access
			Msgbox {Unable to create adminp request "Add or Modify 
			  Group"}, 0, {adminp failure}
		End If
	End If
End Sub

DeleteGroup

Determinando o nome de um grupo, este método exclui o grupo do Diretório Domino. Além disso, o nome do grupo é removido da lista de membros de todos os outros grupos, de ACLs de banco de dados e dos campos de nomes Reader e Author de documentos em todos os bancos de dados. Como opção, esse método também exclui o grupo do Windows com o mesmo nome, se o servidor usar o sistema operacional Windows.

RenameGroup

O método RenameGroup toma dois argumentos de cadeia de caracteres: o nome antigo e o nome novo do grupo. Além de alterar o nome do registro de grupo real, este método também atualiza listas de ACL de bancos de dados e de membros de outros grupos, campos de nomes Reader/Author e outros lugares em que o nome do grupo possa ser usado.


A biblioteca de scripts GroupManager

A biblioteca de scripts GroupManager contém duas classes e diversas constantes que são úteis como argumentos de método e valores de propriedade e em outras instruções de erro. As classes são:

  • NotesGroupManager acompanha o Diretório Domino e gerencia um cache na memória das informações sobre o grupo. Isso permite realizar eficientemente diversas operações em diferentes grupos sem precisar recarregá-los constantemente na memória. O processo de salvar alterações pode ser adiado até que todo o processamento seja concluído. NotesGroupManager pode ser usada em modo recursivo ou não recursivo. Em modo recursivo, ela percebe quais grupos contêm outros grupos e permite realizar operações recursivas, como remover um usuário do grupo atual e de todos os subgrupos.
  • NotesGroup contém informações sobre um único grupo.

A maioria das tarefas pode ser realizada diretamente por meio dos métodos NotesGroupManager, fornecendo um nome de grupo como argumento. Se você precisar usar a classe NotesGroup, solicite um objeto NotesGroup de NotesGroupManager usando os métodos GetGroup ou CreateGroup. Isso é útil para algumas operações avançadas (como alterar a propriedade do grupo) e para código mais simples e maior eficiência ao realizar diversas operações no mesmo grupo.

Subgrupos, subgrupos de quebra e modo recursivo

A biblioteca de scripts GroupManager inclui funcionalidade para lidar com hierarquias de grupos (que contêm outros grupos como membros) de até seis níveis de aninhamento. Neste artigo, um grupo que é membro de outro grupo é chamado de um subgrupo.

Ao criar um objeto NotesGroupManager, existe a opção de desativar a funcionalidade recursiva e lidar com os grupos como coleções "simples" de membros, para melhor desempenho. Isso não significa que os membros do subgrupo parecem ser membros do grupo principal. Significa que não é possível perceber que são membros, a menos que sejam membros do grupo principal.

Há um tipo especial de subgrupo chamado de subgrupo de quebra. Subgrupos de quebra são usados quando há membros demais para caber no grupo principal, considerando o limite de 32 KB no tamanho do campo de resumo (nesse caso, o campo contendo a lista de membros). O gerenciador de grupo cria automaticamente grupos adicionais suficientes para conter a lista inteira de membros e inclui esses grupos como membros do grupo principal.

O nome de um subgrupo de quebra é o nome do grupo principal, seguido por um espaço e um número. Essa é uma convenção de nosso código, não do Lotus Domino. O Lotus Domino não trata os grupos de forma diferente dependendo de seus nomes, mas nosso gerenciador de grupo sim.

OBSERVAÇÃO: A funcionalidade de subgrupos de quebra só opera em modo recursivo.

Como exemplo de subgrupos normais contra subgrupos de quebra, considere as duas hierarquias de grupos mostradas na Figura 1.

Figura 1. Subgrupos normais versus de quebra
Subgrupos normais versus de quebra

O grupo Sailors contém o nome de alguns marinheiros e também dois outros grupos. Pirate e Naval Officer são marinheiros. Eles são mantidos em grupos separados porque é útil para nós. Por exemplo, o grupo Naval Officers tem acesso ao banco de dados de classificação de desempenho da tripulação, que não pode ser usado por quem não é oficial. E o grupo Pirates é usado como uma lista de e-mails para a Pillaging Newsletter, que não é de interesse dos marinheiros em geral.

O grupo Hispaniola Crew, por outro lado, contém subgrupos de quebra. Seus subgrupos não são usados em outros lugares, e eles não existem por conveniência e fins organizacionais, mas devido à limitação de tamanho de campo do Notes. Falaremos sobre esses grupos mais tarde.

Exemplo 2: Mais manutenção de lista de e-mails

Assim como no Exemplo 1, o agente GMan Process Subscription Requests controla a associação de grupos apenas de correio com base em solicitações de assinatura de correio de usuários. Para dar ao agente alguns dados com os quais trabalhar, o banco de dados de amostra contém uma visualização Memos com algumas solicitações de assinatura e cancelamento de assinatura de correio. É claro que, normalmente, o Diretório Domino nunca é um banco de dados de correio. Os registros de grupo são colocados no mesmo banco de dados apenas para fins de demonstração.

O agente GMan Process Subscription Requests está configurado para executar quando um novo e-mail for recebido. Ele processa cada memorando na coleção UnprocessedDocuments. O código do agente aparece abaixo. Para que você possa experimentar sem criar um banco de dados de correio, há um agente semelhante, "GMan Samples\1. Process subscription requests", que pode ser executado em documentos selecionados na visualização Memos.

Option Public
Option Declare	' Always use Option Declare
Use "GroupManager"
Sub Initialize
	Dim session As New NotesSession
	Dim db As NotesDatabase
	Dim coll As NotesDocumentCollection
	Dim doc As NotesDocument
	Dim strSubject As String, strVerb As String, strGroupName  
	  As String, strFrom As String
	Dim result As Boolean
	Dim gman As New NotesGroupManager(True)
	Call gman.LoadPublicAddressBooks
	gman.DefaultType = GROUP_TYPE_MAIL ' If we create 
	' a group, make it a mail-only group.
	
	Set db = session.CurrentDatabase
	Set coll = db.UnprocessedDocuments
	Set doc = coll.GetFirstDocument( )

	Do Until doc Is Nothing
		strSubject = Fulltrim(doc.GetItemValue("Subject")(0))
		' We expect subject = "subscribe" or "unsubscribe"  
		' followed by group name.
		strVerb = Lcase(Strleft(strSubject, " "))
		strGroupName = Strright(strSubject, " ")
		strFrom = doc.GetItemValue("From")(0)
		' Make sure group name specified is one we let people
		'subscribe to, e.g., don't allow changes to LocalDomainAdmins 
		'membership.
		If ValidateGroup(strGroupName) Then
			If strVerb = "unsubscribe" Then
				' Remove sender's email from group. Also from 
				' subgroups, in case list is so large that there are 
				' 'breakout' subgroups.
				Call gman.RemoveFromGroup(strGroupName, 
				  strFrom, GROUP_RECURSE)
				SendMessage db, strFrom, "Your unsubscribe request  
				  was processed", {You have been removed from group "} 
				  & strGroupName & {". So long!}
			Elseif strVerb = "subscribe" Then
				' Add member to the group with these options:
				'  -- Create the group if it doesn't exist.
				'  -- Don't add name if it's already in a subgroup.
				'  -- If name is already there but not an exact match, 
				' update it.
				result = gman.AddToGroup(strGroupName, strFrom, 0,  
				  GROUP_CREATE + GROUP_RECURSE + GROUP_UPDATE)
				If result Then
					' Not already in the group (or name changed) -- 
					' welcome them.
					SendMessage db, strFrom, "Your subscription to 
					  "& strGroupName & " was processed.", 
					  {Welcome to the "} & strGroupName & 
					  {" mailing list! Please review our policy 
					  at http://www.iupp.org before posting to 
					  this list.}
				End If
			End If ' Subscribe
		End If ' Group name valid
		Call session.UpdateProcessedDoc(doc)
		Set doc = coll.GetNextDocument(doc)
	Loop
	gman.SaveAll ' Or none of your group changes will be saved
End Sub

As sub-rotinas ValidateGroup e SendMessage não são mostradas aqui, mas elas podem ser encontradas no banco de dados de amostra. A implementação de ValidateGroup varia dependendo de quais grupos o agente deve gerenciar, e SendMessage está além do propósito deste artigo. Ao contrário do Exemplo 1, este agente lida com solicitações de assinatura e de cancelamento de assinatura. A maior parte do código obtém informações sobre o que precisa ser feito. A execução real está nas seguintes linhas de código:

  • Use "GroupManager" carrega a biblioteca GroupManager.
  • Dim gman As New NotesGroupManager(True) cria o objeto NotesGroupManager.
  • Call gman.LoadPublicAddressBooks diz ao gerenciador de grupo para usar todo o Diretório Domino/listas de endereços públicas.
  • gman.DefaultType = GROUP_TYPE_MAIL especifica que, se um grupo for criado automaticamente (para que possamos incluir alguém nele), ele será um grupo de lista de e-mails.
  • Call gman.RemoveFromGroup(strGroupName, strFrom, GROUP_RECURSE) remove alguém de um grupo e de todos os subgrupos. A opção GROUP_RECURSE também remove essa pessoa de todos os subgrupos. Por padrão, ela é removida apenas do grupo nomeado. Isso é importante ao lidar com grupos que são grandes o suficiente para exigir subgrupos de quebra. A menos que a pessoa seja removida de todos os subgrupos, ela ainda é membro do grupo principal.
  • result = gman.AddToGroup(strGroupName, strFrom, 0, GROUP_CREATE + GROUP_RECURSE + GROUP_UPDATE) inclui alguém em um grupo. Alguns pontos sobre essa linha:

    O terceiro argumento (0) é o índice de base zero do diretório no qual o grupo deve ser criado se não existir. Esse índice é baseado na lista de Diretórios Domino que foram carregados. Como chamamos LoadPublicAddressBooks anteriormente, 0 é o índice do Diretório Domino primário, names.nsf.

    A opção GROUP_RECURSE especifica que não queremos incluir alguém no grupo principal se a pessoa já for membro de um subgrupo. Ao trabalhar com grupos que possam ser grandes o suficiente para estourar em subgrupos de quebra, essa opção deve ser especificada para todas as inclusões, evitando a duplicação.

    GROUP_UPDATE controla o que acontece se houver um membro do grupo cujo endereço de e-mail seja o mesmo de um endereço que queremos incluir, mas não idêntico (por exemplo, se "Hester Prynne <hester@bigredletter.org>" é membro e nós pedimos a inclusão de "Hester A. Prynne <hester@bigredletter.org>"). Por padrão, o grupo não é atualizado nesse caso. Se GROUP_UPDATE for especificado, o grupo é atualizado para corresponder exatamente ao novo nome.
  • gman.SaveAll salva todas as alterações de grupo feitas pelo gerenciador de grupo.

Exemplo 3: Excluindo e criando grupos

O agente "GMan Samples\2. Delete and Create Groups" mostra como excluir e criar grupos e lidar com uma hierarquia simples de grupos. Esse agente primeiro exclui todos os grupos mostrados na figura 1. Para os grupos Sailors, Naval Officers e Pirates, isso é simples porque sabemos seus nomes e podemos usar gman.RemoveGroup. No entanto, para o grupo Hispaniola Crew é um pouco mais complicado, pois ele pode ter um número desconhecido de subgrupos de quebra. Excluir o grupo principal não exclui automaticamente qualquer subgrupo, portanto devemos criar um código para fazer isso manualmente. Aqui está o código para excluir todos esses grupos:

	Dim gman As New NotesGroupManager(True)
	Dim group As NotesGroup
. . .
	Call gman.RemoveGroup("Pirates")
	Call gman.RemoveGroup("Sailors")
	Call gman.RemoveGroup("Naval Officers")
	
	' Because we'll be doing several operations on one group, 
	' get a NotesGroup object to make things more efficient.
	Set group = gman.GetGroup("Hispaniola Crew")
	If Not (group Is Nothing) Then
		Dim subgroups
		' Are there subgroups to hold overflow (e.g., "Hispaniola Crew 2")?
		subgroups = group.BreakoutSubgroups
		Forall subgroup In subgroups
			Dim strTemp
			strTemp = subgroup.Name
			Call group.RemoveMembers(strTemp, 0) 'Remove subgroup from 
			  main group.
			Call gman.RemoveGroup(strTemp) 'Delete the group altogether.
		End Forall
		gman.RemoveGroup("Hispaniola Crew")
	End If

A propriedade BreakoutSubgroups retorna o nome dos subgrupos cujo nome corresponde ao padrão que nosso código usa para nomeá-los (o nome do grupo principal seguido por um espaço e um número). Nesse caso, a classe NotesGroupManager não tinha as propriedades de que precisávamos para acessar a lista de subgrupos de quebra associados com um grupo, portanto tivemos que usar um objeto NotesGroup para obter os detalhes de um grupo específico.

Outra maneira de excluir um grupo e todos os seus subgrupos de quebra é descobrir quais são seus nomes e excluir os grupos com esses nomes:

Sub DeleteBreakoutGroup(gman As NotesGroupManager, strName As String)
	Dim intInd As Integer
	If gman.RemoveGroup(strName) Then
		intInd = 2
		While gman.RemoveGroup(strName & " " & intInd)
			intInd = intInd + 1
		Wend
	End If
End Sub

O método RemoveGroup retorna uma variável booleana True se o grupo que a exclusão foi solicitada existir realmente, de modo que é possível testar o valor de retorno para descobrir se é necessário procurar por mais grupos com nomes semelhantes. Isso é de fácil codificação, mas menos seguro, pois não há garantia absoluta de que alguém não tenha excluído um dos subgrupos de quebra manualmente, o que levaria o método a não excluir grupos com numeração maior.

Em seguida, os grupos excluídos serão recriados. Há duas maneiras de criar grupos: incluir membros usando a opção GROUP_CREATE, como no Exemplo 2, ou usar gman.CreateGroup, como mostrado a seguir:

	Redim values(0 To 3) As String
	Set group = gman.CreateGroup("Naval Officers", GROUP_TYPE_MULTI, 0)
	group.Description = "Current serving officers only."
	values(0) = "Horatio Hornblower/Hotspur/HRMN"
	values(1) = "Jack Aubrey/Surprise/HRMN"
	values(2) = "Stephen Maturin/Surprise/HRMN"
	values(3) = "James Hook/BadGuys/Neverland"
	Call group.AddMembers(values, 0) ' 2nd argument is options

Observe que usamos a propriedade Description de NotesGroup para atribuir os campos de descrição de lista. Isso apenas pode ser feito se houver um objeto NotesGroup, mas tal objeto não existe se criarmos o grupo usando gman.AddToGroup. É claro que é possível obter o grupo NotesGroup mais tarde usando GetGroup, por exemplo:

gman.GetGroup("Pirates").Description = "Scourges of the Sea"

Até agora, discutimos duas maneiras de incluir membros em um grupo, gman.AddToGroup e group.AddMembers. Todos os métodos para incluir e remover membros aceitam uma cadeia de caracteres única ou um array de cadeias de caracteres, de modo que é possível trabalhar com diversos membros ao mesmo tempo. Nesse caso, em vez de atribuir elementos de um array e passar o array para AddMembers, poderíamos ter escrito:

	Call group.AddMembers("Horatio Hornblower/Hotspur/HRMN", 0)
	Call group.AddMembers("Jack Aubrey/Surprise/HRMN", 0)
	Call group.AddMembers("Stephen Maturin/Surprise/HRMN", 0)
	Call group.AddMembers("James Hook/BadGuys/Neverland", 0)

Observe que usamos IDs do Notes de forma abreviada. Nomes de usuário em documentos de Grupo devem estar no formato canônico ("CN=..."), mas o código do gerenciador de grupo aceita ambos os formatos e faz a conversão automaticamente.

Uma terceira maneira de incluir membros em um grupo é usando a propriedade Members de NotesGroup. Essa é uma propriedade de leitura/gravação, portanto, é possível atribuí-la com um valor de array para alterar a associação do grupo inteiro ao mesmo tempo. Aqui temos mais um código do agente de amostra:

	Set group = gman.CreateGroup("Sailors", GROUP_TYPE_MULTI, 0)
	group.Description = "All navvies"
	values(0) = "Queequeg/Pequod/Whalers"
	values(1) = "Jack Dawson/Titanic/White Star"
	values(2) = "Pirates" ' the group
	values(3) = "Naval Officers" ' the group
	group.Members = values

Essa maneira de atribuir a associação ao grupo é sempre uma inclusão "simples". A lista de membros é exatamente o que foi especificado, mesmo que haja alguns nomes duplicados em subgrupos.

Exemplo 4: Criando um subgrupo de quebra

Não há diferença entre criar um subgrupo de quebra e criar grupos normais como no exemplo anterior. Basta criar o objeto NotesGroupManager em modo recursivo (ou seja, o argumento do método New deve ser True), e isso será resolvido automaticamente se o grupo ficar grande demais.

O agente "GMan Samples\3. Add many members" mostra isso. Para criar um grupo grande o suficiente para precisar de um subgrupo de quebra, ele contém um gerador de nomes de piratas que seleciona aleatoriamente dentre listas de adjetivos, nomes e sobrenomes para formar nomes, tais como Long John Silver ou Whistling Ned Doggett. O nome aleatório é incluído no grupo Hispaniola Crew desta forma:

		If group.AddMembers(strCrewName, GROUP_RECURSE) Then
			intCount = intCount + 1
		End If

Ao trabalhar com grupos que possam ser grandes o suficiente para conter subgrupos de quebra, é importante usar a opção GROUP_RECURSE. Do contrário, você pode acabar incluindo alguém no grupo principal que já está em um subgrupo de quebra. O mesmo se aplica ao remover membros.

O valor de retorno de AddMembers é usado para determinar se um nome foi realmente incluído. Se a pessoa ainda não era um membro, esse método retorna True. Nesse caso, nós o fazemos para manter o controle de quantos nomes exclusivos foram incluídos, para saber quando parar.

Execute esse agente diversas vezes caso queira saber quantos membros é possível colocar em um único grupo. Há cerca de 16.000 combinações diferentes de adjetivo, nome e sobrenome. É possível editar o agente e incluir nas listas para aumentar o número de combinações.

Exemplo 5: Procurando grupos

NotesGroupManager tem uma propriedade, CachedGroups, que é uma lista de todos os grupos que ele carregou em seu cache. Geralmente, os grupos são carregados quando são solicitados por nome. Em modo recursivo, todos os subgrupos de grupos solicitados também são carregados.

É possível procurar grupos que correspondam a uma consulta de texto completa usando group.FTSearch. Isso toma como argumento de uma cadeia de caracteres de consulta que é usada como um argumento para o método FTSearch em cada um dos Diretórios Domino que o gerenciador de grupo conhece. Os documentos de Grupo que correspondem à procura são retidos no cache.

Se o Diretório Domino contiver índice de texto total, este método pode ser usado para localizar rapidamente todos os grupos de que uma determinada pessoa é membro, procurando pelo nome comum dela ou endereço de e-mail no campo Members. Em seguida, a propriedade group.IsMember pode ser usada para eliminar falsas correspondências. O código a seguir vem do agente "GMan Samples\4. Full Text Search":

	strSearch = Trim(Inputbox( "Search string:"))
. . .
	lngCount = gman.FTSearch(strSearch)
	Dim groupList As Variant
	Dim strGroupDesc As String
	
	If lngCount = 0 Then
		Msgbox "No groups matched your query."
	Else
		groupList = gman.CachedGroups
		Forall group In groupList
			strGroupDesc =  strGroupDesc & ", " & group.Name
		End Forall
		Msgbox "The following " & lngCount & " groups matched 
		  your query: " & Mid$(strGroupDesc, 3)
	End If

Se você quiser apenas os grupos que correspondem aos resultados da procura, e não seus subgrupos, deve usar o gerenciador de grupo em modo não recursivo.

Há alguns outros métodos que manipulam o cache : LoadAllGroups, LoadGroup, Uncache e ClearCache. LoadAllGroups obtém informações sobre todos os grupos em todos os diretórios, de modo que é possível usar um loop, como aquele descrito anteriormente, para fazer uma iteração por eles.


Conclusão

As amostras apresentadas neste artigo têm como objetivo ser uma introdução ao uso deste código customizado. Há outros métodos e propriedades que não mencionamos que permitem controlar a associação ao grupo, classificar a lista de membros, acessar o documento de Grupo para alterar campos que não têm uma propriedade correspondente e assim por diante. Todos eles estão completamente documentados no banco de dados de amostra encontrados em LotusScript Gold Collection em OpenNTF.org.

Com o código de origem, é possível modificar ou estender as classes conforme desejado. Se você modificar esta versão, recomendamos enviar a modificação para OpenNTF.org para que outros a usem. Caso você encontre problemas com a documentação do banco de dados de amostra ou com o código, envie um e-mail para o autor.

Recursos

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Lotus
ArticleID=768918
ArticleTitle= Trabalhando com grupos no LotusScript
publish-date=11032011