コード例 #1
0
        public void Publish(BasicLogger BasicLogger)
        {
            string val = "";

            if (BasicLogger is MobileLog)
            {
                val = (BasicLogger as MobileLog).MobileNumber;
            }
            if (BasicLogger is UsernameLog)
            {
                val = (BasicLogger as UsernameLog).Username;
            }
            if (BasicLogger is MailLog)
            {
                val = (BasicLogger as MailLog).Mail;
            }

            var tempList = RedisClient.redis.GetEndPoints().First();

            RedisKey[] keys = RedisClient.redis.GetServer(tempList).Keys().ToArray();

            bool t = true;

            foreach (var key in keys)
            {
                if (key == MakeHash(BasicLogger.TimeStamp.ToUniversalTime().ToString(), val))
                {
                    t = false;
                }
            }
            if (t)
            {
                RedisClient.Database.StringSet(MakeHash(BasicLogger.TimeStamp.ToUniversalTime().ToString(), val), JsonConvert.SerializeObject(BasicLogger), TimeSpan.FromMinutes(5));
            }
        }
コード例 #2
0
        /// <summary>
        /// When you new up a TaskBasedStateMachine, it's log information will be saved in a
        /// "TaskBasedStateMachineLog.log" file under the current application directory.
        /// </summary>
        public TaskBasedStateMachine() : base()
        {
            List <int> list = new List <int>();

            // Setup Configuration
            LoggerManagerConfiguration.SaveDebugFile = TaskBasedStateMachineLibraryConfiguration.SaveDebugFile;
            // Setup Configuration
            LoggerManagerConfiguration.OverrideDebugFile = TaskBasedStateMachineLibraryConfiguration.OverrideDebugFile;

            // Initialize the logger
            TaskBasedStateMachineLogger.InitiateLogger();

            // Use the file logger for debug message
            BasicLogger.Construct().UseFileLogger(@".\TaskBasedStateMachineLog.log");

            // Initialize task dictionary
            mTasks = new Dictionary <string, Func <TParam, TParam> >()
            {
                { InitialTask, null },
                { ExceptionTask, null },
                { UnhandledExceptionTask, null }
            };


            // Register the error from the helper
            GraphvizHelper.OnErrorOccurs += GraphvizHelper_OnErrorOccurs;
        }
コード例 #3
0
        public void ScoresTest()
        {
            var scoreDb = new ScoresDb();
            var logger  = new BasicLogger();

            scoreDb.ReadFile(logger);
            var scores = scoreDb.ScoreLists.Sum(s => s.Replays.Count);
        }
コード例 #4
0
ファイル: Form1.cs プロジェクト: k11tqa25/LoggerManager
        private void UseBasicLogger()
        {
            // Test for basic logger
            BasicLogger.Construct()
            .UseFileLogger(@".\test.txt")
            .UseCustomFunctionAsyncLogger(msg => MessageBox.Show(msg))
            .Build();

            BasicLogger.ErrorOccurs += BasicLogger_ErrorOccurs;
        }
コード例 #5
0
        private static void RunSimulation(object simObject)
        {
            try
            {
                Stages = (simObject as Simulation).RunSimulation(null);

                if (Stages != null && Stages.Length > 0)
                {
                    if (logOutput)
                    {
                        foreach (var stage in Stages)
                        {
                            stage.Dump(log);
                        }
                    }
                    LastStage = Stages[Stages.Length - 1];
                }
            }
            catch (Exception e)
            {
                BasicLogger.Exception(e, "SimManager.RunSimulation()");
                Stages      = null;
                LastStage   = null;
                failMessage = e.ToString();
            }
            lock (locker)
            {
                timer.Stop();
#if TIMERS
                log.AppendLine("Total simulation time: ", timer.ElapsedMilliseconds, "ms");
#else
                if (logOutput)
                {
                    log.AppendLine("Total simulation time: ", timer.ElapsedMilliseconds, "ms");
                }
#endif

                delayBetweenSims = minSimTime - timer.Elapsed;
                if (delayBetweenSims < TimeSpan.Zero)
                {
                    delayBetweenSims = TimeSpan.Zero;
                }

                timer.Reset();
                timer.Start();

                bRunning = false;
                if (OnReady != null)
                {
                    OnReady.Invoke();
                }
            }

            logOutput = false;
        }
