예제 #1
0
        protected override Result ExecuteCore()
        {
            var order = RF.Find <PurchaseOrder>().GetById(this.OrderId) as PurchaseOrder;

            if (order == null)
            {
                throw new ArgumentNullException("order");
            }

            if (order.StorageInStatus != OrderStorageInStatus.Waiting)
            {
                return("该订单已经完全入库,操作失败。");
            }

            //生成入库单
            var storageIn = new OrderStorageInBill
            {
                Order   = order,
                Code    = order.Code + " - 入库",
                Date    = DateTime.Now,
                Comment = "系统生成"
            };

            //默认直接入库第一个仓库
            storageIn.Storage = RF.ResolveInstance <StorageRepository>().CacheAll().First() as Storage;

            //调用另外一个服务直接入库
            var siService = ServiceFactory.Create <AddOrderStorageInBillService>();

            siService.Item = storageIn;
            siService.Invoke();
            return(siService.Result);
        }
        protected override void Up()
        {
            this.RunCode((Action<Rafy.Data.IDbAccesser>)(db =>
            {
                //由于本类没有支持 Down 操作,所以这里面的 Up 需要防止重入。
                var repo = RF.ResolveInstance<PersonRepository>();
                var list = repo.GetAll();
                if (list.Count == 0)
                {
                    list.Add(new Person
                    {
                        Name = "胡庆访",
                        IsDefault = true
                    });

                    var tagRepo = RF.Find<Tag>();
                    var tagList = tagRepo.NewList();
                    tagList.Add(new Tag { Name = "衣" });
                    tagList.Add(new Tag { Name = "食" });
                    tagList.Add(new Tag { Name = "住" });
                    tagList.Add(new Tag { Name = "行" });
                    tagList.Add(new Tag { Name = "人情" });
                    tagList.Add(new Tag { Name = "公司" });
                    tagList.Add(new Tag { Name = "工资" });

                    using (var tran = RF.TransactionScope(repo))
                    {
                        repo.Save(list);
                        tagRepo.Save(tagList);

                        tran.Complete();
                    }
                }
            }));
        }
예제 #3
0
        /// <summary>
        /// 执行查询操作。
        /// <remarks>可能执行本地查询,也可能是远程查询。</remarks>
        /// </summary>
        /// <param name="resultView"></param>
        private void FireQuery(LogicalView resultView)
        {
            var args = new QueryEventArgs {
                ResultView = resultView
            };

            this.OnQuerying(args);

            //如果是本地查询模式,则尝试为 ListLogicalView 进行过滤。
            var criteria = this.Current;

            if (criteria.CanLocalFilter)
            {
                var listView = resultView as ListLogicalView;
                if (listView != null)
                {
                    listView.Filter = criteria.LocalFilter;

                    this.OnQueryCompleted(args);
                    return;
                }
            }

            //需要复制一个查询对象,这样可以保存下当前的查询值,
            //否则会造成 ReloadDataAsync 方法查询时不是使用当前的这些值来查询。
            var queryCriteria = Entity.New(this.EntityType);

            queryCriteria.Clone(this.Current, CloneOptions.NewComposition());

            //导航面板的查询使用隐式查询。
            resultView.DataLoader.LoadDataAsync(
                () => RF.Find(resultView.EntityType).GetBy(queryCriteria),
                () => this.OnQueryCompleted(args)
                );
        }
예제 #4
0
        /// <summary>
        /// 实体的自定义反序列化方法。
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="jObject">The j object.</param>
        /// <param name="id">实体的标识。如果已经在 jObject 中指定时,此参数可以传入 null。</param>
        /// <returns></returns>
        public Entity DeserializeEntity(Type type, JObject jObject, object id)
        {
            Entity entity = null;

            if (id != null)
            {
                if (_creationMode == UpdatedEntityCreationMode.RequeryFromRepository)
                {
                    var repository = RF.Find(type);
                    entity = repository.GetById(id);
                }
                else
                {
                    entity = Activator.CreateInstance(type) as Entity;
                    entity.PersistenceStatus = PersistenceStatus.Unchanged;
                }
            }
            if (entity == null)
            {
                entity = Activator.CreateInstance(type) as Entity;
            }

            //反序列化一般属性
            DeserializeProperties(jObject, entity);

            return(entity);
        }
