Como adicionar uma nova coluna a todas as visualizações de uma lista usando PowerShell

19, março, 2013 Sem comentários

Dependendo de quantas visualizações/views nossa lista do SharePoint tem, se torna difícil e chato ficar adicionando um novo campo a cada uma delas. Um processo repetitivo, desgastante e sujeito a falha humana, no qual o PowerShell pode nos ajudar com excelência.

 

Este código vale para o PowerShell 1.0 que pode ser usado em um Windows 2003 server que tenha o SharePoint 2007 instalado.

Adapte-o conforme sua necessidade.

[System.Reflection.Assembly]::LoadWithPartialName(“Microsoft.SharePoint”)
[System.Reflection.Assembly]::LoadWithPartialName(“Microsoft.SharePoint.Portal”)
[System.Reflection.Assembly]::LoadWithPartialName(“Microsoft.SharePoint.Publishing”)
[System.Reflection.Assembly]::LoadWithPartialName(“System.Web”)
$weburl = “http://site”
$listname = “ListDisplayName”
$fieldname = “FieldDisplayName”
$field = $null
$views = $null
$site = new-object Microsoft.SharePoint.SPSite($weburl)
$web = $site.OpenWeb()
$list = $web.Lists[$listname]
if ($list -ne $null) {
$field = $list.Fields[$fieldname]
if ($field -ne $null) {
Write-Host “Total of items: ” $list.Items.Count
$views = $list.Views;
$i = 0;
$n = $views.Count;
$view = $null;
for($i=0; $i -lt $n; $i++) {
$view = $views[$i]
Write-Host “View Name =” $view.Title “…” -nonewline
if ($view.ViewFields.Exists($field.StaticName)) {
Write-Host -foregroundcolor green “Sim Contém” -nonewline
Write-Host -foregroundcolor yellow “… Nada precisou ser adicionado!”
}
else {
Write-Host -foregroundcolor red “Não Contém” -nonewline
$view.ViewFields.Add($field.StaticName)
$view.Update()
Write-Host -foregroundcolor green “… Adicionado!”
}
#break;
}
}
}
$web.Dispose()
$site.Dispose();

Categories: PowerShell, SharePoint Tags:

Funções úteis

1, outubro, 2012 Sem comentários
/// <summary>
/// Capitalization is the writing of a word with its first letter as an upper case and the remaining letters in lower case.
/// </summary>
/// <param name=”s”>A word to be capitalized.</param>
/// <returns>A capitalized word.</returns>
public static String Capitalize(String s)
{
    // Check for empty string.
    if (String.IsNullOrEmpty(s))
        return String.Empty;
    // Return char and concat substring.
    return String.Concat(Char.ToUpper(s[0]), s.Substring(1).ToLower());
}

/// <summary>
/// Capitalization is the writing of a word with its first letter as an upper case and the remaining letters in lower case.
/// </summary>
/// <param name=”s”>An array of string, each string to be capitalized.</param>
/// <returns>A capitalized text (phrase)</returns>
public static String Capitalize(String[] sColl)
{
    List<String> lt = new List<String>(sColl.Length);
    foreach (String s in sColl)
        lt.Add(Capitalize(s));
    return String.Join(” “, lt.ToArray());
}

Categories: Sem categoria Tags: ,

Depurar nunca foi tão fácil

24, setembro, 2012 Sem comentários

Como usar:

Treatment t = new Treatment(“SharePoint Server”, “3AS – “);
t.WriteInformation(“Iniciando variáveis”);
t.WriteInformation(“Arquivo encontrado.”);
t.WriteError(“Arquivo não pode ser aberto”);
t.WriteFailureAudit(“Falha na comunicação.”);
t.WriteJustInDebug(“Depurando usando o DebugViewer somente.”);
t.WriteWarning(“Um usuário não foi importado, pois já estava na lista.”);
t.WriteSuccessAudit(“Concluído com sucesso.”);

 

A classe:

