public async Task <DavResponse> DeleteCardDavAddressBook()
        {
            var currUser         = CoreContext.UserManager.GetUsers(SecurityContext.CurrentAccount.ID);
            var currentUserEmail = currUser.Email;
            var cardDavAB        = new CardDavAddressbook();
            var authorization    = cardDavAB.GetSystemAuthorization();
            var myUri            = HttpContext.Current.Request.GetUrlRewriter();
            var requestUrlBook   = cardDavAB.GetRadicaleUrl(myUri.ToString(), currentUserEmail, true, true);
            var tenant           = CurrentTenant;
            var davRequest       = new DavRequest()
            {
                Url           = requestUrlBook,
                Authorization = authorization,
                Header        = myUri.ToString()
            };
            await RadicaleClient.RemoveAsync(davRequest).ConfigureAwait(false);

            try
            {
                var dbConn = new DbRadicale();
                dbConn.RemoveCardDavUser(tenant, currUser.ID.ToString());

                return(new DavResponse()
                {
                    Completed = true,
                    Data = Resource.RadicaleCardDavDeleteMessage
                });
            }
            catch (Exception ex)
            {
                Log.Error("ERROR: " + ex.Message);
                return(new DavResponse()
                {
                    Completed = false,
                    Error = ex.Message
                });
            }
        }
        public async Task <DavResponse> GetCardDavUrl()
        {
            if (WebItemManager.Instance[WebItemManager.PeopleProductID].IsDisabled())
            {
                await DeleteCardDavAddressBook().ConfigureAwait(false);

                throw new MethodAccessException("Method not available");
            }

            var myUri               = HttpContext.Current.Request.GetUrlRewriter();
            var currUser            = CoreContext.UserManager.GetUsers(SecurityContext.CurrentAccount.ID);
            var userName            = currUser.Email.ToLower();
            var currentAccountPaswd = InstanceCrypto.Encrypt(userName);
            var cardBuilder         = CardDavAllSerialization(myUri);


            var cardDavAddBook    = new CardDavAddressbook();
            var userAuthorization = userName + ":" + currentAccountPaswd;
            var rootAuthorization = cardDavAddBook.GetSystemAuthorization();
            var sharedCardUrl     = cardDavAddBook.GetRadicaleUrl(myUri.ToString(), userName, true, true, true);
            var getResponse       = cardDavAddBook.GetCollection(sharedCardUrl, userAuthorization, myUri.ToString()).Result;

            if (getResponse.Completed)
            {
                return(new DavResponse()
                {
                    Completed = true,
                    Data = sharedCardUrl
                });
            }
            else if (getResponse.StatusCode == 404)
            {
                var cardAB         = new CardDavAddressbook();
                var createResponse = cardAB.Create("", "", "", sharedCardUrl, rootAuthorization).Result;
                if (createResponse.Completed)
                {
                    try
                    {
                        var dbConn = new DbRadicale();
                        dbConn.SaveCardDavUser(CurrentTenant, currUser.ID.ToString());
                    }
                    catch (Exception ex)
                    {
                        Log.Error("ERROR: " + ex.Message);
                    }

                    await cardAB.UpdateItem(sharedCardUrl, rootAuthorization, cardBuilder, myUri.ToString()).ConfigureAwait(false);

                    return(new DavResponse()
                    {
                        Completed = true,
                        Data = sharedCardUrl
                    });
                }
                Log.Error("ERROR: " + createResponse.Error);
                throw new RadicaleException(createResponse.Error);
            }
            else
            {
                Log.Error("ERROR: " + getResponse.Error);
                throw new RadicaleException(getResponse.Error);
            }
        }