ICalendarDiscoveryAsync Interface

public interface ICalendarDiscoveryAsync : ICalendarItem

public interface ICalendarDiscoveryAsync : ICalendarItem

Public Interface ICalendarDiscoveryAsync
	Inherits ICalendarItem

Public Interface ICalendarDiscoveryAsync
	Inherits ICalendarItem

public interface class ICalendarDiscoveryAsync : ICalendarItem

public interface class ICalendarDiscoveryAsync : ICalendarItem

type ICalendarDiscoveryAsync =  
    interface
        interface ICalendarItem
    end

type ICalendarDiscoveryAsync =  
    interface
        interface ICalendarItem
    end

public class Discovery : ICalendarDiscoveryAsync
{
    protected DavContext Context;

    public Discovery(DavContext context)
    {
        this.Context = context;
    }

    public async Task<IEnumerable<IItemCollectionAsync>> GetCalendarHomeSetAsync()
    {
        return new[] { new CalendarsRootFolder(Context) };
    }

    public bool CalendarHomeSetEnabled
    {
        get
        {
            return true;
        }
    }

Public Class Discovery
    Implements ICalendarDiscoveryAsync

    Protected Context As DavContext

    Public Sub New(context As DavContext)
        Me.Context = context
    End Sub

    Public Async Function GetCalendarHomeSetAsync() As Task(Of IEnumerable(Of IItemCollectionAsync)) Implements ICalendarDiscoveryAsync.GetCalendarHomeSetAsync
        Return {New CalendarsRootFolder(Context)}
    End Function

    Public ReadOnly Property CalendarHomeSetEnabled As Boolean Implements ICalendarDiscoveryAsync.CalendarHomeSetEnabled
        Get
            Return True
        End Get
    End Property
End Class

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.

public class Discovery : IAddressbookDiscoveryAsync
{
    protected DavContext Context;

    public Discovery(DavContext context)
    {
        this.Context = context;
    }

    public async Task<IEnumerable<IItemCollectionAsync>> GetAddressbookHomeSetAsync()
    {
        return new[] { new AddressbooksRootFolder(Context) };
    }

    public bool AddressbookHomeSetEnabled
    {
        get
        {
            return true;
        }
    }

Public Class Discovery
    Implements IAddressbookDiscoveryAsync

    Protected Context As DavContext

    Public Sub New(context As DavContext)
        Me.Context = context
    End Sub

    Public Async Function GetAddressbookHomeSetAsync() As Task(Of IEnumerable(Of IItemCollectionAsync)) Implements IAddressbookDiscoveryAsync.GetAddressbookHomeSetAsync
        Return {New AddressbooksRootFolder(Context)}
    End Function

    Public ReadOnly Property AddressbookHomeSetEnabled As Boolean Implements IAddressbookDiscoveryAsync.AddressbookHomeSetEnabled
        Get
            Return True
        End Get
    End Property
End Class

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.

public class CalendarsRootFolder : LogicalFolder, IFolderAsync
{
    private static readonly string calendarsRootFolderName = "calendars";

    public static string CalendarsRootFolderPath = DavLocationFolder.DavLocationFolderPath + calendarsRootFolderName + '/';

    public CalendarsRootFolder(DavContext context)
        : base(context, CalendarsRootFolderPath)
    {
    }

    public override async Task<PageResults> GetChildrenAsync(IList<PropertyName> propNames, long? offset, long? nResults, IList<OrderProperty> orderProps)
    {           
        // Here we list calendars from back-end storage. 
        // You can filter calendars if requied and return only calendars that user has access to.
        return new PageResults((await CalendarFolder.LoadAllAsync(Context)).OrderBy(x => x.Name), null);
    }

    public Task<IFileAsync> CreateFileAsync(string name)
    {
        throw new DavException("Not implemented.", DavStatus.NOT_IMPLEMENTED);
    }

    public async Task CreateFolderAsync(string name)
    {
        await CalendarFolder.CreateCalendarFolderAsync(Context, name, "");
    }
}

Public Class CalendarsRootFolder
    Inherits LogicalFolder
    Implements IFolderAsync

    Private Shared ReadOnly calendarsRootFolderName As String = "calendars"

    Public Shared CalendarsRootFolderPath As String = DavLocationFolder.DavLocationFolderPath & calendarsRootFolderName & "/"c