예제 #5
0
        protected override object CreateModel(ControllerContext controllerContext, ModelBindingContext bindingContext, Type modelType)
        {
            /*********************** 代码块解释 *********************************
             * 如果要绑定的模型是一个实体,而且已经提供了这个实体的Id,说明是在对旧实体的更新,
             * 这时需要把旧实体从数据库中获取出来再设置新的值。这样可以解决两个问题:
             * * 在更新时,不需要再主动设置实体的 PersistenceStatus 为 Modified。
             * * 在更新树节点时,不会因为在 TreePId 没有变化的情况下更新 TreePId,而造成 TreeIndex 出错的问题。
             **********************************************************************/
            if (modelType.IsSubclassOf(typeof(Entity)) &&
                !string.Equals(controllerContext.HttpContext.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase))
            {
                var idValue = bindingContext.ValueProvider.GetValue(Entity.IdProperty.Name);
                if (idValue != null)
                {
                    var id = (string)idValue.ConvertTo(typeof(string));
                    if (!string.IsNullOrWhiteSpace(id))
                    {
                        var repository = RF.Find(modelType);
                        var entity     = repository.GetById(id);
                        if (entity != null)
                        {
                            return(entity);
                        }
                    }
                }
            }

            return(base.CreateModel(controllerContext, bindingContext, modelType));
        }
예제 #6
0
        protected override void Up()
        {
            this.RunCode(db =>
            {
                //由于本类没有支持 Down 操作,所以这里面的 Up 需要防止重入。
                var repo = RF.Find <Storage>();
                var list = repo.GetAll();
                if (list.Count == 0)
                {
                    repo.Save(new Storage
                    {
                        Code              = "20120423-0001",
                        Name              = "北京仓库",
                        Address           = "北京",
                        ResponsiblePerson = "胡庆访",
                        Area              = "海淀区",
                        IsDefault         = true
                    });

                    repo.Save(new Storage
                    {
                        Code              = "20120425-0002",
                        Name              = "云南仓库",
                        Address           = "云南省",
                        ResponsiblePerson = "胡庆访",
                        Area              = "昭通市"
                    });
                }
            });
        }
예제 #7
0
        private List <EntityMeta> GetMappingEntityTypes()
        {
            var tableEntityTypes = new List <EntityMeta>();

            //程序集列表,生成数据库会反射找到程序集内的实体类型进行数据库映射
            foreach (var assembly in RafyEnvironment.AllPlugins)
            {
                foreach (var type in assembly.Assembly.GetTypes())
                {
                    if (!type.IsAbstract)
                    {
                        //判断实体类型是否映射了某一个数据库
                        var em = CommonModel.Entities.Find(type);
                        if (em != null && em.TableMeta != null)
                        {
                            var entityDb = RdbDataProvider.Get(RF.Find(type)).ConnectionStringSettingName;
                            if (entityDb == this._dbSetting.Name)
                            {
                                tableEntityTypes.Add(em);
                            }
                        }
                    }
                }
            }

            return(tableEntityTypes);
        }
예제 #8
0
        /// <summary>
        /// 反序列化指定的数组为一个实体的列表。
        /// </summary>
        /// <param name="listType"></param>
        /// <param name="jArray"></param>
        /// <returns></returns>
        public EntityList DeserializeList(Type listType, JArray jArray)
        {
            var entityType = EntityMatrix.FindByList(listType).EntityType;
            var repo       = RF.Find(entityType);

            //构造或查询出数据对应的实体列表。
            EntityList list = null;

            if (_creationMode == UpdatedEntityCreationMode.RequeryFromRepository)
            {
                //先从数据库中找出所有提供了 Id 的实体。
                var idList = jArray.Cast <JObject>().Select(item => TryGetId(item))
                             .Where(id => id != null).ToArray();
                list = repo.GetByIdList(idList);
            }
            else
            {
                list = repo.NewList();
            }

            //依次反序列化数组中的实体:
            //如果有 Id,则在数据库中查询出的列表 list 中查找出对应的实体,然后反序列化值。否则,直接构造新实体。
            for (int i = 0, c = jArray.Count; i < c; i++)
            {
                var jEntity = jArray[i] as JObject;
                var child   = FindOrCreate(list, jEntity);
                DeserializeProperties(jEntity, child);
            }

            return(list);
        }