コード例 #6
0
        public void CollectionTest()
        {
            var collectionDb = new CollectionDb();
            var logger       = new BasicLogger();

            collectionDb.ReadFile(logger);
            var scores  = collectionDb.Collections.Sum(c => c.Count);
            var deleted = collectionDb.RemoveEmpty();

            collectionDb.WriteFile();
        }
コード例 #7
0
        private static void StartSimulation()
        {
            try
            {
                lock (locker)
                {
                    bRunning = true;
                }

                ClearResults();

                lock (locker)
                {
                    timer.Start();
                }

                if (HighLogic.LoadedSceneIsEditor)
                {
                    parts = EditorLogic.fetch.ship.parts;
                }
                else
                {
                    parts      = FlightGlobals.ActiveVessel.Parts;
                    Atmosphere = FlightGlobals.ActiveVessel.staticPressurekPa * PhysicsGlobals.KpaToAtmospheres;
                }

                // This call doesn't ever fail at the moment but we'll check and return a sensible error for display
                if (simulation.PrepareSimulation(null, parts, Gravity, Atmosphere, Mach, dumpTree, vectoredThrust))
                {
                    ThreadPool.QueueUserWorkItem(_runSim, simulation);
                    //RunSimulation(simulation);
                }
                else
                {
                    failMessage = "PrepareSimulation failed";
                    lock (locker)
                    {
                        bRunning = false;
                    }
                    logOutput = false;
                }
            }
            catch (Exception e)
            {
                BasicLogger.Exception(e, "SimManager.StartSimulation()");
                failMessage = e.ToString();
                lock (locker)
                {
                    bRunning = false;
                }
                logOutput = false;
            }
            dumpTree = false;
        }
コード例 #8
0
    public void logAllDataInStore()
    {
        /* Logging everything to Trial File*/
        BasicLogger.newLine("<vmwm-log>");
        /*global information */
        BasicLogger.newLine("<global-info>");
        BasicLogger.newLine("<name>" + ExperimentModel.logDataStore.experimentName + "</name>");
        BasicLogger.newLine("<vp>" + ExperimentModel.logDataStore.VP + "</vp>");
        BasicLogger.newLine("<description>" + ExperimentModel.logDataStore.description + "</description>");
        BasicLogger.newLine("<log-frequency>" + ExperimentModel.LOG_FREQUENCY.ToString() + "</log-frequency>");
        BasicLogger.newLine("<date>" + ExperimentModel.logDataStore.date.ToString() + "</date>");
        BasicLogger.newLine("</global-info>");
        /* Run specific logging */
        BasicLogger.newLine("<run-specific-data>");
        BasicLogger.newLine("<run-id>" + ExperimentModel.logDataStore.runID + "</run-id>");
        BasicLogger.newLine("<goal-distance>" + ExperimentModel.logDataStore.goalDistance + "</goal-distance>");
        BasicLogger.newLine("<goal-degree>" + ExperimentModel.logDataStore.goalDegree + "</goal-degree>");
        BasicLogger.newLine("<goal-size>" + ExperimentModel.logDataStore.goalSize + "</goal-size>");
        BasicLogger.newLine("<pond-size>" + ExperimentModel.logDataStore.pondSize + "</pond-size>");
        BasicLogger.newLine("<spatial-cue-presence>" + ExperimentModel.logDataStore.spatialCuePresence + "</spatial-cue-presence>");
        BasicLogger.newLine("<time-threshold>" + ExperimentModel.logDataStore.timethreshold + "</time-threshold>");
        BasicLogger.newLine("<scripted-spawn-points>" + ExperimentModel.logDataStore.scriptedSpawnPoints + "</scripted-spawn-points>");
        BasicLogger.newLine("<spatial-cue-visibility>" + ExperimentModel.logDataStore.spatialCueVisibility + "</spatial-cue-visibility>");
        BasicLogger.newLine("<show-target-platform>" + ExperimentModel.logDataStore.showTargetPlatform + "</show-target-platform>");
        BasicLogger.newLine("<show-fireworks>" + ExperimentModel.logDataStore.showFireworks + "</show-fireworks>");
        BasicLogger.newLine("<movement-speed>" + ExperimentModel.logDataStore.movementSpeed + "</movement-speed>");
        BasicLogger.newLine("<wait-time-before-trial>" + ExperimentModel.logDataStore.waitTimeBeforeTrial + "</wait-time-before-trial>");
        BasicLogger.newLine("<simple-skybox>" + ExperimentModel.logDataStore.simpleSkybox + "</simple-skybox>");
        BasicLogger.newLine("<fov-degree>" + ExperimentModel.logDataStore.fovDegree + "<fov-degree>");
        BasicLogger.newLine("</run-specific-data>");
        /* Trial specific logging */
        BasicLogger.newLine("<trial-specific-data>");
        BasicLogger.newLine("<spawn-point>" + ExperimentModel.logDataStore.spawnPoint + "</spawn-point>");
        BasicLogger.newLine("<duration>" + ExperimentModel.trialTotalTime + "</duration>");
        BasicLogger.newLine("<coordinate-log>");
        foreach (CoordinateSample coordinateSample in ExperimentModel.logDataStore.coordinateLog)
        {
            BasicLogger.newLine("<sample>");
            BasicLogger.newLine("<timestamp>" + coordinateSample.timestamp + "</timestamp>");
            BasicLogger.newLine("<coordinate>");
            BasicLogger.newLine("<x>" + coordinateSample.x.ToString() + "</x>");
            BasicLogger.newLine("<z>" + coordinateSample.z.ToString() + "</z>");
            BasicLogger.newLine("</coordinate>");
            BasicLogger.newLine("</sample>");
        }
        BasicLogger.newLine("<samples>" + ExperimentModel.logDataStore.coordinateLog.Count.ToString() + "</samples>");
        BasicLogger.newLine("</coordinate-log>");
        BasicLogger.newLine("</trial-specific-data>");
        BasicLogger.newLine("</vmwm-log>");

        BasicLogger.closeFile();
    }
