public FilenameParser(string filename) { try { //////////////////////////////////////////////////////////////////////////////////////////// // Parsing filename for all recognized naming formats to extract episode information //////////////////////////////////////////////////////////////////////////////////////////// m_Filename = filename; if (sExpressions.Count == 0) { reLoadExpressions(); } int index = 0; // run Before replacements m_FileNameAfterReplacement = RunReplacements(replacementRegexBefore, m_Filename); foreach (Regex regularExpression in regularExpressions) { Match matchResults; matchResults = regularExpression.Match(m_FileNameAfterReplacement); if (matchResults.Success) { for (int i = 1; i < matchResults.Groups.Count; i++) { string GroupName = regularExpression.GroupNameFromNumber(i); string GroupValue = matchResults.Groups[i].Value; if (GroupValue.Length > 0 && GroupName != "unknown") { // ´run after replacements on captures GroupValue = RunReplacements(replacementRegexAfter, GroupValue); GroupValue = GroupValue.Trim(); m_Matches.Add(GroupName, GroupValue); } } // stop on the first successful match m_RegexpMatched = sExpressions[index]; m_RegexpMatchedIdx = index; return; } index++; } } catch (Exception ex) { MPTVSeriesLog.Write("And error occured in the 'FilenameParser' function (" + ex.ToString() + ")"); } }
public static void StartDiskWatcher() { lock (syncRoot) { if (!MonitorStarted) { MPTVSeriesLog.Write("Starting Disk Watcher...", MPTVSeriesLog.LogLevel.Normal); watcherThread = new Thread(new ThreadStart(WatchDisks)); watcherThread.Name = "DeviceManager.WatchDisks"; watcherThread.Start(); MPTVSeriesLog.Write("Successfully started Disk Watcher.", MPTVSeriesLog.LogLevel.Normal); } } }
public List <DBSeries> getSeriesItems(int stepIndex, string[] currentStepSelection) { MPTVSeriesLog.Write("View: Get Series Items", MPTVSeriesLog.LogLevel.Debug); SQLCondition conditions = null; if (stepIndex >= m_steps.Count) { return(null); // wrong index specified!! } addHierarchyConditions(ref stepIndex, ref currentStepSelection, ref conditions); MPTVSeriesLog.Write("View: Get Series Items: Executing SQL", MPTVSeriesLog.LogLevel.Debug); return(DBSeries.Get(conditions)); }
private static void GetDefines(XmlDocument doc) { MPTVSeriesLog.Write("Loading Skin Defines", MPTVSeriesLog.LogLevel.Normal); // clear defines Defines.Clear(); XmlNode node = null; node = doc.DocumentElement.SelectSingleNode(string.Format("/settings/defines//property[@key='{0}']", cfanartlistlayout)); if (node != null) { Defines.Add(cfanartlistlayout, node.InnerText); } node = doc.DocumentElement.SelectSingleNode(string.Format("/settings/defines//property[@key='{0}']", cfanarticonslayout)); if (node != null) { Defines.Add(cfanarticonslayout, node.InnerText.ToLowerInvariant()); } node = doc.DocumentElement.SelectSingleNode(string.Format("/settings/defines//property[@key='{0}']", cfanartfilmstriplayout)); if (node != null) { Defines.Add(cfanartfilmstriplayout, node.InnerText.ToLowerInvariant()); } node = doc.DocumentElement.SelectSingleNode(string.Format("/settings/defines//property[@key='{0}']", cfanartcoverflowlayout)); if (node != null) { Defines.Add(cfanartcoverflowlayout, node.InnerText.ToLowerInvariant()); } node = doc.DocumentElement.SelectSingleNode(string.Format("/settings/defines//property[@key='{0}']", cfanartseriesview)); if (node != null) { Defines.Add(cfanartseriesview, node.InnerText.ToLowerInvariant()); } node = doc.DocumentElement.SelectSingleNode(string.Format("/settings/defines//property[@key='{0}']", cfanartseasonview)); if (node != null) { Defines.Add(cfanartseasonview, node.InnerText.ToLowerInvariant()); } node = doc.DocumentElement.SelectSingleNode(string.Format("/settings/defines//property[@key='{0}']", cfanartepisodeview)); if (node != null) { Defines.Add(cfanartepisodeview, node.InnerText.ToLowerInvariant()); } }
public static void UpdateEpisodeCounts(DBSeries series) { if (series == null) { return; } int seriesEpsTotal = 0; int seriesEpsUnWatched = 0; int epsTotal = 0; int epsUnWatched = 0; // Update for each season in series and add each to total series count SQLCondition condition = new SQLCondition(); if (!DBOption.GetOptions(DBOption.cShowHiddenItems)) { //don't include hidden seasons unless the ShowHiddenItems option is set condition.Add(new DBSeason(), DBSeason.cHidden, 0, SQLConditionType.Equal); } List <DBSeason> Seasons = DBSeason.Get(series[DBSeries.cID], condition); foreach (DBSeason season in Seasons) { epsTotal = 0; epsUnWatched = 0; DBEpisode.GetSeasonEpisodeCounts(series, season, out epsTotal, out epsUnWatched); season[DBSeason.cEpisodeCount] = epsTotal; season[DBSeason.cEpisodesUnWatched] = epsUnWatched; season[DBSeason.cUnwatchedItems] = epsUnWatched > 0; season.Commit(); seriesEpsTotal += epsTotal; // Count the Special (Season 0 (zero)) episodes as watched! if ((season[DBSeason.cIndex] != 0) || (season[DBSeason.cIndex] == 0 && !DBOption.GetOptions(DBOption.cCountSpecialEpisodesAsWatched))) { seriesEpsUnWatched += epsUnWatched; } MPTVSeriesLog.Write(string.Format("Series \"{0} Season {1}\" has {2}/{3} unwatched episodes", series.ToString(), season[DBSeason.cIndex], epsUnWatched, epsTotal), MPTVSeriesLog.LogLevel.Debug); } MPTVSeriesLog.Write(string.Format("Series \"{0}\" has {1}/{2} unwatched episodes", series.ToString(), seriesEpsUnWatched, seriesEpsTotal), MPTVSeriesLog.LogLevel.Debug); series[DBOnlineSeries.cEpisodeCount] = seriesEpsTotal; series[DBOnlineSeries.cEpisodesUnWatched] = seriesEpsUnWatched; series[DBOnlineSeries.cUnwatchedItems] = seriesEpsUnWatched > 0; series.Commit(); }
/// <summary> /// Gets all properties used by this plugin /// </summary> /// <param name="skinfile"></param> static void GetSkinProperties(string filename) { string content = string.Empty; StreamReader r = new StreamReader(filename); content = r.ReadToEnd(); Regex reg = new Regex(@"(#TVSeries\.\w+(?:\.\w+)*)"); MatchCollection matches = reg.Matches(content); MPTVSeriesLog.Write("Skin uses " + matches.Count.ToString() + " fields", MPTVSeriesLog.LogLevel.Debug); for (int i = 0; i < matches.Count; i++) { string pre = string.Empty; string remove = string.Empty; if (matches[i].Value.Contains((remove = "#TVSeries.Episode."))) { pre = "Episode"; } else if (matches[i].Value.Contains((remove = "#TVSeries.Season."))) { pre = "Season"; } else if (matches[i].Value.Contains((remove = "#TVSeries.Series."))) { pre = "Series"; } string value = matches[i].Value.Trim().Replace(remove, string.Empty); if (pre.Length > 0) { if (SkinProperties.ContainsKey(pre)) { if (!SkinProperties[pre].Contains(value)) { SkinProperties[pre].Add(value); } } else { List <string> v = new List <string>(); v.Add(value); SkinProperties.Add(pre, v); } } } }
public static void DeleteXmlCache(int aSeriesID) { string lPath = Path.Combine(Settings.GetPath(Settings.Path.config), string.Format(@"Cache\{0}\", aSeriesID.ToString())); MPTVSeriesLog.Write($"Deleting series API cache. Path={lPath}"); try { Directory.Delete(lPath, true); } catch (Exception e) { MPTVSeriesLog.Write($"Error deleting series API cache. Exception={e.Message}"); } }
private static void InitDB() { if (System.Diagnostics.Process.GetCurrentProcess().ProcessName.ToLower() == "devenv") { return; } string databaseFile = Settings.GetPath(Settings.Path.database); bool databaseExists = true; if (!File.Exists(databaseFile)) { databaseExists = false; } try { m_db = new SQLiteClient(databaseFile); // check database integrity if (databaseExists) { if (CheckIntegrity()) { // backup volume if all is good Backup(); } else { // restore last known good volume if corrupt Restore(); } } ExecutePragmas(); MPTVSeriesLog.Write("Successfully opened database. Filename = '{0}'", databaseFile); return; } catch (Exception ex) { MPTVSeriesLog.Write("Failed to open database. Filename = '{0}', Reason = '{1}'", databaseFile, ex.Message); // restore last known good volume Restore(); ExecutePragmas(); } }
internal static void LogOptions() { lock (thisLock) { foreach (string key in optionsCache.Keys) { // dont log private options if (!key.Equals(DBOption.cOnlineUserID)) { MPTVSeriesLog.Write(string.Format("Option {0}: {1}", key, optionsCache[key].ToString()), MPTVSeriesLog.LogLevel.Debug); } } } }
public bool Load(PlayList incomingPlaylist, string playlistFileName) { if (playlistFileName == null) { return(false); } playlist = incomingPlaylist; playlist.Clear(); XmlDocument doc = new XmlDocument(); try { doc.Load(playlistFileName); } catch (XmlException e) { MPTVSeriesLog.Write(string.Format("Cannot Load Playlist file: {0}", playlistFileName)); MPTVSeriesLog.Write(e.Message); return(false); } try { playlist.Name = Path.GetFileName(playlistFileName); basePath = Path.GetDirectoryName(Path.GetFullPath(playlistFileName)); XmlNodeList nodeList = doc.DocumentElement.SelectNodes("/Playlist/Episode"); if (nodeList == null) { return(false); } foreach (XmlNode node in nodeList) { if (!AddItem(node.SelectSingleNode("ID").InnerText)) { return(false); } } } catch (Exception ex) { MPTVSeriesLog.Write(string.Format("exception loading playlist {0} err:{1} stack:{2}", playlistFileName, ex.Message, ex.StackTrace)); return(false); } return(true); }
public virtual bool AddColumn(String sName, DBField field) { // verify if we already have that field avail if (!m_fields.ContainsKey(sName)) { if (m_fields.Count == 0 && !field.Primary) { throw new Exception("First field added needs to be the index"); } try { // ok, we don't, add it SQLiteResultSet results; results = DBTVSeries.Execute("SELECT name FROM sqlite_master WHERE name='" + m_tableName + "'"); if (results != null && results.Rows.Count > 0) { // table already exists, alter it String sQuery = "ALTER TABLE " + m_tableName + " ADD " + sName + " " + field.Type; DBTVSeries.Execute(sQuery); } else { // new table, create it // no tables, assume it's going to be created later (using AddColumn) string type = field.Type.ToString(); if (field.Primary && field.Type == DBField.cType.Int && field.AutoIncrement) { //for the automatic creation of an auto incremental integer primary key you must use the full "Integer" not just "int" type = "Integer"; } String sQuery = "CREATE TABLE " + m_tableName + " (" + sName + " " + type + (field.Primary ? " primary key)" : ")"); DBTVSeries.Execute(sQuery); } // delete the s_fields cache so newed up objects get the right fields lock (fields) fields.Remove(m_tableName); m_fields.Add(sName, field); return(true); } catch (Exception ex) { MPTVSeriesLog.Write(m_tableName + " table.AddColumn failed (" + ex.Message + ")."); return(false); } } return(false); }
static cache() { if (!Settings.isConfig) { // for globalset and clear we dumb all objects in question DBTable.dbUpdateOccured += new DBTable.dbUpdateOccuredDelegate(DBTable_dbUpdateOccured); // for commits on single object we can update the specific object in question // (if commited ones are not yet in cache we don't add them though) DBSeries.dbSeriesUpdateOccured += new DBSeries.dbSeriesUpdateOccuredDelegate(DBSeries_dbSeriesUpdateOccured); DBSeason.dbSeasonUpdateOccured += new DBSeason.dbSeasonUpdateOccuredDelegate(DBSeason_dbSeasonUpdateOccured); DBEpisode.dbEpisodeUpdateOccured += new DBEpisode.dbEpisodeUpdateOccuredDelegate(DBEpisode_dbEpisodeUpdateOccured); MPTVSeriesLog.Write("Cache Initialized", MPTVSeriesLog.LogLevel.Debug); } }
public Watcher(List <String> WatchedFolders, int nScanLapse) { MPTVSeriesLog.Write("File Watcher: Creating new File System Watcher", MPTVSeriesLog.LogLevel.Normal); m_nScanLapse = nScanLapse; foreach (String folder in WatchedFolders) { string sRoot = System.IO.Path.GetPathRoot(folder); try { DriveInfo info = new DriveInfo(sRoot); if (info.DriveType == DriveType.CDRom) { // do nothing as filesystemwatchers do nothing for cd or dvd drives MPTVSeriesLog.Write(string.Format("File Watcher: Skipping CD/DVD drive: {0}", sRoot), MPTVSeriesLog.LogLevel.Normal); } else if (info.DriveType == DriveType.Network) { //string sUNCPath=MPR.GetUniversalName(folder); MPTVSeriesLog.Write(string.Format("File Watcher: Adding watcher on folder: {0}", folder), MPTVSeriesLog.LogLevel.Normal); m_ScannedFolders.Add(folder); } else { MPTVSeriesLog.Write(string.Format("File Watcher: Adding watcher on folder: {0}", folder), MPTVSeriesLog.LogLevel.Normal); m_WatchedFolders.Add(folder); } } catch (System.ArgumentException) { // this has to be a UNC path MPTVSeriesLog.Write(string.Format("File Watcher: Adding watcher on folder: {0}", folder), MPTVSeriesLog.LogLevel.Normal); m_ScannedFolders.Add(folder); } } DeviceManager.OnVolumeInserted += OnVolumeInsertedRemoved; DeviceManager.OnVolumeRemoved += OnVolumeInsertedRemoved; worker.WorkerReportsProgress = true; worker.WorkerSupportsCancellation = true; worker.ProgressChanged += new ProgressChangedEventHandler(worker_ProgressChanged); worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_Completed); worker.DoWork += new DoWorkEventHandler(workerWatcher_DoWork); }
public static void AddWatchDrive(string path, bool localOnly) { try { // if the path does not point to logical volume do not add it to the drive watcher if (PathIsUnc(path)) { return; } if (localOnly) { if (PathIsOnNetwork(path)) { return; } } // get the driveletter string driveLetter = GetDriveLetter(path); if (driveLetter == null) { return; } // add the drive to the drive watcher lock (syncRoot) { if (watchedDrives == null) { watchedDrives = new List <string>(); } if (!watchedDrives.Contains(driveLetter)) { watchedDrives.Add(driveLetter); StartDiskWatcher(); MPTVSeriesLog.Write("Added " + driveLetter + " to Disk Watcher", MPTVSeriesLog.LogLevel.Normal); } } } catch (Exception e) { if (e is ThreadAbortException) { throw e; } MPTVSeriesLog.Write("Error adding \"" + path + "\" to Disk Watcher!!", MPTVSeriesLog.LogLevel.Debug); } }
public static void Close() { string databaseFile = Settings.GetPath(Settings.Path.database); try { m_db.Close(); m_db.Dispose(); m_db = null; MPTVSeriesLog.Write("Successfully closed database. Filename = '{0}'", databaseFile); } catch (Exception) { MPTVSeriesLog.Write("Failed to close database. Filename = '{0}'", databaseFile); } }
public static void cleanUP() // there is no static destructor in .NET, so this has to be called explicitally { // clean up all dynLogoFiles MPTVSeriesLog.Write("Cleaning up cached, generated Logos"); foreach (string file in System.IO.Directory.GetFiles(pathfortmpfile, "TVSeriesDynLogo*")) { try { System.IO.File.Delete(file); } catch (Exception ex) { MPTVSeriesLog.Write("Error: Could not delete temporary Logo File " + file, ex.Message, MPTVSeriesLog.LogLevel.Normal); } } }
private static void CreateTable() { try { SQLiteResultSet results = DBTVSeries.Execute("SELECT name FROM sqlite_master WHERE name='options' and type='table' UNION ALL SELECT name FROM sqlite_temp_master WHERE type='table' ORDER BY name"); if (results == null || results.Rows.Count == 0) { // no table, create it DBTVSeries.Execute("CREATE TABLE options (option_id integer primary key, property text, value text)"); } } catch (Exception ex) { MPTVSeriesLog.Write("DBOption.CreateTable failed (" + ex.Message + ")."); } }
void DoFileScan(List <String> scannedFolders, ref List <PathPair> previousScan) { MPTVSeriesLog.Write("File Watcher: Performing File Scan on Import Paths for changes", MPTVSeriesLog.LogLevel.Normal); // Check if Fullscreen Video is active as this can cause stuttering/dropped frames if (!DBOption.GetOptions(DBOption.cImportScanWhileFullscreenVideo) && Helper.IsFullscreenVideo) { MPTVSeriesLog.Write("File Watcher: Fullscreen Video has been detected, aborting file scan"); return; } List <PathPair> newScan = Filelister.GetFiles(scannedFolders); List <PathPair> addedFiles = new List <PathPair>(); addedFiles.AddRange(newScan); foreach (PathPair pair in previousScan) { addedFiles.RemoveAll(item => item.m_sFull_FileName == pair.m_sFull_FileName); } List <PathPair> removedFiles = new List <PathPair>(); removedFiles.AddRange(previousScan); foreach (PathPair pair in newScan) { removedFiles.RemoveAll(item => item.m_sFull_FileName == pair.m_sFull_FileName); } lock (m_modifiedFilesList) { foreach (PathPair pair in addedFiles) { m_modifiedFilesList.Add(new WatcherItem(pair, WatcherItemType.Added)); } foreach (PathPair pair in removedFiles) { m_modifiedFilesList.Add(new WatcherItem(pair, WatcherItemType.Deleted)); } } previousScan = newScan; MPTVSeriesLog.Write("File Watcher: Finished File Scan on Import Paths", MPTVSeriesLog.LogLevel.Normal); }
static void appendLogos(List <string> logosForBuilding, ref Graphics g, int totalHeight, int totalWidth) { int noImgs = logosForBuilding.Count; List <Image> imgs = new List <Image>(); List <Size> imgSizes = new List <Size>(); int spacer = 5; int checkWidth = 0; // step one: get all sizes (not all logos are obviously square) and scale them to fit vertically Image single = null; float scale = 0, totalHeightf = (float)totalHeight; Size tmp = default(Size); int x_pos = 0; for (int i = 0; i < logosForBuilding.Count; i++) { try { single = ImageAllocator.LoadImageFastFromFile(logosForBuilding[i]); } catch (Exception) { MPTVSeriesLog.Write("Could not load Image file... " + logosForBuilding[i]); return; } scale = totalHeightf / (float)single.Size.Height; tmp = new Size((int)(single.Width * scale), (int)(single.Height * scale)); checkWidth += tmp.Width; imgSizes.Add(tmp); imgs.Add(single); } // step two: check if we are too big horizontally and if so scale again checkWidth += imgSizes.Count * spacer; if (checkWidth > totalWidth) { scale = (float)checkWidth / (float)totalWidth; for (int i = 0; i < imgSizes.Count; i++) { imgSizes[i] = new Size((int)(imgSizes[i].Width / scale), (int)(imgSizes[i].Height / scale)); } } // step three: finally draw them for (int i = 0; i < imgs.Count; i++) { g.DrawImage(imgs[i], x_pos, totalHeight - imgSizes[i].Height, imgSizes[i].Width, imgSizes[i].Height); x_pos += imgSizes[i].Width + spacer; } }
public void Delete() { // first let's delete the physical file if (this.IsAvailableLocally) { try { System.IO.File.Delete(FullLocalPath); MPTVSeriesLog.Write("Fanart Deleted: " + FullLocalPath); } catch (Exception ex) { MPTVSeriesLog.Write("Failed to delete file: " + FullLocalPath + " (" + ex.Message + ")"); } } Clear(this[cIndex]); }
public static List <P> getPropertyListFromList <T, P>(string PropertyNameToGet, List <T> elements) { List <P> results = new List <P>(); foreach (T elem in elements) { try { results.Add((P)elem.GetType().InvokeMember(PropertyNameToGet, System.Reflection.BindingFlags.GetProperty | System.Reflection.BindingFlags.GetField, null, elem, null)); } catch (Exception) { MPTVSeriesLog.Write("Wrong call of getPropertyListFromList<T,P>: Type " + elem.GetType().Name); } } return(results); }
void signalModifiedFiles() { try { lock (m_modifiedFilesList) { if (m_modifiedFilesList.Count > 0) { m_modifiedFilesList = removeDuplicates(m_modifiedFilesList); MPTVSeriesLog.Write("File Watcher: Signaling " + m_modifiedFilesList.Count + " modified files"); List <WatcherItem> outList = new List <WatcherItem>(); // leave locked files in the m_modifiedFilesList foreach (WatcherItem watcherItem in m_modifiedFilesList) { if (!watcherItem.IsLocked()) { outList.Add(watcherItem); } else { MPTVSeriesLog.Write("File " + watcherItem.m_sParsedFileName + " is locked, leaving for later parsing!", MPTVSeriesLog.LogLevel.Debug); } } // clear m_modifiedFilesList foreach (WatcherItem watcherItem in outList) { m_modifiedFilesList.Remove(watcherItem); } // go over the modified files list once in a while & update //outList.AddRange(m_modifiedFilesList); //m_modifiedFilesList.Clear(); if (outList.Count > 0) { worker.ReportProgress(0, outList); } } } } catch (Exception exp) { MPTVSeriesLog.Write("File Watcher: Exception happened in Signal Modified Files: " + exp.Message); } }
public bool ReadPrimary(DBValue Value) { try { m_fields[PrimaryKey()].Value = Value; SQLCondition condition = new SQLCondition(); condition.Add(this, PrimaryKey(), m_fields[PrimaryKey()].Value, SQLConditionType.Equal); String sqlQuery = "select * from " + m_tableName + condition; SQLiteResultSet records = DBTVSeries.Execute(sqlQuery); return(Read(ref records, 0)); } catch (Exception ex) { MPTVSeriesLog.Write("An Error Occurred (" + ex.Message + ")."); } return(false); }
public static IEnumerable <DBFormatting> GetAll(bool includeDisabled) { if (cache == null || Settings.isConfig) { try { // make sure the table is created - create a dummy object DBFormatting dummy = new DBFormatting(); // retrieve all fields in the table String sqlQuery = "select * from " + cTableName; if (!includeDisabled) { sqlQuery += " where " + cEnabled + " = 1"; } sqlQuery += " order by " + cIndex; SQLiteResultSet results = DBTVSeries.Execute(sqlQuery); if (results.Rows.Count > 0) { cache = new DBFormatting[results.Rows.Count]; for (int index = 0; index < results.Rows.Count; index++) { cache[index] = new DBFormatting(); cache[index].Read(ref results, index); } } MPTVSeriesLog.Write("Found and loaded " + results.Rows.Count + " User Formatting Rules", MPTVSeriesLog.LogLevel.Debug); if (results.Rows.Count == 0) { cache = new DBFormatting[0]; } } catch (Exception ex) { MPTVSeriesLog.Write("Error in DBFormatting.Get (" + ex.Message + ")."); } } if (cache != null) { for (int i = 0; i < cache.Length; i++) { yield return(cache[i]); } } }
public WatcherItem(FileSystemWatcher watcher, FileSystemEventArgs e) { m_sFullPathFileName = e.FullPath; m_sParsedFileName = m_sFullPathFileName.Substring(watcher.Path.Length).TrimStart('\\'); switch (e.ChangeType) { case WatcherChangeTypes.Deleted: m_type = WatcherItemType.Deleted; break; default: m_type = WatcherItemType.Added; fileInfo = new FileInfo(m_sFullPathFileName); break; } MPTVSeriesLog.Write("File monitor: " + m_sParsedFileName + " " + m_type); }
public WatcherItem(FileSystemWatcher watcher, RenamedEventArgs e, bool bOldName) { if (bOldName) { m_sFullPathFileName = e.OldFullPath; m_sParsedFileName = m_sFullPathFileName.Substring(watcher.Path.Length).TrimStart('\\'); m_type = WatcherItemType.Deleted; MPTVSeriesLog.Write("File monitor: " + m_sParsedFileName + " " + m_type); } else { m_sFullPathFileName = e.FullPath; m_sParsedFileName = m_sFullPathFileName.Substring(watcher.Path.Length).TrimStart('\\'); fileInfo = new FileInfo(m_sFullPathFileName); m_type = WatcherItemType.Added; MPTVSeriesLog.Write("File monitor: " + m_sParsedFileName + " " + m_type); } }
/// <summary> /// Removes non-existant files from a list of filenames /// </summary> /// <param name="filenames"></param> /// <returns></returns> public static List <string> filterExistingFiles(List <string> filenames) { for (int f = 0; f < filenames.Count; f++) { bool wasCached = false; if ((wasCached = nonExistingFiles.Contains(filenames[f])) || !System.IO.File.Exists(filenames[f])) { if (!wasCached) { MPTVSeriesLog.Write("File does not exist: " + filenames[f], MPTVSeriesLog.LogLevel.Debug); nonExistingFiles.Add(filenames[f]); } filenames.RemoveAt(f); f--; } } return(filenames); }
public static List <string> getFieldNameListFromList <T>(string FieldNameToGet, List <T> elements) where T : DBTable { MPTVSeriesLog.Write("Elements found: " + elements.Count.ToString()); List <string> results = new List <string>(); foreach (T elem in elements) { try { results.Add((string)elem[FieldNameToGet]); } catch (Exception) { MPTVSeriesLog.Write("Wrong call of getPropertyListFromList<T,P>: Type " + elem.GetType().Name); } } return(results); }
public static List <DBValue> GetSingleField(string field, SQLCondition conds, DBTable obj) { string sql = "select " + field + " from " + obj.m_tableName + conds + conds.orderString + conds.limitString; List <DBValue> results = new List <DBValue>(); try { foreach (SQLiteResultSet.Row result in DBTVSeries.Execute(sql).Rows) { results.Add(result.fields[0]); } } catch (Exception ex) { MPTVSeriesLog.Write("GetSingleField SQL method generated an error: " + ex.Message); } return(results); }
public virtual DBValue this[String fieldName] { get { DBField result; if (!m_fields.TryGetValue(fieldName, out result)) { return(string.Empty); } return(result.Value); } set { try { DBField result; if (m_fields.TryGetValue(fieldName, out result)) { if (result.Value != value) { if (result.Type == DBField.cTypeInt) { result.Value = (long)value; } else { result.Value = value; } result.WasChanged = true; m_CommitNeeded = true; } } else { AddColumn(fieldName, new DBField(DBField.cTypeString)); this[fieldName] = value; } } catch (SystemException) { MPTVSeriesLog.Write("Cast exception when trying to assign " + value + " to field " + fieldName + " in table " + m_tableName); } } }