Exemplo n.º 1
0
        public IList <FeedingSourceDTO> GetFeedingSourceDTOs(bool canViewAndSearchAll, bool includeRestricted, string uploadedByUserId)
        {
            FeedingSourceDTO output               = null;
            FeedingSource    feedingSourceAlias   = null;
            AdminUser        uploadedByAlias      = null;
            AdminUser        approvedByAlias      = null;
            AdminUser        rejectedByAlias      = null;
            Source           sourceAlias          = null;
            PersonSource     personSourceAlias    = null;
            EventSource      eventSourceAlias     = null;
            UnitSource       unitSourceAlias      = null;
            OperationSource  operationSourceAlias = null;

            var q = Session.QueryOver <FeedingSource>(() => feedingSourceAlias)
                    .JoinAlias(() => feedingSourceAlias.UploadedBy, () => uploadedByAlias, JoinType.LeftOuterJoin)
                    .JoinAlias(() => feedingSourceAlias.ApprovedBy, () => approvedByAlias, JoinType.LeftOuterJoin)
                    .JoinAlias(() => feedingSourceAlias.RejectedBy, () => rejectedByAlias, JoinType.LeftOuterJoin)
                    .JoinAlias(() => feedingSourceAlias.Source, () => sourceAlias, JoinType.LeftOuterJoin)
                    .JoinAlias(() => sourceAlias.PersonSources, () => personSourceAlias, JoinType.LeftOuterJoin)
                    .JoinAlias(() => sourceAlias.EventSources, () => eventSourceAlias, JoinType.LeftOuterJoin)
                    .JoinAlias(() => sourceAlias.UnitSources, () => unitSourceAlias, JoinType.LeftOuterJoin)
                    .JoinAlias(() => sourceAlias.OperationSources, () => operationSourceAlias, JoinType.LeftOuterJoin)
                    .SelectList(list => list
                                .Select(Projections.Group(() => feedingSourceAlias.Id)).WithAlias(() => output.Id)
                                .Select(Projections.Group(() => feedingSourceAlias.Name)).WithAlias(() => output.Name)
                                .Select(Projections.Group(() => feedingSourceAlias.Restricted)).WithAlias(() => output.Restricted)
                                .Select(Projections.Group(() => feedingSourceAlias.FileModifiedDateTime)).WithAlias(() => output.FileModifiedDateTime)
                                .Select(Projections.Group(() => uploadedByAlias.UserName)).WithAlias(() => output.UploadedBy)
                                .Select(Projections.Group(() => feedingSourceAlias.UploadDate)).WithAlias(() => output.UploadDate)
                                .Select(Projections.Group(() => approvedByAlias.UserName)).WithAlias(() => output.ApprovedBy)
                                .Select(Projections.Group(() => feedingSourceAlias.ApprovedDate)).WithAlias(() => output.ApproveDate)
                                .Select(Projections.Group(() => rejectedByAlias.UserName)).WithAlias(() => output.RejectedBy)
                                .Select(Projections.Group(() => feedingSourceAlias.RejectedDate)).WithAlias(() => output.RejectedDate)
                                .Select(Projections.Group(() => feedingSourceAlias.RejectedReason)).WithAlias(() => output.RejectedReason)
                                .Select(Projections.Group(() => feedingSourceAlias.UploadNotes)).WithAlias(() => output.UploadNotes)
                                .Select(Projections.Group(() => feedingSourceAlias.Source.Id)).WithAlias(() => output.SourceID)
                                .Select(Projections.Group(() => feedingSourceAlias.IsReadOnly)).WithAlias(() => output.IsReadOnly)
                                .Select(Projections.Group(() => feedingSourceAlias.IsPublic)).WithAlias(() => output.IsPublic)
                                .Select(Projections.Count(() => personSourceAlias.Person.Id)).WithAlias(() => output.PersonSourceCount)
                                .Select(Projections.Count(() => eventSourceAlias.Event.Id)).WithAlias(() => output.EventSourceCount)
                                .Select(Projections.Count(() => unitSourceAlias.Unit.Id)).WithAlias(() => output.UnitSourceCount)
                                .Select(Projections.Count(() => operationSourceAlias.Operation.Id)).WithAlias(() => output.OperationSourceCount)
                                );

            if (canViewAndSearchAll)
            {
                if (!includeRestricted)
                {
                    q = q.Where(() => feedingSourceAlias.Restricted == false);
                }
            }
            else
            {
                // user can access sources they uploaded as well as sources marked public
                q = q.Where(() => uploadedByAlias.UserID == uploadedByUserId || feedingSourceAlias.IsPublic);
            }

            return(q.TransformUsing(Transformers.AliasToBean <FeedingSourceDTO>())
                   .List <FeedingSourceDTO>());
        }
