C# Repository.FindBy方法代码示例

        public player find(string id)
        {
            int idP = int.Parse(id);
            Repository<player> players = new Repository<player>();

            return players.FindBy(g => g.Id == idP).FirstOrDefault();
        }

 public game getCurrentGame(string id)
 {
     int idL = int.Parse(id);
     var lanes = new Repository<lane>();
     lane lane = lanes.FindBy(l => l.Id == idL).Single();
     return lane.getCurrentGame();
 }

        public void GetLongLineTrip([Values(15850)] int tripId)
        {
            Mapper.AssertConfigurationIsValid();
            using (var session = Observer.DataService.GetSession())
            {
                var repo = new Repository<Observer.Entities.Trip>(session);
                var source = repo.FindBy(tripId);
                Assert.NotNull(source);
                Assert.IsInstanceOf<Observer.Entities.LongLineTrip>(source);
                var destination = Mapper.Map<Observer.Entities.Trip, Tubs.Entities.Trip>(source) as Tubs.Entities.LongLineTrip;
                Assert.NotNull(destination);
                Assert.NotNull(destination.Gear);
                Assert.NotNull(destination.Electronics);
                Assert.AreEqual(30, destination.Electronics.Count);
                // select count(*) from l_sethaul where obstrip_id = 15850
                // 9 entities
                Assert.NotNull(destination.FishingSets);
                Assert.AreEqual(9, destination.FishingSets.Count);

                var events =
                    from fset in destination.FishingSets
                    select fset.EventList.Count;
                Assert.AreEqual(96, events.Sum());

                var setcatch =
                    from fset in destination.FishingSets
                    select fset.CatchList.Count;
                Assert.AreEqual(900, setcatch.Sum());
            }
        }

        private void btnSave_Click(object sender, EventArgs e)
        {
            // Sanity cecking.

            _unitOfWork = new UnitOfWork(_sessionHelper.GetSessionFactory("APL"));
            Repository<Guid, APLBackendDB.Venue> _venueRepo = new Repository<Guid, APLBackendDB.Venue>(_unitOfWork.Session);
            Repository<Guid, APLBackendDB.Region> _regionRepo = new Repository<Guid, APLBackendDB.Region>(_unitOfWork.Session);
            _venue.Name = tbxVenueName.Text;
            _venue.Address1 = tbxAddr1.Text;
            _venue.Address2 = tbxAddr2.Text;
            _venue.Description = tbxDesc.Text;
            _venue.EmailAddress = tbxEmail.Text;
            _venue.Phone = tbxPhone.Text;
            int _pcode = 0;
            if (int.TryParse(tbxPcode.Text, out _pcode))
            {
                _venue.Postcode = (short)_pcode;
            }
            Guid _regionId = Guid.Empty;
            if (Guid.TryParse(cbxRegion.SelectedValue.ToString(), out _regionId))
            {
                _venue.Region = _regionRepo.FindBy(_regionId);
                _venue.State = _venue.Region.State;
            }
            _venue.Suburb = tbxSuburb.Text;
            _venue.Website = tbxURL.Text;
            if ( ! string.IsNullOrEmpty(tbxLat.Text) && ! String.IsNullOrEmpty(tbxLong.Text) )
            {
                _venue.Lattitude = float.Parse(tbxLat.Text);
                _venue.Longitude = float.Parse(tbxLong.Text);
            }
            _venueRepo.AddOrUpdate(_venue);
            _unitOfWork.Commit();
        }

        public void GetSetHaul([Values(63596, 63595, 62870, 60561, 59123, 50800)] int sethaulId)
        {
            Mapper.AssertConfigurationIsValid();
            using (var session = Observer.DataService.GetSession())
            {
                var repo = new Repository<Observer.Entities.LonglineFishingSet>(session);
                var src = repo.FindBy(sethaulId);
                Assert.NotNull(src);
                var dest = Mapper.Map<Observer.Entities.LonglineFishingSet, Tubs.Entities.LongLineSet>(src);
                Assert.NotNull(dest);
                Assert.NotNull(dest.NotesList);
                Assert.NotNull(dest.Baskets);
                Assert.NotNull(dest.EventList);
                Assert.True(dest.EventList.Count > 1);
                if (dest.LineSettingSpeedUnit.HasValue)
                {
                    Assert.True(Tubs.Common.UnitOfMeasure.Knots.Equals(dest.LineSettingSpeedUnit.Value));
                }
                if (!String.IsNullOrEmpty(dest.TargetSpeciesCode))
                {
                    StringAssert.AreEqualIgnoringCase("ALB", dest.TargetSpeciesCode);
                }
                Assert.True(dest.TotalHookCount.HasValue);
                Assert.AreEqual(1830, dest.TotalHookCount.Value);
                Assert.True(dest.TotalBasketCount.HasValue);
                Assert.AreEqual(61, dest.TotalBasketCount);
                Assert.True(dest.IsTargetingTuna.HasValue && dest.IsTargetingTuna.Value);

            }
        }

 public bool isAvalaible(string id)
 {
     int idL = int.Parse(id);
     var lanes = new Repository<lane>();
     lane lane = lanes.FindBy(l => l.Id == idL).Single();
     return lane.isAvalaible();
 }

 public void GetByStaffCode([Values("DJB")] string staffCode)
 {
     var repo = new Repository<FieldStaff>(DataService.GetSession());
     var person = repo.FindBy(staffCode);
     Assert.NotNull(person);
     StringAssert.AreEqualIgnoringCase(staffCode, person.StaffCode);
     Assert.AreEqual("DAVE J", person.FirstName);
     Assert.IsTrue("Dave J".Equals(person.FirstName.Trim(), StringComparison.CurrentCultureIgnoreCase));
 }

 public void GetKiobTrip([Values(3900)] int tripId)
 {
     using (var session = Observer.DataService.GetSession())
     {
         var repo = new Repository<Observer.Entities.Trip>(session);
         var source = repo.FindBy(tripId);
         Assert.NotNull(source);
         Assert.IsInstanceOf<Observer.Entities.PurseSeineTrip>(source);
         var destination = Mapper.Map<Observer.Entities.Trip, Tubs.Entities.Trip>(source) as Tubs.Entities.PurseSeineTrip;
         Assert.NotNull(destination);
     }
 }

        private System.Threading.Tasks.Task DoSync()
        {
            System.Threading.Tasks.Task t = new System.Threading.Tasks.Task(() =>
            {
                DataLayer.SessionHelper _sessionHelper = new SessionHelper();
                UnitOfWork _unitOfWork = new UnitOfWork(_sessionHelper.GetSessionFactory("APL"));
                Repository<Guid, Setting> _settingRepo = new Repository<Guid, APLBackendDB.Setting>(_unitOfWork.Session);
                Setting _settings = new Setting();

                SetStatusText("Starting sync...");

                Util.DBSync d = new Util.DBSync();
                d.ProgressUpdate += D_ProgressUpdate;

                SetStatusText("Syncing States...");
                d.SyncState();

                SetStatusText("Syncing Brands...");
                d.SyncBrand();

                SetStatusText("Syncing Regions...");
                d.SyncRegion();

                SetStatusText("Syncing Venues...");
                d.SyncVenue();

                SetStatusText("Syncing Game Types...");
                d.SyncGameType();

                SetStatusText("Syncing Games...");
                d.SyncGame();

                SetStatusText("Syncing Customers...");
                d.SyncCustomer();

                SetStatusText("Sync Completed.");
                btSync.Enabled = true;

                Setting lastSync = _settingRepo.FindBy(p => (p.Keyname == "LastCompleteSync"));
                if (lastSync == null || string.IsNullOrEmpty(lastSync.Value))
                {
                    lastSync = new Setting();
                    lastSync.Keyname = "LastCompleteSync";
                }
                lastSync.Value = DateTime.Now.ToString();

                _settingRepo.AddOrUpdate(lastSync);
                _unitOfWork.Commit();

            });
            t.Start();
            return t;
        }

        public NewsItemEdit(Guid newsItemId)
        {
            this.ShowInTaskbar = false;

            AllowDrop = true;
            _newsItemId = newsItemId;
            _sessionHelper = new SessionHelper();
            Repository<Guid, NewsItem> _newsItemRepo = new Repository<Guid, NewsItem>(_sessionHelper.GetSession("APL"));
            _newsItem = _newsItemRepo.FindBy(_newsItemId);
            InitializeComponent();
            PopulateForm();
        }

 public void GetSeaDay()
 {
     Mapper.AssertConfigurationIsValid();
     using (var session = Observer.DataService.GetSession())
     {
         var repo = new Repository<Observer.Entities.PsDay>(session);
         var src = repo.FindBy(12345);
         Assert.NotNull(src);
         var dest = Mapper.Map<Observer.Entities.PsDay, Tubs.Entities.PurseSeineSeaDay>(src);
         Assert.NotNull(dest);
     }
 }

        public void GetVesselAttributes()
        {
            Mapper.AssertConfigurationIsValid();
            using (var session = Observer.DataService.GetSession())
            {
                var repo = new Repository<Observer.Entities.PsVesselAttributes>(session);
                var src = repo.FindBy(2212); // obstrip_id 15735
                Assert.NotNull(src);
                var dest = Mapper.Map<Observer.Entities.PsVesselAttributes, Tubs.Entities.PurseSeineVesselAttributes>(src);
                Assert.NotNull(dest);

            }
        }

 public void GetVesselNotes()
 {
     Mapper.AssertConfigurationIsValid();
     using (var session = Observer.DataService.GetSession())
     {
         var repo = new Repository<Observer.Entities.Trip>(session);
         var source = repo.FindBy(572);
         Assert.NotNull(source);
         var destination = Mapper.Map<Observer.Entities.Trip, Tubs.Entities.VesselNotes>(source);
         Assert.NotNull(destination);
         StringAssert.AreEqualIgnoringCase("PNG-PH-524", destination.Licenses);
     }
 }

 public void GetPollutionEvent()
 {
     Mapper.AssertConfigurationIsValid();
     using (var session = Observer.DataService.GetSession())
     {
         var repo = new Repository<Observer.Entities.PollutionHeader>(session);
         var src = repo.FindBy(2588); // From obstrip_id 15013
         Assert.NotNull(src);
         var dest = Mapper.Map<Observer.Entities.PollutionHeader, Tubs.Entities.PollutionEvent>(src);
         Assert.NotNull(dest);
         Assert.NotNull(dest.Details);
     }
 }

 public void GetMarineDevice()
 {
     Mapper.AssertConfigurationIsValid();
     using (var session = Observer.DataService.GetSession())
     {
         var repo = new Repository<Observer.Entities.MarineDevice>(session);
         var source = repo.FindBy(72);
         Assert.NotNull(source);
         var destination = Mapper.Map<Observer.Entities.MarineDevice, Tubs.Entities.MarineDevice>(source);
         Assert.NotNull(destination);
         StringAssert.AreEqualIgnoringCase("WIND SPEED/DIRECTION GAUGE", destination.Description);
         StringAssert.AreEqualIgnoringCase("Wind Speed / Direction Gauge", destination.Category);
     }
 }