public WithMisNamedQueryChildGraph(IEfGraphQLService graphQlService) : base(graphQlService)
 {
     Field(x => x.Id);
     AddNavigationField <WithMisNamedQueryParentGraph, WithMisNamedQueryParentEntity>(
         name: "parent",
         resolve: context => context.Source.Parent);
 }
Beispiel #2
0
 public LeaveRequestCommentType(IEfGraphQLService service) : base(service)
 {
     Field <DateTimeGraphType>("createdOn", resolve: ctx => ctx.Source.CreatedOn);
     Field <StringGraphType>("createdBy", resolve: ctx => ctx.Source.CreatedBy);
     Field <StringGraphType>("content", resolve: ctx => ctx.Source.Content);
     Field <CommentTypeEnum>("type", resolve: ctx => ctx.Source.Type);
 }
        public AssetGraphQl(IEfGraphQLService <DatabaseContext> graphQlService, bool isEmptyLoad = false) : base(graphQlService)
        {
            if (!isEmptyLoad)
            {
                Field(x => x.Id);

                Field(x => x.Name);
                Field(x => x.Description, true);
                Field(x => x.Payload, true);
                Field(x => x.RootId);

                if (Core.Database.Config.Instance == Config.InstanceEnum.Core)
                {
                    GetVulnerabilities();
                }

                GetRisks();
                GetTreatments();
                GetGroups();
                GetEvidences();

                Field(x => x.IsDeleted);
                Field <DateTimeGraphType>(
                    name: "createdDateTime",
                    resolve: context => context.Source.CreatedDateTime);
            }
        }
Beispiel #4
0
 public Query(IEfGraphQLService <MyDbContext> graphQlService) :
     base(graphQlService)
 {
     AddQueryConnectionField(
         name: "companies",
         resolve: context => context.DbContext.Companies);
 }
Beispiel #5
0
 public DerivedChildGraph(IEfGraphQLService <IntegrationDbContext> graphQlService) :
     base(graphQlService)
 {
     AutoMap(new List <string> {
         "Parent", "TypedParent"
     });
 }