コード例 #9
0
        public void MapsTest()
        {
            var osuDb  = new OsuDb();
            var logger = new BasicLogger();

            osuDb.ReadFile(logger);
            var beatmap = osuDb.Beatmaps.FirstOrDefault(d => d.Mode == GameMode.Mania);

            Assert.IsNotNull(beatmap);
            beatmap.ReadFile(logger);
            beatmap.FileName += "-copy";
            beatmap.WriteFile();
            Assert.IsTrue(logger.Errors.Count == 0);
        }
コード例 #10
0
        public void ReadAllMapsTest()
        {
            var osuDb  = new OsuDb();
            var logger = new BasicLogger();

            osuDb.ReadFile(logger);
            foreach (var dbBeatmap in osuDb.Beatmaps)
            {
                try {
                    dbBeatmap.ReadFile(logger);
                }
                catch (Exception ex) {
                    Console.WriteLine(ex.Message);
                }
            }
        }
コード例 #11
0
ファイル: Client.cs プロジェクト: NStef26/NBPLogger
        public static void Start()
        {
            var logger = new LoggerConfiguration()
                         .WriteTo.Console()
                         .CreateLogger();
            int i = 0;

            while (true)
            {
                BasicLogger basic = new BasicLogger();

                if (i % 3 == 0)
                {
                    basic = new MailLog(RandomGenerator.GenerateRandomMail(), DateTime.UtcNow, RandomGenerator.GenerateRandomPassword());
                }
                if (i % 3 == 1)
                {
                    basic = new MobileLog(RandomGenerator.GenerateRandomMobileNumber(), DateTime.UtcNow, RandomGenerator.GenerateRandomPassword());
                }
                if (i % 3 == 2)
                {
                    basic = new UsernameLog(RandomGenerator.GenerateRandomUsername(), DateTime.UtcNow, RandomGenerator.GenerateRandomPassword());
                }

                logger.Information(JsonConvert.SerializeObject(basic));
                i++;
                if (i > 100)
                {
                    break;
                }

                if (basic is MailLog)
                {
                    DataProvider.AddMail(basic as MailLog);
                }
                if (basic is MobileLog)
                {
                    DataProvider.AddMobile(basic as MobileLog);
                }
                if (basic is UsernameLog)
                {
                    DataProvider.AddUsername(basic as UsernameLog);
                }

                Thread.Sleep(300);
            }
        }
