private async void CheckForUpdates(bool silent)
{
miUpdateVersion.Enabled = false;
VersionResponse oldVersion = Configs.Instance.UpdateHelper.UpdateAvailable;
await Task.Run(() => Configs.Instance.UpdateHelper.CheckForUpdates());
VersionResponse version = Configs.Instance.UpdateHelper.UpdateAvailable;
miUpdateVersion.Enabled = true;
if (version == null || version == oldVersion)
{
miUpdateVersion.Text = "Check for Updates";
if (!silent)
{
MessageBox.Show(this, $"You are using an actual version of the {APP_TITLE}.", "Update Check", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
return;
}
miUpdateVersion.Text = $"Update to {version.Version}...";
if (TaskDialogHelper.ShowTaskDialog(
Handle,
"Update is Available",
"The Obfuscar Mapping Parser update is available. Update now?",
version.Description,
TaskDialogStandardIcon.Information,
new string[] { "Update now", "Don't update" },
null,
new TaskDialogResult[] { TaskDialogResult.Yes, TaskDialogResult.No }
) == TaskDialogResult.Yes)
{
DoUpdateVersion();
}
}
public void СheckForNewVersion()
{
try
{
string v = response.Params.Version;
string pack = _http.GetContent(globalVars.host + "/api/?method=version");
VersionResponse m = JsonConvert.DeserializeObject <VersionResponse>(pack);
string ver = m.version;
globalVars.link = m.link;
if (v == ver)
{
linkLabelUpdate.Visible = false;
}
else
{
linkLabelUpdate.Visible = true;
linkLabelUpdate.Text = "Upgrade to v" + ver;
try
{
Process.Start("launcher_informer.exe");
}
catch (Exception ex)
{
_error.writeLogLine("Start launcher " + ex.Message, "error");
}
}
}
catch (Exception ex)
{
_error.writeLogLine("CheckNewVersion " + ex.Message, "error");
}
}
protected void ConnectButton_OnClick(object sender, EventArgs e)
{
ResultLabel.Text = null;
ErrorLabel.Text = null;
string host = ServerAddressTextBox.Text.Trim();
ushort port = Convert.ToUInt16(ServerPortTextBox.Text);
try
{
using (QueryRunner queryRunner = new QueryRunner(new SyncTcpDispatcher(host, port))) // host and port
{
// connection to the TS3-Server is established with the first query command
VersionResponse versionResponse = queryRunner.GetVersion();
if (versionResponse.IsErroneous)
{
ErrorLabel.Text = "Could not get server version: " + versionResponse.ErrorMessage;
return;
}
ResultLabel.Text = string.Format("Server version:<br>Platform: {0}<br>Version: {1}<br>Build: {2}", versionResponse.Platform, versionResponse.Version, versionResponse.Build);
}
}
catch (Exception ex)
{
ErrorLabel.Text = ex.Message;
}
}
/// <summary>
/// Handles returning information about space/bytes usage of the database.
/// </summary>
/// <param name="shandler"></param>
/// <param name="request"></param>
/// <param name="body"></param>
/// <param name="encoder"></param>
/// <returns></returns>
public static async Task <Task> Action(ServerHandler shandler, HTTPRequest request, Stream body, IProxyHTTPEncoder encoder)
{
var buf = new byte[512];
int cnt;
do
{
cnt = await body.ReadAsync(buf, 0, buf.Length);
} while (cnt > 0);
InternalVersonInfo ver_info;
using (var strm = Assembly.GetExecutingAssembly().GetManifestResourceStream("MDACSDatabase.buildinfo.json"))
{
var json_data = await new StreamReader(strm).ReadToEndAsync();
ver_info = JsonConvert.DeserializeObject <InternalVersonInfo>(json_data);
}
var resp = new VersionResponse()
{
version = ver_info.version,
};
await encoder.WriteQuickHeader(200, "OK");
await encoder.BodyWriteSingleChunk(JsonConvert.SerializeObject(resp));
return(Task.CompletedTask);
}
public static string GetVersion( )
{
try
{
string stdout_contents;
string stderr_contents;
if( !ProcessUtilities.InvokeExe( NonCancellable.Instance, GetClientExePath( ), null, @"{""cmd"":""v""}", out stdout_contents, out stderr_contents, EncodingEnum.UTF8 ) )
{
return null;
}
if( !string.IsNullOrWhiteSpace( stderr_contents ) )
{
throw new Exception( stderr_contents );
}
VersionResponse response = JsonSerializer.Deserialize<VersionResponse>( stdout_contents );
return $"{response.v.Major}.{response.v.Minor}.{response.v.Build}";
}
catch( Exception exc )
{
_ = exc;
if( Debugger.IsAttached ) Debugger.Break( );
return null;
}
}
public async void CheckVersion()
{
try
{
if (!alreadyChecked)
{
AssureVersion();
var myVersion = VersionUtils.getVersion();
var config = DB.Instance.GetConfig();
alreadyChecked = true;
VersionResponse checkVersion = await _irpyteDownloader.CheckVersion(currentVersion);
var newVersionStatus =
new NewVersionStatus(checkVersion.newestVersion, checkVersion.needToUpdate,
checkVersion.url, myVersion);
config.NewVersionStatus = newVersionStatus;
logger.Info("NewVersionStatus: " + newVersionStatus);
DB.Instance.UpdateConfig(config);
}
}
catch (Exception e)
{
logger.Error(e, "Couldn't check version");
}
}
public static void CheckUpdate(object state)
{
try
{
if (!StateCenter.Instance.HasRepalced || !StateCenter.Instance.HasRunDynCoded)
{
ModifierDelegate("【修改线程】 等待客户端空闲替换下载好的文件");
return;
}
SelfUpdater.UpdateSelf();
ModifierDelegate("【修改线程】 开始请求");
var url = $"{UserConfigInstance.Instance.Config.ServerUrl}/api/RequestNewestPackageUrl/{UserConfigInstance.Instance.Config.HospitalID}/{UserConfigInstance.Instance.Config.TerminalVersion}";
VersionResponse = HttpHelper.Comunication <VersionResponse>(url);
JudgeDynamicCodeVersion();
if (VersionResponse.Success)
{
DownLoad(VersionResponse.Data.FilePath);
_autoResetEvent.WaitOne();
}
else
{
ModifierDelegate($"【修改线程】 请求结束：{VersionResponse.Msg}");
}
}
catch (Exception ex)
{
LogHelper.Instance.Logger.Info($"【修改线程】 请求结束：{ex.Message}");
ModifierDelegate($"【修改线程】 请求结束：{ex.Message}");
}
}
public static VersionInfo From(VersionResponse response)
{
return(new VersionInfo {
Version = response.Version,
EnabledFeatures = response.EnabledFeatures
});
}
public HttpResponseMessage Get()
{
VersionResponse result = GetSpecificVersion(WebAppVersionSettings.VERSION,
WebAppVersionSettings.GUID,
WebAppVersionSettings.PATH);
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
private IPEndPoint ConnectToDispathServer()
{
MessengerSocket socketP = new MessengerSocket();
//socket.AutoFlush = false;
#region Request
//Request this Data!
PackageRequest[] request = new PackageRequest[]
{
new VersionRequest(),
new MachineInfoRequest(this.Account),
new AuthenticationRequest(this.Account)
};
//Get responses from the server!
Dictionary <int, PackageTransaction> responses = socketP.SendRangeAndBlock(request);
#endregion
#region Parse Responses if Any
//Agora que temos as respostas vamos verificar se estão correctas!
//Seja em quantidade, seja em 'qualidade'...
if (responses.Count != 3)
{
throw new MessengerException("Unable to receive one or more responses from the server");
}
//Responses!
VersionResponse version = responses[request[0].TransactionID].Response as VersionResponse;
MachineInfoResponse machine = responses[request[1].TransactionID].Response as MachineInfoResponse;
DispatchServerRedirectionResponse redirection = responses[request[2].TransactionID].Response as DispatchServerRedirectionResponse;
//Verificar se recebemos as respostas certas!
version.NotNull <VersionResponse, MessengerProtocolException>("Unexpected response");
machine.NotNull <MachineInfoResponse, MessengerProtocolException>("Unexpected response");
redirection.NotNull <DispatchServerRedirectionResponse, MessengerProtocolException>("Unexpected response");
//Verificar se é uma versão suportada do protocolo!
version.Protocols.MustContainElement <string, MessengerProtocolException>("MSNP15", "Unsupported Protocol");
//Verificar se o nosso cliente ainda é aceitável!
if ((request[1] as MachineInfoRequest).ClientVersion < machine.MinimumSafeVersion)
{
//Ignore! We are not a client! We are just the libraries!
//throw new Exception("Unsupported client");
}
#endregion
return(redirection.Host);
}
public Objects.Version VerifyVersion()
{
Endpoint p = ConnectionStrings.Endpoints["version"].Clone();
String version = (ConfigurationManager.AppSettings["version"] != null) ? ConfigurationManager.AppSettings["version"] : "0.3";
p.Path = p.Path.Replace("{version}", version);
VersionResponse response = connection.Send <VersionResponse>(p);
return(response.Version);
}
public VersionResponse GetVersionNumber()
{
var Request = new RestRequest("auth/app_version", Method.GET);
Request.AddHeader("Accept-Language", this.Language);
Request.AddHeader("Authorization", string.Format("Bearer {0}", this.AccessToken));
var Response = this.Client.Execute(Request);
VersionResponse ResponseObject = JsonConvert.DeserializeObject <VersionResponse>(Response.Content);
ResponseObject.HttpResponse = Response;
return(ResponseObject);
}
private async void InitData()
{
Task task = new Task(() => {
EventAggregatorRepository.EventAggregator.GetEvent <SettingWindowBusyIndicatorEvent>().Publish(new AppBusyIndicator {
IsBusy = true
});
try
{
string version = FileVersionInfo.GetVersionInfo(System.Reflection.Assembly.GetEntryAssembly().Location).ProductVersion;
viewModel.CurrentVersionInfo = version;
viewModel.CurrentVersionTimeInfo = System.IO.File.GetLastWriteTime(System.Reflection.Assembly.GetEntryAssembly().Location).ToString("yyyy.MM.dd");
APIService service = new APIService();
VersionResponse versionResponse = service.GetVersionInfo();
if (versionResponse != null && !string.IsNullOrEmpty(versionResponse.latestClient))
{
viewModel.NewVersionInfo = versionResponse.latestClient;
if (versionResponse.descriptionInfos != null)
{
foreach (var itemInfo in versionResponse.descriptionInfos)
{
Dispatcher.Invoke(new Action(() => {
viewModel.DiscriptionInfos.Add(new CheckWordModel.VersionInfo {
DiscriptionInfo = itemInfo
});
}));
}
}
if (versionResponse.time != null)
{
viewModel.NewVersionTimeInfo = versionResponse.time.ToString("yyyy.MM.dd");
}
if (new Version(viewModel.NewVersionInfo) > new Version(version))
{
viewModel.UpdateBtnVisibility = Visibility.Visible;
viewModel.UpdateTipsVisibility = Visibility.Collapsed;
}
}
else
{
EventAggregatorRepository.EventAggregator.GetEvent <SendNotifyMessageEvent>().Publish("60020");
}
}
catch (Exception ex)
{ }
System.Threading.Thread.Sleep(500);
EventAggregatorRepository.EventAggregator.GetEvent <SettingWindowBusyIndicatorEvent>().Publish(new AppBusyIndicator {
IsBusy = false
});
});
task.Start();
await task;
}
public IActionResult GetVersionNumber(
)
{
VersionResponse Result = VisualInspection.GetVersionNumber();
ViewData["HttpResponse"] = "Status code: " + (int)Result.HttpResponse.StatusCode + " " + Result.HttpResponse.StatusCode;
ViewData["StringMessage"] = Result.HttpResponse.Content;
ViewBag.BearerAvailable = VisualInspection.IsAuthorized;
ViewBag.Active = "getVersionNumber";
return(Index());
}
public ActionResult Post([FromBody] VersionQuery query)
{
_logger.LogInformation("Version Api {0}, Version App {1}", query.ApiVersion.ToString(), query.AppVersion.ToString());
var result = new VersionResponse
{
ApiVersion = new Version(1, 0, 0, 0),
ServerVersion = Assembly.GetExecutingAssembly().GetName().Version,
DeviceVersion = new Version(0, 0, 0, 2) ///TODO: Get Version from device
};
return(Ok(result));
}
private void QueryDispatcher_ReadyForSendingCommands(object sender, System.EventArgs e)
{
// you can only run commands on the queryrunner when this event has been raised first!
QueryRunner = new QueryRunner(QueryDispatcher);
VersionResponse versionResponse = QueryRunner.GetVersion();
if (versionResponse.IsErroneous)
{
Console.WriteLine("Could not get server version: " + versionResponse.ErrorMessage);
return;
}
Console.WriteLine("Server version:\n\nPlatform: {0}\nVersion: {1}\nBuild: {2}", versionResponse.Platform, versionResponse.Version, versionResponse.Build);
}
private void QueryDispatcher_ReadyForSendingCommands(object sender, EventArgs e)
{
UpdateUI(ConnectionState.Connected);
// you can only run commands on the queryrunner when this event has been raised first!
QueryRunner = new QueryRunner(QueryDispatcher);
VersionResponse versionResponse = QueryRunner.GetVersion();
if (versionResponse.IsErroneous)
{
MessageBox.Show("Could not get server version: " + versionResponse.ErrorMessage);
return;
}
MessageBox.Show(string.Format("Server version:\n\nPlatform: {0}\nVersion: {1}\nBuild: {2}", versionResponse.Platform, versionResponse.Version, versionResponse.Build));
}
public VersionResponse GetVersion()
{
// Our return value:
VersionResponse version = new VersionResponse();
// Try to get the assembly version information:
version.AssemblyVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
// Try to get the build.html file if it's in the same directory:
if (File.Exists(System.AppDomain.CurrentDomain.BaseDirectory + "build.html"))
{
version.BuildHtml = File.ReadAllText(System.AppDomain.CurrentDomain.BaseDirectory + "build.html").Trim();
}
return(version);
}
public void Success()
{
Console.WriteLine("Success Start");
var JsonString = File.ReadAllText("../../../Files/GetVersionNumber.txt");
var Client = MockGenerator.MockRestClient <ItemsResponse>(HttpStatusCode.OK, JsonString);
HacarusVisualInspection VisualInspection = new HacarusVisualInspection(Client);
VersionResponse Response = VisualInspection.GetVersionNumber();
Assert.IsNotNull(Response);
Assert.IsNotNull(Response.HttpResponse);
Assert.IsNotNull(Response.VersionNumber);
Assert.IsNull(Response.Errors);
Assert.IsTrue(Response.HttpResponse.StatusCode.Equals(HttpStatusCode.OK));
Assert.IsTrue(Response.VersionNumber.Equals("1.0.0.0"));
Console.WriteLine("Success End");
}
public void GetVersionResponse_Can_Get_Output()
{
//Arrange
var versionResponse = new VersionResponse {
Version = "1.2.3.4"
};
var commandContext = TestCommandHelpers.GenerateCliResponseCommandContext(_testScheduler);
var getVersionCommand = new GetVersionCommand(commandContext, Substitute.For <ILogger>());
//Act
TestCommandHelpers.GenerateResponse(commandContext, versionResponse);
_testScheduler.Start();
//Assert
commandContext.UserOutput.Received(1).WriteLine(versionResponse.ToJsonString());
}
public async Task <bool> CheckUpdateAvailableAsync()
{
//1. Get current version
//2. Get address
//3. Make a call to the json
CancellationToken cancellationToken = new CancellationToken();
AuthenticationHeaderValue authenticationHeaderValue = new AuthenticationHeaderValue(BEARER_TOKEN_NAME, _AutoUpdateComponent.BearerToken);
string url = _AutoUpdateComponent.SourceUrl.EndsWith("/", StringComparison.OrdinalIgnoreCase) ? _AutoUpdateComponent.SourceUrl : _AutoUpdateComponent.SourceUrl + "/";
_VersionResponse = await Loader.LoadAsync <VersionResponse>(cancellationToken, authenticationHeaderValue, HttpMethod.Get, null, url + VERSION_JSON);
Version versionCurrentComponent = new Version(_AutoUpdateComponent.Version);
_VersionServerComponent = new Version(_VersionResponse.TargetVersion);
//4. Compare versions
_NeedUpdate = _VersionServerComponent.CompareTo(versionCurrentComponent) > 0;
return(_NeedUpdate);
}
public async Task <VersionResponse> Version()
{
NotifyFunctionCalled();
await Task.Delay(100);
var result = new VersionResponse();
result.ApiVersion = new MyVersion {
Major = 1, Minor = 0, Revision = 0
};
result.DeviceVersion = new MyVersion {
Major = 1, Minor = 0, Revision = 1
};
result.ServerVersion = new MyVersion {
Major = 0, Minor = 0, Revision = 1
};
return(result);
}
public VersionResponse GetVersionInfo()
{
VersionResponse versionResponse = null;
try
{
string apiName = "version";
string resultStr = HttpHelper.HttpUrlGet(apiName, "GET");
CommonResponse resultResponse = JsonConvert.DeserializeObject <CommonResponse>(resultStr);
if (resultResponse.state)
{
versionResponse = JsonConvert.DeserializeObject <VersionResponse>(resultResponse.result);
}
}
catch (Exception ex)
{
WPFClientCheckWordUtil.Log.TextLog.SaveError(ex.Message);
}
return(versionResponse);
}
private void reader_ResponseReceived(Reader sender, ResponseReceivedEventArgs e)
{
string MethodeName = MethodBase.GetCurrentMethod().ToString();
if (e.Message is VersionResponse)
{
VersionResponse r = (VersionResponse)e.Message;
Console.WriteLine("Hardware version = " + r.HardwareVersion);
Console.WriteLine("Firmware version = " + r.FirmwareVersion);
}
else if (e.Message is RegionResponse)
{
RegionResponse r = (RegionResponse)e.Message;
Console.WriteLine("Region " + r.Region.ToString() + " set. Regions supported by this reader:");
foreach (Region region in r.SupportedRegions)
{
Console.WriteLine("- " + region.ToString());
}
}
}
private string[] GetAllPackageVersions()
{
string package = ResolverOptions["package"];
string url = _baseUrl + package + "/" + "index.json";
try
{
WebClient webClient = new WebClient();
Logger.LogVerbose($"GET {url}");
string json = webClient.DownloadString(url);
Logger.LogVerbose($"GET {url}");
VersionResponse response = JsonConvert.DeserializeObject <VersionResponse>(json);
return(response.Versions);
}
catch (Exception ex)
{
Logger.LogVerbose(ex.ToString());
return(null);
}
}
public string GetVersion()
{
string version = "";
try
{
string apiName = "version";
string resultStr = HttpHelper.HttpUrlGet(apiName, "GET");
VersionResponse resultInfo = JsonConvert.DeserializeObject <VersionResponse>(resultStr);
if (resultInfo != null)
{
version = resultInfo.version;
}
}
catch (Exception ex)
{
WPFClientCheckWordUtil.Log.TextLog.SaveError(ex.Message);
}
return(version);
}
public async Task SubscribeToResponse_Without_Response_Handler_Should_Throw_Exception()
{
var nodeRpcClientFactory = new RpcClientFactory(_channelFactory, _clientEventLoopGroupFactory,
new List <IRpcResponseObserver>());
var nodeRpcClient = await nodeRpcClientFactory.GetClientAsync(null, _rpcClientConfig);
var targetVersionResponse = new VersionResponse {
Version = "1.2.3.4"
};
var protocolMessage =
targetVersionResponse.ToProtocolMessage(_peerIdentifier, CorrelationId.GenerateCorrelationId());
var observerDto = new ObserverDto(_channelHandlerContext, protocolMessage);
Assert.Throws <ResponseHandlerDoesNotExistException>(() =>
{
_mockSocketReplySubject.OnNext(observerDto);
nodeRpcClient.SubscribeToResponse <VersionResponse>(response => { });
_testScheduler.Start();
});
}
private IEnumerator checkIsLatestVersion()
{
using (UnityWebRequest req = UnityWebRequest.Get(LATEST_VERSION_URL))
{
yield return(req.SendWebRequest());
if (req.isNetworkError)
{
Debug.LogWarning($"Unable to check for latest version: {req.error}");
}
else
{
VersionResponse version = JsonConvert.DeserializeObject <VersionResponse>(req.downloadHandler.text);
if (!string.IsNullOrEmpty(version.latest) && !isLatestVersion(version.latest))
{
NewVersionText.text =
$"A new version is available! Go to itch.io to download version {version.latest}";
}
}
}
}
public HttpResponseMessage Get(string id)
{
VersionResponse result;
if (id.ToLower() == "test")
{
result = GetSpecificVersion(WebAppVersionSettings.VERSION, WebAppVersionSettings.GUID, WebAppVersionSettings.PATH);
}
else if (id.ToLower() == "prod")
{
result = GetSpecificVersion(WebAppVersionSettings.VERSION, WebAppVersionSettings.GUID, WebAppVersionSettings.PATH);
}
else
{
result = new VersionResponse()
{
Version = "", GUID = "0", DownloadURL = ""
}
};
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
private IList <ContainerListResponse> FindContainer()
{
IList <ContainerListResponse> r = null;
try
{
using (DockerClient client = new DockerClientConfiguration(new Uri(m_DockerEndpoint)).CreateClient())
{
if (m_FirstConnection)
{
VersionResponse version = client.System.GetVersionAsync().Result;
LogMessage($"Connected to {version.Version}, api : {version.APIVersion}, arch: {version.Arch}, build: {version.BuildTime}, os: {version.Os}");
m_FirstConnection = false;
}
try
{
r = client.Containers.ListContainersAsync(
new ContainersListParameters {
All = true
}
).Result;
m_DockerPollingErrorCount = 0;
}
catch (Exception ex)
{
m_DockerPollingErrorCount++;
LogMessage($"Cannot connect to docker deamon: {ex.InnerException?.Message ?? ex.Message}", LogLevel.Error);
}
}
}
catch (Exception ex)
{
m_DockerPollingErrorCount++;
LogMessage($"Cannot connect to docker deamon: {ex.InnerException?.Message ?? ex.Message}", LogLevel.Error);
}
return(r);
}
private void HandleIncomingVersionRequest(Packet p)
{
VersionRequest req = WConvert.ToVersionRequest(p);
VersionResponse resp = new VersionResponse(req, "SoapBox Sample Client", this.GetType().Assembly.GetName().Version.ToString(), System.Environment.OSVersion.ToString());
this.Session.SendAndForget(resp);
}