Beispiel #6
0
        public LactalisQuery(IEfGraphQLService <LactalisDBContext> efGraphQlService) : base(efGraphQlService)
        {
            // Add query types for each entity
            AddModelQueryField <TradingPostListingEntityType, TradingPostListingEntity>("TradingPostListingEntity");
            AddModelQueryField <TradingPostCategoryEntityType, TradingPostCategoryEntity>("TradingPostCategoryEntity");
            AddModelQueryField <AdminEntityType, AdminEntity>("AdminEntity");
            AddModelQueryField <FarmEntityType, FarmEntity>("FarmEntity");
            AddModelQueryField <MilkTestEntityType, MilkTestEntity>("MilkTestEntity");
            AddModelQueryField <FarmerEntityType, FarmerEntity>("FarmerEntity");
            AddModelQueryField <ImportantDocumentCategoryEntityType, ImportantDocumentCategoryEntity>("ImportantDocumentCategoryEntity");
            AddModelQueryField <TechnicalDocumentCategoryEntityType, TechnicalDocumentCategoryEntity>("TechnicalDocumentCategoryEntity");
            AddModelQueryField <QualityDocumentCategoryEntityType, QualityDocumentCategoryEntity>("QualityDocumentCategoryEntity");
            AddModelQueryField <QualityDocumentEntityType, QualityDocumentEntity>("QualityDocumentEntity");
            AddModelQueryField <TechnicalDocumentEntityType, TechnicalDocumentEntity>("TechnicalDocumentEntity");
            AddModelQueryField <ImportantDocumentEntityType, ImportantDocumentEntity>("ImportantDocumentEntity");
            AddModelQueryField <NewsArticleEntityType, NewsArticleEntity>("NewsArticleEntity");
            AddModelQueryField <AgriSupplyDocumentCategoryEntityType, AgriSupplyDocumentCategoryEntity>("AgriSupplyDocumentCategoryEntity");
            AddModelQueryField <SustainabilityPostEntityType, SustainabilityPostEntity>("SustainabilityPostEntity");
            AddModelQueryField <AgriSupplyDocumentEntityType, AgriSupplyDocumentEntity>("AgriSupplyDocumentEntity");
            AddModelQueryField <PromotedArticlesEntityType, PromotedArticlesEntity>("PromotedArticlesEntity");

            // Add query types for each many to many reference
            AddModelQueryField <TradingPostListingsTradingPostCategoriesType, TradingPostListingsTradingPostCategories>("TradingPostListingsTradingPostCategories");
            AddModelQueryField <FarmersFarmsType, FarmersFarms>("FarmersFarms");
        }
        public ProductGraph(IEfGraphQLService efGraphQlService) : base(efGraphQlService)
        {
            Field(x => x.ProductId);
            Field(x => x.ProductName);
            Field(x => x.ProductImage);
            Field(x => x.Discontinued);

            //Field(x => x.Supplier);
            //Field(x => x.Category);

            Field(x => x.QuantityPerUnit);
            Field(x => x.UnitPrice);

            Field(x => x.UnitsInStock);
            Field(x => x.UnitsOnOrder);
            Field(x => x.ReorderLevel);

            //AddNavigationField<CategoryGraph, Category>(
            //    name: "category",
            //    resolve: context => context.Source.Category);

            //AddNavigationField<SupplierGraph, Supplier>(
            //    name: "supplier",
            //    resolve: context => context.Source.Supplier);
        }
 public MappingQuery(
     IEfGraphQLService <MappingContext> graphQlService)
 {
     graphQlService.AddSingleField(
         graph: this,
         name: "child",
         resolve: context =>
     {
         return(context.DbContext.Children);
     });
     graphQlService.AddQueryField(
         graph: this,
         name: "children",
         resolve: context =>
     {
         return(context.DbContext.Children);
     });
     graphQlService.AddSingleField(
         graph: this,
         name: "parent",
         resolve: context =>
     {
         return(context.DbContext.Parents);
     });
     graphQlService.AddQueryField(
         graph: this,
         name: "parents",
         resolve: context =>
     {
         return(context.DbContext.Parents);
     });
 }