예제 #9
0
        private void AsyncLoadPositions(ViewModel[] viewModels)
        {
            AsyncHelper.InvokeSafe(() =>
            {
                foreach (var model in viewModels)
                {
                    var positions = (RF.Find <OrgPosition>() as OrgPositionRepository)
                                    .GetList(model.UserId).Cast <OrgPosition>().ToList();
                    if (positions.Count > 0)
                    {
                        var positionResult = new StringBuilder();
                        for (int i = 0, c = positions.Count; i < c; i++)
                        {
                            var item = positions[i];
                            if (i != 0)
                            {
                                positionResult.Append('/');
                            }
                            positionResult.Append(item.View_Name);
                        }

                        model.Position = positionResult.ToString();
                    }
                }
            });
        }
예제 #10
0
 /// <summary>
 /// 加载数据
 ///
 /// 如果已经初始化CslaDataProvider,则从里面获取数据。
 /// 否则表示
 /// </summary>
 /// <param name="async">
 /// 是否使用异步模式
 /// </param>
 private void EnsureDataLoaded(bool async)
 {
     if (this.IsUseLocalData())
     {
         //本地时,每次都检测属性的值是否是最新的。
         this.RefreshPropertyDataSource();
     }
     else
     {
         if (this._listView.Data == null)
         {
             if (async)
             {
                 this._listView.DataLoader.LoadDataAsync(() =>
                 {
                     using (this._process.TryEnterProcess(LLPEProcess.AsyncDataLoaded))
                     {
                         this.SyncValueToSelection();
                     }
                 });
             }
             else
             {
                 this._listView.Data = RF.Find(this._listView.EntityType).CacheAll();
             }
         }
     }
 }
예제 #11
0
        /// <summary>
        /// 根据物料大类代码查找物料大类
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        private ItemLargeCategory FindLargeCategoryByCode(string code)
        {
            var categoryRepo    = RF.Find <ItemLargeCategory>();
            var categoryQueryer = categoryRepo.CreateEntityQueryer <ItemLargeCategory>();

            categoryQueryer.Where(f => f.Code == code);
            return(categoryRepo.QueryFirst(categoryQueryer) as ItemLargeCategory);
        }
예제 #12
0
        private void TrySetProperty(Entity e, string pName, JToken value)
        {
            //有些小写的客户端数据被传输到了服务端,需要被过滤掉。
            if (char.IsLower(pName[0]))
            {
                return;
            }

            var pm = _entityMeta.Property(pName) as PropertyMeta ??
                     _entityMeta.ChildrenProperty(pName);

            if (pm != null)
            {
                var mp = pm.ManagedProperty;
                if (mp is IListProperty)
                {
                    //todo: 此处的性能可能需要优化,聚合保存子列表时,重复的查询 Repository
                    var entityType = EntityMatrix.FindByList(pm.PropertyType).EntityType;
                    var repo       = RF.Find(entityType);

                    //列表属性的设置不能使用 SetProperty,否则,list.Parent 将会无值。
                    //但是也不能直接使用 LoadProperty,否则会导致调用 list.MarkOld,从而不会保存这个列表。
                    //所以只能先装载一个空列表,然后再把 json 中的数据转换为实体加入到这个列表中。
                    var list = repo.NewList();
                    e.LoadProperty(mp, list);

                    ListReader.JsonToEntity(value as JObject, repo, list);
                }
                else
                {
                    var rawValue = (value as JValue).Value;

                    rawValue = EntityJsonConverter.ToServerValue(pm.PropertyType, rawValue);

                    e.SetProperty(mp, rawValue, ManagedPropertyChangedSource.FromUIOperating);
                }
            }
            else
            {
                var rawValue = (value as JValue).Value;

                //如果没有找到一般的属性,则尝试查找外键属性
                for (int i = 0, c = _refIdProperties.Count; i < c; i++)
                {
                    var rip = _refIdProperties[i];
                    if (rip.Name == pName)
                    {
                        e.SetRefId(rip, rawValue);
                        break;
                    }
                }
                //只读属性。
                //if(notFound)
                //{
                //    throw new InvalidOperationException("没有在实体中找到这个属性:" + pName);
                //}
            }
        }