Exemplo n.º 2
0
        public ActionResult Person(int sourceId, int targetId)
        {
            Source source = this.sourceTasks.GetSource(sourceId);

            if (source != null)
            {
                Profiling2.Domain.Prf.Persons.Person person = this.personTasks.GetPerson(targetId);
                if (person != null)
                {
                    PersonSourceViewModel vm = new PersonSourceViewModel();
                    vm.SourceId = source.Id;
                    vm.PersonId = person.Id;
                    vm.PopulateDropDowns(this.sourceTasks.GetReliabilities());

                    ViewBag.Person = person;
                    ViewBag.Source = source;

                    PersonSource ps = source.GetPersonSource(person);
                    if (ps != null)
                    {
                        // Person is already attached to Source
                        vm.Id         = ps.Id;
                        vm.Commentary = ps.Commentary;
                        vm.Notes      = ps.Notes;
                    }
                    return(View(vm));
                }
            }
            return(new HttpNotFoundResult());
        }
Exemplo n.º 3
0
 public JsonNetResult Edit(PersonSourceViewModel vm)
 {
     if (ModelState.IsValid)
     {
         PersonSource ps = this.sourceAttachmentTasks.GetPersonSource(vm.Id.Value);
         if (ps != null)
         {
             if (vm.ReliabilityId.HasValue)
             {
                 ps.Reliability = this.sourceTasks.GetReliability(vm.ReliabilityId.Value);
             }
             ps.Commentary = vm.Commentary;
             ps.Notes      = vm.Notes;
             ps            = this.sourceAttachmentTasks.SavePersonSource(ps);
             return(JsonNet(string.Empty));
         }
         else
         {
             Response.StatusCode = (int)HttpStatusCode.NotFound;
             return(JsonNet("Person source not found."));
         }
     }
     else
     {
         return(JsonNet(this.GetErrorsForJson()));
     }
 }
Exemplo n.º 4
0
        public void Expected_Not_Matched_PropertyCount()
        {
            var source = new PersonSource() { Name = "Junil, Um" };
            var target = new PersonTarget2();

            var mapping = new ReflectionMapping(source, target, new ReflectionMappingOption() { ThrowIfNotMatched = true });
        }
Exemplo n.º 5
0
        public IList <PersonSourceDTO> GetPersonSourceDTOs(int personId)
        {
            PersonSourceDTO dto     = null;
            PersonSource    psAlias = null;
            Source          sAlias  = null;
            Person          pAlias  = null;
            Reliability     rAlias  = null;

            return(Session.QueryOver <PersonSource>(() => psAlias)
                   .JoinAlias(() => psAlias.Source, () => sAlias)
                   .JoinAlias(() => psAlias.Person, () => pAlias)
                   .JoinAlias(() => psAlias.Reliability, () => rAlias)
                   .Where(() => pAlias.Id == personId)
                   .And(() => !psAlias.Archive)
                   .SelectList(list => list
                               .Select(() => psAlias.Id).WithAlias(() => dto.Id)
                               .Select(() => psAlias.Commentary).WithAlias(() => dto.Commentary)
                               .Select(() => psAlias.Notes).WithAlias(() => dto.Notes)
                               .Select(() => sAlias.Id).WithAlias(() => dto.SourceId)
                               .Select(() => sAlias.SourceName).WithAlias(() => dto.SourceName)
                               .Select(() => sAlias.IsRestricted).WithAlias(() => dto.SourceIsRestricted)
                               .Select(() => pAlias.Id).WithAlias(() => dto.PersonId)
                               .Select(() => rAlias.Id).WithAlias(() => dto.ReliabilityId)
                               .Select(() => rAlias.ReliabilityName).WithAlias(() => dto.ReliabilityName)
                               )
                   .TransformUsing(Transformers.AliasToBean <PersonSourceDTO>())
                   .List <PersonSourceDTO>());
        }