Beispiel #9
0
        public TechnicalDocumentEntityType(IEfGraphQLService <LactalisDBContext> service) : base(service)
        {
            // Add model fields to type
            Field(o => o.Id, type: typeof(IdGraphType));
            Field(o => o.Created, type: typeof(DateTimeGraphType));
            Field(o => o.Modified, type: typeof(DateTimeGraphType));
            Field(o => o.FileId, type: typeof(IdGraphType));
            Field(o => o.Name, type: typeof(StringGraphType));

            // Add entity references
            Field(o => o.TechnicalDocumentCategoryId, type: typeof(IdGraphType));

            // GraphQL reference to entity TechnicalDocumentCategoryEntity via reference TechnicalDocumentCategory
            AddNavigationField("TechnicalDocumentCategory", context => {
                var graphQlContext = (LactalisGraphQlContext)context.UserContext;
                var filter         = SecurityService.CreateReadSecurityFilter <TechnicalDocumentCategoryEntity>(
                    graphQlContext.IdentityService,
                    graphQlContext.UserManager,
                    graphQlContext.DbContext,
                    graphQlContext.ServiceProvider);
                var value = context.Source.TechnicalDocumentCategory;

                if (value != null)
                {
                    return(new List <TechnicalDocumentCategoryEntity> {
                        value
                    }.All(filter.Compile()) ? value : null);
                }
                return(null);
            });
        }
        public FarmerEntityType(IEfGraphQLService <LactalisDBContext> service) : base(service)
        {
            // Add model fields to type
            Field(o => o.Id, type: typeof(IdGraphType));
            Field(o => o.Created, type: typeof(DateTimeGraphType));
            Field(o => o.Modified, type: typeof(DateTimeGraphType));
            Field(o => o.Email, type: typeof(StringGraphType));

            // Add entity references

            // GraphQL reference to entity TradingPostListingEntity via reference TradingPostListings
            IEnumerable <TradingPostListingEntity> TradingPostListingssResolveFunction(ResolveFieldContext <FarmerEntity> context)
            {
                var graphQlContext = (LactalisGraphQlContext)context.UserContext;
                var filter         = SecurityService.CreateReadSecurityFilter <TradingPostListingEntity>(graphQlContext.IdentityService, graphQlContext.UserManager, graphQlContext.DbContext, graphQlContext.ServiceProvider);

                return(context.Source.TradingPostListingss.Where(filter.Compile()));
            }

            AddNavigationListField("TradingPostListingss", (Func <ResolveFieldContext <FarmerEntity>, IEnumerable <TradingPostListingEntity> >)TradingPostListingssResolveFunction);
            AddNavigationConnectionField("TradingPostListingssConnection", TradingPostListingssResolveFunction);

            // GraphQL many to many reference to entity FarmEntity via reference Farms
            IEnumerable <FarmersFarms> FarmssResolveFunction(ResolveFieldContext <FarmerEntity> context)
            {
                var graphQlContext = (LactalisGraphQlContext)context.UserContext;
                var filter         = SecurityService.CreateReadSecurityFilter <FarmersFarms>(graphQlContext.IdentityService, graphQlContext.UserManager, graphQlContext.DbContext, graphQlContext.ServiceProvider);

                return(context.Source.Farmss.Where(filter.Compile()));
            }

            AddNavigationListField("Farmss", (Func <ResolveFieldContext <FarmerEntity>, IEnumerable <FarmersFarms> >)FarmssResolveFunction);
            AddNavigationConnectionField("FarmssConnection", FarmssResolveFunction);
        }
        public Query(IEfGraphQLService <BeawreContext> efGraphQlService) : base(efGraphQlService)
        {
            AddQueryField(
                name: "users",
                resolve: context => context.DbContext.User.Where(x => !x.IsDeleted)
                );

            Field <ListGraphType <AssetGraphQl> >(
                name: "groups",
                resolve: context =>
            {
                var dbContext     = (BeawreContext)context.UserContext;
                var relationships = dbContext.Relationship.Where(x => x.FromType == ObjectType.AssetGroup && !x.IsDeleted).Select(x => x.FromId).ToArray();
                return(dbContext.Assets.Where(x => relationships.Contains(x.Id) && !x.IsDeleted && x.IsGroup).ToList());
            });

            AddQueryField(
                name: "containers",
                resolve: context => context.DbContext.Container.Where(x => !x.IsDeleted)
                );

            AddQueryField(
                name: "assets",
                resolve: context => context.DbContext.Assets.Where(x => !x.IsDeleted)
                );

            AddQueryField(
                name: "edges",
                resolve: context => context.DbContext.Relationship.Where(x => x.FromType == ObjectType.Asset && x.ToType == ObjectType.Asset).Where(x => !x.IsDeleted)
                );
        }
 public DependencyQuery(IEfGraphQLService <DependencyDbContext> efGraphQlService) :
     base(efGraphQlService)
 {
     AddQueryField(
         name: "entities",
         resolve: context => context.DbContext.Entities);
 }
    public Query(IEfGraphQLService efGraphQlService) : base(efGraphQlService)
    {
        AddQueryField <CompanyGraph, Company>(
            name: "companies",
            resolve: context =>
        {
            var dataContext = (MyDataContext)context.UserContext;
            return(dataContext.Companies);
        });

        AddQueryConnectionField <CompanyGraph, Company>(
            name: "companiesConnection",
            resolve: context =>
        {
            var dataContext = (MyDataContext)context.UserContext;
            return(dataContext.Companies);
        });

        AddQueryField <EmployeeGraph, Employee>(
            name: "employees",
            resolve: context =>
        {
            var dataContext = (MyDataContext)context.UserContext;
            return(dataContext.Employees);
        });

        AddQueryConnectionField <EmployeeGraph, Employee>(
            name: "employeesConnection",
            resolve: context =>
        {
            var dataContext = (MyDataContext)context.UserContext;
            return(dataContext.Employees);
        });
    }
 public Level2Graph(IEfGraphQLService graphQlService) : base(graphQlService)
 {
     Field(x => x.Id);
     AddNavigationField <Level3Graph, Level3Entity>(
         name: "level3Entity",
         resolve: context => context.Source.Level3Entity);
 }
        public MilkTestEntityType(IEfGraphQLService <LactalisDBContext> service) : base(service)
        {
            // Add model fields to type
            Field(o => o.Id, type: typeof(IdGraphType));
            Field(o => o.Created, type: typeof(DateTimeGraphType));
            Field(o => o.Modified, type: typeof(DateTimeGraphType));
            Field(o => o.Time, type: typeof(DateTimeGraphType));
            Field(o => o.Volume, type: typeof(IntGraphType));
            Field(o => o.Temperature, type: typeof(FloatGraphType));
            Field(o => o.MilkFat, type: typeof(FloatGraphType));
            Field(o => o.Protein, type: typeof(FloatGraphType));

            // Add entity references
            Field(o => o.FarmId, type: typeof(IdGraphType));

            // GraphQL reference to entity FarmEntity via reference Farm
            AddNavigationField("Farm", context => {
                var graphQlContext = (LactalisGraphQlContext)context.UserContext;
                var filter         = SecurityService.CreateReadSecurityFilter <FarmEntity>(
                    graphQlContext.IdentityService,
                    graphQlContext.UserManager,
                    graphQlContext.DbContext,
                    graphQlContext.ServiceProvider);
                var value = context.Source.Farm;

                if (value != null)
                {
                    return(new List <FarmEntity> {
                        value
                    }.All(filter.Compile()) ? value : null);
                }
                return(null);
            });
        }