예제 #13
0
        public void MPT_ORM_PropertiesMapping_Inheritance()
        {
            var repo = RF.Find <TestAdministrator>() as TestUserRepository;

            //清空历史数据
            var user = repo.GetByName("huqf");

            if (user != null)
            {
                user.PersistenceStatus = PersistenceStatus.Deleted;
                repo.Save(user);
            }

            //新建用户并设置一些值。
            var user1 = repo.New().CastTo <TestAdministrator>();

            user1.Name  = "huqf";
            user1.Level = 1;
            TestUserExt.SetUserCode(user1, "NewUserCode");

            //为用户添加一个角色
            var userRoles = user1.TestRoleList;
            var role      = new TestRole();

            userRoles.Add(role);
            role.Name = "admin";
            Assert.AreEqual(user1.Id, role.TestUserId);

            //保存新建用户
            repo.Save(user1);

            //重新获取保存的用户
            var user2 = repo.GetByName("huqf").CastTo <TestAdministrator>();

            Assert.IsNotNull(user2);
            Assert.AreEqual(user1.Name, user2.Name);
            Assert.AreEqual(user2.Level, 1);
            Assert.AreEqual(TestUserExt.GetUserCode(user2), "NewUserCode");
            Assert.AreEqual(user1.TestRoleList.Count, 1);
            Assert.AreEqual(user1.TestRoleList[0].CastTo <TestRole>().Name, "admin");

            //获取 Role
            var role2 = RF.Find <TestRole>().GetById(role.Id).CastTo <TestRole>();

            Assert.AreEqual(role.Name, "admin");
            Assert.AreEqual(role2.Name, "admin");
            Assert.AreEqual(user1.Id, role2.TestUserId);
            Assert.IsNotNull(role2.TestUser);

            //删除用户
            user1.PersistenceStatus = PersistenceStatus.Deleted;
            repo.Save(user1);
            var users = repo.GetAll();

            Assert.IsTrue(!users.Cast <TestUser>().Any(u => u.Name == "huqf"));
        }
예제 #14
0
        /// <summary>
        /// 清空所有版本号,所有缓存都会过期。
        /// </summary>
        public void Clear()
        {
            var cacheRepo = RF.Find <ScopeVersion>();

            var allList = cacheRepo.GetAll();

            allList.Clear();

            cacheRepo.Save(allList);
        }
예제 #15
0
        public void MPT_WPFBinding()
        {
            var userList = RF.Find <TestUser>().NewList();
            var newUser  = Get <TestUser>();

            newUser.Name = "1";
            userList.Add(newUser);

            //创建 binding view
            var view = CollectionViewSource.GetDefaultView(userList) as ListCollectionView;

            Assert.IsNotNull(view);
            var userListView = view.SourceCollection as TestUserList;

            Assert.AreEqual(userListView, userList);

            //list change 事件
            NotifyCollectionChangedEventArgs eventArgs = null;

            userListView.CollectionChanged += (oo, ee) => { eventArgs = ee; };

            newUser      = Get <TestUser>();
            newUser.Name = "2";
            userList.Add(newUser);

            Assert.IsNotNull(eventArgs);
            Assert.AreEqual(eventArgs.Action, NotifyCollectionChangedAction.Add);
            Assert.AreEqual(userListView.Count, userList.Count);

            //测试 ICustomTypeDescriptor 的实现
            var newUserView       = userListView[1];
            var properties        = (newUserView as ICustomTypeDescriptor).GetProperties();
            var managedProperties = newUser.PropertiesContainer.GetAvailableProperties();

            Assert.IsTrue(managedProperties.All(mp => properties.Cast <PropertyDescriptor>().Any(p => p.Name == mp.Name)));
            //去掉索引器
            var clrProperties = typeof(TestUser).GetProperties().Where(p => p.GetMethod.GetParameters().Length == 0).ToArray();

            Assert.IsTrue(clrProperties.All(clr => properties.Cast <PropertyDescriptor>().Any(p => p.Name == clr.Name)));

            //view model 的属性更改事件
            var namePropertyChanged = false;

            newUserView.PropertyChanged += (oo, ee) =>
            {
                if (ee.PropertyName == "Name")
                {
                    namePropertyChanged = true;
                }
            };
            newUser.Name += "_Modified";
            Assert.IsTrue(namePropertyChanged);
        }
예제 #16
0
 protected override void Up()
 {
     this.RunCode(db =>
     {
         var repo = RF.Find <TestUser>();
         for (int i = 0; i < 10; i++)
         {
             var user = new TestUser();
             repo.Save(user);
         }
     });
 }
예제 #17
0
 protected override void Down()
 {
     this.RunCode(db =>
     {
         var repo = RF.Find <TestUser>();
         var all  = repo.GetAll();
         foreach (var user in all)
         {
             user.PersistenceStatus = PersistenceStatus.Deleted;
         }
         repo.Save(all);
     });
 }
예제 #18
0
        public DataPortalResult Action(Type objectType, string methodName, object criteria, DataPortalContext context)
        {
            var obj = RF.Find(objectType);
            var res = MethodCaller.CallMethodIfImplemented(obj, methodName, criteria);

            if (res != null)
            {
                return(new DataPortalResult(res));
            }
            else
            {
                return(new DataPortalResult(obj));
            }
        }
예제 #19
0
파일: EntityTest.cs 프로젝트: yungtau/oea
        public void ET_Repository_CantHasNoRepo()
        {
            bool success = false;

            try
            {
                var repo = RF.Find <NoRepoEntity>();
                success = true;
            }
            catch (TypeInitializationException)
            {
            }
            Assert.IsFalse(success, "没有编写仓库类型的实体,获取其相应的仓库时应该报错。");
        }
예제 #20
0
        public void DMT_ManualMigrate()
        {
            using (var context = new RafyDbMigrationContext(UnitTestEntityRepositoryDataProvider.DbSettingName))
            {
                context.HistoryRepository    = new DbHistoryRepository();
                context.RunDataLossOperation = DataLossOperation.All;

                try
                {
                    context.ManualMigrations.Clear();
                    context.ManualMigrations.Add(new DMT_ManualMigrateEntity());
                    context.ManualMigrations.Add(new DMT_ManualMigrateTest());

                    //手工更新
                    context.MigrateManually();

                    //历史记录
                    var histories = context.GetHistories();
                    Assert.IsTrue(histories.Count == 2);
                    Assert.IsTrue(histories[0] is DMT_ManualMigrateTest);
                    Assert.IsTrue(histories[1] is DMT_ManualMigrateEntity);

                    //数据库结构
                    var database = context.DatabaseMetaReader.Read();
                    var table    = database.FindTable("TestingTable");
                    Assert.IsTrue(table.Columns.Count == 2);
                    var pk = table.FindPrimaryColumn();
                    Assert.IsTrue(pk.Name.EqualsIgnoreCase("Id"));
                    Assert.IsTrue(pk.DbType == DbType.Int32);

                    //数据库数据
                    using (var db = DbAccesserFactory.Create(context.DbSetting))
                    {
                        var rows = db.QueryDataTable("select * from TestingTable");
                        Assert.IsTrue(rows.Rows.Count == 2);
                    }
                    var repo = RF.Find <TestUser>();
                    Assert.IsTrue(repo.CountAll() == 10);
                }
                finally
                {
                    //回滚
                    context.RollbackAll(RollbackAction.DeleteHistory);

                    var database = context.DatabaseMetaReader.Read();
                    Assert.IsTrue(database.FindTable("TestingTable") == null);
                }
            }
        }
예제 #21
0
        protected override Result ExecuteCore()
        {
            var orgPosition = RF.Find <OrgPosition>().GetById(this.OrgPositionId) as OrgPosition;

            if (orgPosition == null)
            {
                return("没有找到对应的岗位。");
            }

            var curModule = RF.Find <ModuleAC>().GetById(this.ModuleId) as ModuleAC;
            var moduleKey = curModule.KeyLabel;

            var ids = this.DenyOperationIds.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
                      .Select(strId => Convert.ToInt32(strId)).ToArray();

            //清空当前模块在 denyList 中的数据
            var denyList         = orgPosition.OrgPositionOperationDenyList;
            var moduleOperations = denyList.Cast <OrgPositionOperationDeny>().Where(d => d.ModuleKey == moduleKey).ToArray();

            foreach (var item in moduleOperations)
            {
                denyList.Remove(item);
            }

            //根据当前的选择项把数据重新加入到 denyList 中。
            var toDeny = ids.Select(id => curModule.OperationACList.FirstOrDefault(op => op.Id.Equals(id)))
                         .Where(op => op != null).ToArray();
            var moduleScopeTranslated = OperationAC.ModuleScope.Translate();

            foreach (OperationAC item in toDeny)
            {
                var deny = new OrgPositionOperationDeny
                {
                    ModuleKey    = moduleKey,
                    OperationKey = item.OperationKey
                };
                if (item.ScopeKeyLabel != moduleScopeTranslated)
                {
                    deny.BlockKey = item.ScopeKeyLabel;
                }

                denyList.Add(deny);
            }

            //保存到数据库中。
            RF.Save(orgPosition);

            return(new Result(true, "权限保存成功。"));
        }
예제 #22
0
        public override void Execute(ListLogicalView view)
        {
            var list = RF.Find <UserLoginLog>().GetAll()
                       .OfType <UserLoginLog>()
                       .ToList();

            var control = new LoginLogStatistic(list);

            App.Windows.ShowDialog(control, w =>
            {
                w.Title         = "登录时间统计".Translate();
                w.MinHeight     = 300;
                w.SizeToContent = SizeToContent.WidthAndHeight;
            });
        }
예제 #23
0
 internal void LoadChildrenProperties()
 {
     if (this.User != null)
     {
         this.Id              = this.User.Id;
         this.Code            = this.User.Code;
         this.Name            = this.User.Name;
         this.IsAuthenticated = true;
         this._roles          = (RF.Find <OrgPosition>() as OrgPositionRepository).GetList(User.Id); // list of roles from security store
     }
     else
     {
         this.Id = 0;
         this.IsAuthenticated = false;
         this._roles          = null;
     }
 }
예제 #24
0
        /// <summary>
        /// 通过指定的数据获取方法,异步加载该视图对应实体类型的指定实体对象
        /// </summary>
        /// <param name="dataProvider">自定义数据提供程序。可以返回 Entity,也可以返回 EntityList。</param>
        /// <param name="changedCallback">数据加载返回后的回调函数</param>
        public void LoadDataAsync(Func <IDomainComponent> dataProvider, Action changedCallback)
        {
            if (dataProvider == null)
            {
                dataProvider = () => RF.Find(this._view.EntityType).CacheAll();
            }

            using (this._dataProvider.DeferRefresh())
            {
                this._dataProvider.DataProducer = dataProvider;
            }

            if (changedCallback != null)
            {
                this.ListenDataChangedOnce(changedCallback);
            }
        }
예제 #25
0
        protected override void Validate(Entity entity, RuleArgs e)
        {
            var id = entity.Id;

            var repo = RF.Find(ReferenceProperty.Owner);

            if (repo != null)
            {
                var criteria = new CommonQueryCriteria();
                criteria.Add(ReferenceProperty.Property, id);

                var count = repo.CountBy(criteria);
                if (count > 0)
                {
                    e.BrokenDescription = this.BuildError(entity, count);
                }
            }
        }
예제 #26
0
        protected override Result ExecuteCore()
        {
            var orderId  = this.ItemId;
            var osibRepo = RF.ResolveInstance <OrderStorageInBillRepository>();

            var storageInList = osibRepo.GetByOrderId(orderId);

            if (storageInList.Count > 0)
            {
                return("该定单已经有相应的入库记录,不能直接删除。");
            }

            var order = RF.Find <PurchaseOrder>().GetById(orderId);

            order.PersistenceStatus = PersistenceStatus.Deleted;
            RF.Save(order);

            return(true);
        }
예제 #27
0
        /// <summary>
        /// 实体的自定义反序列化方法。
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="jObject">The j object.</param>
        /// <param name="id">实体的标识。如果已经在 jObject 中指定时,此参数可以传入 null。</param>
        /// <returns></returns>
        public Entity DeserializeEntity(Type type, JObject jObject, object id)
        {
            Entity entity = null;

            if (id != null)
            {
                var repository = RF.Find(type);
                entity = repository.GetById(id);
            }
            if (entity == null)
            {
                entity = Activator.CreateInstance(type) as Entity;
            }

            //反序列化一般属性
            DeserializeProperties(jObject, entity);

            return(entity);
        }
예제 #28
0
        public void MPT_ORM_PropertiesMapping()
        {
            using (RF.TransactionScope(UnitTestEntityRepositoryDataProvider.DbSettingName))
            {
                var repo = RF.ResolveInstance <TestUserRepository>();

                //新建用户并设置一些值。
                var user1 = repo.New();
                user1.Name = "huqf";
                TestUserExt.SetUserCode(user1, "NewUserCode");

                //为用户添加一个角色
                var userRoles = user1.TestRoleList;
                var role      = new TestRole();
                userRoles.Add(role);
                role.Name = "admin";
                Assert.AreEqual(user1.Id, role.TestUserId);

                //保存新建用户
                repo.Save(user1);

                //重新获取保存的用户
                var user2 = repo.GetByName("huqf");
                Assert.IsNotNull(user2);
                Assert.AreEqual(user1.Name, user2.Name);
                Assert.AreEqual(TestUserExt.GetUserCode(user2), "NewUserCode");
                Assert.AreEqual(user1.TestRoleList.Count, 1);
                Assert.AreEqual(user1.TestRoleList[0].CastTo <TestRole>().Name, "admin");

                //获取 Role
                var role2 = RF.Find <TestRole>().GetById(role.Id).CastTo <TestRole>();
                Assert.AreEqual(role.Name, "admin");
                Assert.AreEqual(role2.Name, "admin");
                Assert.AreEqual(user1.Id, role2.TestUserId);
                Assert.IsNotNull(role2.TestUser);

                //删除用户
                user1.PersistenceStatus = PersistenceStatus.Deleted;
                repo.Save(user1);
                var users = repo.GetAll();
                Assert.IsTrue(!users.Cast <TestUser>().Any(u => u.Name == "huqf"));
            }
        }
예제 #29
0
        private EntityList DeserializeList(Type listType, JArray jArray)
        {
            var entityType = EntityMatrix.FindByList(listType).EntityType;
            var repo       = RF.Find(entityType);

            //先从数据库中找出所有提供了 Id 的实体。
            var idList = jArray.Cast <JObject>().Select(item => TryGetId(item))
                         .Where(id => id != null).ToArray();
            var list = repo.GetByIdList(idList);

            //依次反序列化数组中的实体:
            //如果有 Id,则在数据库中查询出的列表 list 中查找出对应的实体,然后反序列化值。否则,直接构造新实体。
            foreach (JObject jEntity in jArray)
            {
                var child = FindOrCreate(list, jEntity);
                DeserializeProperties(jEntity, child);
            }

            return(list);
        }
예제 #30
0
파일: EntityTest.cs 프로젝트: yungtau/oea
        public void ET_Repository_Simple()
        {
            var pbsRepository = RF.Find <PBS>();

            using (RF.TransactionScope(pbsRepository))
            {
                pbsRepository.Save(new PBSType
                {
                    Name    = "PBSType1",
                    PBSList =
                    {
                        new PBS {
                            Name = "PBS1"
                        },
                        new PBS {
                            Name = "PBS2"
                        },
                        new PBS {
                            Name = "PBS3"
                        },
                        new PBS {
                            Name = "PBS4"
                        },
                        new PBS {
                            Name = "PBS5"
                        },
                    }
                });

                var pbss = pbsRepository.GetAll();
                if (pbss.Count > 0)
                {
                    var pbsOriginal = pbss[0] as PBS;
                    var pbs         = pbsRepository.GetById(pbsOriginal.Id) as PBS;
                    Assert.IsNotNull(pbs);
                    Assert.AreEqual(pbs.Id, pbsOriginal.Id);
                    Assert.AreEqual(pbs.PBSTypeId, pbsOriginal.PBSTypeId);
                    Assert.AreEqual(pbs.Name, pbsOriginal.Name);
                }
            }
        }