Exemplo n.º 6
0
        static void Main(string[] args)
        {
            PeopleRepository  allPeople       = null;
            PeopleRepository  offLimitsPeople = null;
            ResultsRepository results         = null;

            new OptionSet {
                { "allpeople=", s => {
                      allPeople = new PeopleRepository(File.ReadLines(s), s);
                  } }, { "offlimits=", s => {
                             offLimitsPeople = new PeopleRepository(File.ReadLines(s), s);
                         } }, { "results=", s => {
                                    results = new ResultsRepository(s);
                                } }
            }.Parse(args);

            var nextBirthday = results.NextBirthday();
            var checkDate    = new DateTime(DateTime.Now.Year, nextBirthday.Month, nextBirthday.Day).AddDays(1).AddSeconds(-1); // meh

            using (SystemClock.Stub(checkDate))
            {
                var personSource   = new PersonSource(allPeople.GetPeople());
                var offLimitSource = new OffLimitsSource(offLimitsPeople.GetPeople(),
                                                         personSource.GetAllPeople().Length);

                var matcher = new Matcher(personSource, offLimitSource);

                results.Save(matcher.Next());
                offLimitsPeople.Save(matcher.GetOffLimits());
            }
        }
Exemplo n.º 7
0
        private static void Displayed()
        {
            PersonSource ps = new PersonSource();

            Console.WriteLine($"Имя: {ps.GetPerson().Name}");
            Thread.Sleep(1000);
        }
Exemplo n.º 8
0
        public void given_a_start_date_Source_should_know_Next()
        {
            var today  = new DateTime(2000, 8, 10);
            var source = new PersonSource(SampleData.People);

            source.GetNextRecipient(today).Name.ShouldBe("Iris");
        }
Exemplo n.º 9
0
 public Source(int ID)
 {
     SourceID = ID;
     mapsource = new MapSource(SourceID);
     personsource1 = new PersonSource(0);
     personsource2 = new PersonSource(1);
     bombsource = new BombSource(SourceID);
     musicsource = new MusicSource(SourceID);
 }
Exemplo n.º 10
0
 public Source(int ID)
 {
     SourceID      = ID;
     mapsource     = new MapSource(SourceID);
     personsource1 = new PersonSource(0);
     personsource2 = new PersonSource(1);
     bombsource    = new BombSource(SourceID);
     musicsource   = new MusicSource(SourceID);
 }
Exemplo n.º 11
0
        public virtual void AddPersonSource(PersonSource ps)
        {
            if (this.PersonSources.Contains(ps))
            {
                return;
            }

            this.PersonSources.Add(ps);
        }
Exemplo n.º 12
0
 private void DeletePersonSource(PersonSource ps)
 {
     if (ps != null)
     {
         ps.Source.RemovePersonSource(ps);
         ps.Person.RemovePersonSource(ps);
         this.personSourceRepo.Delete(ps);
     }
 }
Exemplo n.º 13
0
        public async Task SyncForPerson(int personId)
        {
            // see if we already have a scholar record for this person
            // TODO: query source values out of enum or resources
            var source = await this.dbContext.PeopleSources.SingleOrDefaultAsync(s => s.Source == "scholar" && s.PersonId == personId);

            if (source == null || string.IsNullOrWhiteSpace(source.SourceKey))
            {
                // no source with key found
                if (source == null)
                {
                    // use the existing source if available, otherwise create a new one
                    source = new PersonSource {
                        Source = "scholar", PersonId = personId
                    };
                    this.dbContext.PeopleSources.Add(source);
                }

                // here we attempt to find source ID through search
                var personName = await this.dbContext.People.Where(p => p.Id == personId).Select(p => p.FullName).SingleOrDefaultAsync();

                var matchingIds = await FindScholarIds(personName);

                if (matchingIds.Length == 1)
                {
                    // if we have exactly one match, use that
                    source.SourceKey = matchingIds[0];
                }
                else
                {
                    // else we have no match, just use the empty record until it can be manually updated
                    if (source.Id == default(int))
                    {
                        this.dbContext.Add(source);
                    }

                    source.LastUpdate = DateTime.UtcNow;

                    await this.dbContext.SaveChangesAsync();

                    return;
                }
            }

            // go grab updated info
            var sourceData = await GetTagsAndPublicationsById(source.SourceKey);

            source.Data        = JsonConvert.SerializeObject(sourceData);
            source.HasKeywords = sourceData.Tags.Any();
            source.HasPubs     = sourceData.Publications.Any();
            source.LastUpdate  = DateTime.UtcNow;

            // save changes to source object
            await this.dbContext.SaveChangesAsync();
        }