Beispiel #16
0
 public GraphQLQuery(IEfGraphQLService <BlogContext> graphQlService) : base(graphQlService)
 {
     AddQueryField(name: "posts", resolve: ctx => ctx.DbContext.Post);
     AddSingleField(name: "post", resolve: ctx => ctx.DbContext.Post);
     AddQueryField(name: "users", resolve: ctx => ctx.DbContext.User);
     AddSingleField(name: "user", resolve: ctx => ctx.DbContext.User);
 }
Beispiel #17
0
 public CompanyGraph(IEfGraphQLService <MyDbContext> graphQlService) :
     base(graphQlService)
 {
     AddNavigationConnectionField(
         name: "employees",
         resolve: context => context.Source.Employees);
 }
 public CrowdactionTagGraph(IEfGraphQLService <ApplicationDbContext> entityFrameworkGraphQlService) : base(entityFrameworkGraphQlService)
 {
     Field <NonNullGraphType <IdGraphType>, int>(nameof(CrowdactionTag.CrowdactionId)).Resolve(x => x.Source.CrowdactionId);
     Field <NonNullGraphType <IdGraphType>, int>(nameof(CrowdactionTag.TagId)).Resolve(x => x.Source.TagId);
     AddNavigationField(nameof(CrowdactionTag.Crowdaction), c => c.Source.Crowdaction);
     AddNavigationField(nameof(CrowdactionTag.Tag), c => c.Source.Tag);
 }
Beispiel #19
0
        public TaskGraph(IEfGraphQLService graphQlService) : base(graphQlService)
        {
            Field(x => x.Id);

            /* AddNavigationField<EmployeeGraph, Employee>(
             *  name: "employees",
             *  resolve: context => context.Source.Employees);*/
        }
Beispiel #20
0
 public SkipLevelGraph(IEfGraphQLService graphQlService) :
     base(graphQlService)
 {
     Field(x => x.Id);
     AddNavigationField(name: "level3Entity",
                        resolve: context => context.Source.Level2Entity.Level3Entity,
                        graphType: typeof(Level3Graph), includeNames: new[] { "Level2Entity.Level3Entity" });
 }
 public WithMisNamedQueryChildGraph(IEfGraphQLService <IntegrationDbContext> graphQlService) :
     base(graphQlService)
 {
     Field(x => x.Id);
     AddNavigationField(
         name: "parent",
         resolve: context => context.Source.Parent);
 }
 public EmployeeGraph(IEfGraphQLService graphQlService) : base(graphQlService)
 {
     Field(x => x.Id);
     Field(x => x.Content);
     AddNavigationField <CompanyGraph, Company>(
         name: "company",
         resolve: context => context.Source.Company);
 }