    Public Sub New(context As DavContext)
        MyBase.New(context, CalendarsRootFolderPath)
    End Sub

    Public Overrides Async Function GetChildrenAsync(propNames As IList(Of PropertyName), offset As Long?, nResults As Long?, orderProps As IList(Of OrderProperty)) As Task(Of PageResults) Implements IItemCollectionAsync.GetChildrenAsync
        ' Here we list calendars from back-end storage. 
        ' You can filter calendars if requied and return only calendars that user has access to.
        Return New PageResults((Await CalendarFolder.LoadAllAsync(Context)).OrderBy(Function(x) x.Name), Nothing)
    End Function

    Public Function CreateFileAsync(name As String) As Task(Of IFileAsync) Implements IFolderAsync.CreateFileAsync
        Throw New DavException("Not implemented.", DavStatus.NOT_IMPLEMENTED)
    End Function

    Public Async Function CreateFolderAsync(name As String) As Task Implements IFolderAsync.CreateFolderAsync
        Await CalendarFolder.CreateCalendarFolderAsync(Context, name, "")
    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.

// Note:
//  - Mozilla Thunderbird Lightning requires ICurrentUserPrincipalAsync on calendar folder, it does not support discovery.
//  - Outlook CalDAV Synchronizer requires IAclHierarchyItemAsync on calendar folder.

public class CalendarFolder : DavHierarchyItem, ICalendarFolderAsync, IAppleCalendarAsync, ICurrentUserPrincipalAsync, IAclHierarchyItemAsync
{
    public static async Task<ICalendarFolderAsync> LoadByIdAsync(DavContext context, Guid calendarFolderId)
    {
        // Load only calendar that the use has access to. 
        // Also load complete ACL for this calendar.
        string sql =
            @"SELECT * FROM [cal_CalendarFolder] 
              WHERE [CalendarFolderId] = @CalendarFolderId
              AND [CalendarFolderId] IN (SELECT [CalendarFolderId] FROM [cal_Access] WHERE [UserId]=@UserId)

            ; SELECT * FROM [cal_Access]
              WHERE [CalendarFolderId] = @CalendarFolderId
              AND [CalendarFolderId] IN (SELECT [CalendarFolderId] FROM [cal_Access] WHERE [UserId]=@UserId)";

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

    public static async Task<IEnumerable<ICalendarFolderAsync>> LoadAllAsync(DavContext context)
    {
        // Load only calendars that the use has access to. 
        // Also load complete ACL for each calendar, but only if user has access to that calendar.
        string sql =
            @"SELECT * FROM [cal_CalendarFolder] 
              WHERE [CalendarFolderId] IN (SELECT [CalendarFolderId] FROM [cal_Access] WHERE [UserId]=@UserId)

            ; SELECT * FROM [cal_Access] 
              WHERE [CalendarFolderId] IN (SELECT [CalendarFolderId] FROM [cal_Access] WHERE [UserId]=@UserId)";

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

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

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

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

            foreach (DataRow rowCalendarFolder in calendars.Rows)
            {
                Guid calendarFolderId = rowCalendarFolder.Field<Guid>("CalendarFolderId");

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

                calendarFolders.Add(new CalendarFolder(context, calendarFolderId, rowCalendarFolder, rowsAccess));
            }
        }

        return calendarFolders;
    }

    public static async Task CreateCalendarFolderAsync(DavContext context, string name, string description)
    {
        // 1. Create calendar.
        // 2. Grant owner privileges to the user on the created calendar.
        string sql = @"INSERT INTO [cal_CalendarFolder] (
                      [CalendarFolderId]
                    , [Name]
                    , [Description]
                ) VALUES (
                      @CalendarFolderId
                    , @Name
                    , @Description
                )
                ; INSERT INTO [cal_Access] (
                      [CalendarFolderId]
                    , [UserId]
                    , [Owner]
                    , [Read]
                    , [Write]
                ) VALUES (
                      @CalendarFolderId
                    , @UserId
                    , @Owner
                    , @Read
                    , @Write
                )";

        Guid calendarFolderId = Guid.NewGuid();

        await context.ExecuteNonQueryAsync(sql,
              "@CalendarFolderId"   , calendarFolderId
            , "@Name"               , name
            , "@Description"        , description
            , "@UserId"             , context.UserId
            , "@Owner"              , true
            , "@Read"               , true
            , "@Write"              , true
            );
    }

