public async Task <ActionResult> UpdateClaim(long claimId, [FromBody] DtoCreateUpdateUserClaim updateUserClaim)
        {
            try
            {
                Log.Information($"Executed UpdateClaim({updateUserClaim}) for claim identifier: {claimId}.");

                var resultClaim = await this.databaseContext.UserClaims.AsNoTracking().FirstOrDefaultAsync(b => b.Id == claimId);

                if (resultClaim == null)
                {
                    Log.Warning($"Claim with identifier {claimId} not found.");
                    return(this.NotFound(claimId));
                }

                var createdAt = resultClaim.CreatedAt;
                resultClaim           = this.autoMapper.Map <UserClaim>(updateUserClaim);
                resultClaim.UpdatedAt = DateTimeOffset.Now;
                resultClaim.CreatedAt = createdAt;
                resultClaim.Id        = claimId;
                this.databaseContext.UserClaims.Update(resultClaim);
                await this.databaseContext.SaveChangesAsync();

                var returnUserClaim = this.autoMapper.Map <DtoReadUserClaim>(resultClaim);
                return(this.Ok(returnUserClaim));
            }
            catch (Exception ex)
            {
                Log.Fatal(ex.Message, ex);
                return(this.InternalServerError(ex));
            }
        }
        public async Task <ActionResult> CreateOrUpdateClaim([FromBody] DtoCreateUpdateUserClaim createUserClaim)
        {
            try
            {
                Log.Information($"Executed CreateOrUpdateClaim({createUserClaim}).");

                var claim = this.autoMapper.Map <UserClaim>(createUserClaim);
                claim.CreatedAt = DateTimeOffset.Now;

                var foundClaim = await this.databaseContext.UserClaims.FirstOrDefaultAsync(
                    uc => uc.ClaimType == claim.ClaimType && uc.UserId == claim.UserId);

                DtoReadUserClaim returnUserClaim;

                if (foundClaim == null)
                {
                    claim.CreatedAt = DateTimeOffset.Now;
                    await this.databaseContext.UserClaims.AddAsync(claim);

                    await this.databaseContext.SaveChangesAsync();

                    returnUserClaim = this.autoMapper.Map <DtoReadUserClaim>(claim);
                }
                else
                {
                    foundClaim.UpdatedAt = DateTimeOffset.Now;
                    var currentClaimValue = JsonConvert.DeserializeObject <List <string> >(foundClaim.ClaimValue);
                    currentClaimValue.AddRange(createUserClaim.ClaimValues);
                    foundClaim.ClaimValue = JsonConvert.SerializeObject(currentClaimValue.Distinct());
                    this.databaseContext.UserClaims.Update(foundClaim);
                    await this.databaseContext.SaveChangesAsync();

                    returnUserClaim = this.autoMapper.Map <DtoReadUserClaim>(foundClaim);
                }

                return(this.Ok(returnUserClaim));
            }
            catch (Exception ex)
            {
                Log.Fatal(ex.Message, ex);
                return(this.InternalServerError(ex));
            }
        }