コード例 #12
0
ファイル: SimManager.cs プロジェクト: Fitiales/SmartTank
        private static void StartSimulation()
        {
            try
            {
                lock (locker)
                {
                    bRunning = true;
                }

                ClearResults();

                lock (locker)
                {
                    timer.Start();
                }

                parts = EditorLogic.fetch.ship.parts;

                // This call doesn't ever fail at the moment but we'll check and return a sensible error for display
                if (simulation.PrepareSimulation(logOutput ? log : null, parts, Gravity, Atmosphere, Mach, dumpTree, vectoredThrust))
                {
                    ThreadPool.QueueUserWorkItem(RunSimulation, simulation);
                    //RunSimulation(simulation);
                }
                else
                {
                    failMessage = "PrepareSimulation failed";
                    lock (locker)
                    {
                        bRunning = false;
                    }
                    logOutput = false;
                }
            }
            catch (Exception e)
            {
                BasicLogger.Exception(e, "SimManager.StartSimulation()");
                failMessage = e.ToString();
                lock (locker)
                {
                    bRunning = false;
                }
                logOutput = false;
            }
            dumpTree = false;
        }
コード例 #13
0
        /// <summary>
        /// Creates an ILogger instance in the specified log path, and of the specified type.
        /// </summary>
        /// <param name="logPath">A <see cref="String"/> representing the Log path value.</param>
        /// <param name="loggerType">Type of the logger.</param>
        /// <returns></returns>
        public static ILogger Create(string logPath, string configFile, LoggerType loggerType)
        {
            ILogger logger = new BasicLogger(logPath, configFile);

            switch (loggerType)
            {
                //case LoggerType.NLog:
                //    logger = new NLogLogger();
                //    break;

                default:
                    // returns the default - BasicLogger implementation
                    break;
            }

            return logger;
        }
コード例 #14
0
        public void Generate()
        {
            Logger = new BasicLogger(Options.Verbose);

            try
            {
                GenerateHelper();
            }
            catch (Exception e)
            {
                Logger.LogError(e, "Exception thrown in generate method");
            }

            if (Logger.HasErrors)
            {
                using (var sw = new StringWriter())
                {
                    Logger.Output(sw);
                    throw new Exception(sw.ToString());
                }
            }
        }
コード例 #15
0
 /// <summary>
 /// Creates an ILogger instance in the specified log path.
 /// </summary>
 /// <param name="logPath">A <see cref="String"/> representing the Log path value.</param>
 /// <returns></returns>
 public static ILogger Create(string logPath, string configFile)
 {
     ILogger logger = new BasicLogger(logPath, configFile);
     return logger;
 }
