private List <SpeakerInfo> GetSpeakers(bool includeRestricted)
        {
            List <SpeakerInfo> speakers = _recordingRepository.GetSpeakers(includeRestricted)
                                          .ConvertAll(s => s.ToSpeakerInfo())
                                          .OrderBy(s => s.LastName)
                                          .ThenBy(s => s.FirstName)
                                          .ToList();

            return(speakers);
        }
Ejemplo n.º 2
0
        //public object Get(Details details)
        //{
        //    Models.Recording recording = _recordingRepository.GetById(details.Id);
        //    if (recording.Restricted && !UserSession.IsAuthenticated)
        //        return HttpResult.Redirect("/Login".AddQueryParam("redirect", Request.AbsoluteUri));

        //    return new DetailsResponse {Recording = recording};
        //}

        //public object Get(Delete delete)
        //{
        //    Models.Recording recording = _recordingRepository.GetById(delete.Id);
        //    if (recording.Restricted && !UserSession.IsAuthenticated) return HttpResult.Redirect("/Login".AddQueryParam("redirect", Request.AbsoluteUri));


        //    return new DeleteResponse {Recording = recording};
        //}

        //[Authenticate]
        //[RequiredRole(RoleNames.Admin)]
        //public object Post(Delete delete)
        //{
        //    _recordingRepository.Delete(delete.Id);

        //    return this.Redirect("/Recording");
        //}

        public object Get(SpeakerDetails speaker)
        {
            if (speaker.EscapedFragment == null && !Request.RawUrl.IsNormalizedUrl())
            {
                return(this.RedirectPermanently(Request.RawUrl.ToNormalizedUrl()));
            }

            if (speaker.EscapedFragment != null && speaker.EscapedFragment.StartsWith("/"))
            {
                speaker.Album = speaker.EscapedFragment.Substring(1);
            }

            var includeRestricted = UserSession.IsAuthenticated;

            NameInfo nameInfo = speaker.Name.ToNameInfo();

            using (IDbConnection db = _dbConnectionFactory.Open())
            {
                DbSpeaker dbSpeaker = db.Single <DbSpeaker>(s => s.FirstName == nameInfo.FirstName && s.LastName == nameInfo.LastName && !s.Deleted);
                if (dbSpeaker == null)
                {
                    throw HttpError.NotFound("Speaker not found");
                }

                SqlExpression <DbRecording> albumIdQuery =
                    db.From <DbRecording>()
                    .Join <DbRecordingSpeaker>((recording, recordingSpeaker) => recording.Id == recordingSpeaker.RecordingId)
                    .Where <DbRecording, DbRecordingSpeaker>((recording, recordingSpeaker) => !recording.Deleted && recordingSpeaker.SpeakerId == dbSpeaker.Id)
                    .SelectDistinct(rs => rs.AlbumId);

                SqlExpression <DbSpeaker> query = db.From <DbSpeaker>()
                                                  .Join <DbRecordingSpeaker>((sp, recordingSpeaker) => sp.Id == recordingSpeaker.SpeakerId)
                                                  .Join <DbRecordingSpeaker, DbRecording>((recordingSpeaker, recording) => recordingSpeaker.RecordingId == recording.Id)
                                                  .Join <DbRecording, DbAlbum>((recording, album) => recording.AlbumId == album.Id)
                                                  .Where <DbSpeaker, DbAlbum>((sp, album) => !sp.Deleted && !album.Deleted && Sql.In(album.Id, albumIdQuery))
                                                  .OrderBy <DbAlbum>(a => a.Name)
                                                  .ThenBy <DbRecording>(r => r.Track);

                if (!includeRestricted)
                {
                    query.And <DbAlbum>(a => !a.Restricted);
                }

                List <Tuple <DbSpeaker, DbRecordingSpeaker, DbRecording, DbAlbum> > recordings = db.SelectMulti <DbSpeaker, DbRecordingSpeaker, DbRecording, DbAlbum>(query);

                Dictionary <long, DbAlbum> albums = recordings.DistinctBy(r => r.Item4.Id).Select(r => r.Item4).ToDictionary(a => a.Id);

                ILookup <long, Tuple <DbSpeaker, DbRecordingSpeaker, DbRecording, DbAlbum> > albumLookup = recordings.ToLookup(r => r.Item4.Id);
                ILookup <long, Tuple <DbSpeaker, DbRecordingSpeaker, DbRecording, DbAlbum> > speakers    = recordings.ToLookup(r => r.Item3.Id);

                List <AlbumInfo> albumInfos =
                    (from g in albumLookup
                     let album = albums[g.Key]
                                 select new AlbumInfo
                {
                    Uid = album.Uid,
                    Name = album.Name,
                    Description = album.Description,
                    AlbumSpeakers = GetSpeakers(g),
                    HasAlbumArt = album.AlbumArtPath != null,
                    Recordings = g.DistinctBy(r => r.Item3.Id)
                                 .OrderBy(r => r.Item3.Track)
                                 .Select(r => new RecordingInfo
                    {
                        Uid = r.Item3.Uid,
                        Title = r.Item3.Title,
                        Track = r.Item3.Track,
                        Year = r.Item3.Year,
                        Comment = r.Item3.Comment,
                        Speakers = speakers[r.Item3.Id]
                                   .DistinctBy(rs => rs.Item1.Id)
                                   .Select(rs => rs.Item1.ToSpeakerInfo())
                                   .ToList()
                    }).ToList(),
                    Attachments = album.AttachmentPaths
                                  .Select((attachment, index) => new AttachmentInfo
                    {
                        Name =
                            _fileSystem.Path.GetFileName(attachment),
                        Index = index
                    }).ToList()
                }).ToList();

                return(new SpeakerDetailsResponse
                {
                    Uid = dbSpeaker.Uid,
                    Speaker = speaker.Name,
                    Albums = albumInfos.ToList(),
                    Speakers = _recordingRepository.GetSpeakers(includeRestricted).Select(s => s.ToSpeakerInfo(sp => sp.FullName == speaker.Name)).ToList(),
                    SelectedAlbum = albumInfos.FirstOrDefault(a => a.Name == (speaker.Album ?? speaker.EscapedFragment)),
                    HasPhoto = dbSpeaker.PhotoPath != null,
                    Description = dbSpeaker.Description
                });
            }
        }