Exemplo n.º 14
0
        public ActionResult Edit(int id)
        {
            PersonSource ps = this.sourceAttachmentTasks.GetPersonSource(id);

            if (ps != null)
            {
                PersonSourceViewModel vm = new PersonSourceViewModel(ps);
                vm.PopulateDropDowns(this.sourceTasks.GetReliabilities());
                vm.PopulateSource(this.sourceTasks.GetSourceDTO(ps.Source.Id));
                return(View(vm));
            }
            return(new HttpNotFoundResult());
        }
Exemplo n.º 15
0
        public void ReflectionMapping_Test()
        {
            var source = new PersonSource() { Name = "Junil, Um" };
            var target = new PersonTarget();

            var mapping = new ReflectionMapping(source, target);

            TestContext.WriteLine("SourcePerson's name is {0}", source.Name);
            TestContext.WriteLine("TargetPerson's name is {0} after Mapped ReflectionMapping", target.name);
            TestContext.WriteLine("{0} = {1}", source.Name, target.name);

            Assert.IsTrue(source.Name == target.name, "리플랙션으로 매핑된 Name 속성의 값이 틀립니다.");
        }
Exemplo n.º 16
0
        public void Expected_Not_Matched_PropertyCount()
        {
            var source = new PersonSource()
            {
                Name = "Junil, Um"
            };
            var target = new PersonTarget2();

            var mapping = new ReflectionMapping(source, target, new ReflectionMappingOption()
            {
                ThrowIfNotMatched = true
            });
        }
Exemplo n.º 17
0
        public PersonSource SavePersonSource(PersonSource ps)
        {
            ps.Person.AddPersonSource(ps);
            ps.Source.AddPersonSource(ps);

            if (!ps.Person.HasValidProfileStatus())
            {
                ps.Person.ProfileStatus = this.personTasks.GetProfileStatus(ProfileStatus.ROUGH_OUTLINE);
                this.personTasks.SavePerson(ps.Person);
            }

            return(this.personSourceRepo.SaveOrUpdate(ps));
        }
Exemplo n.º 18
0
        public void should_run()
        {
            var personSource = new PersonSource(SampleData.People);
            var matcher      = new Matcher(personSource, new OffLimitsSource(new Person[0], SampleData.People.Length));

            for (int i = 0; i < 250; i++)
            {
                using (SystemClock.Stub(DateTime.Now.AddMonths(i)))
                {
                    Console.WriteLine(matcher.Next());
                }
            }
        }
Exemplo n.º 19
0
        public JsonNetResult Delete(int id)
        {
            PersonSource ps = this.sourceAttachmentTasks.GetPersonSource(id);

            if (ps != null)
            {
                this.sourceAttachmentTasks.DeletePersonSource(ps.Id);
                Response.StatusCode = (int)HttpStatusCode.OK;
                return(JsonNet("Source successfully detached from person."));
            }
            else
            {
                Response.StatusCode = (int)HttpStatusCode.NotFound;
                return(JsonNet("Person source not found."));
            }
        }
Exemplo n.º 20
0
        public void ReflectionMapping_Test()
        {
            var source = new PersonSource()
            {
                Name = "Junil, Um"
            };
            var target = new PersonTarget();

            var mapping = new ReflectionMapping(source, target);

            TestContext.WriteLine("SourcePerson's name is {0}", source.Name);
            TestContext.WriteLine("TargetPerson's name is {0} after Mapped ReflectionMapping", target.name);
            TestContext.WriteLine("{0} = {1}", source.Name, target.name);

            Assert.IsTrue(source.Name == target.name, "리플랙션으로 매핑된 Name 속성의 값이 틀립니다.");
        }
