C# UserRepository.Get方法代码示例

        public void UserExample()
        {
            var interests = new HashSet<string> { "distributed systems", "Erlang" };
            var joe = new User("Joe", "Armstrong", interests);

            var entityManager = new EntityManager(client);
            entityManager.Add(joe);
            var repo = new UserRepository(client);
            repo.Save(joe);

            joe.VisitPage();

            joe.AddInterest("riak");

            repo.UpgradeAccount(joe);

            var joeFetched = repo.Get(joe.ID);

            Assert.GreaterOrEqual(joe.PageVisits, 0);
            Assert.Contains("riak", joeFetched.Interests.ToArray());

            PrintObject(joeFetched);

            repo.DowngradeAccount(joe);

            joeFetched = repo.Get(joe.ID);
            PrintObject(joeFetched);
        }

        public ViewResult Index(string Name, string Email, string Password)
        {
            try
            {
                UserRepository userRep = new UserRepository();
                Expression<Func<t_user, bool>> filter =
                x => (x.mail == Email && Email != null);
                List<t_user> users = userRep.Get(filter).ToList();
                LoginModel model = new LoginModel();

                if (users.Count > 0)
                {
                    return View(model);
                }
                else
                {
                    t_user newUser = new t_user();
                    newUser.name = Name;
                    newUser.mail = Email;
                    newUser.password = Password;
                    newUser.roleID = 2;
                    userRep.Save(newUser);

                    model.Name = Name;
                    model.Email = Email;
                    model.Password = Password;
                }

                return View(model);
            }
            catch (Exception)
            {
                return null;
            }
        }

        public void IsLoggedInIsFalseWhenValueIsMissingFromConfiguration()
        {
            var watchingConfigRepoMock = MockRepository.GenerateMock<IWatchingConfigurationRepository>();
            var repository = new UserRepository(watchingConfigRepoMock);
            var mockConfig = MockRepository.GenerateMock<IConfigurationElement>();
            mockConfig.Stub(x => x.Attributes).Return(new Dictionary<string, string>());
            var mockFriendsConfig = MockRepository.GenerateMock<IConfigurationElement>();
            mockFriendsConfig.Stub(x => x.Name).Return("friends");
            mockFriendsConfig.Stub(x => x.Attributes).Return(new Dictionary<string, string>()
            {
                { "PersonaName", "User Name" },
            });
            var mockProfileDetailConfig = MockRepository.GenerateMock<IConfigurationElement>();
            mockProfileDetailConfig.Stub(x => x.Name).Return("123");
            mockProfileDetailConfig.Stub(x => x.Attributes).Return(new Dictionary<string, string>()
            {
                { "name", mockFriendsConfig.Attributes["PersonaName"] }
            });
            mockFriendsConfig.Stub(x => x.Children).Return(new[] { mockProfileDetailConfig });
            mockConfig.Stub(x => x.Children).Return(new[] { mockFriendsConfig });

            watchingConfigRepoMock.Raise(x => x.Added += delegate { }, mockConfig);

            var user = repository.Get().FirstOrDefault();
            Assert.IsNotNull(user);

            Assert.AreEqual(int.Parse(mockProfileDetailConfig.Name), user.Id);
            Assert.AreEqual(mockProfileDetailConfig.Attributes["name"], user.Name);
            Assert.AreEqual(false, user.IsLoggedIn);
        }

        public void OrderDetails()
        {
            var conn = new NHibernateConnection();
            var orderRepo = new OrdersRepository(conn);
            var productRepo = new ProductsRepository(conn);
            var userRepo = new UserRepository(conn);
            var deliveryRepo = new DeliveryTypesRepository(conn);
            Users user = userRepo.Get("[email protected]");
            var orderDetailsRepo = new OrderDetailsRepository(conn);
            Products product = productRepo.GetAll().First();

            var delivetyType = deliveryRepo.GetAll().First();

            if (delivetyType == null)
            {
                delivetyType = new DeliveryTypes("Poczta Polska", Convert.ToDecimal(8.99));
                deliveryRepo.Save(delivetyType);
            }

            var order = new Orders(user, DateTime.Now,
                Convert.ToDecimal(299.99),delivetyType);

            orderRepo.Save(order);

            var orderDetails = new OrderDetails(order, product, 2, Convert.ToDecimal(29.99));
            orderDetailsRepo.Save(orderDetails);

            var fromDB = orderDetailsRepo.Get(orderDetails.ID);

            Assert.IsNotNull(fromDB);
        }

 public static void GetMySql()
 {
     UserRepository rep = new UserRepository(new MySqlDbContext());
     rep.Insert(new User { ID = new Guid("12736219-9398-4DBD-A392-BF8C5CCC3635"), Mobile = "01819421877", Password = "NewPassword", Username = "SiamDeath" });
     rep.Commit();
     var data = rep.Get(new Guid("C1C8D804-0645-4006-B9C8-192EBD944944"));
     var collection = rep.GetAll().ToList();
 }

        public static void GetSql()
        {
            UserRepository rep = new UserRepository(new WebApiDBContext());
            rep.Insert(new User { ID = new Guid("19D40AEC-37B7-4114-A5BF-E4E3B3CFC97A"), Mobile = "01819421877", Password = "NewPassword", Username = "SiamDeath" });
            rep.Commit();

            var data = rep.Get(new Guid("C1C8D804-0645-4006-B9C8-192EBD944944"));
            var collection = rep.GetAll().ToList();

        }

        public void TestGet_InitializeNoUsers_ShouldReturnNull()
        {
            // Arrange
            var roomsRepo = new UserRepository();

            // Act
            var user = roomsRepo.Get(1);

            // Assert
            Assert.IsNull(user);
        }

 public int getUserId(string name)
 {
     UserRepository user_rep = new UserRepository();
     int user_id = -1;
     User user = user_rep.Get(u => u.Email == name);
     if (user != null)
     {
         user_id = user.Id;
     }
     return user_id;
 }

 public void ChangeIDCard(string userName, string idCardNo, string chineseName)
 {
     using (UserRepository userRepository = new UserRepository())
     {
         var user = userRepository.Get(userName);
         if (user != null)
         {
             user.ChangeIDCard(idCardNo, chineseName);
             userRepository.Commit();
         }
     }
 }

 public void ActivateAccountTest()
 {
     IUserService accountSrv = new UserService();
     UserAppService target = new UserAppService(accountSrv);
     using (UserRepository repository = new UserRepository())
     {
         Guid accountId = new Guid("D1111C18-A0BD-480B-99CA-AAF50B2D1818");
         var account = repository.Get(accountId);
         string activationCode = account.ActivationCode;
         target.ActivateAccount(accountId, activationCode);
         repository.Refresh(account);
         Assert.AreEqual(account.IsActive, true);
     }
 }

        public void TestGet_InitializeValidUsers_PasswordsShouldMatch()
        {
            // Arrange
            var roomsRepo = new UserRepository();
            roomsRepo.Add(new User("username1", "password123", Roles.User));
            roomsRepo.Add(new User("username2", "password1234", Roles.VenueAdmin));
            roomsRepo.Add(new User("username3", "password123", Roles.User));

            // Act
            var user = roomsRepo.Get(2);

            // Assert
            Assert.AreEqual(HashUtilities.GetSha256Hash("password1234"), user.PasswordHash, "Passwords don't match.");
        }

        public bool DeleteUser(int id)
        {
            UserRepository repo = new UserRepository(entities);
            User user = repo.Get(id);

            try {
                repo.Delete(user);
                return true;
            }
            catch (Exception ex) {
                _errorMessage = ex.Message;
                return false;
            }
        }

        public void TestGet_InitializeValidUsers_UsernamesShouldMatch()
        {
            // Arrange
            var roomsRepo = new UserRepository();
            roomsRepo.Add(new User("username1", "password123", Roles.User));
            roomsRepo.Add(new User("username2", "password123", Roles.VenueAdmin));
            roomsRepo.Add(new User("username3", "password123", Roles.User));

            // Act
            var user = roomsRepo.Get(2);

            // Assert
            Assert.AreEqual("username2", user.Username, "Usernames don't match.");
        }

        public JsonResult GetUserData(string page, string sidx, string sord)
        {
            var repo = new UserRepository();

            var jqGridUserDto = new JqGridUserDto()
            {
                Data = repo.Get(),
                Page = page,
                PageSize = 5,
                SortColumn = sidx,
                SortOrder = sord
            };

            return Json(jqGridUserDto, JsonRequestBehavior.AllowGet);
        }

        public void CreateApplication(Domain.Context.Application application)
        {
            if (application == null)
                throw new ArgumentNullException("application");

            using (UserRepository userRepository = new UserRepository())
            {
                var user = userRepository.Get(application.UserId);

                if (user != null)
                {
                    var achievement = user.Achievements.SingleOrDefault<Achievement>(a => a.Year == DateTime.Now.Year);
                    if (achievement != null)
                    {
                        //using (SpecialityEnrollPlanRepository enrollPlanRepository = new SpecialityEnrollPlanRepository())
                        //{
                        //    var enrollPlans = enrollPlanRepository.GetFiltered(e => e.SpecialityId == application.SpecialityId && e.Province == achievement.Province).SingleOrDefault<SpecialityEnrollPlan>();
                        //    if (enrollPlans != null)
                        //    {
                        using (ApplicationRepository appRepository = new ApplicationRepository())
                        {
                            var apps = appRepository.GetFiltered(app => app.Year == application.Year && app.Batch == application.Batch && app.ApplicationSequence == application.ApplicationSequence);
                            if (apps != null && apps.ToList<Domain.Context.Application>().Count > 0)
                            {
                                // throw existing application exception
                                throw new UniversityApplicationExistException(Resource.UserMessages.ex_UniversityApplicationExist);
                            }
                            appRepository.Add(application);
                            appRepository.Commit();
                        }
                        //}
                        //else
                        //{
                        //    // throw no enroll plan exception
                        //    throw new UniversityNoEnrollPlanException(Resource.ResourceMessage.ex_UnversityNoEnrollPlan);
                        //}
                        //}
                    }
                    else
                    {
                        throw new UniversityApplicationExistException(Resource.UserMessages.ex_AchievementNotExist);
                    }
                }
            }
        }