class Treatment
{
    public List<String> Error = new List<String>();
    private EventLog Log = new EventLog();
    private String _DebugInitials = null;

    public Treatment(String eventLogSource, String debugInitials)
    {
        Log.Source = eventLogSource;
        _DebugInitials = debugInitials;
    }

    private void Write(String s, EventLogEntryType eventLogEntryType)
    {
        this.WriteJustInDebug(s);
        Log.WriteEntry(s, EventLogEntryType.Information);
    }

    #region Publics
    public void WriteError(String s)
    {
        this.Write(s, EventLogEntryType.Error);
        this.Error.Add(s);
    }
    public void WriteFailureAudit(String s)
    {
        this.Write(s, EventLogEntryType.FailureAudit);
    }

    public void WriteInformation(String s)
    {
        this.Write(s, EventLogEntryType.Information);
    }

    public void WriteSuccessAudit(String s)
    {
        this.Write(s, EventLogEntryType.SuccessAudit);
    }
    public void WriteWarning(String s)
    {
        this.Write(s, EventLogEntryType.Warning);
    }
    #endregion

    public void WriteJustInDebug(String s)
    {
        Debug.WriteLine(String.Concat(_DebugInitials, s));
    }
}

 

Pode parecer bem boba, mas pode ajudar bastante em momentos críticos, como por exemplo:

- quando estiver com problemas no servidor de produção.

- quando estiver utilizando UpdatePanel.

 

Recomendo utilizar juntamente o DebugViewer.

Categories: Sem categoria Tags: , ,

Classe para gerenciar permissões

15, agosto, 2012 Sem comentários
Esta classe pode ser melhorada, mas já pode te ajudar a dar uma direção e você mesmo melhorá-la. Fique à vontade caso melhore-a e queira compartilhar aqui nos comentários.
class ManagePermissions
{
    /// <summary>
    /// Quebra a herança de permissões do item e remove todas permissões.
    /// </summary>
    /// <param name=”CurrentlistItem”>Item de lista que você deseja remover as permissões</param>
    public static void RemoveAllPermissions(SPListItem CurrentListItem)
    {
        // Se não tem permissões únicas, quebra a herança do item
        if (!CurrentListItem.HasUniqueRoleAssignments)
            CurrentListItem.BreakRoleInheritance(false);

        // Pega a lista de permissões do item de lista e remove uma a uma
        SPRoleAssignmentCollection SPRoleAssColn = CurrentListItem.RoleAssignments;
        for (int i = SPRoleAssColn.Count – 1; i >= 0; i–)
            SPRoleAssColn.Remove(i);
        // Não precisa atualizar o item depois de removidas as permissões!
    }

    /// <summary>
    /// Seta em um item de lista um nível de permissão especifico para um usuário ou grupo
    /// </summary>
    /// <param name=”CurrentListItem”>Item de lista a receber as permissões</param>
    /// <param name=”oSPWeb”>Web onde está o item</param>
    /// <param name=”strRoleDefName”>Nome do nível de permissão</param>
    /// <param name=”Autorizado”>Usuário ou Grupo a quem será dada a permissão</param>
    public static void GrantPermission(SPListItem CurrentListItem, SPWeb oSPWeb, string strRoleDefName, SPFieldUserValue Autorizado)
    {
        SPPrincipal UserOrGroup = (Autorizado.User != null ? (SPPrincipal)Autorizado.User : (SPPrincipal)oSPWeb.SiteGroups.GetByID(Autorizado.LookupId));
        ManagePermissions.GrantPermission(CurrentListItem, oSPWeb, strRoleDefName, UserOrGroup);
    }

