IAddressbookFolder Interface

public interface IAddressbookFolder : IAddressbookItem, 
	IFolder, IItemCollection, IHierarchyItem, IHierarchyItemBase, IAddressbookReport

Public Interface IAddressbookFolder
	Inherits IAddressbookItem, IFolder, IItemCollection, IHierarchyItem, 
	IHierarchyItemBase, IAddressbookReport

public interface class IAddressbookFolder : IAddressbookItem, 
	IFolder, IItemCollection, IHierarchyItem, IHierarchyItemBase, IAddressbookReport

type IAddressbookFolder =  
    interface
        interface IAddressbookItem
        interface IFolder
        interface IItemCollection
        interface IHierarchyItem
        interface IHierarchyItemBase
        interface IAddressbookReport
    end

public class AddressbookFolder : DavHierarchyItem, IAddressbookFolder, ICurrentUserPrincipal, IAclHierarchyItem
{
    public static async Task<IAddressbookFolder> LoadByIdAsync(DavContext context, Guid addressbookFolderId)
    {
        // Load only address book that the use has access to. 
        // Also load complete ACL for this address book.
        string sql =
            @"SELECT * FROM [card_AddressbookFolder] 
              WHERE [AddressbookFolderId] = @AddressbookFolderId
              AND [AddressbookFolderId] IN (SELECT [AddressbookFolderId] FROM [card_Access] WHERE [UserId]=@UserId)

            ; SELECT * FROM [card_Access]
              WHERE [AddressbookFolderId] = @AddressbookFolderId
              AND [AddressbookFolderId] IN (SELECT [AddressbookFolderId] FROM [card_Access] WHERE [UserId]=@UserId)";

        return (await LoadAsync(context, sql,
              "@UserId"             , context.UserId
            , "@AddressbookFolderId", addressbookFolderId
            )).FirstOrDefault();
    }

    public static async Task<IEnumerable<IAddressbookFolder>> LoadAllAsync(DavContext context)
    {
        // Load only address books that the use has access to. 
        // Also load complete ACL for each address book, but only if user has access to that address book.
        string sql =
            @"SELECT * FROM [card_AddressbookFolder] 
              WHERE [AddressbookFolderId] IN (SELECT [AddressbookFolderId] FROM [card_Access] WHERE [UserId]=@UserId)

            ; SELECT * FROM [card_Access] 
              WHERE [AddressbookFolderId] IN (SELECT [AddressbookFolderId] FROM [card_Access] WHERE [UserId]=@UserId)";

        return await LoadAsync(context, sql, "@UserId", context.UserId);
    }

    private static async Task<IEnumerable<IAddressbookFolder>> LoadAsync(DavContext context, string sql, params object[] prms)
    {
        IList<IAddressbookFolder> addressbookFolders = new List<IAddressbookFolder>();

        using (SqlDataReader reader = await context.ExecuteReaderAsync(sql, prms))            
        {
            DataTable addressbooks = new DataTable();
            addressbooks.Load(reader);

            DataTable access = new DataTable();
            access.Load(reader);

            foreach (DataRow rowAddressbookFolder in addressbooks.Rows)
            {
                Guid addressbookFolderId = rowAddressbookFolder.Field<Guid>("AddressbookFolderId");

                string filter = string.Format("AddressbookFolderId = '{0}'", addressbookFolderId);
                DataRow[] rowsAccess = access.Select(filter);

                addressbookFolders.Add(new AddressbookFolder(context, addressbookFolderId, rowAddressbookFolder, rowsAccess));
            }
        }

        return addressbookFolders;
    }

    internal static async Task<IAddressbookFolder> CreateAddressbookFolderAsync(DavContext context, string name, string description)
    {
        // 1. Create address book.
        // 2. Grant owner privileges to the user on the created address book(s).
        string sql = @"INSERT INTO [card_AddressbookFolder] (
                      [AddressbookFolderId]
                    , [Name]
                    , [Description]
                ) VALUES (
                      @AddressbookFolderId
                    , @Name
                    , @Description
                )
                ; INSERT INTO [card_Access] (
                      [AddressbookFolderId]
                    , [UserId]
                    , [Owner]
                    , [Read]
                    , [Write]
                ) VALUES (
                      @AddressbookFolderId
                    , @UserId
                    , @Owner
                    , @Read
                    , @Write
                )";

        Guid addressbookFolderId = Guid.NewGuid();

