Beispiel #1
0
        public static void Initialize(this QLContext db)
        {
            if (!db.Droids.Any())
            {
                Droid droid = new Droid
                {
                    Id   = 1,
                    Name = "R2-D2"
                };
                db.Droids.Add(droid);
                droid = new Droid
                {
                    Id   = 2,
                    Name = "R3-D3"
                };
                db.Droids.Add(droid);
                droid = new Droid
                {
                    Id   = 3,
                    Name = "R4-D4"
                };
                db.Droids.Add(droid);
                db.SaveChanges();
            }

            if (!db.Friends.Any())
            {
                Friend friend = new Friend {
                    Id = 1, Name = "R2-A", Sex = 0, Droid = new Droid {
                        Id = 1, Name = "R2-D2"
                    }
                };
                db.Friends.Add(friend);
                friend = new Friend {
                    Id = 2, Name = "R2-B", Sex = 0, Droid = new Droid {
                        Id = 1, Name = "R2-D2"
                    }
                };
                db.Friends.Add(friend);
                friend = new Friend {
                    Id = 3, Name = "R2-C", Sex = 1, Droid = new Droid {
                        Id = 2, Name = "R3-D3"
                    }
                };
                db.Friends.Add(friend);
                friend = new Friend {
                    Id = 4, Name = "R2-D", Sex = 1, Droid = new Droid {
                        Id = 3, Name = "R4-D4"
                    }
                };
                db.Friends.Add(friend);
                db.SaveChanges();
            }
        }
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));
            });
        }
Beispiel #3
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));
            });
        }