CRUD Listas Sharepoint

Apenas para mostrar como fazer um CRUD na lista do sharepoint que criamos no post Criação de Listas Programaticamente. Para isso utilizei novamente um console aplication referenciando a dll Microsoft.Sharepoint.dll

Vamos ao código:

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

   5:  using Microsoft.SharePoint;

   6:   

   7:  namespace Sharepoint.Crud

   8:  {

   9:      class Program

  10:      {

  11:          static void Main(string[] args)

  12:          {

  13:              using (SPSite oSite = new SPSite("http://intranet.contoso.com/"))

  14:              {

  15:                  using (SPWeb oWeb = oSite.OpenWeb())

  16:                  {

  17:                      bool allowUnsafeUpdates = oWeb.AllowUnsafeUpdates;

  18:                      oWeb.AllowUnsafeUpdates = true;

  19:                      try

  20:                      {

  21:                          SPList oList = oWeb.Lists.TryGetList("Ramais Empresa");

  22:                          if (oList != null)

  23:                          {

  24:                              //Adiciona um novo item e pega o id gerado

  25:                              int id = AdicionarRamal(oList, "João Carlos", "Administativo", "Filial - São Paulo", "Somente pode ser encontrado após as <b>18:00</b>.");

  26:   

  27:                              //Atualiza o Ramal

  28:                              AtualizarRamal(oList, id, "Maria Antônia", "Administrativo", "Filial - Rio de Janeiro", "");

  29:   

  30:                              //Envia o item criado para a lixeira

  31:                              RemoverRamal(oList, id, false);

  32:   

  33:                              //Adiciona um novo item

  34:                              id = AdicionarRamal(oList, "Joaquina Ferreira", "Financeiro", "Filial - São Paulo", "Trabalho apenas nas quartas e sextas.");

  35:   

  36:                              //Remove o item permanentemente

  37:                              RemoverRamal(oList, id, true);

  38:                          }

  39:                      }

  40:                      finally

  41:                      {

  42:                          oWeb.AllowUnsafeUpdates = allowUnsafeUpdates;

  43:                      }

  44:                  }

  45:              }

  46:          }

  47:   

  48:          private static void RemoverRamal(SPList oList, int id, bool excluirPermanentemente)

  49:          {

  50:              try

  51:              {

  52:                  SPListItem oListItem = oList.GetItemById(id);

  53:                  if (excluirPermanentemente)

  54:                  {

  55:                      //Exclui o item permanentemente

  56:                      oListItem.Delete();

  57:                  }

  58:                  else

  59:                  {

  60:                      //Envia o item para a lixeira do site

  61:                      oListItem.Recycle();

  62:                  }

  63:              }

  64:              catch

  65:              {

  66:                  throw new Exception("Item inexistente!");

  67:              }

  68:          }

  69:   

  70:          private static void AtualizarRamal(SPList oList, int id, string nome, string setor, string unidade, string observacao)

  71:          {

  72:              try

  73:              {

  74:                  SPListItem oListItem = oList.GetItemById(id);

  75:                  oListItem[SPBuiltInFieldId.Title] = nome;

  76:                  oListItem["Setor"] = setor;

  77:                  oListItem["Unidade"] = unidade;

  78:                  oListItem["Observacao"] = observacao;

  79:                  oListItem.Update();

  80:              }

  81:              catch

  82:              {

  83:                  throw new Exception("Item inexistente!");

  84:              }

  85:          }

  86:   

  87:          private static int AdicionarRamal(SPList oList, string nome, string setor, string unidade, string observacao)

  88:          {

  89:              SPListItem oListItem = oList.AddItem();

  90:              oListItem[SPBuiltInFieldId.Title] = nome;

  91:              oListItem["Setor"] = setor;

  92:              oListItem["Unidade"] = unidade;

  93:              oListItem["Observacao"] = observacao;

  94:              oListItem.Update();

  95:              return oListItem.ID;

  96:          }

  97:      }

  98:  }

Algumas observações:

Linha 17:

oWeb.AllowUnsafeUpdates: Esse AllowUnsafeUpdates permite atualizações não seguras no banco de dados. Para atualizações via código devemos setar essa propriedade para true, o que ocorre na linha 18.

Linha 56 e 61:

Na linha 56 o item é enviado para a lixeira do site através do método Recycle(). Já se utilizarmos o método Delete() o item é excluído permanentemente.

Linha 89:

O Objeto SPList agora possui o método AddItem(). Esse método não existia nas versões anteriores então era necessário fazer da seguinte forma: SPList.Items.Add();
E os resultados:

Cadastro do primeiro item:

Atualização do item:

Item enviado para a lixeira do site:

Cadastro de um novo item:

Bom então é isso, até a próxima e qualquer dúvida postem ai!

Readmore...

Criação de Listas Programaticamente

Olá para todos!!! Uma das necessidades que ocorre durante o desenvolvimento de alguma feature é a utilização de listas customizadas. Para não deixar a criação dessas listas para o usuário gosto de criar as listas que preciso programaticamente. O visual studio 2010 tem um tipo de projeto especial para a criação de listas, mas não irei trabalhar com esse tipo de projeto neste exemplo. Aqui vamos criar uma lista via código mesmo. O objetivo é demonstrar que é realmente fácil criar uma lista via código. Então vamos lá:
Para esse projeto criei um console application. Adicionei a referência da Dll Microsoft.SharePoint.dll. Como sabemos o Sharepoint 2010 trabalha na plataforma 64 bits logo temos que alterar nossa aplicação para que também rode em 64 bits. Acesse as propriedades do projeto e altere a seguinte configuração:

Feito isso salve e vamos a codificação:

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

   5:  using Microsoft.SharePoint;

   6:   

   7:  namespace Sharepoint.CriacaoListas

   8:  {

   9:      class Program

  10:      {

  11:          static void Main(string[] args)

  12:          {

  13:              using (SPSite oSite = new SPSite("http://intranet.contoso.com/"))

  14:              {

  15:                  using (SPWeb oWeb = oSite.OpenWeb())

  16:                  {

  17:                      string nomeLista = "Ramais Empresa";

  18:                      SPList oList = oWeb.Lists.TryGetList(nomeLista);

  19:                      if (oList == null)

  20:                      {

  21:                          CriaListaRamaisEmpresa(oWeb);

  22:                      }                    

  23:                  }

  24:              }

  25:          }

  26:   

  27:          private static void CriaListaRamaisEmpresa(SPWeb oWeb)

  28:          {

  29:              //Seguindo as boas práticas colocamos a lista sem espaços ou caracteres especiais.

  30:              Guid idLista = oWeb.Lists.Add("Ramais_Empresa", "Lista com os ramais da empresa", SPListTemplateType.GenericList);

  31:              SPList oList = oWeb.Lists[idLista];

  32:              

  33:              //Colocando o nome amigável para o usuário

  34:              oList.Title = "Ramais Empresa";

  35:   

  36:              //Informo que não quero que a lista apareça na barra de inicio rápido do site.

  37:              oList.OnQuickLaunch = false;

  38:              

  39:              //Atualizo a lista

  40:              oList.Update();

  41:              

  42:              //Atualizando o campo titulo

  43:              SPField oField = oList.Fields[SPBuiltInFieldId.Title];

  44:              oField.Title = "Funcionário";

  45:              oField.Update();

  46:              

  47:              //Adiciono os campos a lista

  48:              //Campo setor do tipo escolha e obrigatório.

  49:              oList.Fields.Add("Setor", SPFieldType.Choice, true);

  50:              SPFieldChoice oChoiceField = (SPFieldChoice)oList.Fields["Setor"];

  51:              oChoiceField.Choices.Add("Financeiro");

  52:              oChoiceField.Choices.Add("Administrativo");

  53:              oChoiceField.Choices.Add("TI");

  54:              oChoiceField.Choices.Add("Recursos Humanos");

  55:              oChoiceField.Description = "Informe o setor do funcionário.";

  56:              oChoiceField.Update();

  57:   

  58:              //Campo unidade

  59:              oList.Fields.Add("Unidade", SPFieldType.Choice, true);

  60:              oChoiceField = (SPFieldChoice)oList.Fields["Unidade"];

  61:              oChoiceField.Choices.Add("Matriz - Belo Horizonte");

  62:              oChoiceField.Choices.Add("Filial - São Paulo");

  63:              oChoiceField.Choices.Add("Filial - Rio de Janeiro");

  64:              oChoiceField.DefaultValue = "Matriz - Belo Horizonte";

  65:              oChoiceField.Description = "Informe qual a unidade do funcionário.";

  66:              oChoiceField.Update();

  67:   

  68:              //Campo Observação

  69:              oList.Fields.Add("Observacao", SPFieldType.Note, false);

  70:              SPFieldMultiLineText oMultilineField = (SPFieldMultiLineText)oList.Fields["Observacao"];

  71:              

  72:              oMultilineField.Title = "Observação";

  73:              

  74:              //Informo que o campo deve aceitar tags Html.

  75:              oMultilineField.RichText = true;

  76:              

  77:              //Informo que ele apenas pode utilizar algumas tags html simples como negrito, itálico e alinhamento.

  78:              oMultilineField.RichTextMode = SPRichTextMode.Compatible;

  79:              oMultilineField.Update();

  80:   

  81:              //Atualiza a view default para exibir os novos campos criados.

  82:              SPView oView = oList.DefaultView;

  83:              oView.ViewFields.Add("Setor");

  84:              oView.ViewFields.Add("Unidade");

  85:              oView.ViewFields.Add("Observacao");

  86:              oView.Update();

  87:          }

  88:      }

  89:  }