    private readonly Guid calendarFolderId;

    private readonly DataRow rowCalendarFolder;

    private readonly DataRow[] rowsAccess;

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

    public override string Path
    {
        get
        {
            return string.Format("{0}{1}/", CalendarsRootFolder.CalendarsRootFolderPath, calendarFolderId);
        }
    }

    private CalendarFolder(DavContext context, Guid calendarFolderId, DataRow calendar, DataRow[] rowsAccess)
        : base(context)
    {
        this.calendarFolderId = calendarFolderId;
        this.rowCalendarFolder = calendar;
        this.rowsAccess = rowsAccess;
    }

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

        return await CalendarFile.LoadByUidsAsync(Context, uids, PropsToLoad.All);
    }

    public async Task<IEnumerable<ICalendarFileAsync>> 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<ICalendarFileAsync>();
    }

    public IEnumerable<CalendarComponentType> SupportedComponentTypes
    {
        get
        {
            return new[]
                {
                    CalendarComponentType.VEVENT,
                    CalendarComponentType.VTODO,
                };
        }
    }

    public string CalendarDescription 
    {
        get { return rowCalendarFolder.Field<string>("Description"); }
    }

    public ulong MaxResourceSize
    {
        get { return ulong.MaxValue; }
    }

    public ulong MaxInstances
    {
        get { return ulong.MaxValue; }
    }

    public ulong MaxAttendeesPerInstance
    {
        get { return ulong.MaxValue; }
    }

    public DateTime UtcMinDateTime
    {
        get { return DateTime.MinValue.ToUniversalTime(); }
    }

    public DateTime UtcMaxDateTime
    {
        get { return DateTime.MaxValue.ToUniversalTime(); }
    }

    public async Task<PageResults> GetChildrenAsync(IList<PropertyName> propNames, long? offset, long? nResults, IList<OrderProperty> orderProps)
    {
        // Here we enumerate all events and to-dos contained in this calendar.
        // 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, that follow this request.

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

        IList<IHierarchyItemAsync> children = new List<IHierarchyItemAsync>();
        return new PageResults((await CalendarFile.LoadByCalendarFolderIdAsync(Context, calendarFolderId, PropsToLoad.Minimum)), null);
    }

    public async Task<IFileAsync> CreateFileAsync(string name)
    {
        // The actual event or to-do object is created in datatbase in CardFile.Write call.
        return CalendarFile.CreateCalendarFile(Context, calendarFolderId);
    }

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

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

        if (await Context.ExecuteNonQueryAsync(sql,
              "@UserId"             , Context.UserId
            , "@CalendarFolderId"   , calendarFolderId
            , "@Name"               , destName) < 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 calendar and all events / to-dos associated with it. Check that user has permissions to delete.
        string sql = @"DELETE FROM [cal_CalendarFolder] 
            WHERE [CalendarFolderId]=@CalendarFolderId
            AND [CalendarFolderId] IN (SELECT [CalendarFolderId] FROM [cal_Access] WHERE [UserId] = @UserId AND [Owner] = 1)";

        if (await Context.ExecuteNonQueryAsync(sql,
              "@UserId"             , Context.UserId
            , "@CalendarFolderId"   , calendarFolderId) < 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 [cal_CalendarFolderProperty] WHERE [CalendarFolderId] = @CalendarFolderId",
                "@CalendarFolderId", calendarFolderId);

        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 (await reader.ReadAsync())
            {
                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 [cal_CalendarFolderProperty]
              WHERE [CalendarFolderId] = @CalendarFolderId AND [Name] = @Name AND [Namespace] = @Namespace";

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

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

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

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

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

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


    public IEnumerable<AppleAllowedSharingMode> AllowedSharingModes
    {
        get
        {
            return new[]
                {
                    AppleAllowedSharingMode.CanBePublished,
                    AppleAllowedSharingMode.CanBeShared,
                };
        }
    }

    public async Task UpdateSharingAsync(IList<AppleShare> sharesToAddAndRemove)
    {
        // Drop all shares first regardless of operation order. When resending 
        // invitations Apple Calendar drops and adds shares for the user in one \
        // request.
        foreach (AppleShare share in sharesToAddAndRemove)
        {
            if (share.Operation == AppleSharingOperation.Withdraw)
            {
                // remove sharing here
                // share.Address
                // share.CommonName
            }
        }

        // Add new shares
        foreach (AppleShare share in sharesToAddAndRemove)
        {
            if (share.Operation != AppleSharingOperation.Withdraw)
            {
                // enable sharing and send invitation here
                // share.Address
                // share.CommonName
            }
        }
    }

    public async Task<IEnumerable<SharingInvite>> GetInviteAsync()
    {

        IList<SharingInvite> invites = new List<SharingInvite>();

        foreach (DataRow rowAccess in rowsAccess)
        {
            if (rowAccess.Field<bool>("Owner"))
                continue;

            string userId = rowAccess.Field<string>("UserId");
            System.Web.Security.MembershipUser user = System.Web.Security.Membership.GetUser(userId);

            SharingInvite ace = new SharingInvite
            {
                  Address       = string.Format("email:{0}", user.Email)
                , Access        = rowAccess.Field<bool>("Write") ? SharingInviteAccess.ReadWrite : SharingInviteAccess.Read
                , CommonName    = user.UserName
                , Status        = SharingInviteStatus.Accepted
            };
        }

        return invites;
    }

    public async Task<CalendarSharedBy> GetSharedByAsync()
    {
        if (rowsAccess.Any(x => !x.Field<bool>("Owner")))
        {
            return CalendarSharedBy.NotShared;
        }

        string ownerId = rowsAccess.First(x => x.Field<bool>("Owner")).Field<string>("UserId");
        if (ownerId.Equals(Context.UserId, StringComparison.InvariantCultureIgnoreCase))
        {
            return CalendarSharedBy.SharedByOwner;
        }
        else
        {
            return CalendarSharedBy.Shared;
        }
    }

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

    public async Task<IPrincipalAsync> 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(IPrincipalAsync value)
    {
        throw new DavException("Group cannot be set", DavStatus.FORBIDDEN);
    }

    public async Task<IPrincipalAsync> 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<IHierarchyItemAsync>> GetInheritedAclSetAsync()
    {
        return new IHierarchyItemAsync[] { };
    }

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

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

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

' Note:
'  - Mozilla Thunderbird Lightning requires ICurrentUserPrincipalAsync on calendar folder, it does not support discovery.
'  - Outlook CalDAV Synchronizer requires IAclHierarchyItemAsync on calendar folder.
Public Class CalendarFolder
    Inherits DavHierarchyItem
    Implements ICalendarFolderAsync, IAppleCalendarAsync, ICurrentUserPrincipalAsync, IAclHierarchyItemAsync

    Public Shared Async Function LoadByIdAsync(context As DavContext, calendarFolderId As Guid) As Task(Of ICalendarFolderAsync)
        ' Load only calendar that the use has access to. 
        ' Also load complete ACL for this calendar.
        Dim sql As String = "SELECT * FROM [cal_CalendarFolder] 
              WHERE [CalendarFolderId] = @CalendarFolderId
              AND [CalendarFolderId] IN (SELECT [CalendarFolderId] FROM [cal_Access] WHERE [UserId]=@UserId)

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

    Public Shared Async Function LoadAllAsync(context As DavContext) As Task(Of IEnumerable(Of ICalendarFolderAsync))
        ' Load only calendars that the use has access to. 
        ' Also load complete ACL for each calendar, but only if user has access to that calendar.
        Dim sql As String = "SELECT * FROM [cal_CalendarFolder] 
              WHERE [CalendarFolderId] IN (SELECT [CalendarFolderId] FROM [cal_Access] WHERE [UserId]=@UserId)

            ; SELECT * FROM [cal_Access] 
              WHERE [CalendarFolderId] IN (SELECT [CalendarFolderId] FROM [cal_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 ICalendarFolderAsync))
        Dim calendarFolders As IList(Of ICalendarFolderAsync) = New List(Of ICalendarFolderAsync)()
        Using reader As SqlDataReader = Await context.ExecuteReaderAsync(sql, prms)
            Dim calendars As DataTable = New DataTable()
            calendars.Load(reader)
            Dim access As DataTable = New DataTable()
            access.Load(reader)
            For Each rowCalendarFolder As DataRow In calendars.Rows
                Dim calendarFolderId As Guid = rowCalendarFolder.Field(Of Guid)("CalendarFolderId")
                Dim filter As String = String.Format("CalendarFolderId = '{0}'", calendarFolderId)
                Dim rowsAccess As DataRow() = access.Select(filter)
                calendarFolders.Add(New CalendarFolder(context, calendarFolderId, rowCalendarFolder, rowsAccess))
            Next
        End Using

        Return calendarFolders
    End Function

    Public Shared Async Function CreateCalendarFolderAsync(context As DavContext, name As String, description As String) As Task
        ' 1. Create calendar.
        ' 2. Grant owner privileges to the user on the created calendar.
        Dim sql As String = "INSERT INTO [cal_CalendarFolder] (
                      [CalendarFolderId]
                    , [Name]
                    , [Description]
                ) VALUES (
                      @CalendarFolderId
                    , @Name
                    , @Description
                )
                ; INSERT INTO [cal_Access] (
                      [CalendarFolderId]
                    , [UserId]
                    , [Owner]
                    , [Read]
                    , [Write]
                ) VALUES (
                      @CalendarFolderId
                    , @UserId
                    , @Owner
                    , @Read
                    , @Write
                )"
        Dim calendarFolderId As Guid = Guid.NewGuid()
        Await context.ExecuteNonQueryAsync(sql,
                                          "@CalendarFolderId", calendarFolderId,
                                          "@Name", name,
                                          "@Description", description,
                                          "@UserId", context.UserId,
                                          "@Owner", True, "@Read", True, "@Write", True)
    End Function

    Private ReadOnly calendarFolderId As Guid

    Private ReadOnly rowCalendarFolder As DataRow

    Private ReadOnly rowsAccess As DataRow()

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

    Public Overrides ReadOnly Property Path As String Implements IHierarchyItemBaseAsync.Path
        Get
            Return String.Format("{0}{1}/", CalendarsRootFolder.CalendarsRootFolderPath, calendarFolderId)
        End Get
    End Property

    Private Sub New(context As DavContext, calendarFolderId As Guid, calendar As DataRow, rowsAccess As DataRow())
        MyBase.New(context)
        Me.calendarFolderId = calendarFolderId
        Me.rowCalendarFolder = calendar
        Me.rowsAccess = rowsAccess
    End Sub

    Public Async Function MultiGetAsync(pathList As IEnumerable(Of String), propNames As IEnumerable(Of PropertyName)) As Task(Of IEnumerable(Of ICalendarFileAsync)) Implements ICalendarReportAsync.MultiGetAsync
        ' Get list of UIDs from path list.
        Dim uids As IEnumerable(Of String) = pathList.Select(Function(a) System.IO.Path.GetFileNameWithoutExtension(a))
        Return Await CalendarFile.LoadByUidsAsync(Context, uids, PropsToLoad.All)
    End Function

    Public Async Function QueryAsync(rawQuery As String, propNames As IEnumerable(Of PropertyName)) As Task(Of IEnumerable(Of ICalendarFileAsync)) Implements ICalendarReportAsync.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 ICalendarFileAsync)()
    End Function

    Public ReadOnly Property SupportedComponentTypes As IEnumerable(Of CalendarComponentType) Implements ICalendarFolderAsync.SupportedComponentTypes
        Get
            Return {CalendarComponentType.VEVENT,
                   CalendarComponentType.VTODO}
        End Get
    End Property

    Public ReadOnly Property CalendarDescription As String Implements ICalendarFolderAsync.CalendarDescription
        Get
            Return rowCalendarFolder.Field(Of String)("Description")
        End Get
    End Property

    Public ReadOnly Property MaxResourceSize As ULong Implements ICalendarFolderAsync.MaxResourceSize
        Get
            Return ULong.MaxValue
        End Get
    End Property

    Public ReadOnly Property MaxInstances As ULong Implements ICalendarFolderAsync.MaxInstances
        Get
            Return ULong.MaxValue
        End Get
    End Property

    Public ReadOnly Property MaxAttendeesPerInstance As ULong Implements ICalendarFolderAsync.MaxAttendeesPerInstance
        Get
            Return ULong.MaxValue
        End Get
    End Property

    Public ReadOnly Property UtcMinDateTime As DateTime Implements ICalendarFolderAsync.UtcMinDateTime
        Get
            Return DateTime.MinValue.ToUniversalTime()
        End Get
    End Property

    Public ReadOnly Property UtcMaxDateTime As DateTime Implements ICalendarFolderAsync.UtcMaxDateTime
        Get
            Return DateTime.MaxValue.ToUniversalTime()
        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 IItemCollectionAsync.GetChildrenAsync
        ' Here we enumerate all events and to-dos contained in this calendar.
        ' 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, that follow this request.
        ' Bynari submits PROPFIND without props - Engine will request getcontentlength
        Dim children As IList(Of IHierarchyItemAsync) = New List(Of IHierarchyItemAsync)()
        Return New PageResults((Await CalendarFile.LoadByCalendarFolderIdAsync(Context, calendarFolderId, PropsToLoad.Minimum)), Nothing)
    End Function

    Public Async Function CreateFileAsync(name As String) As Task(Of IFileAsync) Implements IFolderAsync.CreateFileAsync
        ' The actual event or to-do object is created in datatbase in CardFile.Write call.
        Return CalendarFile.CreateCalendarFile(Context, calendarFolderId)
    End Function

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

    Public Overrides Async Function MoveToAsync(destFolder As IItemCollectionAsync, destName As String, multistatus As MultistatusException) As Task Implements IHierarchyItemAsync.MoveToAsync
        ' Here we support only calendars renaming. Check that user has permissions to write.
        Dim sql As String = "UPDATE [cal_CalendarFolder] SET Name=@Name
            WHERE [CalendarFolderId]=@CalendarFolderId
            AND [CalendarFolderId] IN (SELECT [CalendarFolderId] FROM [cal_Access] WHERE [UserId] = @UserId AND [Write] = 1)"
        If Await Context.ExecuteNonQueryAsync(sql,
                                             "@UserId", Context.UserId,
                                             "@CalendarFolderId", calendarFolderId,
                                             "@Name", destName) < 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 IHierarchyItemAsync.DeleteAsync
        ' Delete calendar and all events / to-dos associated with it. Check that user has permissions to delete.
        Dim sql As String = "DELETE FROM [cal_CalendarFolder] 
            WHERE [CalendarFolderId]=@CalendarFolderId
            AND [CalendarFolderId] IN (SELECT [CalendarFolderId] FROM [cal_Access] WHERE [UserId] = @UserId AND [Owner] = 1)"
        If Await Context.ExecuteNonQueryAsync(sql,
                                             "@UserId", Context.UserId,
                                             "@CalendarFolderId", calendarFolderId) < 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 IHierarchyItemAsync.GetPropertiesAsync
        Dim propVals As IList(Of PropertyValue) = Await GetPropertyValuesAsync("SELECT [Name], [Namespace], [PropVal] FROM [cal_CalendarFolderProperty] WHERE [CalendarFolderId] = @CalendarFolderId",
                                                                              "@CalendarFolderId", calendarFolderId)
        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 IHierarchyItemAsync.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 Await reader.ReadAsync()
                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 [cal_CalendarFolderProperty]
              WHERE [CalendarFolderId] = @CalendarFolderId AND [Name] = @Name AND [Namespace] = @Namespace"
        Dim count As Integer = Await Context.ExecuteScalarAsync(Of Integer)(selectCommand,
                                                                           "@CalendarFolderId", calendarFolderId,
                                                                           "@Name", prop.QualifiedName.Name,
                                                                           "@Namespace", prop.QualifiedName.Namespace)
        ' insert
        If count = 0 Then
            Dim insertCommand As String = "INSERT INTO [cal_CalendarFolderProperty] ([CalendarFolderId], [Name], [Namespace], [PropVal])
                                      VALUES(@CalendarFolderId, @Name, @Namespace, @PropVal)"
            Await Context.ExecuteNonQueryAsync(insertCommand,
                                              "@PropVal", prop.Value,
                                              "@CalendarFolderId", calendarFolderId,
                                              "@Name", prop.QualifiedName.Name,
                                              "@Namespace", prop.QualifiedName.Namespace)
        Else
            ' update
            Dim command As String = "UPDATE [cal_CalendarFolderProperty]
                  SET [PropVal] = @PropVal
                  WHERE [CalendarFolderId] = @CalendarFolderId AND [Name] = @Name AND [Namespace] = @Namespace"
            Await Context.ExecuteNonQueryAsync(command,
                                              "@PropVal", prop.Value,
                                              "@CalendarFolderId", calendarFolderId,
                                              "@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 [cal_CalendarFolderProperty]
                          WHERE [CalendarFolderId] = @CalendarFolderId
                          AND [Name] = @Name
                          AND [Namespace] = @Namespace"
        Await Context.ExecuteNonQueryAsync(command,
                                          "@CalendarFolderId", calendarFolderId,
                                          "@Name", name,
                                          "@Namespace", ns)
    End Function

    Public ReadOnly Property AllowedSharingModes As IEnumerable(Of AppleAllowedSharingMode) Implements IAppleCalendarAsync.AllowedSharingModes
        Get
            Return {AppleAllowedSharingMode.CanBePublished,
                   AppleAllowedSharingMode.CanBeShared}
        End Get
    End Property

    Public Async Function UpdateSharingAsync(sharesToAddAndRemove As IList(Of AppleShare)) As Task Implements IAppleCalendarAsync.UpdateSharingAsync
        ' Drop all shares first regardless of operation order. When resending 
        ' invitations Apple Calendar drops and adds shares for the user in one \
        ' request.
        For Each share As AppleShare In sharesToAddAndRemove
            If share.Operation = AppleSharingOperation.Withdraw Then
                ' remove sharing here
                ' share.Address
                ' share.CommonName
                 End If
        Next

        ' Add new shares
        For Each share As AppleShare In sharesToAddAndRemove
            If share.Operation <> AppleSharingOperation.Withdraw Then
                ' enable sharing and send invitation here
                ' share.Address
                ' share.CommonName
                 End If
        Next
    End Function

    Public Async Function GetInviteAsync() As Task(Of IEnumerable(Of SharingInvite)) Implements IAppleCalendarAsync.GetInviteAsync
        Dim invites As IList(Of SharingInvite) = New List(Of SharingInvite)()
        For Each rowAccess As DataRow In rowsAccess
            If rowAccess.Field(Of Boolean)("Owner") Then Continue For
            Dim userId As String = rowAccess.Field(Of String)("UserId")
            Dim user As System.Web.Security.MembershipUser = System.Web.Security.Membership.GetUser(userId)
            Dim ace As SharingInvite = New SharingInvite With {.Address = String.Format("email:{0}", user.Email),
                                                         .Access = If(rowAccess.Field(Of Boolean)("Write"), SharingInviteAccess.ReadWrite, SharingInviteAccess.Read),
                                                         .CommonName = user.UserName,
                                                         .Status = SharingInviteStatus.Accepted
                                                         }
        Next

        Return invites
    End Function

    Public Async Function GetSharedByAsync() As Task(Of CalendarSharedBy) Implements IAppleCalendarAsync.GetSharedByAsync
        If rowsAccess.Any(Function(x) Not x.Field(Of Boolean)("Owner")) Then
            Return CalendarSharedBy.NotShared
        End If

        Dim ownerId As String = rowsAccess.First(Function(x) x.Field(Of Boolean)("Owner")).Field(Of String)("UserId")
        If ownerId.Equals(Context.UserId, StringComparison.InvariantCultureIgnoreCase) Then
            Return CalendarSharedBy.SharedByOwner
        Else
            Return CalendarSharedBy.Shared
        End If
    End Function

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

    Public Async Function GetOwnerAsync() As Task(Of IPrincipalAsync) Implements IAclHierarchyItemAsync.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 IPrincipalAsync) As Task Implements IAclHierarchyItemAsync.SetGroupAsync
        Throw New DavException("Group cannot be set", DavStatus.FORBIDDEN)
    End Function

    Public Async Function GetGroupAsync() As Task(Of IPrincipalAsync) Implements IAclHierarchyItemAsync.GetGroupAsync
        Return Nothing
    End Function

    Public Async Function GetSupportedPrivilegeSetAsync() As Task(Of IEnumerable(Of SupportedPrivilege)) Implements IAclHierarchyItemAsync.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 IAclHierarchyItemAsync.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 IAclHierarchyItemAsync.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 IAclHierarchyItemAsync.SetAclAsync
        Throw New DavException("Not implemented.", DavStatus.NOT_IMPLEMENTED)
    End Function

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

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

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

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

    Public Function GetItemsByPropertyAsync(matchBy As MatchBy, props As IList(Of PropertyName)) As Task(Of IEnumerable(Of IAclHierarchyItemAsync)) Implements IAclHierarchyItemAsync.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.