public async Task CreateAsync_DataIsNotNull_InsertsClaimMapping(ClaimMappingCreationData data)
        {
            (var modixContext, var uut) = BuildTestContext();

            var id = await uut.CreateAsync(data);

            modixContext.ClaimMappings.ShouldContain(x => x.Id == id);
            var claimMapping = modixContext.ClaimMappings.First(x => x.Id == id);

            claimMapping.GuildId.ShouldBe(data.GuildId);
            claimMapping.Type.ShouldBe(data.Type);
            claimMapping.RoleId.ShouldBe(data.RoleId);
            claimMapping.UserId.ShouldBe(data.UserId);
            claimMapping.Claim.ShouldBe(data.Claim);

            modixContext.ConfigurationActions
            .ShouldContain(x => x.Id == claimMapping.CreateActionId);
            var createAction = modixContext.ConfigurationActions
                               .First(x => x.Id == claimMapping.CreateActionId);

            createAction.GuildId.ShouldBe(data.GuildId);
            createAction.Type.ShouldBe(ConfigurationActionType.ClaimMappingCreated);
            createAction.Created.ShouldBeInRange(
                DateTimeOffset.Now - TimeSpan.FromSeconds(1),
                DateTimeOffset.Now + TimeSpan.FromSeconds(1));
            createAction.CreatedById.ShouldBe(data.CreatedById);
            createAction.ClaimMappingId.ShouldBe(id);
            createAction.DesignatedChannelMappingId.ShouldBeNull();
            createAction.DesignatedRoleMappingId.ShouldBeNull();

            await modixContext.ShouldHaveReceived(2)
            .SaveChangesAsync();
        }
Example #2
0
 /// <inheritdoc />
 public async Task <long> CreateAsync(ClaimMappingCreationData data)
 {
     using (await _createLock.LockAsync())
     {
         return(await DoCreateAsync(data));
     }
 }
Example #3
0
        private async Task <long> DoCreateAsync(ClaimMappingCreationData data)
        {
            if (data == null)
            {
                throw new ArgumentNullException(nameof(data));
            }

            var entity = data.ToEntity();

            await ModixContext.ClaimMappings.AddAsync(entity);

            await ModixContext.SaveChangesAsync();

            return(entity.Id);
        }
        /// <inheritdoc />
        public async Task <long> CreateAsync(ClaimMappingCreationData data)
        {
            if (data == null)
            {
                throw new ArgumentNullException(nameof(data));
            }

            var entity = data.ToEntity();

            await ModixContext.Set <ClaimMappingEntity>().AddAsync(entity);

            await ModixContext.SaveChangesAsync();

            entity.CreateAction.ClaimMappingId = entity.Id;
            await ModixContext.SaveChangesAsync();

            return(entity.Id);
        }
Example #5
0
        /// <inheritdoc />
        public async Task <long?> TryCreateAsync(ClaimMappingCreationData data)
        {
            using (await _createLock.LockAsync())
            {
                if (await ModixContext.ClaimMappings.AsNoTracking()
                    .FilterClaimMappingsBy(new ClaimMappingSearchCriteria()
                {
                    Types = new [] { data.Type },
                    GuildId = data.GuildId,
                    RoleIds = (data.RoleId == null) ? null : new [] { data.RoleId.Value },
                    UserId = data.UserId,
                    Claims = new [] { data.Claim },
                    IsRescinded = false
                })
                    .AnyAsync())
                {
                    return(null);
                }

                return(await DoCreateAsync(data));
            }
        }