public IEnumerable <Talk> Load(ScheduleTalkBy loadTaskBy)
        {
            var talks = this.Load();

            switch (loadTaskBy)
            {
            case ScheduleTalkBy.DurationDescending:
                talks = talks.OrderByDescending(p => p.Duration);
                break;

            case ScheduleTalkBy.DurationAscending:
                talks = talks.OrderBy(p => p.Duration);
                break;

            case ScheduleTalkBy.TitleAscending:
                talks = talks.OrderBy(p => p.Title);
                break;

            case ScheduleTalkBy.TitleDescending:
                talks = talks.OrderByDescending(p => p.Title);
                break;
            }

            return(talks);
        }
Example #2
0
        public void Given_LoadTalkByTitleDescending_Then_ItShouldLoadTheTalksInDescendingOrderOfTalk()
        {
            // Arrange
            ScheduleTalkBy loadTalkBy = ScheduleTalkBy.TitleDescending;

            // Act
            var result = this.fileTalksLoader.Load(loadTalkBy);

            // Assert
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count() > 0);
            Assert.AreEqual("Woah", result.First().Title);
        }
Example #3
0
        public void Given_LoadTalkByTitleAscending_Then_ItShouldLoadTheTalksInAscendingOrderOTalk()
        {
            // Arrange
            ScheduleTalkBy loadTalkBy = ScheduleTalkBy.TitleAscending;

            // ACt
            var result = this.fileTalksLoader.Load(loadTalkBy);

            // Assert
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count() > 0);
            Assert.AreEqual("A World Without HackerNews", result.First().Title);
        }
Example #4
0
        public void Given_LoadTalkByDurationAscending_Then_ItShouldLoadTheTalksInAscendingOrderOfDuration()
        {
            // Arrange
            ScheduleTalkBy loadTalkBy = ScheduleTalkBy.DurationAscending;

            // Act
            var result = this.fileTalksLoader.Load(loadTalkBy);

            // Assert
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count() > 0);
            Assert.AreEqual(5, result.First().Duration);
        }
Example #5
0
        public IEnumerable <Track> Schedule(ScheduleTalkBy scheduleTalkBy)
        {
            List <Track> tracks   = new List <Track>();
            var          allTalks = talksLoader.Load(scheduleTalkBy);
            var          trackId  = 1;

            int totalMinutesAllowed     = 60 * (Constants.LUNCHHOUR - Constants.SESSIONSTARTSAT);;
            int afternoonMinutesAllowed = 60 * (Constants.SESSIONENDSAT - Constants.LUNCHHOUR - 1);

            while (allTalks.Any(p => !p.AlreadyTaken))
            {
                var track = new Track {
                    Name = $"Track {trackId}", Talks = new List <Talk>()
                };
                bool lunchTalkAdded          = false;
                bool networkTalkAdded        = false;
                int  ellapsedMinutes         = 0;
                int  afternoonElapsedMinutes = 0;
                var  talks = new List <Talk>();
                var  today = DateTime.Today.Add(new TimeSpan(09, 00, 00));

                foreach (var talk in allTalks.Where(p => !p.AlreadyTaken))
                {
                    // morning session talks
                    if ((talk.Duration + ellapsedMinutes) <= totalMinutesAllowed && !talk.AlreadyTaken)
                    {
                        talks.AddTalk(talk, today);
                        today            = today.Add(new TimeSpan(00, talk.Duration, 00));
                        ellapsedMinutes += talk.Duration;
                        continue;
                    }

                    if (!lunchTalkAdded && ellapsedMinutes <= totalMinutesAllowed)
                    {
                        var tk = allTalks.FirstOrDefault(p => p.Duration == (totalMinutesAllowed - ellapsedMinutes));
                        if (tk != null)
                        {
                            talks.Add(tk);
                            tk.AlreadyTaken = true;
                        }

                        today          = AddLunchTalk(talks);
                        lunchTalkAdded = true;
                    }

                    // afternoon session talks
                    if ((talk.Duration + afternoonElapsedMinutes) <= afternoonMinutesAllowed && !talk.AlreadyTaken)
                    {
                        talks.AddTalk(talk, today);
                        today = today.Add(new TimeSpan(00, talk.Duration, 00));
                        afternoonElapsedMinutes += talk.Duration;
                        continue;
                    }

                    if (!networkTalkAdded && afternoonElapsedMinutes <= afternoonMinutesAllowed)
                    {
                        var tk = allTalks.FirstOrDefault(p => p.Duration == (afternoonMinutesAllowed - afternoonElapsedMinutes));
                        if (tk != null)
                        {
                            talks.Add(tk);
                            tk.AlreadyTaken = true;
                        }

                        today            = this.AddNetworkTalk(talks, today);
                        networkTalkAdded = true;
                        break;
                    }
                }

                if (!talks.Any(p => p.Title == TitleNetworking))
                {
                    today = this.AddNetworkTalk(talks, today);
                }

                track.Talks.AddRange(talks);
                tracks.Add(track);
                trackId += 1;
            }

            return(tracks);
        }