コード例 #16
0
 private void UpdateDatabaseWithWatchable(CompleteWatchable watchable, DatabaseBuilderType type, string path = "")
 {
     if (type == DatabaseBuilderType.Movies)
     {
         var files     = Directory.GetFileSystemEntries(path).ToList();
         var actors    = new List <Actor>(watchable.Actors);
         var writers   = new List <Writer>(watchable.Writers);
         var directors = new List <Director>(watchable.Directors);
         var genres    = new List <Genre>(watchable.Genres);
         watchable.Actors.Clear();
         watchable.Writers.Clear();
         watchable.Directors.Clear();
         watchable.Genres.Clear();
         _moviesRepository.Create((Movie)watchable);
         foreach (var file in files)
         {
             if (file.EndsWith("srt"))
             {
                 if (files.Count > 2)
                 {
                     BasicLogger.Log(watchable.Title +
                                     "'s subtitles not added due to more than 2 files being present in the directory.", Verbosity.Error);
                 }
                 else
                 {
                     var subs = new Subtitles
                     {
                         Language  = SubtitleLanguage.English,
                         Path      = file,
                         Watchable = watchable
                     };
                     _subtitlesRepository.Create(subs);
                 }
             }
             else if (file.EndsWith("mp4") || file.EndsWith("avi") || file.EndsWith("mkv") || file.EndsWith("wmv"))
             {
                 watchable.Path = file;
                 _moviesRepository.Update((Movie)watchable);
             }
         }
         foreach (var actor in actors)
         {
             var databaseActor = _actorsRepository.Query(x => x.Name == actor.Name).FirstOrDefault();
             if (databaseActor == null)
             {
                 actor.Watchables = new List <Watchable> {
                     watchable
                 };
                 _actorsRepository.Create(actor);
             }
             else
             {
                 if (databaseActor.Watchables == null)
                 {
                     databaseActor.Watchables = new List <Watchable>();
                 }
                 if (databaseActor.Watchables.Contains(watchable))
                 {
                     continue;
                 }
                 databaseActor.Watchables.Add(watchable);
                 _actorsRepository.Update(databaseActor);
             }
         }
         foreach (var writer in writers)
         {
             var databaseWriter = _writersRepository.Query(x => x.Name == writer.Name).FirstOrDefault();
             if (databaseWriter == null)
             {
                 writer.Watchables = new List <Watchable> {
                     watchable
                 };
                 _writersRepository.Create(writer);
             }
             else
             {
                 if (databaseWriter.Watchables == null)
                 {
                     databaseWriter.Watchables = new List <Watchable>();
                 }
                 if (databaseWriter.Watchables.Contains(watchable))
                 {
                     continue;
                 }
                 databaseWriter.Watchables.Add(watchable);
                 _writersRepository.Update(databaseWriter);
             }
         }
         foreach (var director in directors)
         {
             var databaseDirector = _directorsRepository.Query(x => x.Name == director.Name).FirstOrDefault();
             if (databaseDirector == null)
             {
                 director.Watchables = new List <Watchable> {
                     watchable
                 };
                 _directorsRepository.Create(director);
             }
             else
             {
                 if (databaseDirector.Watchables == null)
                 {
                     databaseDirector.Watchables = new List <Watchable>();
                 }
                 if (databaseDirector.Watchables.Contains(watchable))
                 {
                     continue;
                 }
                 databaseDirector.Watchables.Add(watchable);
                 _directorsRepository.Update(databaseDirector);
             }
         }
         foreach (var genre in genres)
         {
             var databaseGenre = _genresRepository.Query(x => x.Name == genre.Name).FirstOrDefault();
             if (databaseGenre == null)
             {
                 genre.Watchables = new List <Watchable> {
                     watchable
                 };
                 _genresRepository.Create(genre);
             }
             else
             {
                 if (databaseGenre.Watchables == null)
                 {
                     databaseGenre.Watchables = new List <Watchable>();
                 }
                 if (databaseGenre.Watchables.Contains(watchable))
                 {
                     continue;
                 }
                 databaseGenre.Watchables.Add(watchable);
                 _genresRepository.Update(databaseGenre);
             }
         }
     }
 }
