Esempio n. 1
0
        /// <summary>
        /// Checks the display FW Version
        /// </summary>
        //  Revision History
        //  MM/DD/YY Who Version ID Number Description
        //  -------- --- ------- -- ------ -------------------------------------------
        //  09/17/09 RCG 2.30.00           Created
        //  09/23/14 jrf 4.00.63 WR 534158 Modified way test details are set.
        private void CheckDisplayFWVersion()
        {
            // Only check this value if it's HW 2.0 or later and earlier than HW 3.0
            if (VersionChecker.CompareTo(m_AmiDevice.HWRevision, CENTRON_AMI.HW_VERSION_2_0) >= 0 &&
                VersionChecker.CompareTo(m_AmiDevice.HWRevision, CENTRON_AMI.HW_VERSION_3_0) < 0)
            {
                XMLOpenWayActiveFiles ActiveFiles = new XMLOpenWayActiveFiles();
                FirmwareSet           MeterFWSet  = ActiveFiles.GetFirmwareSet(FirmwareSet.DetermineMeterType(m_AmiDevice.DeviceClass,
                                                                                                              m_AmiDevice.HWRevision, m_AmiDevice.MeterKey_TransparentDeviceSupported));

                string MeterValue    = m_AmiDevice.DisplayModVer + "." + m_AmiDevice.DisplayModBuild;
                string ExpectedValue = "";
                string Result        = "";
                string Details       = "";
                string Reason        = "";

                if (MeterFWSet != null && File.Exists(FW_PATH + MeterFWSet.DisplayFWFile))
                {
                    CENTRON_AMI_FW_File FWFile = new CENTRON_AMI_FW_File(FW_PATH + MeterFWSet.DisplayFWFile);
                    ExpectedValue = FWFile.CompleteVersion;
                }
                else
                {
                    Reason = TestResources.ReasonNoFirmwareFile;
                }

                // Get the result string. We skip if the expected value is empty string. Pass if the values are equal
                Result = GetResultString(String.IsNullOrEmpty(ExpectedValue), MeterValue.Equals(ExpectedValue));

                Details = GetFWVersionDetails(MeterValue, ExpectedValue);

                AddTestDetail(TestResources.DisplayFirmwareVersion, Result, Details, Reason);
            }
        }
Esempio n. 2
0
        public override void Logon(Google.ProtocolBuffers.IRpcController controller, bnet.protocol.authentication.LogonRequest request, Action <bnet.protocol.NoData> done)
        {
            Logger.Trace("LogonRequest(): Email={0}", request.Email);

            if (!VersionChecker.Check(this.Client, request)) // if the client trying to connect doesn't match required version, disconnect him.
            {
                Logger.Error("Client [{0}] doesn't match required version {1}, disconnecting..", request.Email, VersionInfo.LogNet.RequiredClientVersion);

                // create the disconnection reason.
                var reason = bnet.protocol.connection.DisconnectNotification.CreateBuilder()
                             .SetErrorCode(3018).Build();

                // Error 3018 => A new patch for Diablo III is available. The game will now close and apply the patch automatically. You will be able to continue playing after the patch has been applied.

                // FIXME: D3 client somehow doesn't show the correct error message yet, and in debug output we only miss a message like [ Recv ] service_id: 254 token: 6 status: 28
                // when I compare NullD's output. That could be the reason. /raist.

                // force disconnect the client as it does not satisfy required version. /raist.
                this.Client.MakeRPC(() => bnet.protocol.connection.ConnectionService.CreateStub(this.Client).ForceDisconnect(null, reason, callback => { }));
                this.Client.Connection.Disconnect();

                return;
            }

            done(bnet.protocol.NoData.CreateBuilder().Build());

            AuthManager.StartAuthentication(this.Client, request);
        }
Esempio n. 3
0
        protected override void ProcessRecord()
        {
            cancellationTokenSource = new CancellationTokenSource();
            CancellationToken token = cancellationTokenSource.Token;

#pragma warning disable CS0618 // NoTelemetry and NoVersionCheck needs to be set through environment variables now
            if (NoTelemetry)
            {
                Environment.SetEnvironmentVariable("PNPPOWERSHELL_DISABLETELEMETRY", "true");
            }
            if (NoVersionCheck)
            {
                Environment.SetEnvironmentVariable("PNPPOWERSHELL_UPDATECHECK", "false");
            }
#pragma warning restore CS6018



            VersionChecker.CheckVersion(this);
            try
            {
                Connect(ref token);
            }
            catch (Exception ex)
            {
                ex.Data["TimeStampUtc"] = DateTime.UtcNow;
                throw;
            }
        }
        public void LoadConfigTest()
        {
            var dbFile       = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\cherrytomato\\database.sqlite";
            var ver          = new Version(Application.ProductVersion);
            var configString = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\r\n" +
                               "<cherryTomato>\r\n" +
                               "  <hasRun />\r\n" +
                               "  <newestKnownVersion major=\"" + ver.Major + "\" minor=\"" + ver.Minor + "\" />\r\n" +
                               "  <databaseFile path=\"" + dbFile + "\" />\r\n" +
                               "  <config />\r\n" +
                               "</cherryTomato>";

            var reader = new StringReader(configString);

            using (var cs = new CherryService())
            {
                var vc = new VersionChecker();
                cs.PluginRepository.RegisterPlugin(new PomodoroSensor());
                cs.PluginRepository.RegisterPlugin(new FakeTimeProvider());
                cs.PluginRepository.RegisterPlugin(new DatabaseController());
                var fr = new FirstRunSensor();
                cs.PluginRepository.RegisterPlugin(fr);
                cs.PluginRepository.RegisterPlugin(vc);
                cs.InitializeCherryServiceEventsAndCommands();
                cs.PluginRepository.TieEvents();
                cs.LoadConfiguration(reader);
                Assert.AreEqual(true, fr.HasRun);
                Assert.AreEqual(ver.Major, vc.NewestKnownVersion.Major);
                Assert.AreEqual(ver.Minor, vc.NewestKnownVersion.Minor);
            }
        }
