public AlbumViewModel(IAlbum iAlbum)
 {
     _Album = iAlbum;
     _ImagesVM = new CollectionWithDetailVM<IAlbumPicture>(_Album.Images);
     var tm = Register(Album.Tracks.LiveOrderBy(t => t.TrackNumber));
     _OrderedTracks = Register(tm.LiveThenBy(t => t.Path));
 }

        /// <summary>
        /// Initializes a new instance of a <see cref="Audio" /> object.
        /// </summary>
        /// <param name="audioFile">A <see cref="FileInfo"/> object containing the original audio file for this object. This is intended to be 
        /// specified when creating a new media object from a file. Specify null when instantiating an object for an existing database
        /// record.</param>
        /// <param name="parentAlbum">The album that contains this object. This is a required parameter.</param>
        /// <exception cref="GalleryServerPro.Events.CustomExceptions.InvalidMediaObjectException">Thrown when 
        /// <paramref name="audioFile"/> refers to a file that is not in the same directory as the parent album's directory.</exception>
        /// <exception cref="GalleryServerPro.Events.CustomExceptions.UnsupportedMediaObjectTypeException">Thrown when
        /// <paramref name="audioFile"/> is specified (not null) and its file extension does not correspond to an audio MIME
        /// type, as determined by the MIME type definition in the configuration file.</exception>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="parentAlbum" /> is null.</exception>
        /// <remarks>This constructor does not verify that <paramref name="audioFile"/> refers to a file type that is enabled in the 
        /// configuration file.</remarks>
        internal Audio(FileInfo audioFile, IAlbum parentAlbum)
            : this(int.MinValue, parentAlbum, string.Empty,
						int.MinValue, int.MinValue, int.MinValue, string.Empty, int.MinValue, int.MinValue,
						int.MinValue, string.Empty, int.MinValue, int.MinValue, int.MinValue, int.MinValue,
						String.Empty, DateTime.Now, String.Empty, DateTime.MinValue, parentAlbum != null ? parentAlbum.IsPrivate : false, false, audioFile, null)
        {
        }

        /// <summary>
        /// Initializes a new instance of an <see cref="Image"/> object.
        /// </summary>
        /// <param name="imageFile">A <see cref="System.IO.FileInfo"/> object containing the original image for this object.</param>
        /// <param name="parentAlbum">The album that contains this object. This is a required parameter.</param>
        /// <exception cref="GalleryServerPro.ErrorHandler.CustomExceptions.InvalidMediaObjectException">Thrown when 
        /// <paramref name="imageFile"/> refers to a file that is not in the same directory as the parent album's directory.</exception>
        /// <exception cref="GalleryServerPro.ErrorHandler.CustomExceptions.UnsupportedMediaObjectTypeException">Thrown when
        /// <paramref name="imageFile"/> is specified (not null) and its file extension does not correspond to an image MIME
        /// type, as determined by the MIME type definition in the configuration file.</exception>
        /// <exception cref="GalleryServerPro.ErrorHandler.CustomExceptions.UnsupportedImageTypeException">Thrown when the 
        /// .NET Framework is unable to load an image file into the <see cref="System.Drawing.Bitmap"/> class. This is 
        /// probably because it is corrupted, not an image supported by the .NET Framework, or the server does not have 
        /// enough memory to process the image. The file cannot, therefore, be handled using the <see cref="Image"/> 
        /// class; use <see cref="GenericMediaObject"/> instead. This exception is thrown only when <paramref name="imageFile"/>
        /// is specified (non-null).</exception>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="parentAlbum" /> is null.</exception>
        /// <remarks>This constructor does not verify that <paramref name="imageFile"/> refers to a file type that is enabled in the 
        /// configuration file.</remarks>
        internal Image(System.IO.FileInfo imageFile, IAlbum parentAlbum)
            : this(int.MinValue, parentAlbum, string.Empty, string.Empty, string.Empty,
				int.MinValue, int.MinValue, int.MinValue, string.Empty, int.MinValue, int.MinValue,
				int.MinValue, string.Empty, int.MinValue, int.MinValue, int.MinValue, int.MinValue,
				String.Empty, DateTime.MinValue, String.Empty, DateTime.MinValue, parentAlbum != null ? parentAlbum.IsPrivate : false, false, imageFile)
        {
        }

        /// <summary>
        /// Initializes a new instance of a <see cref="Video" /> object.
        /// </summary>
        /// <param name="videoFile">A <see cref="FileInfo"/> object containing the original video file for this object. This is intended to be 
        /// specified when creating a new media object from a file. Specify null when instantiating an object for an existing database
        /// record.</param>
        /// <param name="parentAlbum">The album that contains this object. This is a required parameter.</param>
        /// <exception cref="GalleryServerPro.Events.CustomExceptions.InvalidMediaObjectException">Thrown when 
        /// <paramref name="videoFile"/> refers to a file that is not in the same directory as the parent album's directory.</exception>
        /// <exception cref="GalleryServerPro.Events.CustomExceptions.UnsupportedMediaObjectTypeException">Thrown when
        /// <paramref name="videoFile"/> is specified (not null) and its file extension does not correspond to an video MIME
        /// type, as determined by the MIME type definition in the configuration file.</exception>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="parentAlbum" /> is null.</exception>
        /// <remarks>This constructor does not verify that <paramref name="videoFile"/> refers to a file type that is enabled in the 
        /// configuration file.</remarks>
        internal Video(System.IO.FileInfo videoFile, IAlbum parentAlbum)
            : this(int.MinValue, parentAlbum, string.Empty,
						int.MinValue, int.MinValue, int.MinValue, string.Empty, int.MinValue, int.MinValue,
						int.MinValue, string.Empty, int.MinValue, int.MinValue, int.MinValue, int.MinValue,
						String.Empty, DateTime.Now, String.Empty, DateTime.MinValue, parentAlbum != null ? parentAlbum.IsPrivate : false, false, videoFile, null)
        {
        }

		public FieldProblem_leftend()
		{
            viewMock = MockRepository.Mock<IAddAlbumPresenter>();
            albumMock = MockRepository.Mock<IAlbum>();

            viewMock.ExpectEvent(x => x.Save += Arg<EventHandler<EventArgs>>.Is.NotNull);
		}

        public FieldProblem_leftend()
        {
            viewMock = (IAddAlbumPresenter)MockRepository.GenerateMock(typeof(IAddAlbumPresenter), null, null);
            albumMock = MockRepository.GenerateStrictMock<IAlbum>();

            saveRaiser = viewMock.Expect(x => x.Save += null).IgnoreArguments().Constraints(Is.NotNull()).GetEventRaiser();
        }

        //public static IAlbum ForAlbum(int iTrackNumber=0)
        //{
        //    CompleteObservableCollectionImpl<ITrack> coci = new CompleteObservableCollectionImpl<ITrack>();
        //    IAlbum res = Substitute.For<IAlbum>();
        //    res.IsAlive.Returns(true);
        //    res.Tracks.Returns(coci);

        //    for (int i = 0; i < iTrackNumber; i++)
        //    {
        //        IInternalTrack subres = ForTrack(res);
        //    }
        //    return res;
        //}

        internal static IInternalTrack ForTrack(IAlbum Father)
        {
            IInternalTrack res = Substitute.For<IInternalTrack>();
            Father.Tracks.Add(res);
            res.Album.Returns(Father);
            res.IsAlive.Returns(true);
            return res;
        }

 public Album(IAlbum album)
 {
     Artist = new Artist(album.Artist);
     CoverId = album.CoverId;
     Name = album.Name;
     Type = album.Type;
     Year = album.Year;
 }

        public AlbumViewer(IAlbum album)
        {
            InitializeComponent();
            _album = album;

            albumName.Text = _album.Name;
            musicList.Items.AddRange(_album.GetAllMusics().Select(p=>p.Name).ToArray());
        }

 public void SaveCommit(IAlbum album, out bool success)
 {
     using (IUnitOfWork u = UnitOfWork.Begin())
     {
         Save(album, out success);
         if (success)
             u.Commit();
     }
 }

        /// <summary>
        /// Copy the specified object and place it in the specified destination album. This method creates a completely separate copy
        /// of the original, including copying the physical files associated with this object. The copy is persisted to the data
        /// store and then returned to the caller. When copying albums, all the album's children, grandchildren, etc are also copied.
        /// The audit fields of the copied objects are automatically updated before saving.
        /// </summary>
        /// <param name="galleryObjectToCopy">The gallery object to copy.</param>
        /// <param name="destinationAlbum">The album to which the current object should be copied.</param>
        /// <returns>
        /// Returns a new gallery object that is an exact copy of the original, except that it resides in the specified
        /// destination album, and of course has a new ID. Child objects are recursively copied.
        /// </returns>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="galleryObjectToCopy" /> is null.</exception>
        public static IGalleryObject CopyGalleryObject(IGalleryObject galleryObjectToCopy, IAlbum destinationAlbum)
        {
            if (galleryObjectToCopy == null)
                throw new ArgumentNullException("galleryObjectToCopy");

            string currentUser = Utils.UserName;

            return galleryObjectToCopy.CopyTo(destinationAlbum, currentUser);
        }

        public static Album ConvertToDto(IAlbum album)
        {
            using (album)
            {
                album.WaitUntilLoaded();

                return Mapper.Map<IAlbum, Album>(album);
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="ViewPhotoForm"/> class.
 /// </summary>
 /// <param name="currentAlbum">The album whose photos the user is viewing.</param>
 /// <param name="photoToDisplay">the specific photo to view.</param>
 /// <remarks>
 /// Author(s): Miguel Gonzales and Andrea Tan
 /// </remarks>
 public ViewPhotoForm(IAlbum currentAlbum, IPhoto photoToDisplay)
 {
     this.InitializeComponent();
     this.album = currentAlbum;
     this.Text = this.album.AlbumId + " - Photo Buddy";
     this.allPhotosInAlbum = new List<IPhoto>(this.album.Photos);
     this.photoIndex = this.allPhotosInAlbum.IndexOf(photoToDisplay);
     this.DisplayPhoto(this.photoIndex);
 }

 public AlbumInformation(IAlbum album, Dispatcher dispatcher)
 {
     _tracks = new ObservableCollection<Track>();
     _copyrights = new ObservableCollection<string>();
     _dispatcher = dispatcher;
     _album = album;
     _browse = _album.Browse();
     _isLoading = !_browse.IsComplete;
     _browse.Completed += AlbumBrowseCompleted;
 }

        public Album(IAlbum album, Dispatcher dispatcher)
        {
            _dispatcher = dispatcher;
            InternalAlbum = album;

            _artist = new Lazy<Artist>(() => new Artist(InternalAlbum.Artist, dispatcher));
            _albumType = new Lazy<TorshifyAlbumType>(GetAlbumType);
            _name = new Lazy<string>(() => InternalAlbum.Name);
            _year = new Lazy<int>(() => InternalAlbum.Year);
        }

        public void DeleteCommit(IAlbum album)
        {
            Checks.Argument.IsNotNull(album, "album");

            using (IUnitOfWork u = UnitOfWork.Begin())
            {
                _repo.Remove(album);
                u.Commit();
            }
        }

		/// <summary>
		/// Move the specified object to the specified destination album. This method moves the physical files associated with this
		/// object to the destination album's physical directory. The object's Save() method is invoked to persist the changes to the
		/// data store. When moving albums, all the album's children, grandchildren, etc are also moved. 
		/// The audit fields are automatically updated before saving.
		/// </summary>
		/// <param name="galleryObjectToMove">The gallery object to move.</param>
		/// <param name="destinationAlbum">The album to which the current object should be moved.</param>
		public static void MoveGalleryObject(IGalleryObject galleryObjectToMove, IAlbum destinationAlbum)
		{
			string currentUser = Util.UserName;
			DateTime currentTimestamp = DateTime.Now;

			galleryObjectToMove.LastModifiedByUserName = currentUser;
			galleryObjectToMove.DateLastModified = currentTimestamp;

			galleryObjectToMove.MoveTo(destinationAlbum);
		}

        public FieldProblem_leftend()
        {
            mocks = new MockRepository();
            viewMock =
                (IAddAlbumPresenter) mocks.DynamicMock(typeof (IAddAlbumPresenter));
            albumMock = mocks.StrictMock<IAlbum>();

            viewMock.Save += null;
            LastCall.IgnoreArguments().Constraints(Is.NotNull());
            saveRaiser = LastCall.GetEventRaiser();
        }

        public static Task<IAlbumBrowse> BrowseAsync(
            this ISession session,
            IAlbum album,
            object userState = null)
        {
            var tcs = new TaskCompletionSource<IAlbumBrowse>();

            var browse = session.Browse(album, userState);
            browse.Completed += (sender, args) => tcs.SetResult(browse);
            return tcs.Task;
        }

		/// <summary>
		/// Update the directory on disk with the current name and location of the album. A new directory is
		/// created for new albums, and the directory is moved to the location specified by FullPhysicalPath if
		/// that property is different than FullPhysicalPathOnDisk.
		/// </summary>
		/// <param name="album">The album to persist to disk.</param>
		private static void PersistToFileSystemStore(IAlbum album)
		{
			if (album.IsNew)
			{
				System.IO.Directory.CreateDirectory(album.FullPhysicalPath);

				// Create directory for thumbnail cache, if needed.
				string thumbnailPath = HelperFunctions.MapAlbumDirectoryStructureToAlternateDirectory(album.FullPhysicalPath, AppSetting.Instance.ThumbnailPath);
				if (thumbnailPath != album.FullPhysicalPath)
				{
					System.IO.Directory.CreateDirectory(thumbnailPath);
				}

				// Create directory for optimized image cache, if needed.
				string optimizedPath = HelperFunctions.MapAlbumDirectoryStructureToAlternateDirectory(album.FullPhysicalPath, AppSetting.Instance.OptimizedPath);
				if (optimizedPath != album.FullPhysicalPath)
				{
					System.IO.Directory.CreateDirectory(optimizedPath);
				}
			}
			else if (album.FullPhysicalPathOnDisk != album.FullPhysicalPath)
			{
				// We need to move the directory to its new location or change its name. Verify that the containing directory doesn't already
				// have a directory with the new name. If it does, alter it slightly to make it unique.
				System.IO.DirectoryInfo di = System.IO.Directory.GetParent(album.FullPhysicalPath);

				string newDirName = HelperFunctions.ValidateDirectoryName(di.FullName, album.DirectoryName);
				if (album.DirectoryName != newDirName)
				{
					album.DirectoryName = newDirName;
				}

				// Now we are guaranteed to have a "safe" directory name, so proceed with the move/rename.
				System.IO.Directory.Move(album.FullPhysicalPathOnDisk, album.FullPhysicalPath);

				// Rename directory for thumbnail cache, if needed.
				string thumbnailPath = HelperFunctions.MapAlbumDirectoryStructureToAlternateDirectory(album.FullPhysicalPath, AppSetting.Instance.ThumbnailPath);
				if (thumbnailPath != album.FullPhysicalPath)
				{
					string currentThumbnailPath = HelperFunctions.MapAlbumDirectoryStructureToAlternateDirectory(album.FullPhysicalPathOnDisk, AppSetting.Instance.ThumbnailPath);

					RenameDirectory(currentThumbnailPath, thumbnailPath);
				}

				// Rename directory for optimized image cache, if needed.
				string optimizedPath = HelperFunctions.MapAlbumDirectoryStructureToAlternateDirectory(album.FullPhysicalPath, AppSetting.Instance.OptimizedPath);
				if (optimizedPath != album.FullPhysicalPath)
				{
					string currentOptimizedPath = HelperFunctions.MapAlbumDirectoryStructureToAlternateDirectory(album.FullPhysicalPathOnDisk, AppSetting.Instance.OptimizedPath);

					RenameDirectory(currentOptimizedPath, optimizedPath);
				}
			}
		}