コード例 #17
0
        public void AddAllMissing(string path, DatabaseBuilderType type)
        {
            var files = Directory.GetFileSystemEntries(path).ToList();

            if (type == DatabaseBuilderType.Movies)
            {
                BasicLogger.Log("Adding all or any missing movies to the database.", Verbosity.Information);
                BasicLogger.Log("Year of each movie in parentheses is expected to appear on each movie's name. Directory will otherwise be ignored.", Verbosity.Information);
                BasicLogger.Log("Accurate Movie Name is expected for each directory. Movie will not be added otherwise.", Verbosity.Information);
                foreach (var file in files)
                {
                    FileAttributes attr = File.GetAttributes(file);
                    if (!attr.HasFlag(FileAttributes.Directory))
                    {
                        continue;
                    }
                    string name = Path.GetFileName(file);
                    if (name == null)
                    {
                        continue;
                    }
                    if (name.Contains("[1080p]"))
                    {
                        name = name.Remove(name.IndexOf("[1080p]", StringComparison.Ordinal)).Trim();
                    }
                    if (name.Contains("(") && name.Contains(")"))
                    {
                        var year = name.Substring(name.LastIndexOf('(') + 1);
                        name = name.Remove(name.LastIndexOf('(')).Trim();
                        year = year.Remove(year.IndexOf(')')).Trim();
                        name = name.Replace("310 to Yuma", "3:10 to Yuma"); //Hardcoded, can't figure out any other way. Unique case.
                        var movie = _moviesRepository.Query(x => x.Title == name && x.Year == year).FirstOrDefault();
                        if (movie != null)
                        {
                            BasicLogger.Log("Conflicting entry: " + name + " (" + year + ")", Verbosity.Warning);
                            continue;
                        }
                        var   obtainedMovieTask = _omdbApiHandler.GetRequestedMovie(name, year: year);
                        Movie obtainedMovieToCheck;
                        try
                        {
                            Task.WaitAll(obtainedMovieTask);
                            obtainedMovieToCheck = obtainedMovieTask.Result;
                            if (obtainedMovieToCheck == null)
                            {
                                throw new Exception();
                            }
                        }
                        catch (Exception)
                        {
                            obtainedMovieTask = _omdbApiHandler.GetRequestedMovie(name); //year might be causing trouble
                            try
                            {
                                Task.WaitAll(obtainedMovieTask);
                                obtainedMovieToCheck = obtainedMovieTask.Result;
                                if (obtainedMovieToCheck == null)
                                {
                                    throw new Exception();
                                }
                                BasicLogger.Log(name + " was searched for without the year (" + year +
                                                "). Please confirm entry.", Verbosity.Warning);
                            }
                            catch (Exception)
                            {
                                if (name.Contains(" and ") || name.Contains(" And "))
                                {
                                    name = name.Replace(" and ", "&");
                                    name = name.Replace(" And ", "&");
                                }
                                obtainedMovieTask = _omdbApiHandler.GetRequestedMovie(name, year: year);
                                try
                                {
                                    Task.WaitAll(obtainedMovieTask);
                                    obtainedMovieToCheck = obtainedMovieTask.Result;
                                    if (obtainedMovieToCheck == null)
                                    {
                                        throw new Exception();
                                    }
                                }
                                catch (Exception)
                                {
                                    if (name.Contains(" and ") || name.Contains(" And "))
                                    {
                                        name = name.Replace(" and ", "&");
                                        name = name.Replace(" And ", "&");
                                    }
                                    obtainedMovieTask = _omdbApiHandler.GetRequestedMovie(name);
                                    try
                                    {
                                        Task.WaitAll(obtainedMovieTask);
                                        BasicLogger.Log(name + " was searched for without the year (" + year +
                                                        "). Please confirm entry.", Verbosity.Warning);
                                    }
                                    catch (Exception ex)
                                    {
                                        BasicLogger.Log(ex.Message + " " + name + " (" + year + ")", Verbosity.Error);
                                        continue;
                                    }
                                }
                            }
                        }
                        var obtainedMovie = obtainedMovieTask.Result;
                        if (obtainedMovie == null)
                        {
                            BasicLogger.Log("Something went wrong with: " + name + " (" + year + ")", Verbosity.Error);
                            continue;
                        }
                        movie = _moviesRepository.Query(x => x.ImdbId == obtainedMovie.ImdbId).FirstOrDefault();
                        if (movie != null)
                        {
                            BasicLogger.Log("Conflicting entries: " + name + " (" + year + "), " + movie.Title + " (" +
                                            movie.Year + ")", Verbosity.Warning);
                            continue;
                        }
                        UpdateDatabaseWithWatchable(obtainedMovie, type, file);
                    }
                    else
                    {
                        BasicLogger.Log("Skipped: " + name, Verbosity.Warning);
                    }
                }
            }
        }
