Beispiel #1
0
        private void ConfigureTypeCar(IObjectTypeDescriptor descriptor)
        {
            descriptor
            .Field("cars")
            .Type <ListType <CarType> >()
            .Resolver(context =>
            {
                QLContext qlContext = context.Service <QLContext>();
                return(qlContext.Car.ToList());
            });

            descriptor
            .Field("car_add")
            .Type <CarType>()
            .Argument("input", x => { x.Type <CarInput>(); })
            .Resolver(context =>
            {
                Car car             = context.Argument <Car>("input");
                QLContext qlContext = context.Service <QLContext>();
                IDbContextTransaction transaction = qlContext.Database.BeginTransaction();
                try
                {
                    qlContext.Car.Add(car);
                    qlContext.SaveChanges();
                    transaction.Commit();
                }
                catch (System.Exception)
                {
                    transaction.Rollback();
                }
                finally
                {
                    transaction.Dispose();
                }
                return(car);
            });

            descriptor
            .Field("car_edit")
            .Type <CarType>()
            .Argument("input", x => { x.Type <CarInput>(); })
            .Resolver(context =>
            {
                Car car             = context.Argument <Car>("input");
                QLContext qlContext = context.Service <QLContext>();
                IDbContextTransaction transaction = qlContext.Database.BeginTransaction();
                try
                {
                    qlContext.Car.Update(car);
                    qlContext.SaveChanges();
                    transaction.Commit();
                }
                catch (System.Exception)
                {
                    transaction.Rollback();
                }
                finally
                {
                    transaction.Dispose();
                }
                return(car);
            });

            descriptor
            .Field("car_find")
            .Type <CarType>()
            .Argument("id", x => { x.Type <IntType>(); x.DefaultValue(0); })
            .Resolver(context =>
            {
                int id = context.Argument <int>("id");
                QLContext qlContext = context.Service <QLContext>();
                return(qlContext.Car.Find(id));
            });

            descriptor
            .Field("car_remove")
            .Type <RemoveType>()
            .Argument("id", x => { x.Type <IntType>(); x.DefaultValue(0); })
            .Resolver(context =>
            {
                int count           = 0;
                int id              = context.Argument <int>("id");
                QLContext qlContext = context.Service <QLContext>();
                var car             = qlContext.Car.Find(id);
                if (car != null)
                {
                    IDbContextTransaction transaction = qlContext.Database.BeginTransaction();
                    try
                    {
                        qlContext.Car.Remove(car);
                        count = qlContext.SaveChanges();
                        transaction.Commit();
                    }
                    catch
                    {
                        transaction.Rollback();
                    }
                    finally
                    {
                        transaction.Dispose();
                    }
                }
                return(Remove.Create(count));
            });
        }
