private IList<Track> MoveFilePacketCheckState(IInternalMusicSession msi, int packect, string iDirectoryIn, string iDirectoryOut, bool FindOriginalFiles)
{
//packect
var HalfFiles = new DirectoryInfo(iDirectoryIn).GetFiles().Where(fi => fi.Extension == FileServices.MP3).Take(packect).ToList();
Assert.That(HalfFiles.Count, Is.EqualTo(packect));
//string myout = this.TempDirectoryOut;
//MusicSessionImpl msi = ms as MusicSessionImpl;
IList<Track> res = null;
if (FindOriginalFiles)
{
var InitialTrack = HalfFiles.SelectMany(fi => msi.Tracks.Find(new FakeTrackDescriptor(fi.FullName))).ToList();
Assert.That(InitialTrack.Count, Is.EqualTo(packect));
Assert.That(InitialTrack.All(mt => mt.Precision == MatchPrecision.Exact), Is.True);
res = InitialTrack.Select(mt => mt.FindItem).ToList();
Assert.That(res.Count, Is.EqualTo(packect));
Assert.That(res.Cast<IInternalTrack>().All(tr => tr.InternalState == ObjectState.Available), Is.True);
}
HalfFiles.Apply(fi => fi.MoveTo(Path.Combine(iDirectoryOut, fi.Name)));
return res;
}
internal OptionArtistChooser(IEnumerable<IList<IArtist>> iOptions,IInternalMusicSession iSession)
{
_Session = iSession;
var l = iOptions.ToList();
if (l.Count == 1)
{
Options = new ObservableCollection<IArtist>();
Values = new ObservableCollection<IArtist>(l[0]);
Values.CollectionChanged += Values_CollectionChanged;
return;
}
var First = l[0];
bool allthesame = l.Skip(1).All(la => la.SequenceEqual(First));
if (allthesame)
{
Options = new ObservableCollection<IArtist>();
Values = new ObservableCollection<IArtist>(l[0]);
Values.CollectionChanged += Values_CollectionChanged;
return;
}
var options = l.SelectMany(al => al).Distinct();
Options = new ObservableCollection<IArtist>(options);
Values = new ObservableCollection<IArtist>();
Values.CollectionChanged += Values_CollectionChanged;
}
internal NonRecursiveFolderInspector(IInternalMusicSession iIMusicConverter, IEnumerable<string> Files, IImportHelper Clue, IEventListener iel)
{
_IMusicConverter = iIMusicConverter;
_Files = Files;
_ClueName = Clue;
_IEL = iel;
}
IMusicImporter IMusicImporterFactory.GetFileService(IInternalMusicSession iconv, string dir, AlbumMaturity iDefaultMaturity)
{
DirectoryInfo DI = new DirectoryInfo(dir);
if (!DI.Exists)
throw new InvalidDataException(string.Format("Need a valid path {0}", dir));
return new LazyLoadingMusicImporter(_Session, ((iel) => GetFrom(iconv, DI, iel)), iDefaultMaturity);
}
internal RarImporter(IInternalMusicSession iconv, string FileName)
{
_IInternalMusicSession = iconv;
_FileName = FileName;
_RarFileNames = new List<string>();
_ExtractedFiles = new List<string>();
_RarFileNames.Add(FileName);
}
internal FolderInspector(IInternalMusicSession iMusicConverter, DirectoryInfo DI, IEventListener iel)
{
_IMusicConverter = iMusicConverter;
_RootDir = DI;
_IEL = iel;
string DirName = Path.GetDirectoryName(DI.FullName);
_SkipDir = (DirName == null) ? DI.FullName.Length : DirName.Length;
_SkipDir++;
}
public void Setup()
{
_Session = MusicSession.GetSession(null) as IInternalMusicSession;
IMusicImporter imi = ((IMusicSession)_Session).GetDBImporter();
imi.Load();
//_IMT = _Session.GetNewSessionContext();
}
private void EmulateBrokenTransaction(IInternalMusicSession msi)
{
using (IDisposable l = msi.GetSessionLock())
{
try
{
msi.Dispose();
int i = msi.AllAlbums.Count;
}
catch
{
Trace.WriteLine("Assertion Raised");
}
}
}
private IEnumerable<IImporter> GetFrom(IInternalMusicSession iconv, DirectoryInfo DI, IEventListener iel)
{
try
{
return new FolderInspector(iconv, DI, iel).Collectors;
}
catch (PathTooLongException ptle)
{
Trace.WriteLine(string.Format("Error during import: {0}", ptle));
throw ImportExportException.FromError(new PathTooLong(string.Empty)); ;
}
catch (Exception e)
{
Trace.WriteLine(string.Format("Error during import: {0}", e));
throw;
}
}
internal iTunesMusicImporterBuilder(IInternalMusicSession msi)
: base(msi)
{
switch (msi.Setting.iTunesSetting.ImportBrokenTrack)
{
case BasicBehaviour.AskEndUser:
ImportBrokenTracks = null;
break;
case BasicBehaviour.Yes:
ImportBrokenTracks = true;
break;
case BasicBehaviour.No:
ImportBrokenTracks = false;
break;
}
ItunesDirectory = null;
}
static internal IMusicImporterBuilder GetFromType(IInternalMusicSession Session, MusicImportType typei)
{
switch (typei)
{
case MusicImportType.CD:
return new CDMusicImporterBuilder(Session);
case MusicImportType.Compressed:
return new CompressedMusicImporterBuilder(Session);
case MusicImportType.Custo:
return new CustoMusicImporterBuilder(Session);
case MusicImportType.Directory:
return new DirectoryMusicImporterBuilder(Session);
case MusicImportType.iTunes:
return new iTunesMusicImporterBuilder(Session);
}
throw new NotImplementedException();
}
public WindowsPhoneExporter(IInternalMusicSession ims)
{
_Ims = ims;
_IIC = ims.GetNewSessionContext();
}
internal MusicImporterFactory(IInternalMusicSession Session)
{
_Session = Session;
}
static internal IMusicImporterFactory GetFactory(IInternalMusicSession Session)
{
return new MusicImporterFactory(Session);
}
internal DirectoryMusicImporterBuilder(IInternalMusicSession msi)
: base(msi)
{
_Session = msi;
_Directory = _Session.Setting.PathUserSettings.PathFolder;
}
static internal MusicRemover GetMusicRemover(IInternalMusicSession session)
{
return new MusicRemover(session.GetNewSessionContext());
}
internal SplashScreenGenerator(IInternalMusicSession msi)
{
_MSI = msi;
}
internal RarCollector(IInternalMusicSession imc, string name)
{
_IMusicConverter = imc;
_Rar = name;
}
internal MusicExporter(IInternalMusicSession MSI, MusicExportType mit)
{
_IIC = MSI.GetNewSessionContext();
CompactFiles = mit;
}
internal CompressedMusicImporterBuilder(IInternalMusicSession msi): base(msi)
{
_Session = msi;
}
internal CustoMusicImporterBuilder(IInternalMusicSession msi)
: base(msi)
{
_Session = msi;
}
internal CDMusicImporterBuilder(IInternalMusicSession msi)
: base(msi)
{
_IMusicImporterExporterUserSettings = msi.Setting.MusicImporterExporter;
_OpenCDDoorOnComplete = _IMusicImporterExporterUserSettings.OpenCDDoorOnEndImport;
}
internal SQLExecute(string isql, IInternalMusicSession iMSI)
{
_SQL = isql;
_MSI = iMSI;
}
static internal IEnumerable<ICollector> CollectorRar(IInternalMusicSession iMusicConverter, IEnumerable<string> rar)
{
HashSet<string> rarFiles = new HashSet<string>();
foreach (string file in rar)
{
string filename = Regex.Replace(file, @"\.part([0-9]+)\.rar", m => new StringBuilder(".part").Append('0',m.Groups[1].Value.Length-1).Append("1.rar").ToString());
if (!File.Exists(filename))
continue;
//mesh name
if (rarFiles.Add(filename))
yield return new RarCollector(iMusicConverter, filename);
}
}
static internal IMusicGenreFactory GetFactory(IInternalMusicSession Session )
{
return new GenreFactory(Session);
}
private LazyLoadingMusicImporter(IInternalMusicSession Session, Func<IEventListener, IEnumerable<IImporter>> Con, AlbumMaturity iDefaultMaturity)
{
_IInternalMusicSession = Session;
_Transaction = Session.GetNewSessionContext(iDefaultMaturity);
_Importers = null;
_Const = Con;
}
internal AlbumMover(IInternalMusicSession msi)
{
_msi = msi;
}
private LazyLoadingMusicImporter(IInternalMusicSession Session, Func<IImporter> Con, AlbumMaturity iDefaultMaturity)
: this(Session, ((iel) => Con().SingleItemCollection<IImporter>()), iDefaultMaturity)
{
}
internal ITunesExporter(IInternalMusicSession MSI)
{
_IIC = MSI.GetNewSessionContext();
//_IIC.Error += ((o, e) => OnError(e));
_MSI = MSI;
}
internal MusicImporterBuilder(IInternalMusicSession Session)
{
Factory = LazyLoadingMusicImporter.GetFactory(Session);
}