コード例 #18
0
        //Returns a Movie based on the information provided. If no movie was found, returns null. No dependencies are modified or added to the TheaterContext.
        public async Task <Movie> GetRequestedMovie(string name = "-1", string imdbId = "-1", string year = "-1", PlotVersion plotVersion = PlotVersion.Both)
        {
            if (name == "-1" && imdbId == "-1")
            {
                throw new InvalidOperationException("While name and ImdbId are both optional, at least one must be provided.");
            }
            var movieToReturn = new Movie();
            var searchBy      = new[] { "", "" };

            if (name == "-1")
            {
                searchBy[0] = "i";
                searchBy[1] = imdbId;
                year        = "-1";
            }
            else
            {
                searchBy[0] = "t";
                searchBy[1] = name;
            }
            var valuesList = new List <Dictionary <string, string> >();

            if (year == "-1")
            {
                if (plotVersion == PlotVersion.Short || plotVersion == PlotVersion.Both)
                {
                    var values = new Dictionary <string, string>
                    {
                        { searchBy[0], searchBy[1] },
                        { "r", "xml" },
                        { "plot", "short" }
                    };
                    valuesList.Add(values);
                }
                if (plotVersion == PlotVersion.Full || plotVersion == PlotVersion.Both)
                {
                    var values = new Dictionary <string, string>
                    {
                        { searchBy[0], searchBy[1] },
                        { "r", "xml" },
                        { "plot", "full" }
                    };
                    valuesList.Add(values);
                }
            }
            else
            {
                if (plotVersion == PlotVersion.Short || plotVersion == PlotVersion.Both)
                {
                    var values = new Dictionary <string, string>
                    {
                        { searchBy[0], searchBy[1] },
                        { "y", year },
                        { "r", "xml" },
                        { "plot", "short" }
                    };
                    valuesList.Add(values);
                }
                if (plotVersion == PlotVersion.Full || plotVersion == PlotVersion.Both)
                {
                    var values = new Dictionary <string, string>
                    {
                        { searchBy[0], searchBy[1] },
                        { "y", year },
                        { "r", "xml" },
                        { "plot", "full" }
                    };
                    valuesList.Add(values);
                }
            }
            var client = new HttpClient();

            var requestUrls = new List <string>();

            foreach (var valuesDictionary in valuesList)
            {
                var omdbUrl = "http://www.omdbapi.com/?";
                for (var i = 0; i < valuesList.ElementAt(0).Count; i++)
                {
                    omdbUrl += (i == 0 ? "" : "&") + valuesDictionary.Keys.ElementAt(i) + "=" + valuesDictionary[valuesDictionary.Keys.ElementAt(i)];
                }
                requestUrls.Add(omdbUrl);
            }
            var responseNodes = new List <XmlNode>();

            for (int i = 0; i < requestUrls.Count; i++)
            {
                var responseString = await client.GetStringAsync(requestUrls.ElementAt(i));

                var doc = new XmlDocument();
                doc.LoadXml(responseString);
                var rootNode = doc.SelectSingleNode("root");
                if (rootNode == null)
                {
                    BasicLogger.Log("Something went wrong while obtaining rootnode from document for " + requestUrls.ElementAt(i).Clone(), Verbosity.Error);
                    requestUrls.Remove(requestUrls.ElementAt(i));
                    i = -1;
                    continue;
                }
                if (rootNode.Attributes != null && rootNode.Attributes.GetNamedItem("response").Value == "False")
                {
                    BasicLogger.Log("Invalid Identifier for " + requestUrls.ElementAt(i), Verbosity.Error);
                    requestUrls.Remove(requestUrls.ElementAt(i));
                    i = -1;
                    continue;
                }
                var docNode = rootNode.SelectSingleNode("movie");
                if (docNode == null)
                {
                    BasicLogger.Log("Empty XML for " + requestUrls.ElementAt(i), Verbosity.Error);
                    requestUrls.Remove(requestUrls.ElementAt(i));
                    i = -1;
                    continue;
                }
                responseNodes.Add(docNode);
            }
            for (var i = 0; i < responseNodes.Count; i++)
            {
                var xmlAttributeCollection = responseNodes.ElementAt(i).Attributes;
                if (xmlAttributeCollection == null)
                {
                    continue;
                }
                if (xmlAttributeCollection.GetNamedItem("type").Value != "movie")
                {
                    BasicLogger.Log("Element " + xmlAttributeCollection.GetNamedItem("imdbID").Value + " is not a movie!", Verbosity.Warning);
                    continue;
                }
                if (i == 0)
                {
                    movieToReturn.Title      = xmlAttributeCollection.GetNamedItem("title").Value;
                    movieToReturn.ImdbId     = xmlAttributeCollection.GetNamedItem("imdbID").Value;
                    movieToReturn.ImdbRating =
                        decimal.Parse(xmlAttributeCollection.GetNamedItem("imdbRating").Value);
                    var runtime = xmlAttributeCollection.GetNamedItem("runtime").Value;
                    if (runtime.Contains("min"))
                    {
                        runtime = runtime.Remove(runtime.IndexOf("min", StringComparison.Ordinal)).Trim();
                    }
                    movieToReturn.RunTime     = short.Parse(runtime);
                    movieToReturn.Language    = xmlAttributeCollection.GetNamedItem("language").Value;
                    movieToReturn.Rating      = xmlAttributeCollection.GetNamedItem("rated").Value;
                    movieToReturn.Year        = xmlAttributeCollection.GetNamedItem("year").Value;
                    movieToReturn.ReleaseDate =
                        DateTime.Parse(xmlAttributeCollection.GetNamedItem("released").Value);
                    movieToReturn.Actors = new List <Actor>();
                    var actorsString = xmlAttributeCollection.GetNamedItem("actors").Value;
                    while (actorsString.Contains("("))
                    {
                        actorsString = actorsString.Remove(actorsString.IndexOf("(", StringComparison.Ordinal),
                                                           actorsString.IndexOf(")", StringComparison.Ordinal) + 1 - actorsString.IndexOf("(", StringComparison.Ordinal));
                    }
                    var actorsList = actorsString.Split(',').ToList();
                    foreach (var actor in actorsList)
                    {
                        if (actor.Trim() == "")
                        {
                            continue;
                        }
                        var act = _actorsRepository.Query(x => x.Name == actor.Trim()).FirstOrDefault() ?? new Actor
                        {
                            Name = actor.Trim()
                        };
                        act.Portrait = _defaultAvatar.ToArray();
                        movieToReturn.Actors.Add(act);
                    }
                    movieToReturn.Directors = new List <Director>();
                    var directorsString = xmlAttributeCollection.GetNamedItem("director").Value;
                    while (directorsString.Contains("("))
                    {
                        directorsString = directorsString.Remove(directorsString.IndexOf("(", StringComparison.Ordinal),
                                                                 directorsString.IndexOf(")", StringComparison.Ordinal) + 1 - directorsString.IndexOf("(", StringComparison.Ordinal));
                    }
                    var directorsList = directorsString.Split(',').ToList();
                    foreach (var director in directorsList)
                    {
                        if (director.Trim() == "")
                        {
                            continue;
                        }
                        var dir = _directorsRepository.Query(x => x.Name == director.Trim()).FirstOrDefault() ?? new Director
                        {
                            Name = director.Trim()
                        };
                        dir.Portrait = _defaultAvatar.ToArray();
                        movieToReturn.Directors.Add(dir);
                    }
                    movieToReturn.Writers = new List <Writer>();
                    var writersString = xmlAttributeCollection.GetNamedItem("writer").Value;
                    while (writersString.Contains("("))
                    {
                        writersString = writersString.Remove(writersString.IndexOf("(", StringComparison.Ordinal),
                                                             writersString.IndexOf(")", StringComparison.Ordinal) + 1 - writersString.IndexOf("(", StringComparison.Ordinal));
                    }
                    var writersList = writersString.Split(',').ToList();
                    foreach (var writer in writersList)
                    {
                        if (writer.Trim() == "")
                        {
                            continue;
                        }
                        var wri = _writersRepository.Query(x => x.Name == writer.Trim()).FirstOrDefault() ?? new Writer
                        {
                            Name = writer.Trim()
                        };
                        wri.Portrait = _defaultAvatar.ToArray();
                        movieToReturn.Writers.Add(wri);
                    }
                    movieToReturn.Genres = new List <Genre>();
                    var genresString = xmlAttributeCollection.GetNamedItem("genre").Value;
                    while (genresString.Contains("("))
                    {
                        genresString = genresString.Remove(genresString.IndexOf("(", StringComparison.Ordinal),
                                                           genresString.IndexOf(")", StringComparison.Ordinal) + 1 - genresString.IndexOf("(", StringComparison.Ordinal));
                    }
                    var genresList = genresString.Split(',').ToList();
                    foreach (var genre in genresList)
                    {
                        var gen = _genresRepository.Query(x => x.Name == genre.Trim()).FirstOrDefault() ?? new Genre
                        {
                            Name = genre.Trim()
                        };
                        movieToReturn.Genres.Add(gen);
                    }
                    var stringImage =
                        client.GetStreamAsync(xmlAttributeCollection.GetNamedItem("poster").Value);
                    await stringImage;
                    var   reader     = new BinaryReader(stringImage.Result);
                    var   imagebytes = reader.ReadAllBytes();
                    movieToReturn.Poster = imagebytes;
                }
                if (requestUrls.ElementAt(i).Contains("plot=short"))
                {
                    movieToReturn.ShortPlot = responseNodes.ElementAt(i).Attributes.GetNamedItem("plot").Value;
                }
                else
                {
                    movieToReturn.LongPlot = responseNodes.ElementAt(i).Attributes.GetNamedItem("plot").Value;
                }
            }
            return(String.IsNullOrEmpty(movieToReturn.ImdbId) ? null : movieToReturn);
        }
コード例 #19
0
 public void CreateLogger()
 {
     var logger = new BasicLogger();
     Assert.IsNotNull(logger);
 }
コード例 #20
0
 public void LogTestInfoMessage()
 {
     var logger = new BasicLogger();
     logger.Info("Test");
 }