Beispiel #2
0
        private void ConfigureTypeSource(IObjectTypeDescriptor descriptor)
        {
            descriptor
            .Field("sources")
            .Type <ListType <SourceType> >()
            .Resolver(context =>
            {
                QLContext qlContext = context.Service <QLContext>();
                return(qlContext.Source.ToList());
            });

            descriptor
            .Field("source_add")
            .Type <SourceType>()
            .Argument("input", x => { x.Type <SourceInput>(); })
            .Resolver(context =>
            {
                Source source       = context.Argument <Source>("input");
                QLContext qlContext = context.Service <QLContext>();
                IDbContextTransaction transaction = qlContext.Database.BeginTransaction();
                try
                {
                    qlContext.Source.Add(source);
                    qlContext.SaveChanges();
                    transaction.Commit();
                }
                catch (System.Exception)
                {
                    transaction.Rollback();
                }
                finally
                {
                    transaction.Dispose();
                }
                return(source);
            });


            descriptor
            .Field("source_param_add")
            .Type <SourceType>()
            .Argument("id", x => { x.Type <UuidType>(); x.DefaultValue(null); })
            .Argument("name", x => { x.Type <StringType>(); x.DefaultValue(null); })
            .Argument("value", x => { x.Type <DecimalType>(); x.DefaultValue(null); })
            .Argument("created", x => { x.Type <DateTimeType>(); x.DefaultValue(null); })
            .Argument("active", x => { x.Type <BooleanType>(); x.DefaultValue(null); })
            .Argument("time", x => { x.Type <TimeSpanType>(); x.DefaultValue(null); })
            .Resolver(context =>
            {
                Guid?id          = context.Argument <Guid?>("id");
                string name      = context.Argument <string>("name");
                decimal?value    = context.Argument <decimal?>("value");
                DateTime?created = context.Argument <DateTime?>("created");
                bool?active      = context.Argument <bool?>("active");
                TimeSpan?time    = context.Argument <TimeSpan?>("time");
                if (id == Guid.Empty)
                {
                    id = null;
                }
                Source source = new Source()
                {
                    Id      = id,
                    Name    = name,
                    Value   = value,
                    Created = created,
                    Active  = active,
                    Time    = time
                };
                QLContext qlContext = context.Service <QLContext>();
                IDbContextTransaction transaction = qlContext.Database.BeginTransaction();
                try
                {
                    qlContext.Source.Add(source);
                    qlContext.SaveChanges();
                    transaction.Commit();
                }
                catch (System.Exception)
                {
                    transaction.Rollback();
                }
                finally
                {
                    transaction.Dispose();
                }
                return(source);
            });


            descriptor
            .Field("source_edit")
            .Type <SourceType>()
            .Argument("input", x => { x.Type <SourceInput>(); })
            .Resolver(context =>
            {
                Source source       = context.Argument <Source>("input");
                QLContext qlContext = context.Service <QLContext>();
                IDbContextTransaction transaction = qlContext.Database.BeginTransaction();
                try
                {
                    qlContext.Source.Update(source);
                    qlContext.SaveChanges();
                    transaction.Commit();
                }
                catch (System.Exception)
                {
                    transaction.Rollback();
                }
                finally
                {
                    transaction.Dispose();
                }
                return(source);
            });

            descriptor
            .Field("source_find")
            .Type <SourceType>()
            .Argument("id", x => { x.Type <UuidType>(); })
            .Resolver(context =>
            {
                Guid id             = context.Argument <Guid>("id");
                QLContext qlContext = context.Service <QLContext>();
                return(qlContext.Source.Find(id));
            });

            descriptor
            .Field("source_remove")
            .Type <RemoveType>()
            .Argument("id", x => { x.Type <UuidType>(); })
            .Resolver(context =>
            {
                Guid id             = context.Argument <Guid>("id");
                QLContext qlContext = context.Service <QLContext>();
                IDbContextTransaction transaction = qlContext.Database.BeginTransaction();
                int count = 0;
                try
                {
                    qlContext.Source.Remove(qlContext.Source.Find(id));
                    count = qlContext.SaveChanges();
                    transaction.Commit();
                }
                catch
                {
                    transaction.Rollback();
                }
                finally
                {
                    transaction.Dispose();
                }
                return(Remove.Create(count));
            });
        }
        private void ConfigureTypeSource(IObjectTypeDescriptor descriptor)
        {
            descriptor
            .Field("sources")
            .Type <ListType <SourceType> >()
            .Resolver(context =>
            {
                return(Sources);
            });

            descriptor
            .Field("source_add")
            .Type <SourceType>()
            .Argument("input", x => { x.Type <SourceInput>(); })
            .Resolver(context =>
            {
                Source source = context.ArgumentValue <Source>("input");
                source.Id     = Sources.Count == 0 ? 1 : Sources.OrderBy(x => x.Id).LastOrDefault().Id;
                Sources.Add(source);
                return(source);
            });


            descriptor
            .Field("source_param_add")
            .Type <SourceType>()
            .Argument("id", x => { x.Type <IntType>(); })
            .Argument("name", x => { x.Type <StringType>(); x.DefaultValue(null); })
            .Argument("value", x => { x.Type <DecimalType>(); x.DefaultValue(null); })
            .Argument("created", x => { x.Type <DateTimeType>(); x.DefaultValue(null); })
            .Argument("active", x => { x.Type <BooleanType>(); x.DefaultValue(null); })
            .Argument("time", x => { x.Type <DateTimeType>(); x.DefaultValue(null); })
            .Resolver(context =>
            {
                int id           = context.ArgumentValue <int>("id");
                string name      = context.ArgumentValue <string>("name");
                decimal?value    = context.ArgumentValue <decimal?>("value");
                DateTime?created = context.ArgumentValue <DateTime?>("created");
                bool?active      = context.ArgumentValue <bool?>("active");
                DateTime?time    = context.ArgumentValue <DateTime>("time");
                if (id == 0)
                {
                    id = Sources.Count == 0 ? 1 : Sources.OrderBy(x => x.Id).LastOrDefault().Id;
                }
                Source source = new Source()
                {
                    Id      = id,
                    Name    = name,
                    Value   = value,
                    Created = created,
                    Active  = active,
                    Time    = time
                };
                Sources.Add(source);
                return(source);
            });


            descriptor
            .Field("source_edit")
            .Type <SourceType>()
            .Argument("input", x => { x.Type <SourceInput>(); })
            .Resolver(context =>
            {
                Source source = context.ArgumentValue <Source>("input");
                Source update = Sources.FirstOrDefault(x => x.Id == source.Id);
                if (update != null)
                {
                    update.Name    = source.Name;
                    update.Time    = source.Time;
                    update.Value   = source.Value;
                    update.Active  = source.Active;
                    update.Created = source.Created;
                    return(source);
                }
                return(update);
            });

            descriptor
            .Field("source_find")
            .Type <SourceType>()
            .Argument("id", x => { x.Type <IntType>(); })
            .Resolver(context =>
            {
                int id = context.ArgumentValue <int>("id");
                return(Sources.FirstOrDefault(x => x.Id == id));
            });

            descriptor
            .Field("source_remove")
            .Type <RemoveType>()
            .Argument("id", x => { x.Type <IntType>(); x.DefaultValue(0); })
            .Resolver(context =>
            {
                int id        = context.ArgumentValue <int>("id");
                int count     = 0;
                Source source = Sources.FirstOrDefault(x => x.Id == id);
                if (source != null)
                {
                    count = Sources.Remove(source) ? 1 : 0;
                }
                return(Remove.Create(count));
            });

            descriptor
            .Field("source_in")
            .Type <ListType <SourceType> >()
            .Argument("id_in", x => { x.Type <ListType <IntType> >(); })
            .Resolver(context =>
            {
                int[] id_in = context.ArgumentValue <int[]>("id_in");
                return(Sources.Where(x => id_in.Contains(x.Id)).ToList());
            });
        }