Beispiel #1
0
        public async Task SeedAsync(DataSeedContext context)
        {
            var fdPrice = await _fieldDefinitionRepository.FindAsync(fd => fd.Name == "price");

            if (fdPrice == null)
            {
                fdPrice = await _fieldDefinitionRepository.InsertAsync(new FieldDefinition(_guidGenerator.Create(), "price", "Price", "number"));
            }

            var fdCpu = await _fieldDefinitionRepository.FindAsync(fd => fd.Name == "CPU");

            if (fdCpu == null)
            {
                fdCpu = await _fieldDefinitionRepository.InsertAsync(new FieldDefinition(_guidGenerator.Create(), "cpu", "CPU", "string"));
            }

            var fdRam = await _fieldDefinitionRepository.FindAsync(fd => fd.Name == "ram");

            if (fdRam == null)
            {
                fdRam = await _fieldDefinitionRepository.InsertAsync(new FieldDefinition(_guidGenerator.Create(), "ram", "RAM", "string"));
            }

            var mdComputer = await _modelDefinitionRepository.FindAsync(md => md.Name == "computer");

            if (mdComputer == null)
            {
                mdComputer = new ModelDefinition(_guidGenerator.Create(), "computer", "Computer", "DynamicEntitySample.Computer");
                mdComputer.AddField(fdCpu.Id, 1);
                mdComputer.AddField(fdRam.Id, 2);
                mdComputer.AddField(fdPrice.Id, 3);
                await _modelDefinitionRepository.InsertAsync(mdComputer);
            }

            var deComputer = await _dynamicEntityRepository.FindAsync(de => de.ModelDefinitionId == mdComputer.Id);

            if (deComputer == null)
            {
                var cpus   = new[] { "Intel I3", "Intel I5", "Intel I7", "Intel I9" };
                var rams   = new[] { "4GB", "8GB", "16GB", "32GB" };
                var prices = new[] { "999", "1999", "2999", "3999" };
                var rnd    = new Random();
                for (int i = 0; i < 30000; i++)
                {
                    var entity = new DynamicEntity(_guidGenerator.Create()).SetModelDefinition(mdComputer.Id);
                    entity.SetProperty("cpu", cpus[rnd.Next() % cpus.Length]);
                    entity.SetProperty("ram", rams[rnd.Next() % rams.Length]);
                    entity.SetProperty("price", prices[rnd.Next() % prices.Length]);
                    await _dynamicEntityRepository.InsertAsync(entity);
                }
            }
        }
        public async Task ShouldGetFields()
        {
            // Arrange
            var mdBook = await _modelDefinitionRepository.FindAsync(md => md.Name == "book");

            // Act
            var output = await _modelDefinitionAppService.GetAsync(mdBook.Id);

            // Assert
            output.ShouldNotBeNull();
            output.Fields.Count.ShouldBe(2);
            output.Fields[0].Name.ShouldBe("name");
            output.Fields[1].Name.ShouldBe("price");
        }
        public async Task SeedAsync(DataSeedContext context)
        {
            var fdPrice = await _fieldDefinitionRepository.FindAsync(fd => fd.Name == "Price");

            if (fdPrice == null)
            {
                fdPrice = await _fieldDefinitionRepository.InsertAsync(new FieldDefinition(_guidGenerator.Create(), "Price", "Price", FieldDataType.Number));
            }

            var fdCpu = await _fieldDefinitionRepository.FindAsync(fd => fd.Name == "Cpu");

            if (fdCpu == null)
            {
                fdCpu = await _fieldDefinitionRepository.InsertAsync(new FieldDefinition(_guidGenerator.Create(), "Cpu", "Cpu", FieldDataType.Text));
            }

            var fdRam = await _fieldDefinitionRepository.FindAsync(fd => fd.Name == "Ram");

            if (fdRam == null)
            {
                fdRam = await _fieldDefinitionRepository.InsertAsync(new FieldDefinition(_guidGenerator.Create(), "Ram", "Ram", FieldDataType.Text));
            }

            var mdComputer = await _modelDefinitionRepository.FindAsync(md => md.Name == "Computer");

            if (mdComputer == null)
            {
                const string permissionPrefix = DynamicEntityConsts.DynamicPermissionPrefix;

                var permissionSet = new PermissionSetValueObject(
                    get: (await GetOrCreatePermissionAsync($"{permissionPrefix}.Computer")).Name,
                    getList: (await GetOrCreatePermissionAsync($"{permissionPrefix}.Computer")).Name,
                    create: (await GetOrCreatePermissionAsync($"{permissionPrefix}.Computer.Create")).Name,
                    update: (await GetOrCreatePermissionAsync($"{permissionPrefix}.Computer.Update")).Name,
                    delete: (await GetOrCreatePermissionAsync($"{permissionPrefix}.Computer.Delete")).Name
                    );

                mdComputer = new ModelDefinition(_guidGenerator.Create(), "Computer", "Computer", "DynamicEntitySample.Computer", permissionSet);
                mdComputer.AddField(fdCpu, 1);
                mdComputer.AddField(fdRam, 2);
                mdComputer.AddField(fdPrice, 3);
                await _modelDefinitionRepository.InsertAsync(mdComputer);
            }

            var deComputer = await _dynamicEntityRepository.FirstOrDefaultAsync(de => de.ModelDefinitionId == mdComputer.Id);

            if (deComputer == null)
            {
                var cpus   = new[] { "Intel I3", "Intel I5", "Intel I7", "Intel I9" };
                var rams   = new[] { "4GB", "8GB", "16GB", "32GB" };
                var prices = new[] { "999", "1999", "2999", "3999" };
                var rnd    = new Random();
                for (int i = 0; i < 300; i++)
                {
                    var entity = new DynamicEntity(_guidGenerator.Create(), context.TenantId, mdComputer.Id);
                    entity.SetProperty("Cpu", cpus[rnd.Next() % cpus.Length]);
                    entity.SetProperty("Ram", rams[rnd.Next() % rams.Length]);
                    entity.SetProperty("Price", prices[rnd.Next() % prices.Length]);
                    await _dynamicEntityRepository.InsertAsync(entity);
                }
            }
        }
        public async Task <ModelDefinitionDto> GetByName(string name)
        {
            var entity = await _modelDefinitionRepository.FindAsync(md => md.Name == name);

            return(await MapToGetOutputDtoAsync(entity));
        }