Creio que o código esta bem comentado mas mesmo assim vamos a alguns pontos:

Linhas 13 e 15:

É uma ótima prática utilizar o using em objetos SPSite e SPWeb pois eles utilizam muita memoria do servidor. Logo quanto mais rápido vocês liberarem esses objetos da memoria melhor. Em um outro post falo mais sobre a importância de dar o dispose nesses objetos.

Linha 18:

Uma coisa muito boa do sharepoint 2010: agora o objeto SPListCollection possui um método TryGetList. Nas versões Wss 3.0 e MOSS 2007 isso não existia. Para contornar esse problema nas versões antigas criavamos alguns extension methods (Novidade a partir do framework 3.0).

Linha 69:

O campo “Observação” é criado sem caracteres especiais e logo na linha 72 é atualizado para o nome correto. Nas imagens abaixo poderemos ver o motivo.
E o resultado desse código:

A lista "Ramais Empresa" criada já se encontra no site. Observe que como setamos a propriedade OnQuickLaunch da lista para false ela não aparece na barra de inicio rápido do site.

Como podemos ver no detalhe da url o campo tem o InternalName como "Observacao" enquanto o DisplayName é "Observação". Mais uma boa prática aplicada.

Observe que a url da lista ficou como Ramais_Empresa sem os caracteres especiais que tanto incomodam.

O Cadastro de novos itens com os campos dropdown.

Item já cadastrado.


Ainda podemos melhorar esse código fazendo os campos de "Setor" e "Unidade" buscarem de outras listas.
Bom é isso qualquer dúvida basta postar!!!

Readmore...

Hierarquia Sharepoint

Olá para todos!!!
Hoje vou falar um pouco da hierarquia do Sharepoint.

Como podemos verificar na image o Sharepoint possui uma hierarquia entre os objetos. A partir dessa hierarquia conseguimos identificar em qual nível estamos e como fazemos para acessar um outro item da hierarquia.

Algumas explicações:

SPFarm:
É o primeiro nível da hierarquia do sharepoint. Ele representa o farm do sharepoint. O objeto SPFarm não pode ser instanciado, ele é um objeto estático. Para acessar o SPFarm em código devemos utilizar o seguinte código:
SPFarm currentFarm = SPFarm.Local;