Exemplo n.º 21
0
 public PersonSourceViewModel(PersonSource ps)
 {
     this.Id = ps.Id;
     if (ps.Person != null)
     {
         this.PersonId   = ps.Person.Id;
         this.PersonName = ps.Person.Name;
     }
     if (ps.Reliability != null)
     {
         this.ReliabilityId   = ps.Reliability.Id;
         this.ReliabilityName = ps.Reliability.ToString();
     }
     this.Commentary = ps.Commentary;
     this.Notes      = ps.Notes;
 }
Exemplo n.º 22
0
        public void MergePersonSourceDuplicates()
        {
            IList <ObjectSourceDuplicateDTO> duplicates = this.objectSourceDuplicatesQuery.GetPersonSourceDuplicates();

            log.Info("Found " + duplicates.Count + " PersonSource duplicates.");
            foreach (ObjectSourceDuplicateDTO dto in duplicates)
            {
                log.Info("Merging " + dto.Count + " PersonSources PersonID=" + dto.ObjectID + " SourceID=" + dto.SourceID);

                // retrieve all duplicates
                IList <PersonSource> personSources = this.sourceAttachmentTasks.GetPersonSources(
                    this.personTasks.GetPerson(dto.ObjectID),
                    this.sourceTasks.GetSource(dto.SourceID));

                // select PersonSource with highest PersonSource.Reliability
                PersonSource keep = personSources.OrderBy(x => x.Reliability).Last();
                personSources.Remove(keep);

                // merge
                string mergedCommentary = keep.Commentary;
                string mergedNotes      = keep.Notes;
                foreach (PersonSource ps in personSources)
                {
                    if (!string.Equals(keep.Commentary, ps.Commentary))
                    {
                        mergedCommentary += "; " + ps.Commentary;
                    }

                    if (!string.Equals(keep.Notes, ps.Notes))
                    {
                        mergedNotes += "; " + ps.Notes;
                    }

                    this.sourceAttachmentTasks.DeletePersonSource(ps.Id);
                }

                // save merged PersonSource
                keep.Commentary = mergedCommentary;
                keep.Notes      = "Merged with duplicates on " + string.Format("{0:ddd MMM yyyy}", DateTime.Now) + ".\n" + mergedNotes;
                this.sourceAttachmentTasks.SavePersonSource(keep);
            }
            log.Info("Finished merging PersonSource duplicates.");
        }
Exemplo n.º 23
0
 public JsonNetResult Add(PersonSourceViewModel vm)
 {
     if (ModelState.IsValid)
     {
         Source s = this.sourceTasks.GetSource(vm.SourceId.Value);
         Person p = this.personTasks.GetPerson(vm.PersonId.Value);
         if (s != null && p != null)
         {
             if (s.GetPersonSource(p) == null)
             {
                 PersonSource ps = new PersonSource()
                 {
                     Source     = s,
                     Person     = p,
                     Commentary = vm.Commentary,
                     Notes      = vm.Notes
                 };
                 if (vm.ReliabilityId.HasValue)
                 {
                     ps.Reliability = this.sourceTasks.GetReliability(vm.ReliabilityId.Value);
                 }
                 this.sourceAttachmentTasks.SavePersonSource(ps);
                 return(JsonNet(string.Empty));
             }
             else
             {
                 Response.StatusCode = (int)HttpStatusCode.BadRequest;
                 return(JsonNet("Source already attached to this person."));
             }
         }
         else
         {
             Response.StatusCode = (int)HttpStatusCode.NotFound;
             return(JsonNet("Person or source not found."));
         }
     }
     else
     {
         return(JsonNet(this.GetErrorsForJson()));
     }
 }
Exemplo n.º 24
0
        public async Task <ActionResult <IList <GenderStatistics> > > GenderStatistics(int age)
        {
            var cacheKey    = $"GenderStatistics";
            var cachedValue = await CacheStore.GetObjectAsync <List <GenderStatistics> >(Cache, cacheKey);

            if (cachedValue == null)
            {
                var stats = await PersonSource.GenderStatistics();

                if (stats == null)
                {
                    return(NotFound());
                }

                await CacheStore.SetObjectAsync <List <GenderStatistics> >(Cache, cacheKey, stats.ToList(), CacheTimeoutInSeconds);

                return(Ok(stats));
            }

            return(Ok(cachedValue));
        }