Beispiel #23
0
 public UserEventGraph(IEfGraphQLService <ApplicationDbContext> entityFrameworkGraphQlService) : base(entityFrameworkGraphQlService)
 {
     Field(x => x.Id);
     Field(x => x.EventData);
     Field <NonNullGraphType <DateTimeOffsetGraphType>, DateTime>(nameof(UserEvent.EventLoggedAt)).Resolve(x => x.Source.EventLoggedAt);
     Field(x => x.UserId, true);
     AddNavigationField(nameof(UserEvent.User), c => c.Source.User, typeof(ApplicationUserGraph));
 }
Beispiel #24
0
 public PostGraph(IEfGraphQLService <BlogDbContext> graphService) : base(graphService)
 {
     Field(x => x.PostId, type: typeof(IdGraphType));
     Field(x => x.Title, nullable: true);
     Field(x => x.PostedAt, nullable: true);
     Field(x => x.UserId, nullable: true, type: typeof(IdGraphType));
     AddNavigationField(name: "User", resolve: context => context.Source.User);
 }
Beispiel #25
0
 public RestrictedApplicationUserGraph(IEfGraphQLService <ApplicationDbContext> efGraphQlService) : base(efGraphQlService)
 {
     Field <NonNullGraphType <IdGraphType>, string>(nameof(ApplicationUser.Id)).Resolve(x => x.Source.Id);
     Field(x => x.FirstName, true);
     Field(x => x.FullName, true);
     Field(x => x.LastName, true);
     Field(x => x.Email).AuthorizeWith(AuthorizationConstants.GraphQlAdminPolicy);
 }
Beispiel #26
0
 public IncludeNonQueryableAGraph(IEfGraphQLService <IntegrationDbContext> graphQlService) :
     base(graphQlService)
 {
     Field(x => x.Id);
     AddNavigationField(
         name: "includeNonQueryableB",
         resolve: context => context.Source.IncludeNonQueryableB);
 }
        public DonationEventLogGraph(IEfGraphQLService <ApplicationDbContext> entityFrameworkGraphQlService) : base(entityFrameworkGraphQlService)
        {
            Field <NonNullGraphType <IdGraphType>, int>(nameof(DonationEventLog.Id)).Resolve(x => x.Source.Id);
            Field(x => x.UserId, true);
            Field(x => x.EventData);

            AddNavigationField(nameof(DonationEventLog.User), c => c.Source.User, typeof(ApplicationUserGraph)).AuthorizeWith(AuthorizationConstants.GraphQlAdminPolicy);
        }
 public Level1Graph(IEfGraphQLService <IntegrationDbContext> graphQlService) :
     base(graphQlService)
 {
     Field(x => x.Id);
     AddNavigationField(
         name: "level2Entity",
         resolve: context => context.Source.Level2Entity);
 }
        public AddressGraph(IEfGraphQLService <BlogDbContext> graphService) : base(graphService)
        {
            Field(x => x.AddressId, type: typeof(IdGraphType));
            Field(x => x.Name, nullable: true);
            Field(x => x.PostalNumber, nullable: true, type: typeof(IntGraphType));
            Field(x => x.CountryId, nullable: true, type: typeof(IdGraphType));

            AddNavigationField(name: "Country", resolve: context => context.Source.Country);
        }
Beispiel #30
0
 public InterfaceGraph(IEfGraphQLService <IntegrationDbContext> graphQlService) :
     base(graphQlService)
 {
     Field(e => e.Id);
     Field(e => e.Property, nullable: true);
     AddNavigationConnectionField <DerivedChildEntity>(
         name: "childrenFromInterface",
         includeNames: new[] { "ChildrenFromBase" });
 }