SPService:
Representa os serviços que estão rodando no farm. Exemplo: Access Services, Performance Point, Sharepoint Search, etc. O SPService é utilizado para trabalhos administrativos como Backup, configruação de serviços, etc. Para retornar os objetos SPService do farm utilize o código:
SPServiceCollection oServiceCollection = SPFarm.Local.Services;

SPWebApplication:
É a representação do site sharepoint no IIS(internet information Services). Podemos utilizar o SPWebApplication para configurar o tamanho maximo de arquivos, criar uma nova site collection.

SPSite
O SPSite representa o site collection. A classe SPSite suporta construtores, para isso basta passarmos o Guid do site ou a URL:

SPSite oSite = SPContext.Current.Site;

Ou:

using (SPSite oSite = new SPSite("http://meusite.com.br"))
{
    //...
}

O Objeto SPSite possui uma coleção de SPWeb.

SPWeb
Representa um web site do Sharepoint. Nele que estão as listas, biblioteca, etc. O Objeto SPWeb pode ser obtido através do SPSite. Alguns exemplos:

SPWebCollection oWebCollection = SPContext.Current.Site.AllWebs;

Ou podemos buscar o Web Atual;

SPWeb currentWeb = SPContext.Current.Web;

Ou ainda:

using (SPSite oSite = new SPSite("http://meusite.com.br"))
{
    using (SPWeb oWeb = oSite.OpenWeb())
    {
        //...
    }
}

O Objeto SPWeb ainda pode ter mais objetos SPWeb.

SPList:
Nos objetos SPList do site que os dados ficam armazenados, tanto documentos, quanto imagens, páginas, etc. Algo interessante que a versão do sharepoint 2010 server possui uma biblioteca especial apenas para midia.
Para obtermos as listas e/ou bibliotecas do site devemos utilizar o objeto SPWeb. Alguns exemplos:

using (SPSite oSite = new SPSite("http://meusite.com.br"))
{
    using (SPWeb oWeb = oSite.OpenWeb())
    {
        SPListCollection oListCollection = oWeb.Lists;
    }
}

Ou buscando apenas a biblioteca de documentos administrativos:

using (SPSite oSite = new SPSite("http://meusite.com.br"))
{
    using (SPWeb oWeb = oSite.OpenWeb())
    {
        SPList oList = oWeb.Lists["Documentos Administativos"];                    
    }
}

SPListItem e SPFolder
Os objetos SPListItem e SPFolder são os registros das listas(SPLists) do SPWeb. O SPFolder é um item do SPList, contudo o SPFolder pode ter SPListItem “dentro” dele. Mas como o SPFolder também é um SPListItem coloquei eles no mesmo nível. Podemos obter o SPListItem e o SPFolder a partir das listas. Alguns exemplos:

using (SPSite oSite = new SPSite("http://meusite.com.br"))
{
    using (SPWeb oWeb = oSite.OpenWeb())
    {
        SPList oList = oWeb.Lists["Documentos Administativos"];
        SPListItem oItem = oList.GetItemById(1);                    
    }
}

Pegando as pastas da lista:

using (SPSite oSite = new SPSite("http://meusite.com.br"))
{
    using (SPWeb oWeb = oSite.OpenWeb())
    {
        SPList oList = oWeb.Lists["Documentos Administativos"];

        //Observe que as pastas são SPListItem
        SPListItemCollection oFoldersCollection = oList.Folders;
    }
}

SPFile
O Objeto SPFile representa os arquivos estão em listas ou bibliotecas do site. Para podermos acessar um objeto SPFile devemos buscar nos itens(SPListItem) das listas ou passando como parametro para o SPWeb a url do arquivo. Alguns exemplos:

using (SPSite oSite = new SPSite("http://meusite.com.br"))
{
    using (SPWeb oWeb = oSite.OpenWeb())
    {
        SPList oList = oWeb.Lists["Documentos Administrativos"];
        SPListItem oListItem = oList.GetItemById(1);
        SPFile oFile = oListItem.File;
    }
}

Bom então é somente isso por hoje. Até mais a todos e qualquer dúvida, comentário ou crítica postem ai!
Abraços!

Readmore...