Exemplo n.º 25
0
        public async Task <ActionResult <IList <Person> > > GetByAge(int age)
        {
            var cacheKey    = $"GetByAge{age}";
            var cachedValue = await CacheStore.GetObjectAsync <List <Person> >(Cache, cacheKey);

            if (cachedValue == null)
            {
                var persons = await PersonSource.GetByAge(age);

                if (persons == null)
                {
                    return(NotFound());
                }

                await CacheStore.SetObjectAsync <List <Person> >(Cache, cacheKey, persons.ToList(), CacheTimeoutInSeconds);

                return(Ok(persons.ToList()));
            }

            return(Ok(cachedValue));
        }
Exemplo n.º 26
0
        public async Task <ActionResult <Person> > GetById(int id)
        {
            var cacheKey    = $"GetById_{id}";
            var cachedValue = await CacheStore.GetObjectAsync <Person>(Cache, cacheKey);

            if (cachedValue == null)
            {
                var person = await PersonSource.GetById(id);

                if (person == null)
                {
                    return(NotFound());
                }

                await CacheStore.SetObjectAsync <Person>(Cache, cacheKey, person, CacheTimeoutInSeconds);

                return(Ok(person));
            }

            return(Ok(cachedValue));
        }
Exemplo n.º 27
0
 public JsonNetResult Person(PersonSourceViewModel vm)
 {
     if (vm.Id.HasValue)
     {
         this.sourceAttachmentTasks.DeletePersonSource(vm.Id.Value);
         Response.StatusCode = (int)HttpStatusCode.OK;
         return(JsonNet("Person successfully detached from source."));
     }
     else if (ModelState.IsValid)
     {
         Source source = this.sourceTasks.GetSource(vm.SourceId.Value);
         Profiling2.Domain.Prf.Persons.Person person = this.personTasks.GetPerson(vm.PersonId.Value);
         if (source != null && person != null)
         {
             if (source.GetPersonSource(person) == null)
             {
                 PersonSource ps = new PersonSource();
                 ps.Source      = source;
                 ps.Person      = person;
                 ps.Reliability = this.sourceTasks.GetReliability(vm.ReliabilityId.Value);
                 ps.Commentary  = vm.Commentary;
                 ps.Notes       = vm.Notes;
                 this.sourceAttachmentTasks.SavePersonSource(ps);
             }
             Response.StatusCode = (int)HttpStatusCode.OK;
             return(JsonNet("Person successfully attached."));
         }
         else
         {
             Response.StatusCode = (int)HttpStatusCode.NotFound;
             return(JsonNet("Person or source not found."));
         }
     }
     else
     {
         Response.StatusCode = (int)HttpStatusCode.BadRequest;
         return(JsonNet("Form data failed validation."));
     }
 }
Exemplo n.º 28
0
        /// <summary>
        /// 通过来源获取第一个人员,若不存在则新
        /// </summary>
        /// <param name="personSource"></param>
        /// <returns></returns>
        public virtual async Task <Person> GetDefaultPersonBySourceOrInsert(PersonSource personSource)
        {
            //先判断是否已有此人员
            var reporter = await Repository.GetAll().Where(o => o.PersonSource == personSource).FirstOrDefaultAsync();

            if (reporter == null)
            {
                reporter = new Person()
                {
                    Name         = personSource.ToString(),
                    PersonSource = personSource
                };
                await Repository.InsertAsync(reporter);

                await CurrentUnitOfWork.SaveChangesAsync();
            }

            await Repository.UpdateAsync(reporter);

            await CurrentUnitOfWork.SaveChangesAsync();

            return(reporter);
        }
Exemplo n.º 29
0
 public virtual void RemovePersonSource(PersonSource ps)
 {
     this.PersonSources.Remove(ps);
 }
Exemplo n.º 30
0
        public static void Displayed()
        {
            PersonSource ps = new PersonSource();

            Console.WriteLine($"Имя: {ps.GetPerson().Name}");
        }