internal void uploadAlbum(LocalAlbum aAlbum, Int32? catId)
{
Boolean rc;
Int32 IdNewAlbum = 0;
String strMsgInfo = String.Empty;
rc = PwgServiceProvider.Instance.PwgAlbumsService.AddAlbum(aAlbum.Name, catId, ref IdNewAlbum, ref strMsgInfo);
if (rc == true)
{
aAlbum.Id = IdNewAlbum;
foreach (LocalImage Img in aAlbum.LocalImages)
{
if (aAlbum.Id.HasValue)
{
Img.UpperCatId = aAlbum.Id.Value;
}
uploadImage(Img);
}
foreach (LocalAlbum Alb in aAlbum.SubAlbums)
{
uploadAlbum(Alb, null);
}
}
else
{
throw new ApplicationException("uploadlabum error");
}
}
public ModelManagerBase()
{
lstCat = new SelectedPwgAlbumList();
lstAlbumLocaux = new LocalAlbumList();
isConnected = false;
AlbumEdited = new LocalAlbum();
ImageEdited = new LocalImage();
UploadOption = new PwgUploadOption();
LstConfidentLevel = Com.Piwigo.Lib.DTO.Helper.PwgEnumHelper<PwgConfidentLevelEnum>.buildChoiceList();
}
public static void DeleteAlbum(ref LocalAlbum alb)
{
//on vire les images
alb.LocalImages.Clear();
foreach (LocalAlbum subAlb in alb.SubAlbums)
{
LocalAlbum subAlbtoDel = subAlb;
// on boucle sur les sous-albums
DeleteAlbum(ref subAlbtoDel);
}
// on vide les sous-album
alb.SubAlbums.Clear();
}
public static void DeleteInTree(LocalAlbum alb)
{
//si l'album depend de la racine
LocalAlbum treeAlb = ModelManager.Instance.lstAlbumLocaux.FirstOrDefault(a => a.LocalDir == alb.LocalDir);
if (treeAlb != default(LocalAlbum))
{
DeleteAlbum(ref treeAlb);
ModelManager.Instance.lstAlbumLocaux.Remove(treeAlb);
}
else
{
LocalAlbumList lal = ModelManager.Instance.lstAlbumLocaux;
DeleteWhenFoundInTree(alb,ref lal);
}
}
public static void DeleteWhenFoundInTree(LocalAlbum alb, ref LocalAlbumList lstAlbum)
{
LocalAlbum treeAlb = null;
for (int i = 0; i < lstAlbum.Count; i += 1)
{
treeAlb = lstAlbum.FirstOrDefault(a => a.LocalDir == alb.LocalDir);
if (treeAlb != default(LocalAlbum))
{
DeleteAlbum(ref treeAlb);
lstAlbum.RemoveAt(i);
return;
}
}
for (int i = 0; i < lstAlbum.Count; i += 1)
{
LocalAlbumList FoundInLstAlb = lstAlbum[i].SubAlbums;
DeleteWhenFoundInTree(alb, ref FoundInLstAlb);
}
}
internal static System.Windows.Forms.TreeNode buildAlbumToNode(LocalAlbum aAlbum)
{
System.Windows.Forms.TreeNode aNode = new System.Windows.Forms.TreeNode(aAlbum.Name,1,1);
aNode.ToolTipText = aAlbum.LocalDir;
aNode.Tag = aAlbum;
foreach (LocalImage Img in aAlbum.LocalImages)
{
System.Windows.Forms.TreeNode imgNode = new System.Windows.Forms.TreeNode(Img.Name, 2, 2);
imgNode.ToolTipText = Img.LocalFile;
imgNode.Tag = Img;
aNode.Nodes.Add(imgNode);
}
foreach (LocalAlbum Alb in aAlbum.SubAlbums)
{
aNode.Nodes.Add(buildAlbumToNode(Alb));
}
return aNode;
}
public bool MatchReleaseWithLocalAlbum(Release release, LocalAlbum localAlbum)
{
if (release.JoinedAlbumArtists != localAlbum.AlbumArtist)
{
return(false);
}
if (release.Title != localAlbum.Title)
{
return(false);
}
if (localAlbum.Year != 0 && release.ReleaseDate.Date.Year != localAlbum.Year)
{
return(false);
}
if (localAlbum.Year == 0 && release.ReleaseDate.IsValid)
{
return(false);
}
if (release.Genre != localAlbum.Genre)
{
return(false);
}
if (release.DiscCount != localAlbum.DiscCount)
{
return(false);
}
if (!MatchReleaseTracklistWithLocalAlbum(release, localAlbum))
{
return(false);
}
return(true);
}
public bool MatchReleaseTracklistWithLocalAlbum(Release release, LocalAlbum localAlbum)
{
List <Track> tracks = this.GenerateTracklistForLocalAlbum(this.collectionManager, localAlbum, null);
for (int i = 0; i < tracks.Count; ++i)
{
Track track = release.Tracklist[i];
Track localTrack = tracks[i];
if (track.RelativeFilename != localTrack.RelativeFilename)
{
return(false);
}
if (track.Title != localTrack.Title)
{
return(false);
}
if (track.JoinedArtists != localTrack.JoinedArtists)
{
return(false);
}
if (track.Disc != localTrack.Disc)
{
return(false);
}
if (track.Position != localTrack.Position)
{
return(false);
}
}
foreach (LocalDisc disc in localAlbum.Discs)
{
foreach (TrackInfoCache track in disc.Tracks)
{
if (track.Year != 0 && track.Year != release.ReleaseDate.Date.Year)
{
return(false);
}
if (track.Year == 0 && release.ReleaseDate.IsValid)
{
return(false);
}
if (track.RelativeFilename != track.RelativeFilename)
{
return(false);
}
if (track.Genre != release.Genre)
{
return(false);
}
if (track.DiscCount != release.DiscCount)
{
return(false);
}
if (track.AlbumArtist != release.JoinedAlbumArtists)
{
return(false);
}
if (track.Album != release.Title)
{
return(false);
}
}
}
return(true);
}
public Release GetReleaseByLocalAlbumName(LocalAlbum localAlbum)
{
return(this.collectionManager.Releases
.Where(r => r.Title == localAlbum.Title && r.JoinedAlbumArtists == localAlbum.AlbumArtist)
.FirstOrDefault());
}
public List <Track> GenerateTracklistForLocalAlbum(ICollectionManager collectionManager, LocalAlbum album, Release release)
{
List <Track> list = new List <Track>();
foreach (LocalDisc disc in album.Discs)
{
bool hasTrackArtists = disc.Tracks.Any(t => t.Artist != disc.Tracks[0].Artist);
foreach (TrackInfoCache localTrack in disc.Tracks)
{
Track track = new Track()
{
Disc = localTrack.Disc,
Position = localTrack.Track,
Title = localTrack.Title,
RelativeFilename = localTrack.RelativeFilename
};
if (hasTrackArtists)
{
track.Artists.Add(new TrackArtist()
{
Artist = collectionManager.GetOrCreateArtist(localTrack.Artist),
});
track.JoinedArtists = localTrack.Artist;
}
list.Add(track);
}
}
return(list);
}
private LocalAlbum loadDirectory(String dirName, Int32? rootAlbumId)
{
DirectoryInfo dir = new DirectoryInfo(dirName);
LocalAlbum album = new LocalAlbum() { LocalDir = dir.FullName, Name = dir.Name };
Int32 parentAlbumId = (rootAlbumId.HasValue ? rootAlbumId.Value : PwgAlbum.RootAlbumId);
album.MessageInfo = "";
album.UpperCatId = parentAlbumId;
// loading image data in album
album.LocalImages = new LocalImageList();
foreach (string strfile in Directory.EnumerateFiles(dir.FullName, "*.*", SearchOption.TopDirectoryOnly)
.Where(s => extensions.Any(ext => ext == Path.GetExtension(s))))
{
album.LocalImages.Add(loadFile(strfile));
}
album.SubAlbums = new LocalAlbumList();
foreach (string strdir in Directory.EnumerateDirectories(dir.FullName))
{
album.SubAlbums.Add(loadDirectory(strdir, null));
}
return album;
}
public void runService()
{
if (File.Exists(ModelManager.Instance.directoryName))
{
if (extensions.Contains<String>(Path.GetExtension(ModelManager.Instance.directoryName)))
{
FileInfo file = new FileInfo(ModelManager.Instance.directoryName);
LocalAlbum album;
album = ModelManager.Instance.lstAlbumLocaux.SingleOrDefault(a => a.Name == file.Directory.Name);
if (album == null)
{
album = new LocalAlbum() { LocalDir = file.Directory.FullName, Name = file.Directory.Name };
album.MessageInfo = "auto created for photo input.";
album.UpperCatId = 0;
album.LocalImages = new LocalImageList();
album.SubAlbums = new LocalAlbumList();
ModelManager.Instance.lstAlbumLocaux.Add(album);
}
if (album.LocalImages.Count(a => a.Name == file.Name) < 1)
{
album.LocalImages.Add(loadFile(file.FullName));
}
}
}
else if (Directory.Exists(ModelManager.Instance.directoryName))
{
Int32 RootAlbumId = PwgAlbum.RootAlbumId;
LocalAlbum rootAlbum = null;
if (ModelManager.Instance.SelectedNode != null)
{
if (ModelManager.Instance.SelectedNode.Tag != null)
{
if (ModelManager.Instance.SelectedNode.Tag is LocalAlbum)
{
rootAlbum = (LocalAlbum)ModelManager.Instance.SelectedNode.Tag;
RootAlbumId = (rootAlbum.Id.HasValue ? rootAlbum.Id.Value : PwgAlbum.RootAlbumId);
}
else if (ModelManager.Instance.SelectedNode.Tag is PwgImage)
{
rootAlbum = (LocalAlbum)ModelManager.Instance.SelectedNode.Parent.Tag;
RootAlbumId = (rootAlbum.Id.HasValue ? rootAlbum.Id.Value : PwgAlbum.RootAlbumId);
}
}
}
if (rootAlbum != null)
{
rootAlbum.SubAlbums.Add(
loadDirectory(ModelManager.Instance.directoryName,
RootAlbumId)
);
}
else
{
ModelManager.Instance.lstAlbumLocaux.Add(
loadDirectory(ModelManager.Instance.directoryName,
PwgAlbum.RootAlbumId)
);
}
}
}
