/// <summary>
        /// Get provider`s fingerprints
        /// </summary>
        /// <param name="id">Id of provider</param>
        /// <returns>List response of provider`s fingerprints</returns>
        public async Task <ApiListResponse <ProviderFingerprintDisplayModel> > GetProviderFingerprints(string id)
        {
            if (string.IsNullOrWhiteSpace(id))
            {
                throw new BadRequestException();
            }

            var user = await GetCurrentUser();

            if (!await _providerRepository.ExistsWithOwner(id, user.Id))
            {
                throw new AccessDeniedException(id, typeof(Provider));
            }

            var entity = await _providerRepository.Get(id);

            if (entity.Fingerprints == null || !entity.Fingerprints.Any())
            {
                return new ApiListResponse <ProviderFingerprintDisplayModel>
                       {
                           Data  = new List <ProviderFingerprintDisplayModel>(),
                           Skip  = 0,
                           Limit = 1,
                           Total = 0
                       }
            }
            ;

            var list = entity.Fingerprints.Select(x => _mapper.Map <ProviderFingerprintDisplayModel>(x)).ToList();

            return(new ApiListResponse <ProviderFingerprintDisplayModel>
            {
                Data = list,
                Limit = list.Count,
                Skip = 0,
                Total = list.Count
            });
        }
        /// <summary>
        /// Invite new user or connect exists
        /// </summary>
        /// <param name="model">Provider create user model</param>
        /// <returns>UserDisplayModel</returns>
        public async Task <UserDisplayModel> InviteUser(ProviderUserCreateModel model)
        {
            var currentUser = await GetCurrentUser();

            if (!await _providerRepository.ExistsWithOwner(model.ProviderId, currentUser.Id))
            {
                throw new AccessDeniedException(currentUser.Id, typeof(AppUser));
            }

            if (model.Roles == null || !model.Roles.Any())
            {
                throw new AccessDeniedException("", typeof(AppUser));
            }

            model.Roles = model.Roles.Select(x => x.ToUpper()).ToList();

            var pShort = await _providerRepository.GetShortById(model.ProviderId);

            var roles = await _providerRepository.GetRolesById(model.ProviderId);

            var rolesToUse = roles.Where(x => model.Roles.Contains(x.Name)).ToList();

            var existsUser = await _appUserRepository.FindByEmailAsync(model.Email.ToLower(), new System.Threading.CancellationToken());

            if (existsUser == null)
            {
                existsUser = new AppUser
                {
                    Email     = model.Email.ToLower(),
                    FirstName = model.FirstName,
                    LastName  = model.LastName,
                    Tels      = new List <MRUserTel>(),
                    Status    = UserStatus.Invited,
                    UserName  = model.Email.ToLower(),
                };

                existsUser.ConnectedProviders = new List <AppUserProvider>
                {
                    new AppUserProvider
                    {
                        ProviderId   = pShort.Id,
                        ProviderName = pShort.Name,
                        Roles        = rolesToUse,
                        Metadata     = new List <AppUserProviderMeta>(),
                        UpdatedTime  = DateTime.UtcNow
                    }
                };

                var insertResult = await _appUserManager.CreateAsync(existsUser);

                if (!insertResult.Succeeded)
                {
                    throw new MRException();
                }

                await _appUserManager.AddToRoleAsync(existsUser, AppUserRoleList.USER);
            }
            else if (!existsUser.ConnectedProviders.Any(x => x.ProviderId == pShort.Id))
            {
                AppUserProvider provider = new AppUserProvider
                {
                    ProviderId   = pShort.Id,
                    Metadata     = new List <AppUserProviderMeta>(),
                    ProviderName = pShort.Name,
                    Roles        = rolesToUse,
                    UpdatedTime  = DateTime.UtcNow
                };

                if ((await _appUserRepository.AddProvider(existsUser.Id, provider)).ModifiedCount != 1)
                {
                    throw new MRException();
                }
            }
            else
            {
                throw new MRException();
            }

            Infrastructure.Model.Template.User.ProviderInviteTemplate templateModel = new Infrastructure.Model.Template.User.ProviderInviteTemplate
            {
                FirstName    = existsUser.FirstName,
                LastName     = existsUser.LastName,
                LoginLink    = "https://google.com",
                ProviderName = pShort.Name
            };

            var email = await _templateParser.Render("Email", "ProviderInvite", templateModel);

            await _emailSendTaskRepository.InsertEmail(existsUser.Email, "Mad Rat Studio invite", email, Infrastructure.Entities.Tasks.EmailTaskBot.MadRatBot);

            return(_mapper.Map <UserDisplayModel>(existsUser));
        }