        await context.ExecuteNonQueryAsync(sql,
              "@AddressbookFolderId", addressbookFolderId
            , "@Name"               , name
            , "@Description"        , description
            , "@UserId"             , context.UserId
            , "@Owner"              , true
            , "@Read"               , true
            , "@Write"              , true
            );
        return await LoadByIdAsync(context, addressbookFolderId);
    }

    private readonly Guid addressbookFolderId;

    private readonly DataRow rowAddressbookFolder;

    private readonly DataRow[] rowsAccess;

    public override string Name
    {
        get { return rowAddressbookFolder != null ? rowAddressbookFolder.Field<string>("Name") : null; }
    }

    public override string Path
    {
        get
        {
            return string.Format("{0}{1}/", AddressbooksRootFolder.AddressbooksRootFolderPath, addressbookFolderId);
        }
    }

    private AddressbookFolder(DavContext context, Guid addressbookFolderId, DataRow addressbook, DataRow[] rowsAccess)
        : base(context)
    {
        this.addressbookFolderId    = addressbookFolderId;
        this.rowAddressbookFolder   = addressbook;
        this.rowsAccess             = rowsAccess;
    }

    public async Task<IEnumerable<ICardFile>> MultiGetAsync(IEnumerable<string> pathList, IEnumerable<PropertyName> propNames)
    {
        // Get list of file names from path list.
        IEnumerable<string> fileNames = pathList.Select(a => System.IO.Path.GetFileNameWithoutExtension(a));

        return await CardFile.LoadByFileNamesAsync(Context, fileNames, PropsToLoad.All);
    }

    public async Task<IEnumerable<ICardFile>> QueryAsync(string rawQuery, IEnumerable<PropertyName> propNames)
    {
        // For the sake of simplicity we just call GetChildren returning all items. 
        // Typically you will return only items that match the query.
        return (await GetChildrenAsync(propNames.ToList(), null, null, null)).Page.Cast<ICardFile>();
    }

    public string AddressbookDescription 
    {
        get { return rowAddressbookFolder.Field<string>("Description"); }
    }

    public async Task<PageResults> GetChildrenAsync(IList<PropertyName> propNames, long? offset, long? nResults, IList<OrderProperty> orderProps)
    {
        // Here we enumerate all business cards contained in this address book.
        // You can filter children items in this implementation and 
        // return only items that you want to be available for this 
        // particular user.

        // Typically only getcontenttype and getetag properties are requested in GetChildren call by CalDAV/CardDAV clients.
        // The iCalendar/vCard (calendar-data/address-data) is typically requested not in GetChildren, but in a separate multiget 
        // report, in MultiGetAsync() method call, that follows this request.

        // Bynari submits PROPFIND without props - Engine will request getcontentlength

        IList<IHierarchyItem> children = new List<IHierarchyItem>();
        return new PageResults((await CardFile.LoadByAddressbookFolderIdAsync(Context, addressbookFolderId, PropsToLoad.Minimum)), null);
    }

    public async Task<IFile> CreateFileAsync(string name, Stream content, string contentType, long totalFileSize)
    {
        // The actual business card file is created in datatbase in CardFile.Write call.
        string fileName = System.IO.Path.GetFileNameWithoutExtension(name);
        return CardFile.CreateCardFile(Context, addressbookFolderId, fileName);
    }

    public async Task<IFolder> CreateFolderAsync(string name)
    {
        throw new DavException("Not allowed.", DavStatus.NOT_ALLOWED);
    }

    public override async Task MoveToAsync(IItemCollection destFolder, string destName, MultistatusException multistatus)
    {
        // Here we support only addressbooks renaming. Check that user has permissions to write.
        string sql = @"UPDATE [card_AddressbookFolder] SET Name=@Name 
            WHERE [AddressbookFolderId]=@AddressbookFolderId
            AND [AddressbookFolderId] IN (SELECT [AddressbookFolderId] FROM [card_Access] WHERE [UserId]=@UserId AND [Write] = 1)";

        if (await Context.ExecuteNonQueryAsync(sql, 
              "@Name"               , destName
            , "@UserId"             , Context.UserId
            , "@AddressbookFolderId", addressbookFolderId) < 1)
        {
            throw new DavException("Item not found or you do not have enough permissions to complete this operation.", DavStatus.FORBIDDEN);
        }
    }

    public override async Task DeleteAsync(MultistatusException multistatus)
    {
        // Delete address book and all vCards associated with it. Check that user has permissions to delete.
        string sql = @"DELETE FROM [card_AddressbookFolder] 
            WHERE [AddressbookFolderId]=@AddressbookFolderId
            AND [AddressbookFolderId] IN (SELECT [AddressbookFolderId] FROM [card_Access] WHERE [UserId]=@UserId AND [Owner] = 1)";

        if (await Context.ExecuteNonQueryAsync(sql,
              "@UserId"             , Context.UserId
            , "@AddressbookFolderId", addressbookFolderId) < 1)
        {
            throw new DavException("Item not found or you do not have enough permissions to complete this operation.", DavStatus.FORBIDDEN);
        }
    }

    public override async Task<IEnumerable<PropertyValue>> GetPropertiesAsync(IList<PropertyName> names, bool allprop)
    {
        IList<PropertyValue> propVals = await GetPropertyValuesAsync(
                "SELECT [Name], [Namespace], [PropVal] FROM [card_AddressbookFolderProperty] WHERE [AddressbookFolderId] = @AddressbookFolderId",
                "@AddressbookFolderId", addressbookFolderId);

        if (allprop)
        {
            return propVals;
        }
        else
        {
            IList<PropertyValue> requestedPropVals = new List<PropertyValue>();
            foreach (PropertyValue p in propVals)
            {
                if (names.Contains(p.QualifiedName))
                {
                    requestedPropVals.Add(p);
                }
            }
            return requestedPropVals;
        }
    }

    public override async Task UpdatePropertiesAsync(
        IList<PropertyValue> setProps,
        IList<PropertyName> delProps,
        MultistatusException multistatus)
    {
        foreach (PropertyValue p in setProps)
        {
            await SetPropertyAsync(p); // create or update property
        }

        foreach (PropertyName p in delProps)
        {
            await RemovePropertyAsync(p.Name, p.Namespace);
        }
    }

    private async Task<IList<PropertyValue>> GetPropertyValuesAsync(string command, params object[] prms)
    {
        List<PropertyValue> l = new List<PropertyValue>();

        using (SqlDataReader reader = await Context.ExecuteReaderAsync(command, prms))            
        {
            while (reader.Read())
            {
                string name = reader.GetString(reader.GetOrdinal("Name"));
                string ns = reader.GetString(reader.GetOrdinal("Namespace"));
                string value = reader.GetString(reader.GetOrdinal("PropVal"));
                l.Add(new PropertyValue(new PropertyName(name, ns), value));
            }
        }

        return l;
    }

    private async Task SetPropertyAsync(PropertyValue prop)
    {
        string selectCommand =
            @"SELECT Count(*) FROM [card_AddressbookFolderProperty]
              WHERE [AddressbookFolderId] = @AddressbookFolderId AND [Name] = @Name AND [Namespace] = @Namespace";

        int count = await Context.ExecuteScalarAsync<int>(
            selectCommand,
            "@AddressbookFolderId"  , addressbookFolderId,
            "@Name"                 , prop.QualifiedName.Name,
            "@Namespace"            , prop.QualifiedName.Namespace);

        // insert
        if (count == 0)
        {
            string insertCommand = @"INSERT INTO [card_AddressbookFolderProperty] ([AddressbookFolderId], [Name], [Namespace], [PropVal])
                                      VALUES(@AddressbookFolderId, @Name, @Namespace, @PropVal)";

            await Context.ExecuteNonQueryAsync(
                insertCommand,
                "@PropVal"              , prop.Value,
                "@AddressbookFolderId"  , addressbookFolderId,
                "@Name"                 , prop.QualifiedName.Name,
                "@Namespace"            , prop.QualifiedName.Namespace);
        }
        else
        {
            // update
            string command = @"UPDATE [card_AddressbookFolderProperty]
                  SET [PropVal] = @PropVal
                  WHERE [AddressbookFolderId] = @AddressbookFolderId AND [Name] = @Name AND [Namespace] = @Namespace";

            await Context.ExecuteNonQueryAsync(
                command,
                "@PropVal"              , prop.Value,
                "@AddressbookFolderId"  , addressbookFolderId,
                "@Name"                 , prop.QualifiedName.Name,
                "@Namespace"            , prop.QualifiedName.Namespace);
        }
    }

    private async Task RemovePropertyAsync(string name, string ns)
    {
        string command = @"DELETE FROM [card_AddressbookFolderProperty]
                          WHERE [AddressbookFolderId] = @AddressbookFolderId
                          AND [Name] = @Name
                          AND [Namespace] = @Namespace";

        await Context.ExecuteNonQueryAsync(
            command,
            "@AddressbookFolderId"  , addressbookFolderId,
            "@Name"                 , name,
            "@Namespace"            , ns);
    }

    public Task SetOwnerAsync(IPrincipal value)
    {
        throw new DavException("Not implemented.", DavStatus.NOT_IMPLEMENTED);
    }

    public async Task<IPrincipal> GetOwnerAsync()
    {
        DataRow rowOwner = rowsAccess.FirstOrDefault(x => x.Field<bool>("Owner") == true);
        if (rowOwner == null)
            return null;

        return await Acl.User.GetUserAsync(Context, rowOwner.Field<string>("UserId"));
    }

    public Task SetGroupAsync(IPrincipal value)
    {
        throw new DavException("Group cannot be set", DavStatus.FORBIDDEN);
    }

    public async Task<IPrincipal> GetGroupAsync()
    {
        return null; // Groups are not supported.
    }

    public async Task<IEnumerable<SupportedPrivilege>> GetSupportedPrivilegeSetAsync()
    {
        return new[] {
            new SupportedPrivilege
            {
                Privilege = Privilege.Read, IsAbstract = false, DescriptionLanguage = "en",
                Description = "Allows or denies the user the ability to read content and properties of files/folders."
            },
            new SupportedPrivilege
            {
                Privilege = Privilege.Write, IsAbstract = false, DescriptionLanguage = "en",
                Description = "Allows or denies locking an item or modifying the content, properties, or membership of a collection."
            }
        };
    }

    public async Task<IEnumerable<Privilege>> GetCurrentUserPrivilegeSetAsync()
    {
        DataRow rowAccess = rowsAccess.FirstOrDefault(x => x.Field<string>("UserId")== Context.UserId);
        if (rowAccess == null)
            return null;

        List<Privilege> privileges = new List<Privilege>();
        if (rowAccess.Field<bool>("Read"))
            privileges.Add(Privilege.Read);

        if (rowAccess.Field<bool>("Write"))
            privileges.Add(Privilege.Write);

        return privileges;
    }

    public async Task<IEnumerable<ReadAce>> GetAclAsync(IList<PropertyName> propertyNames)
    {
        IList<ReadAce> aceList = new List<ReadAce>();
        foreach (DataRow rowAccess in rowsAccess)
        {
            ReadAce ace = new ReadAce();
            ace.Principal = await Acl.User.GetUserAsync(Context, rowAccess.Field<string>("UserId"));
            if (rowAccess.Field<bool>("Read"))
                ace.GrantPrivileges.Add(Privilege.Read);
            if (rowAccess.Field<bool>("Write"))
                ace.GrantPrivileges.Add(Privilege.Write);

            ace.IsProtected = rowAccess.Field<bool>("Owner");
            aceList.Add(ace);
        }
        return aceList;
    }

    public Task SetAclAsync(IList<WriteAce> aces)
    {
        throw new DavException("Not implemented.", DavStatus.NOT_IMPLEMENTED);
    }

    public async Task<AclRestriction> GetAclRestrictionsAsync()
    {
        return new AclRestriction { NoInvert = true, GrantOnly = true };
    }

    public async Task<IEnumerable<IHierarchyItem>> GetInheritedAclSetAsync()
    {
        return new IHierarchyItem[] { };
    }

    public async Task<IEnumerable<IPrincipalFolder>> GetPrincipalCollectionSetAsync()
    {
        return new IPrincipalFolder[] { new Acl.UsersFolder(Context) };
    }

    public async Task<IPrincipal> ResolveWellKnownPrincipalAsync(WellKnownPrincipal wellKnownPrincipal)
    {
        return null;
    }

    public Task<IEnumerable<IAclHierarchyItem>> GetItemsByPropertyAsync(MatchBy matchBy, IList<PropertyName> props)
    {
        throw new DavException("Not implemented.", DavStatus.NOT_IMPLEMENTED);
    }
}