Esempio n. 5
0
 // ReSharper disable once UnusedParameter.Local
 private static void Main(string[] args)
 {
     Loading.OnLoadingComplete += delegate
     {
         VersionChecker.LoadVersionChecker();
     };
 }
        public MainWindow()
        {
            logger          = NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger();
            telemetryWriter = new TelemetryWriter();
            logger.Info("\n\nApp start");
            telemetryWriter.WriteAppStart();
            messageBoxService  = new MessageBoxService();
            dbService          = new DbService();
            drawService        = new DrawService(logger);
            throwService       = new ThrowService(logger);
            configService      = new ConfigService(logger, dbService);
            scoreBoardService  = new ScoreBoardService(logger, configService, drawService);
            camsDetectionBoard = new CamsDetectionBoard(configService, logger, drawService);
            fileSystemService  = new FileSystemService();
            versionChecker     = new VersionChecker(appVersion, fileSystemService, dbService, configService, messageBoxService);
            detectionService   = new DetectionService(drawService, configService, throwService, logger, camsDetectionBoard);
            manualThrowPanel   = new ManualThrowPanel(logger, detectionService);
            gameService        = new GameService(scoreBoardService, camsDetectionBoard, detectionService, logger, dbService, manualThrowPanel);

            InitializeComponent();
            viewModel = new MainWindowViewModel(logger,
                                                messageBoxService,
                                                dbService,
                                                versionChecker,
                                                scoreBoardService,
                                                camsDetectionBoard,
                                                drawService,
                                                detectionService,
                                                manualThrowPanel,
                                                gameService,
                                                configService);
            DataContext = viewModel;
        }