    /// <summary>
    /// Adiciona permissão a um item de lista. Um nível de permissão especifico para um usuário ou grupo
    /// </summary>
    /// <param name=”CurrentListItem”>Item de lista a receber as permissões</param>
    /// <param name=”oSPWeb”>Web onde está o item</param>
    /// <param name=”strRoleDefName”>Nome do nível de permissão</param>
    /// <param name=”Autorizado”>Usuário ou Grupo a quem será dada a permissão</param>
    public static void GrantPermission(SPListItem CurrentListItem, SPWeb oSPWeb, string strRoleDefName, SPPrincipal Autorizado)
    {
        // Pego um nível de permissão existente
        SPRoleDefinition oSPRoleDefinition = oSPWeb.RoleDefinitions[strRoleDefName];
        // Cria uma regra de atribuição para um usuário ou grupo
        SPRoleAssignment oSPRoleAssignment = new SPRoleAssignment(Autorizado);
        // Dou um Bind na permissao ao objeto de regra de atribuição para o usuário/grupo.
        oSPRoleAssignment.RoleDefinitionBindings.Add(oSPRoleDefinition);
        // Adiciono isto para o item de lista especificado
        CurrentListItem.RoleAssignments.Add(oSPRoleAssignment);
        // NÃO É NECESSÁRIO ATUALIZAR O ITEM PARA AS PERMISSÕES TEREM EFEITO! — Atualizo o item de lista com as permissões para o usuário/grupo
        //CurrentListItem.SystemUpdate();
    }

    /// <summary>
    /// Verifica se o nível de permissão existe. Se não, cria.
    /// </summary>
    /// <param name=”web”>Site em questão a ser verificado</param>
    /// <param name=”RoleDefName”>Nome do nível de permissão</param>
    public static void EnsurePermissionLevel(SPWeb web, string RoleDefName)
    {
        SPRoleDefinition roleDef;
        try
        {
            // Se existir, blz.
            roleDef = web.RoleDefinitions[RoleDefName];
        }
        catch
        {
            // Se não existir, criamos um novo nível de permissão
            roleDef = new SPRoleDefinition();
            roleDef.BasePermissions = SPBasePermissions.ViewListItems | SPBasePermissions.EditListItems;
            roleDef.Description = “Pode exibir e editar itens de lista, não podendo adicionar ou remover”;
            roleDef.Name = RoleDefName;
            // Adicionamos a coleção de permissões da web
            web.RoleDefinitions.Add(roleDef);
        }
    }
}

Filtrar itens comparando uma data com AGORA

2, maio, 2012 Sem comentários

Hoje precisei filtrar itens em uma lista do SharePoint que usa o modelo de Avisos, que tem o campo Vencimento (Expires) do tipo DateTime.

Necessitava exibir apenas os itens que estavam dentro do prazo, isto é, não exibir os itens que estavam vencidos.

A primeira coisa que vem em mente é usar CAML para filtrar os dados. Tentei utilizar o <Now /> que é nativo e não funcionou. Com isso resolvi usando usando o método CreateISO8601DateTimeFromSystemDateTime da classe SPUtility.

The CreateISO8601DateTimeFromSystemDateTime method converts, for example, “6/16/2003 6:37:44 PM” to “2003-06-16T18:37:44Z”.

No exemplo abaixo ilustro que usei a variável date2 ao invés da date1.

// Expires >= Now
String caml = @”<Where>
    <Geq>
        <FieldRef Name=’Expires’ />
        <Value Type=’DateTime’ IncludeTimeValue=’TRUE’>{0}</Value>
    </Geq>
</Where>”;
String date1 = “<Now />”/*Assigned but its value is never used.*/,
       date2 = SPUtility.CreateISO8601DateTimeFromSystemDateTime(DateTime.Now);
SPQuery q = new SPQuery
{
    Query = String.Format(caml, date2)// I tried to use <Now /> (variable date1), but doesn’t work. Then I used a method from SPUtility
};

Nasce um blog sobre SharePoint e EPM em pt-br

21, junho, 2011 Sem comentários

E aí pessoal!

Em breve começarei a postar sobre SharePoint e EPM. Experiências aqui serão compartilhadas, a fim de trocar conhecimento. Espero que este blog seja útil para todos.

Categories: Sem categoria Tags: