C# UnitOfWork.Add方法代码示例

        public void Add_ValidEntity_EntityAddedToDbContext()
        {
            FakeSet<User> setStub = new FakeSet<User>();
            Mock<DbContext> contextStub = new Mock<DbContext>();
            contextStub.Setup(c => c.Set<User>()).Returns(setStub);

            IInterceptorsResolver interceptorsResolver =  new Mock<IInterceptorsResolver>().Object;
            UnitOfWork uof = new UnitOfWork(contextStub.BuildFactoryStub(), interceptorsResolver);

            User u = new User();
            uof.Add(u);

            Assert.IsTrue(setStub.Values.Contains(u));
        }

        public ServerModel AddServer(ServerModel model)
        {
            if (model == null)
                throw new ArgumentNullException("model");

            Server appToReturn;

            using (var unitOfWork = new UnitOfWork(_connectionString))
            {
                bool userAuthorised = UserAuthorizedToAccessSuite(unitOfWork, model.UserId, model.SuiteId,
                    new[] {RoleType.Admin});
                if (!userAuthorised)
                    throw new UnauthorizedUserException(
                        "User does not have access or sufficient privileges for this action to suite: " + model.SuiteId);

                appToReturn = model.ToNewDbObject();
                unitOfWork.Add(appToReturn);
            }

            if (appToReturn != null)
                return appToReturn.ToModel();
            return null;
        }

        public SuiteModel AddSuite(SuiteCreateModel suiteModel)
        {
            Suite suiteReturn;
            using (var unitOfWork = new UnitOfWork(_connectionString))
            {
                if (unitOfWork.Context.Suites.Any(x => x.SuiteName == suiteModel.SuiteName))
                    throw new InvalidOperationException("Suite already exists with name:" + suiteModel.SuiteName);

                var suiteDB = suiteModel.ToNewDbObject();
                unitOfWork.Add(suiteDB);

                suiteReturn = suiteDB;

                //if (unitOfWork.Context.SuiteUsers.Any(x => x.UserId == suiteModel.UserId && x.SuiteId == suiteDB.SuiteId)) return;

                //var userMapping = new SuiteUser()
                //{
                //    SuiteId = suiteDB.SuiteId,
                //    UserId = suiteModel.UserId
                //};

                //unitOfWork.Add(userMapping);

                foreach (var environment in suiteModel.Environments)
                {
                    environment.SuiteId = suiteDB.SuiteId;
                    environment.IsActive = true;

                    unitOfWork.Add(environment.ToNewDbObject());
                }

                foreach (var application in suiteModel.Applications)
                {
                    application.SuiteId = suiteDB.SuiteId;
                    application.IsActive = true;

                    unitOfWork.Add(application.ToNewDbObject());
                }

                foreach (var region in suiteModel.Regions)
                {
                    region.SuiteId = suiteDB.SuiteId;
                    region.IsActive = true;

                    unitOfWork.Add(region.ToNewDbObject());
                }

                foreach (var server in suiteModel.Servers)
                {
                    server.SuiteId = suiteDB.SuiteId;
                    server.IsActive = true;

                    unitOfWork.Add(server.ToNewDbObject());
                }

                unitOfWork.Add(new SuiteUser
                {
                    SuiteId = suiteReturn.SuiteId,
                    UserId = (int) suiteModel.UserId,
                    RoleId = (int) RoleType.Admin
                });
            }

            return GetSuite(suiteModel.UserId, suiteReturn.SuiteId);
        }

        public EnvironmentModel AddEnvironment(EnvironmentModel model)
        {
            if (model == null)
                throw new ArgumentNullException("model");

            Environment environmentToReturn = null;

            using (var unitOfWork = new UnitOfWork(_connectionString))
            {
                bool userAuthorised = UserAuthorizedToAccessSuite(unitOfWork, model.UserId, model.SuiteId,
                    new[] {RoleType.Admin});
                if (!userAuthorised)
                    throw new UnauthorizedUserException(
                        "User does not have access or sufficient privileges for this action to suite: " + model.SuiteId);

                environmentToReturn = model.ToNewDbObject();
                unitOfWork.Add(environmentToReturn);
            }

            return environmentToReturn.ToModel();
        }

 public void AddAuditRecord(AuditRecordModel auditRecord)
 {
     using (var unitOfWork = new UnitOfWork(_connectionString))
     {
         unitOfWork.Add(auditRecord.ToNewDbObject());
     }
 }

        public MappingModel AddMapping(MappingModel model)
        {
            if (model == null)
                throw new ArgumentNullException("model");

            Mapping mapToReturn;

            using (var unitOfWork = new UnitOfWork(_connectionString))
            {
                bool userAuthorised = UserAuthorizedToAccessSuite(unitOfWork, model.UserId, model.SuiteId,
                    new[] {RoleType.Admin});
                if (!userAuthorised)
                    throw new UnauthorizedUserException(
                        "User does not have access or sufficient privileges for this action to suite: " + model.SuiteId);

                if (
                    !unitOfWork.Context.Parameters.Any(
                        x => x.ParameterId == model.ParameterId && x.SuiteId == model.SuiteId))
                    throw new InvalidOperationException(
                        "Mismatch between parameter id and suite id. Can not add mapping!");

                if (!unitOfWork.Context.Servers.Any(x => x.ServerId == model.ServerId && x.SuiteId == model.SuiteId))
                    throw new InvalidOperationException("Mismatch between server id and suite id. Can not add mapping!");

                if (!unitOfWork.Context.Regions.Any(x => x.RegionId == model.RegionId && x.SuiteId == model.SuiteId))
                    throw new InvalidOperationException("Mismatch between region id and suite id. Can not add mapping!");

                if (
                    !unitOfWork.Context.Environments.Any(
                        x => x.EnvironmentId == model.EnvironmentId && x.SuiteId == model.SuiteId))
                    throw new InvalidOperationException(
                        "Mismatch between environment id and suite id. Can not add mapping!");

                if (
                    !unitOfWork.Context.Applications.Any(
                        x => x.ApplicationId == model.ApplicationId && x.SuiteId == model.SuiteId))
                    throw new InvalidOperationException(
                        "Mismatch between application id and suite id. Can not add mapping!");

                mapToReturn = model.ToNewDbObject();
                unitOfWork.Add(mapToReturn);
            }

            if (mapToReturn != null)
                return mapToReturn.ToModel();
            return null;
        }