Esempio n. 7
0
        public void CheckForNewVersion()
        {
            //NewVersionAvailable
            try
            {
                VersionChecker vcReleasedPageStripper = new VersionChecker("Pulse", new RssFeedReleases());

                //get the release record for the version installed on the client
                Release client = vcReleasedPageStripper.GetReleaseByName(string.Format("Pulse {0}",
                                                                                       System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString()));

                //if we weren't able to find the current version then return
                if (client == null)
                {
                    return;
                }

                //get the default release
                Release defaultRelease = vcReleasedPageStripper.GetDefaultRelease();

                //compare against the version installed on client (logic is up to you)
                if (defaultRelease.ReleaseDate > client.ReleaseDate)
                {
                    //Notify user of upgrade
                    if (NewVersionAvailable != null)
                    {
                        NewVersionAvailable(defaultRelease);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Logger.Write(string.Format("Error checking for new Pulse Versions: {0}", ex.ToString()), Log.LoggerLevels.Warnings);
            }
        }
Esempio n. 8
0
        public LoginWindowViewModel(UserControl view)
        {
            _view = view as LoginView;

            ForceRefresh = Settings.UserSettings.ContainsKey("ForceRefresh") ?
                           bool.Parse(Settings.UserSettings["ForceRefresh"]) : true;

            Email = Settings.UserSettings["AccountLogin"];

            if (!string.IsNullOrEmpty(Settings.UserSettings["AccountPassword"]))
            {
                _view.txtPassword.Password = string.Empty.PadLeft(8); //For the visuals
            }
            _view.txtPassword.PasswordChanged += new RoutedEventHandler(TxtPassword_PasswordChanged);
            PropertyChanged += LoginWindow_PropertyChanged;

            _characterInjector = new CharacterTabInjector();

            _statusController = new StatusController(_view.StatusBox);

            ApplicationState.Model.Authenticating += Model_Authenticating;
            ApplicationState.Model.Throttled      += Model_Throttled;
            ApplicationState.InitializeFont(Properties.Resources.fontin_regular_webfont);
            ApplicationState.InitializeFont(Properties.Resources.fontin_smallcaps_webfont);

            _statusController.DisplayMessage(ApplicationState.Version + " Initialized.\r");

            VersionChecker.CheckForUpdates();

            //Todo: Feed this in from a setting so that console players will have their preference remembered
            SelectedRealm = AvailableRealms.First();
        }
Esempio n. 9
0
 void Check(string fodyFile)
 {
     if (VersionChecker.IsVersionNewer(fodyFile))
     {
         taskFileReplacer.AddFile(Path.GetDirectoryName(fodyFile));
     }
 }
Esempio n. 10
0
        public async Task <string> GetUpdatesHistory()
        {
            string result = "";

            try
            {
                var updatesInfo = await VersionChecker.GetUpdatesInformation(false);

                if (updatesInfo.ChangesByVersions.Keys.Count() == 0)
                {
                    result = "Історія оновлень не знайдена.";
                }
                else
                {
                    var sb = new StringBuilder();

                    foreach (var updateVersion in updatesInfo.ChangesByVersions.Keys)
                    {
                        sb.AppendLine(updateVersion.ToString());
                        sb.AppendLine(updatesInfo.ChangesByVersions[updateVersion]);
                        sb.AppendLine();
                    }
                    result = sb.ToString();
                }
            }
            catch (WebException ex)
            {
                logger.Error("Error occured during update download");
                logger.Error(ex.Message);
            }
            return(result);
        }
Esempio n. 11
0
        public override void Entry(IModHelper helper)
        {
            // init
            modPath = helper.DirectoryPath;
            Config  = helper.ReadConfig <MorePetsConfig>();

            // load textures
            EntoFramework.GetContentRegistry().RegisterTexture("paths_objects_MorePetsTilesheet", Path.Combine(modPath, "box.png"));
            this.LoadPetSkins(out CatTextures, out DogTextures);
            Monitor.Log($"Found [{CatTextures.Length}] Cat and [{DogTextures.Length}] Dog skins", LogLevel.Info);

            // hook events
            GameEvents.UpdateTick                 += GameEvents_UpdateTick;
            TimeEvents.AfterDayStarted            += TimeEvents_AfterDayStarted;
            ControlEvents.ControllerButtonPressed += ControlEvents_ControllerButtonPressed;
            ControlEvents.MouseChanged            += ControlEvents_MouseChanged;
            //LocationEvents.CurrentLocationChanged += LocationEvents_CurrentLocationChanged;
            helper.ConsoleCommands.Add("kill_pets", "Kills all the pets you adopted using MorePets, you monster", this.CommandFired_KillPets);

            // add console commands
            if (Config.DebugMode)
            {
                // DEV COMMANDS, kept in should they be needed in the future
                helper.ConsoleCommands
                .Add("spawn_pet", "Spawns either a `dog` or a `cat` depending on the given name | spawn_pet <type> <skin>", this.CommandFired_SpawnPet)
                .Add("test_adoption", "Triggers the adoption dialogue", this.CommandFired_TestAdoption);
            }

            // check version
            Version version = new Version(this.ModManifest.Version.MajorVersion, this.ModManifest.Version.MinorVersion, this.ModManifest.Version.PatchVersion);

            VersionChecker.AddCheck("MorePets", version, "https://raw.githubusercontent.com/Entoarox/StardewMods/master/VersionChecker/MorePets.json");
        }
Esempio n. 12
0
        public LoginWindowViewModel(UserControl view)
        {
            this.view = view as LoginView;

            UseSession = Settings.UserSettings.ContainsKey("UseSessionID") ?
                         bool.Parse(Settings.UserSettings["UseSessionID"]) : false;
            ForceRefresh = Settings.UserSettings.ContainsKey("ForceRefresh") ?
                           bool.Parse(Settings.UserSettings["ForceRefresh"]) : true;

            Email = Settings.UserSettings["AccountLogin"];

            if (!string.IsNullOrEmpty(Settings.UserSettings["AccountPassword"]))
            {
                this.view.txtPassword.Password = string.Empty.PadLeft(8); //For the visuals
            }
            this.view.txtPassword.PasswordChanged += new RoutedEventHandler(txtPassword_PasswordChanged);
            PropertyChanged += loginWindow_PropertyChanged;

            characterInjector = new CharacterTabInjector();

            statusController = new StatusController(this.view.StatusBox);

            ApplicationState.Model.Authenticating += model_Authenticating;
            ApplicationState.Model.Throttled      += model_Throttled;
            ApplicationState.InitializeFont(Properties.Resources.fontin_regular_webfont);
            ApplicationState.InitializeFont(Properties.Resources.fontin_smallcaps_webfont);

            statusController.DisplayMessage($"WTF is {ApplicationState.Version} Initialized. RIP TotalBiscuit.\r");

            VersionChecker.CheckForUpdates();
        }
Esempio n. 13
0
        public async Task <string> GetUpdatesInformation()
        {
            string result = "";

            try
            {
                var updatesInfo = await VersionChecker.GetUpdatesInformation(true);

                if (!updatesInfo.HasNewVersion)
                {
                    result = "Версія програми є найновішою.";
                }
                else
                {
                    var sb = new StringBuilder();

                    foreach (var updateVersion in updatesInfo.ChangesByVersions.Keys)
                    {
                        sb.AppendLine(updateVersion.ToString());
                        sb.AppendLine(updatesInfo.ChangesByVersions[updateVersion]);
                        sb.AppendLine();
                    }
                    result = sb.ToString();

                    MsgDispatcher.Post(MessageType.UPDATES_AVAILABLE);
                }
            }
            catch (WebException ex)
            {
                logger.Error("Error occured during update download");
                logger.Error(ex.Message);
            }
            return(result);
        }
Esempio n. 14
0
        /// <summary>
        ///     Called when [load].
        /// </summary>
        protected sealed override void OnLoad()
        {
            this.versionChecker = new VersionChecker(GlobalVariables.GitHubPath);

            this.Menu = new Menu(this.Name, this.Name);
            this.Menu.AddItem(new MenuItem(this.Name + "Enabled", "Enabled").SetValue(true));

            //this.AssemblyVersion.Check(Variables.GitHubPath);

            this.Menu.AddItem(
                this.versionChecker.UpdateAvailable
                    ? new MenuItem(this.Name + "Version", "Version: " + 1337)
                    : new MenuItem(this.Name + "Version", "Version is outdated"));

            this.Menu.AddItem(
                new MenuItem(this.Name + "LiveCheck", "Check For new Version").SetValue(true)
                .SetTooltip(
                    "If this is enabled, the assembly will look every few minutes if a newer version is available"));

            this.Menu.AddItem(
                new MenuItem(this.Name + "NotifyNewVersion", "Notify if new Version available").SetValue(true)
                .SetTooltip(
                    "If this is enabled, the assembly will notify you when a new version is available. It will always inform you about important updates."));

            this.Parent.Menu.AddSubMenu(this.Menu);

            this.lastChecked = Game.Time;
        }
Esempio n. 15
0
 public AuthController(
     ServiceLocation serviceLocation,
     IConfiguration configuration,
     IHostingEnvironment env,
     AuthService <KahlaUser> authService,
     OAuthService oauthService,
     UserManager <KahlaUser> userManager,
     SignInManager <KahlaUser> signInManager,
     UserService userService,
     AppsContainer appsContainer,
     KahlaPushService pusher,
     ChannelService channelService,
     VersionChecker version,
     KahlaDbContext dbContext,
     IMemoryCache cache)
 {
     _serviceLocation = serviceLocation;
     _configuration   = configuration;
     _env             = env;
     _authService     = authService;
     _oauthService    = oauthService;
     _userManager     = userManager;
     _signInManager   = signInManager;
     _userService     = userService;
     _appsContainer   = appsContainer;
     _pusher          = pusher;
     _channelService  = channelService;
     _version         = version;
     _dbContext       = dbContext;
     _cache           = cache;
 }
Esempio n. 16
0
 public AuthController(
     ServiceLocation serviceLocation,
     IWebHostEnvironment env,
     AuthService <KahlaUser> authService,
     UserManager <KahlaUser> userManager,
     SignInManager <KahlaUser> signInManager,
     UserService userService,
     AppsContainer appsContainer,
     KahlaPushService pusher,
     ChannelService channelService,
     VersionChecker version,
     KahlaDbContext dbContext,
     IOptions <List <DomainSettings> > optionsAccessor,
     AiurCache cache)
 {
     _serviceLocation = serviceLocation;
     _env             = env;
     _authService     = authService;
     _userManager     = userManager;
     _signInManager   = signInManager;
     _userService     = userService;
     _appsContainer   = appsContainer;
     _pusher          = pusher;
     _channelService  = channelService;
     _version         = version;
     _dbContext       = dbContext;
     _cache           = cache;
     _appDomains      = optionsAccessor.Value;
 }
Esempio n. 17
0
        void MenuVersionCheckDoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
        {
            VersionChecker vc = GetVersionChecker();

            e.Result = vc;
            vc.CheckForNewVersion();
        }
Esempio n. 18
0
        private void Window_Opened(object sender, EventArgs e)
        {
            Height = _prefsShown ? 277 + 320 : 277;
            Width  = 504;

            if (Environment.OSVersion.Version.Major > 5 && ConfigManager.SettingsManager.LoadSetting("ControlCenter", "AeroWarning", true))
            {
                bool aeroEnabled;
                NativeMethods.DwmIsCompositionEnabled(out aeroEnabled);
                if (!aeroEnabled)
                {
                    AeroWarning warningDialog = new AeroWarning();
                    warningDialog.Owner = this;
                    warningDialog.ShowDialog();

                    if (warningDialog.DisplayAgainCheckbox.IsChecked == true)
                    {
                        ConfigManager.SettingsManager.SaveSetting("ControlCenter", "AeroWarning", false);
                    }
                }
            }


            App app = Application.Current as App;

            if (app != null && app.StartupProfile != null && File.Exists(app.StartupProfile))
            {
                LoadProfileList(app.StartupProfile);
                LoadProfile(app.StartupProfile);
                StartProfile();
            }

            VersionChecker.CheckVersion();
        }
    void Configure(ConfigureWindowModel model, Project project)
    {
        var directoryInfo = fullPathResolver.GetFullPath(model.ToolsDirectory, project);
        var targetFile    = new FileInfo(Path.Combine(directoryInfo.FullName, "NotifyPropertyWeaverMsBuildTask.dll"));

        if (!targetFile.Exists || VersionChecker.IsVersionNewer(targetFile))
        {
            if (!fileExporter.ExportTask(directoryInfo))
            {
                taskFileReplacer.AddFile(directoryInfo);
            }
        }

        if (model.IncludeAttributeAssembly)
        {
            var frameworkType = FrameworkTypeReader.GetFrameworkType(project.FullName);
            fileExporter.ExportAttribute(fullPathResolver.GetFullPath(model.DependenciesDirectory, project), frameworkType);
        }

        var defaulter       = new Defaulter();
        var projectInjector = new NotifyPropertyWeaverProjectInjector
        {
            ProjectFile = project.FullName
        };

        defaulter.FromModel(projectInjector, model);
        projectInjector.Execute();
    }
Esempio n. 20
0
        private async void afterActions()
        {
            try
            {
                await Client.Current.RefreshCookiesAsync();
            }
            catch (Exception)
            {
                //Ignore exceptions here.
            }
            try
            {
                var ver = await VersionChecker.CheckAsync();

                if (ver is VersionChecker.GitHubRelease v)
                {
                    var dialog = new UpdateDialog(v);
                    await dialog.ShowAsync();
                }
            }
            catch (Exception)
            {
                //Ignore exceptions here.
            }
            try
            {
                await ExClient.HentaiVerse.HentaiVerseInfo.FetchAsync();
            }
            catch (Exception)
            {
                //Ignore exceptions here.
            }
            try
            {
                if (await EhTagTranslatorClient.Client.NeedUpdateAsync())
                {
                    AboutControl.UpdateETT.Execute();
                }
            }
            catch (Exception)
            {
                RootControl.RootController.SendToast(Strings.Resources.Database.EhTagTranslatorClient.Update.Failed, null);
            }
            if (DateTimeOffset.Now - EhTagClient.Client.LastUpdate > new TimeSpan(7, 0, 0, 0))
            {
                AboutControl.UpdateEhWiki.Execute();
            }
            if (DateTimeOffset.Now - BannerProvider.Provider.LastUpdate > new TimeSpan(7, 0, 0, 0))
            {
                try
                {
                    await BannerProvider.Provider.FetchBanners();
                }
                catch (Exception)
                {
                    //Ignore exceptions here.
                }
            }
        }
Esempio n. 21
0
        // Method invoked when the user requests to download the latest update
        public async void DownloadNewVersion(object sender, EventArgs e)
        {
            mnuNewVersion.Enabled        = false;
            stripUpdateProgress.Visible  = true;
            stripUpdateProgress.AutoSize = true;

            await VersionChecker.DownloadUpdate(stripNewVersion.Tag as VersionChecker.VersionState, Core.UserDownloadsPath, DownloadProgressUpdated, DownloadComplete).ConfigureAwait(false);
        }
        public void DbExistsChecks()
        {
            CreateVersionChecker();

            VersionChecker.CheckAndUpdate();

            FileSystemServiceMock.Verify(fss => fss.CheckFileExists(DbService.DatabaseName), Times.Once);
        }
 public AboutWindowViewModel(AboutWindow view)
 {
     this.view = view;
     applicationInformation = new ApplicationInformation();
     versionChecker = new VersionChecker(view, true);
     versionChecker.TaskFinished += VersionCheckerTaskFinished;
     CreateCommands();
 }
Esempio n. 24
0
        public void GetServerVersionIdShouldReturnExactlyFourCharacters()
        {
            var versionChecker = new VersionChecker(string.Empty);
            var serverVersion  = versionChecker.GetServerVersionId();

            Console.WriteLine(serverVersion);
            Assert.AreEqual(4, serverVersion.Length);
        }
Esempio n. 25
0
        public void Test_ThisVersionIsUpToDate()
        {
            var c = new VersionChecker();

            Console.WriteLine("Current version is " + c.CurrentVersion());
            Console.WriteLine("Latest version is " + c.LatestVersion());
            Assert.IsTrue(c.ThisVersionIsUpToDate());
        }
Esempio n. 26
0
        public void Test_VersionChecker_VersionIsNotZero()
        {
            // can't confirm what version to test platform has
            Version ver = VersionChecker.GetDotnetVersion();

            Assert.NotNull(ver);
            Assert.NotZero(ver.Major);
        }
Esempio n. 27
0
        public void Test_VersionChecker_DoesNotCrashOrReturnNull()
        {
            // can't confirm what version to test platform has
            string output = VersionChecker.GetConsoleOutput("dotnet --version");

            Console.WriteLine(output);
            Assert.NotNull(output);
        }
        public async Task <IActionResult> EntryPlayer([FromBody] EntryPlayer.Request req)
        {
            if (req.pingResults != null)
            {
                var results = new List <LogModels.PingResults.Result>();
                foreach (var pingResult in req.pingResults)
                {
                    results.Add(new LogModels.PingResults.Result
                    {
                        regionCode = pingResult.regionCode,
                        time       = pingResult.time,
                    });
                }

                Logger.Logging(
                    new LogObj().AddChild(new LogModels.PingResults
                {
                    PlayerId = SelfHost.playerInfo.playerId,
                    Results  = results,
                })
                    );
            }


            if (!VersionChecker.Get(VersionChecker.CheckTarget.EnabledMatchmake).Check())
            {
                return(BuildErrorResponse(Error.LowCode.DisabledMatchmake));
            }

            var requester = new evomatching.ProtocolModels.Matching.EntryPlayer();

            requester.request.playerId  = SelfHost.playerInfo.playerId;
            requester.request.matchType = req.matchType.Value;
            var response = await requester.PostAsyncXXX(MatchingServerInfo.AreaUri(SelfHost.matchingArea));

            if (response.StatusCode != System.Net.HttpStatusCode.OK)
            {
                return(BuildErrorResponse(Error.LowCode.ServerInternalError));
            }

            switch (response.Payload.resultCode)
            {
            case evomatching.ProtocolModels.Matching.EntryPlayer.Response.ResultCode.Ok:
                return(Ok(new EntryPlayer.Response()));

            case evomatching.ProtocolModels.Matching.EntryPlayer.Response.ResultCode.OldPackageVersion:
                return(BuildErrorResponse(Error.LowCode.NgPackageVersion));

            case evomatching.ProtocolModels.Matching.EntryPlayer.Response.ResultCode.SendedPgInvitation:
                return(BuildErrorResponse(Error.LowCode.SentPgInvitation));

            case evomatching.ProtocolModels.Matching.EntryPlayer.Response.ResultCode.RecievedPgInvitation:
                return(BuildErrorResponse(Error.LowCode.RecievedPgInvitation));

            default:
                return(BuildErrorResponse(Error.LowCode.CouldNotMatchingEnty));
            }
        }
        protected override void OnStartup(StartupEventArgs e)
        {
            VersionChecker.CheckVersion("v0.9");

            Current.DispatcherUnhandledException += new DispatcherUnhandledExceptionEventHandler(DispatcherUnhandledExceptionHandler);

            _config = new DependencyInjectionConfig();
            _config.ShowMainWindow();
        }
Esempio n. 30
0
        void FillNewerVersionAvailable(PSObject result)
        {
            var versionAvailable = VersionChecker.GetAvailableVersion();

            if (versionAvailable != null && VersionChecker.IsNewer(versionAvailable))
            {
                AddProperty(result, "NewerVersionAvailable", versionAvailable.ToString());
            }
        }
Esempio n. 31
0
        public static void Main(string[] args)
        {
            Application.Init ();
            MainWindow win = new MainWindow ();
            VersionChecker vc = new VersionChecker ();

            win.ShowAll();
            Application.Run ();
        }
        public void SimpleTest()
        {
            var vc = new VersionChecker();
            var v = vc.GetNewestVersion();
            if (v == null)
            {
                // The internet is not available.
                return;
            }

            Assert.That(v, Is.EqualTo(new Version(0, 4)), "Test is not up to date");
        }
        public void TestDialog()
        {
            var xmlData = "<cherrytomatoVersionHistory>" +
                "<version major=\"0\" minor=\"2\">" +
                "<comment>First release</comment>" +
                "</version>" +
                "</cherrytomatoVersionHistory>";

            var currentVersion = new Version(0, 1);

            var vc = new VersionChecker(xmlData, currentVersion);
            vc.CheckNewestVersion(new Version(0, 1));
        }
Esempio n. 34
0
        public void CheckForNewVersion()
        {
            //NewVersionAvailable
            try
            {
                VersionChecker vcReleasedPageStripper = new VersionChecker("Pulse", new RssFeedReleases());

                //get the release record for the version installed on the client
                Release client = vcReleasedPageStripper.GetReleaseByName(string.Format("Pulse {0}",
                                        System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString()));

                //if we weren't able to find the current version then return
                if (client == null) return;

                //get the default release
                Release defaultRelease = vcReleasedPageStripper.GetDefaultRelease();

                //compare against the version installed on client (logic is up to you)
                if (defaultRelease.ReleaseDate > client.ReleaseDate)
                {
                    //Notify user of upgrade
                    if (NewVersionAvailable != null)
                        NewVersionAvailable(defaultRelease);
                }
            }
            catch (Exception ex)
            {
                Log.Logger.Write(string.Format("Error checking for new Pulse Versions: {0}", ex.ToString()), Log.LoggerLevels.Warnings);
            }
        }
Esempio n. 35
0
    public MainWindow()
        : base(Gtk.WindowType.Toplevel)
    {
        Build();
        //textview2.Visible=false;
        //endMark = textview2.Buffer.CreateMark("end-mark", textview2.Buffer.EndIter, false);

        string settingFile = System.IO.Path.Combine(MainClass.Paths.SettingDir, "moscrif.mss");
        if(!File.Exists(settingFile)){
            SetLabel("Setting file not found!");
            btnQuit.Visible = true;
            return;
        }
        try{
            Console.WriteLine(settingFile);
            XmlDocument xml = new XmlDocument();
            //xml.LoadXml(settingFile);
            StreamReader reader = new StreamReader(settingFile);

            xml.LoadXml(reader.ReadToEnd());

            XmlNodeList xnList = xml.SelectNodes("/Settings");

            filePublishPath= xnList[0].Attributes["publishDir"].Value ;
            fileLibsPath= xnList[0].Attributes["frameworkDir"].Value ;
            fileEmulatorPath= xnList[0].Attributes["emulatorDir"].Value ;
        } catch(Exception ex){
            Console.WriteLine(ex.Message);
            SetLabel("Setting file is corrupted");
            btnQuit.Visible = true;
            return;
        }

        //timer.Interval = 250;
        //timer.Elapsed += new ElapsedEventHandler(OnTimeElapsed);
        ZipConstants.DefaultCodePage = Encoding.UTF8.CodePage;

        /*for (int i = 0; i < args.Length; i++){
            WriteMesage(args[i]);
        }*/

        /*if (!MainClass.Auto){
            messageLabel.LabelProp = "ERROR.";
            WriteMesage("Incorect parameter.");
            return;
        }*/

        //tag = new TextTag("0");
        if(MainClass.Platform.IsWindows){
            WriteMesage("Process -->");
            Process []pArry = Process.GetProcesses();
            foreach(Process p in pArry)
            {
                string s = p.ProcessName;
                s = s.ToLower();

                WriteMesage("\t"+s);
                if (s.CompareTo("moscrif-ide") ==0){

                    try{
                        p.Kill();
                    } catch{
                        SetLabel("Moscrif IDE is already running!");
                        btnQuit.Visible = true;
                        return;
                    }
                }
            }
        }

        string moscriftIdePath = System.IO.Path.Combine(MainClass.Paths.AppPath, "moscrif-ide.exe");

        if (!System.IO.File.Exists(moscriftIdePath)){
            SetLabel("Moscrif IDE not found!");
            btnQuit.Visible = true;
            return;
        }
        string version = "";

        FileVersionInfo moFI = FileVersionInfo.GetVersionInfo(moscriftIdePath);

        VersionChecker vers = new VersionChecker();

        if (moFI== null){
            WriteMesage("ERROR: Unknown version.");
            btnQuit.Visible = true;
            return;
        } else {
            version = moFI.FileVersion;
            string[] versions = version.Split('.');
            if (versions.Length != 4){
                WriteMesage("ERROR: Invalid Version.");
                btnQuit.Visible = true;
                return;
            }
            string webVersion = vers.VersionConverter(version);

            WriteMesage("Old Version "+ webVersion);
            //return;
        }
        string newVersion;
        string message ;
        try{
            if(!String.IsNullOrEmpty(MainClass.Token) )
                message = vers.CheckVersionSynch(version,MainClass.Token,out newVersion,false,test);
            else
                message = vers.CheckVersionSynch(version,"",out newVersion,false,test);
        }catch(Exception ex){
            SetLabel(ex.Message);
            WriteMesage(ex.Message);
            btnQuit.Visible = true;
            return;
        }
        bool nextVersion = true;

        while(nextVersion){
            nextVersion = false;
            newVersion = System.IO.Path.GetFileNameWithoutExtension(newVersion);

            if(String.IsNullOrEmpty(newVersion) ){
                SetLabel("Your version is up-to-date.");
                WriteMesage( message);
                btnQuit.Visible = true;
                return;
            }

            WriteMesage( message);
            WriteMesage("New Version "+ newVersion);
            //pd = new ProgressDialog("Download",ProgressDialog.CancelButtonType.None,1,null);//MainClass.MainWindow
            Reset(1,"Downloading version : " + newVersion);
            string fullpath = System.IO.Path.Combine(MainClass.Paths.TempDir,newVersion+".zip");//Temp
            //timer.Start();
        //		data = null;
            //Stream str ;
            isFinish = false;
            isError = false;
            try{
                if(!String.IsNullOrEmpty(MainClass.Token) ){
                    //vers.GetVersionSynch(newVersion,MainClass.Token,out str);
                    GetVersionAsynch(newVersion,MainClass.Token,fullpath,test);
                    //	GetVersionHandler
                }
                else
                    GetVersionAsynch(newVersion,"",fullpath,test);

                int indx = 0;
                while (!isFinish)//(client.IsBusy)
                    {
                        //progressBar.Text=indx.ToString();
                    AutomaticUpdate();
                    indx++;
                    while (Application.EventsPending ())
                        Application.RunIteration ();
                    Thread.Sleep(150);
                    }

            } catch(Exception ex){
                SetLabel(ex.Message);
                WriteMesage(ex.Message);
                //timer.Enabled = false;
                //timer.Stop();
                btnQuit.Visible = true;
                return;
            }
            if((!File.Exists(fullpath)) || (isError)){
                WriteMesage("Error downloading file.");
                SetLabel("Error downloading file!");
                //timer.Enabled = false;
                //timer.Stop();
                btnQuit.Visible = true;
                //if(pd != null) pd.Destroy();
                return;
            }
            /*if (data!= null){	//str
                FileStream writeStream = new FileStream(fullpath, FileMode.Create, FileAccess.Write);
                Copy(data,writeStream);
                writeStream.Close();
                writeStream.Dispose();
            } else {
                WriteMesage("Error downloading file.");
                SetLabel("Error downloading file!");
                timer.Enabled = false;
                timer.Stop();
                btnQuit.Visible = true;
                //if(pd != null) pd.Destroy();
                return;
            }*/
            //timer.Enabled = false;
                //timer.Stop();
            //if(pd != null) pd.Destroy();
            Reset(1,"Download Finish");

            string outputPath = System.IO.Path.Combine(MainClass.Paths.Temp,newVersion);

            if(!Directory.Exists(outputPath)){

                try{
                    Directory.CreateDirectory(outputPath);
                }catch{
                    SetLabel("Error creating output directory!");
                    WriteMesage("ERROR: FILE CANNOT BY CREATE.");
                    btnQuit.Visible = true;
                    return;
                }
            }

            List<string> listFile = new List<string>();
            try{
                listFile = UnzipFile(fullpath,outputPath);
            } catch{
                SetLabel("Error unpacking new version!");
                WriteMesage("ERROR:FILE CANNOT BY UNPACK.");
                btnQuit.Visible = true;
                return;
            }
            Console.WriteLine("btnQuit.Visible 4 -> {0}",btnQuit.Visible);
            if ((listFile == null) || (listFile.Count<1)){
                SetLabel("Error unpacking new version!");
                WriteMesage("ERROR:FILE CANNOT BY UNPACK.");
                btnQuit.Visible = true;
                return;
            }
            Console.WriteLine("btnQuit.Visible 5 -> {0}",btnQuit.Visible);
            foreach(string file in listFile){

                string fileName = System.IO.Path.GetFileName(file).ToLower();
                string fileNameWE = System.IO.Path.GetFileNameWithoutExtension(file).ToLower();
                string fileOutputPath =	"";

                switch (fileName){

                    case "emu.win.zip":
                        if (MainClass.Platform.IsWindows){
                            fileOutputPath = fileEmulatorPath;
                        } else continue;
                        break;
                    case "emu.mac.zip":
                        if (MainClass.Platform.IsMac){
                            fileOutputPath = fileEmulatorPath;
                        } else continue;
                        break;
                    case "emu.lin.zip":
                        if (MainClass.Platform.IsX11){
                            fileOutputPath = fileEmulatorPath;
                        } else continue;
                        break;
                        case "ide.zip":
                            fileOutputPath = MainClass.Paths.AppPath;
                            break;
                        case "lib.zip":
                            fileOutputPath = fileLibsPath;
                            break;
                        /*case "pub.zip":
                            fileOutputPath = filePublishPath;
                            break;	*/
                    case "pub.win.zip":
                        if (MainClass.Platform.IsWindows){
                            fileOutputPath = filePublishPath;
                        } else continue;
                        break;
                    case "pub.mac.zip":
                        if (MainClass.Platform.IsMac){
                            fileOutputPath = filePublishPath;
                        } else continue;
                        break;
                    case "pub.lin.zip":
                        if (MainClass.Platform.IsX11){
                            fileOutputPath = filePublishPath;
                        } else continue;
                        break;

                        case "sam.zip":
                            fileOutputPath = MainClass.Paths.SampleDir;
                            break;
                    default:
                        fileOutputPath =System.IO.Path.Combine(MainClass.Paths.AppPath,fileNameWE);
                        break;
                }
                WriteMesage("fileName :"+file);
                try{
                    UnzipFile(file,fileOutputPath);
                    if (cancelUnpack){
                        WriteMesage("SKIP ");
                        goto nav;
                    }

                }catch (Exception ex) {
                    WriteMesage("Error unpacking file: "+ex.Message);
                    SetLabel("Error unpacking file '"+file + "'!");
                }
            }

            string fixVersion = "";
            if(newVersion.Length == 7)
                fixVersion = newVersion[6].ToString();

            string versionPath = System.IO.Path.Combine(MainClass.Paths.AppPath,"version.txt");

            using (StreamWriter fileVersion = new StreamWriter(versionPath)) {
                fileVersion.Write(fixVersion);
                fileVersion.Close();
                fileVersion.Dispose();
            }

            nav:;
            try{
                WriteMesage("Delete temp file.");
                SetLabel("Deleting temporary files.");
                System.IO.File.Delete(fullpath);
                System.IO.Directory.Delete(outputPath,true);
            }catch{

            }

            try{
                version = newVersion;
                Console.WriteLine("newVersion -> {0}",newVersion);
                Console.WriteLine("version -> {0}",version);
                if(!String.IsNullOrEmpty(MainClass.Token) )
                    message = vers.CheckVersionSynch(version,MainClass.Token,out newVersion,true,test);
                else
                    message = vers.CheckVersionSynch(version,"",out newVersion,true,test);

                if(String.IsNullOrEmpty(newVersion) ){
                    nextVersion = false;
                } else {
                    nextVersion = true;
                }

            }catch{//(Exception ex){
                //SetLabel(ex.Message);
                //WriteMesage(ex.Message);
                //btnQuit.Visible = true;
                //return;
                nextVersion = false;
            }
        }

        btnQuit.Visible = true;
        SetLabel("Update is completed.");
    }