Public Class AddressbookFolder
    Inherits DavHierarchyItem
    Implements IAddressbookFolder, ICurrentUserPrincipal, IAclHierarchyItem

    Public Shared Async Function LoadByIdAsync(context As DavContext, addressbookFolderId As Guid) As Task(Of IAddressbookFolder)
        ' Load only address book that the use has access to. 
        ' Also load complete ACL for this address book.
        Dim sql As String = "SELECT * FROM [card_AddressbookFolder] 
              WHERE [AddressbookFolderId] = @AddressbookFolderId
              AND [AddressbookFolderId] IN (SELECT [AddressbookFolderId] FROM [card_Access] WHERE [UserId]=@UserId)

            ; SELECT * FROM [card_Access]
              WHERE [AddressbookFolderId] = @AddressbookFolderId
              AND [AddressbookFolderId] IN (SELECT [AddressbookFolderId] FROM [card_Access] WHERE [UserId]=@UserId)"
        Return(Await LoadAsync(context, sql,
                              "@UserId", context.UserId,
                              "@AddressbookFolderId", addressbookFolderId
                              )).FirstOrDefault()
    End Function

    Public Shared Async Function LoadAllAsync(context As DavContext) As Task(Of IEnumerable(Of IAddressbookFolder))
        ' Load only address books that the use has access to. 
        ' Also load complete ACL for each address book, but only if user has access to that address book.
        Dim sql As String = "SELECT * FROM [card_AddressbookFolder] 
              WHERE [AddressbookFolderId] IN (SELECT [AddressbookFolderId] FROM [card_Access] WHERE [UserId]=@UserId)

            ; SELECT * FROM [card_Access] 
              WHERE [AddressbookFolderId] IN (SELECT [AddressbookFolderId] FROM [card_Access] WHERE [UserId]=@UserId)"
        Return Await LoadAsync(context, sql, "@UserId", context.UserId)
    End Function

    Private Shared Async Function LoadAsync(context As DavContext, sql As String, ParamArray prms As Object()) As Task(Of IEnumerable(Of IAddressbookFolder))
        Dim addressbookFolders As IList(Of IAddressbookFolder) = New List(Of IAddressbookFolder)()
        Using reader As SqlDataReader = Await context.ExecuteReaderAsync(sql, prms)
            Dim addressbooks As DataTable = New DataTable()
            addressbooks.Load(reader)
            Dim access As DataTable = New DataTable()
            access.Load(reader)
            For Each rowAddressbookFolder As DataRow In addressbooks.Rows
                Dim addressbookFolderId As Guid = rowAddressbookFolder.Field(Of Guid)("AddressbookFolderId")
                Dim filter As String = String.Format("AddressbookFolderId = '{0}'", addressbookFolderId)
                Dim rowsAccess As DataRow() = access.Select(filter)
                addressbookFolders.Add(New AddressbookFolder(context, addressbookFolderId, rowAddressbookFolder, rowsAccess))
            Next
        End Using

        Return addressbookFolders
    End Function

    Friend Shared Async Function CreateAddressbookFolderAsync(context As DavContext, name As String, description As String) As Task(Of IAddressbookFolder)
        ' 1. Create address book.
        ' 2. Grant owner privileges to the user on the created address book(s).
        Dim sql As String = "INSERT INTO [card_AddressbookFolder] (
                      [AddressbookFolderId]
                    , [Name]
                    , [Description]
                ) VALUES (
                      @AddressbookFolderId
                    , @Name
                    , @Description
                )
                ; INSERT INTO [card_Access] (
                      [AddressbookFolderId]
                    , [UserId]
                    , [Owner]
                    , [Read]
                    , [Write]
                ) VALUES (
                      @AddressbookFolderId
                    , @UserId
                    , @Owner
                    , @Read
                    , @Write
                )"
        Dim addressbookFolderId As Guid = Guid.NewGuid()
        Await context.ExecuteNonQueryAsync(sql,
                                          "@AddressbookFolderId", addressbookFolderId,
                                          "@Name", name,
                                          "@Description", description,
                                          "@UserId", context.UserId,
                                          "@Owner", True, "@Read", True, "@Write", True)
        Return Await LoadByIdAsync(context, addressbookFolderId)
    End Function

    Private ReadOnly addressbookFolderId As Guid

    Private ReadOnly rowAddressbookFolder As DataRow

    Private ReadOnly rowsAccess As DataRow()

    Public Overrides ReadOnly Property Name As String Implements IHierarchyItemBase.Name
        Get
            Return If(rowAddressbookFolder IsNot Nothing, rowAddressbookFolder.Field(Of String)("Name"), Nothing)
        End Get
    End Property

    Public Overrides ReadOnly Property Path As String Implements IHierarchyItemBase.Path
        Get
            Return String.Format("{0}{1}/", AddressbooksRootFolder.AddressbooksRootFolderPath, addressbookFolderId)
        End Get
    End Property

    Private Sub New(context As DavContext, addressbookFolderId As Guid, addressbook As DataRow, rowsAccess As DataRow())
        MyBase.New(context)
        Me.addressbookFolderId = addressbookFolderId
        Me.rowAddressbookFolder = addressbook
        Me.rowsAccess = rowsAccess
    End Sub

    Public Async Function MultiGetAsync(pathList As IEnumerable(Of String), propNames As IEnumerable(Of PropertyName)) As Task(Of IEnumerable(Of ICardFile)) Implements IAddressbookReport.MultiGetAsync
        ' Get list of file names from path list.
        Dim fileNames As IEnumerable(Of String) = pathList.Select(Function(a) System.IO.Path.GetFileNameWithoutExtension(a))
        Return Await CardFile.LoadByFileNamesAsync(Context, fileNames, PropsToLoad.All)
    End Function

    Public Async Function QueryAsync(rawQuery As String, propNames As IEnumerable(Of PropertyName)) As Task(Of IEnumerable(Of ICardFile)) Implements IAddressbookReport.QueryAsync
        ' For the sake of simplicity we just call GetChildren returning all items. 
        ' Typically you will return only items that match the query.
        Return(Await GetChildrenAsync(propNames.ToList(), Nothing, Nothing, Nothing)).Page.Cast(Of ICardFile)()
    End Function

    Public ReadOnly Property AddressbookDescription As String Implements IAddressbookFolder.AddressbookDescription
        Get
            Return rowAddressbookFolder.Field(Of String)("Description")
        End Get
    End Property

    Public Async Function GetChildrenAsync(propNames As IList(Of PropertyName), offset As Long?, nResults As Long?, orderProps As IList(Of OrderProperty)) As Task(Of PageResults) Implements IItemCollection.GetChildrenAsync
        ' Here we enumerate all business cards contained in this address book.
        ' You can filter children items in this implementation and 
        ' return only items that you want to be available for this 
        ' particular user.
        ' Typically only getcontenttype and getetag properties are requested in GetChildren call by CalDAV/CardDAV clients.
        ' The iCalendar/vCard (calendar-data/address-data) is typically requested not in GetChildren, but in a separate multiget 
        ' report, in MultiGetAsync() method call, that follows this request.
        ' Bynari submits PROPFIND without props - Engine will request getcontentlength
        Dim children As IList(Of IHierarchyItem) = New List(Of IHierarchyItem)()
        Return New PageResults((Await CardFile.LoadByAddressbookFolderIdAsync(Context, addressbookFolderId, PropsToLoad.Minimum)), Nothing)
    End Function

    Public Async Function CreateFileAsync(name As String, content As Stream, contentType As String, totalFileSize As Long) As Task(Of IFile) Implements IFolder.CreateFileAsync
        ' The actual business card file is created in datatbase in CardFile.Write call.
        Dim fileName As String = System.IO.Path.GetFileNameWithoutExtension(name)
        Return CardFile.CreateCardFile(Context, addressbookFolderId, fileName)
    End Function

    Public Async Function CreateFolderAsync(name As String) As Task(Of IFolder) Implements IFolder.CreateFolderAsync
        Throw New DavException("Not allowed.", DavStatus.NOT_ALLOWED)
    End Function

    Public Overrides Async Function MoveToAsync(destFolder As IItemCollection, destName As String, multistatus As MultistatusException) As Task Implements IHierarchyItem.MoveToAsync
        ' Here we support only addressbooks renaming. Check that user has permissions to write.
        Dim sql As String = "UPDATE [card_AddressbookFolder] SET Name=@Name 
            WHERE [AddressbookFolderId]=@AddressbookFolderId
            AND [AddressbookFolderId] IN (SELECT [AddressbookFolderId] FROM [card_Access] WHERE [UserId]=@UserId AND [Write] = 1)"
        If Await Context.ExecuteNonQueryAsync(sql, 
                                             "@Name", destName,
                                             "@UserId", Context.UserId,
                                             "@AddressbookFolderId", addressbookFolderId) < 1 Then
            Throw New DavException("Item not found or you do not have enough permissions to complete this operation.", DavStatus.FORBIDDEN)
        End If
    End Function

    Public Overrides Async Function DeleteAsync(multistatus As MultistatusException) As Task Implements IHierarchyItem.DeleteAsync
        ' Delete address book and all vCards associated with it. Check that user has permissions to delete.
        Dim sql As String = "DELETE FROM [card_AddressbookFolder] 
            WHERE [AddressbookFolderId]=@AddressbookFolderId
            AND [AddressbookFolderId] IN (SELECT [AddressbookFolderId] FROM [card_Access] WHERE [UserId]=@UserId AND [Owner] = 1)"
        If Await Context.ExecuteNonQueryAsync(sql,
                                             "@UserId", Context.UserId,
                                             "@AddressbookFolderId", addressbookFolderId) < 1 Then
            Throw New DavException("Item not found or you do not have enough permissions to complete this operation.", DavStatus.FORBIDDEN)
        End If
    End Function

    Public Overrides Async Function GetPropertiesAsync(names As IList(Of PropertyName), allprop As Boolean) As Task(Of IEnumerable(Of PropertyValue)) Implements IHierarchyItem.GetPropertiesAsync
        Dim propVals As IList(Of PropertyValue) = Await GetPropertyValuesAsync("SELECT [Name], [Namespace], [PropVal] FROM [card_AddressbookFolderProperty] WHERE [AddressbookFolderId] = @AddressbookFolderId",
                                                                              "@AddressbookFolderId", addressbookFolderId)
        If allprop Then
            Return propVals
        Else
            Dim requestedPropVals As IList(Of PropertyValue) = New List(Of PropertyValue)()
            For Each p As PropertyValue In propVals
                If names.Contains(p.QualifiedName) Then
                    requestedPropVals.Add(p)
                End If
            Next

            Return requestedPropVals
        End If
    End Function

    Public Overrides Async Function UpdatePropertiesAsync(setProps As IList(Of PropertyValue),
                                                         delProps As IList(Of PropertyName),
                                                         multistatus As MultistatusException) As Task Implements IHierarchyItem.UpdatePropertiesAsync
        For Each p As PropertyValue In setProps
            Await SetPropertyAsync(p)
        Next

        For Each p As PropertyName In delProps
            Await RemovePropertyAsync(p.Name, p.Namespace)
        Next
    End Function

    Private Async Function GetPropertyValuesAsync(command As String, ParamArray prms As Object()) As Task(Of IList(Of PropertyValue))
        Dim l As List(Of PropertyValue) = New List(Of PropertyValue)()
        Using reader As SqlDataReader = Await Context.ExecuteReaderAsync(command, prms)
            While reader.Read()
                Dim name As String = reader.GetString(reader.GetOrdinal("Name"))
                Dim ns As String = reader.GetString(reader.GetOrdinal("Namespace"))
                Dim value As String = reader.GetString(reader.GetOrdinal("PropVal"))
                l.Add(New PropertyValue(New PropertyName(name, ns), value))
            End While
        End Using

        Return l
    End Function

    Private Async Function SetPropertyAsync(prop As PropertyValue) As Task
        Dim selectCommand As String = "SELECT Count(*) FROM [card_AddressbookFolderProperty]
              WHERE [AddressbookFolderId] = @AddressbookFolderId AND [Name] = @Name AND [Namespace] = @Namespace"
        Dim count As Integer = Await Context.ExecuteScalarAsync(Of Integer)(selectCommand,
                                                                           "@AddressbookFolderId", addressbookFolderId,
                                                                           "@Name", prop.QualifiedName.Name,
                                                                           "@Namespace", prop.QualifiedName.Namespace)
        ' insert
        If count = 0 Then
            Dim insertCommand As String = "INSERT INTO [card_AddressbookFolderProperty] ([AddressbookFolderId], [Name], [Namespace], [PropVal])
                                      VALUES(@AddressbookFolderId, @Name, @Namespace, @PropVal)"
            Await Context.ExecuteNonQueryAsync(insertCommand,
                                              "@PropVal", prop.Value,
                                              "@AddressbookFolderId", addressbookFolderId,
                                              "@Name", prop.QualifiedName.Name,
                                              "@Namespace", prop.QualifiedName.Namespace)
        Else
            ' update
            Dim command As String = "UPDATE [card_AddressbookFolderProperty]
                  SET [PropVal] = @PropVal
                  WHERE [AddressbookFolderId] = @AddressbookFolderId AND [Name] = @Name AND [Namespace] = @Namespace"
            Await Context.ExecuteNonQueryAsync(command,
                                              "@PropVal", prop.Value,
                                              "@AddressbookFolderId", addressbookFolderId,
                                              "@Name", prop.QualifiedName.Name,
                                              "@Namespace", prop.QualifiedName.Namespace)
        End If
    End Function

    Private Async Function RemovePropertyAsync(name As String, ns As String) As Task
        Dim command As String = "DELETE FROM [card_AddressbookFolderProperty]
                          WHERE [AddressbookFolderId] = @AddressbookFolderId
                          AND [Name] = @Name
                          AND [Namespace] = @Namespace"
        Await Context.ExecuteNonQueryAsync(command,
                                          "@AddressbookFolderId", addressbookFolderId,
                                          "@Name", name,
                                          "@Namespace", ns)
    End Function

    Public Function SetOwnerAsync(value As IPrincipal) As Task Implements IAclHierarchyItem.SetOwnerAsync
        Throw New DavException("Not implemented.", DavStatus.NOT_IMPLEMENTED)
    End Function

    Public Async Function GetOwnerAsync() As Task(Of IPrincipal) Implements IAclHierarchyItem.GetOwnerAsync
        Dim rowOwner As DataRow = rowsAccess.FirstOrDefault(Function(x) x.Field(Of Boolean)("Owner") = True)
        If rowOwner Is Nothing Then Return Nothing
        Return Await Acl.User.GetUserAsync(Context, rowOwner.Field(Of String)("UserId"))
    End Function

    Public Function SetGroupAsync(value As IPrincipal) As Task Implements IAclHierarchyItem.SetGroupAsync
        Throw New DavException("Group cannot be set", DavStatus.FORBIDDEN)
    End Function

    Public Async Function GetGroupAsync() As Task(Of IPrincipal) Implements IAclHierarchyItem.GetGroupAsync
        Return Nothing
    End Function

    Public Async Function GetSupportedPrivilegeSetAsync() As Task(Of IEnumerable(Of SupportedPrivilege)) Implements IAclHierarchyItem.GetSupportedPrivilegeSetAsync
        Return {New SupportedPrivilege With {.Privilege = Privilege.Read, .IsAbstract = False, .DescriptionLanguage = "en",
                                       .Description = "Allows or denies the user the ability to read content and properties of files/folders."},
               New SupportedPrivilege With {.Privilege = Privilege.Write, .IsAbstract = False, .DescriptionLanguage = "en",
                                                                                                                                                                                                                                                             .Description = "Allows or denies locking an item or modifying the content, properties, or membership of a collection."}}
    End Function

    Public Async Function GetCurrentUserPrivilegeSetAsync() As Task(Of IEnumerable(Of Privilege)) Implements IAclHierarchyItem.GetCurrentUserPrivilegeSetAsync
        Dim rowAccess As DataRow = rowsAccess.FirstOrDefault(Function(x) x.Field(Of String)("UserId") = Context.UserId)
        If rowAccess Is Nothing Then Return Nothing
        Dim privileges As List(Of Privilege) = New List(Of Privilege)()
        If rowAccess.Field(Of Boolean)("Read") Then privileges.Add(Privilege.Read)
        If rowAccess.Field(Of Boolean)("Write") Then privileges.Add(Privilege.Write)
        Return privileges
    End Function

    Public Async Function GetAclAsync(propertyNames As IList(Of PropertyName)) As Task(Of IEnumerable(Of ReadAce)) Implements IAclHierarchyItem.GetAclAsync
        Dim aceList As IList(Of ReadAce) = New List(Of ReadAce)()
        For Each rowAccess As DataRow In rowsAccess
            Dim ace As ReadAce = New ReadAce()
            ace.Principal = Await Acl.User.GetUserAsync(Context, rowAccess.Field(Of String)("UserId"))
            If rowAccess.Field(Of Boolean)("Read") Then ace.GrantPrivileges.Add(Privilege.Read)
            If rowAccess.Field(Of Boolean)("Write") Then ace.GrantPrivileges.Add(Privilege.Write)
            ace.IsProtected = rowAccess.Field(Of Boolean)("Owner")
            aceList.Add(ace)
        Next

        Return aceList
    End Function

    Public Function SetAclAsync(aces As IList(Of WriteAce)) As Task Implements IAclHierarchyItem.SetAclAsync
        Throw New DavException("Not implemented.", DavStatus.NOT_IMPLEMENTED)
    End Function

    Public Async Function GetAclRestrictionsAsync() As Task(Of AclRestriction) Implements IAclHierarchyItem.GetAclRestrictionsAsync
        Return New AclRestriction With {.NoInvert = True, .GrantOnly = True}
    End Function

    Public Async Function GetInheritedAclSetAsync() As Task(Of IEnumerable(Of IHierarchyItem)) Implements IAclHierarchyItem.GetInheritedAclSetAsync
        Return New IHierarchyItem() {}
    End Function

    Public Async Function GetPrincipalCollectionSetAsync() As Task(Of IEnumerable(Of IPrincipalFolder)) Implements IAclHierarchyItem.GetPrincipalCollectionSetAsync
        Return New IPrincipalFolder() {New Acl.UsersFolder(Context)}
    End Function

    Public Async Function ResolveWellKnownPrincipalAsync(wellKnownPrincipal As WellKnownPrincipal) As Task(Of IPrincipal) Implements IAclHierarchyItem.ResolveWellKnownPrincipalAsync
        Return Nothing
    End Function

    Public Function GetItemsByPropertyAsync(matchBy As MatchBy, props As IList(Of PropertyName)) As Task(Of IEnumerable(Of IAclHierarchyItem)) Implements IAclHierarchyItem.GetItemsByPropertyAsync
        Throw New DavException("Not implemented.", DavStatus.NOT_IMPLEMENTED)
    End Function
End Class
Namespace

No code example is currently available or this language may not be supported.

No code example is currently available or this language may not be supported.