private void OnRegisteredAsPlayer(RegistrationResults result, Versioning serverVersion, int playerId, bool isServerMaster)
{
if (result == RegistrationResults.RegistrationSuccessful)
{
AddServerToLatest();
}
}
private void DisplayRegistrationFailMessage(RegistrationResults result, Versioning serverVersion)
{
string message = "*** You've FAILED registering !!!"; // defaulting
switch (result)
{
case RegistrationResults.IncompatibleVersion:
if (serverVersion != null)
{
message = String.Format("*** You've FAILED registering !!! Application incompatible with server version {0}.{1}", serverVersion.Major, serverVersion.Minor);
}
else
{
message = String.Format("*** You've FAILED registering !!! Application incompatible with unknown server version");
}
break;
case RegistrationResults.RegistrationFailedInvalidName:
message = "*** You've FAILED registering !!! Your name is not valid";
break;
case RegistrationResults.RegistrationFailedPlayerAlreadyExists:
message = "*** You've FAILED registering !!! A player with the same name is already registered";
break;
case RegistrationResults.RegistrationFailedTooManyPlayers:
message = "*** You've FAILED registering !!! Too many players already connected";
break;
case RegistrationResults.RegistrationFailedInvalidId:
message = "*** You've FAILED registering !!! Internal server problem";
break;
}
AddServerMessage(ChatColor.Red, message);
}
public async Task <RegistrationResults> postRegistration(Registrations registration)
{
RegistrationResults registrationResults = new RegistrationResults();
var uri = new Uri($"{urlWebServices}/pendaftarantgl/");
try
{
var jsonObj = JsonConvert.SerializeObject(registration);
var content = new StringContent(jsonObj,
Encoding.UTF8, "application/json");
var response = await client.PostAsync(uri, content);
if (!response.IsSuccessStatusCode)
{
throw new Exception("Gagal Registrasi Online");
}
else
{
var result = await response.Content.ReadAsStringAsync();
registrationResults = JsonConvert.DeserializeObject <RegistrationResults>(result);
return(registrationResults);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private void OnRegisteredAsSpectator(RegistrationResults result, Versioning serverVersion, int spectatorId)
{
if (result == RegistrationResults.RegistrationSuccessful)
{
AddServerToLatest();
}
}
private async void doRegistration()
{
registration = new Registrations();
registrationServices = new RegistrationServices();
registration.norm = Preferences.Get("noRM", "");
registration.tglreg = dtTglPeriksa.Date.ToShortDateString();
registration.kodedokter = App.KodeDokterRegis;
registration.kodeklinik = App.KodeKlinikRegis;
try
{
registrationResults = new RegistrationResults();
registrationResults = await registrationServices.postRegistration(registration);
}
catch (Exception ex)
{
await PopupNavigation.Instance.PushAsync(new DialogAlertCustom("Error", ex.Message));
}
if (registrationResults.response.ToString() == "gagal")
{
await PopupNavigation.Instance.PushAsync(new DialogAlertCustom("Warning", registrationResults.deskripsiresponse));
}
else
{
await PopupNavigation.Instance.PushAsync(new DialogAlertCustom("Sukses", registrationResults.deskripsiresponse));
}
}
private void OnRegisteredAsPlayer(RegistrationResults result, Versioning serverVersion, int playerId, bool isServerMaster)
{
if (result == RegistrationResults.RegistrationSuccessful)
{
PlayerId = playerId;
}
HasLost = false;
}
private void OnRegisteredAsSpectator(RegistrationResults result, Versioning serverVersion, int spectatorId)
{
if (result == RegistrationResults.RegistrationSuccessful)
{
Options = Client.Options;
IsGameNotStarted = !Client.IsGameStarted;
}
}
private void OnRegisteredAsPlayer(RegistrationResults result, Versioning serverVersion, int playerId, bool isServerMaster)
{
_isRegistered = Client.IsRegistered;
_isGameStarted = Client.IsGameStarted;
_isServerMaster = Client.IsServerMaster;
_isGamePaused = false;
UpdateEnabilityAndLabel();
//Client.ChangeTeam(Team);
}
private void OnRegisteredAsSpectator(RegistrationResults result, Versioning serverVersion, int spectatorId)
{
if (result == RegistrationResults.RegistrationSuccessful)
{
DisplayRegistrationSuccessfullMessage(serverVersion);
IsRegistered = true;
}
else
{
DisplayRegistrationFailMessage(result, serverVersion);
}
}
private void OnRegisteredAsPlayer(RegistrationResults result, Versioning serverVersion, int playerId, bool isServerMaster)
{
if (result == RegistrationResults.RegistrationSuccessful)
{
DisplayRegistrationSuccessfullMessage(serverVersion);
IsRegistered = true;
}
else
{
DisplayRegistrationFailMessage(result, serverVersion);
}
}
public RegistrationSuccessNewPatientForm(RegistrationResults registrationResults, NewPatientResults newPatientResults)
{
InitializeComponent();
this.registrationResults = registrationResults;
this.newPatientResults = newPatientResults;
TxtNoKTP.Text = newPatientResults.vc_no_ktp;
txtTgl.Text = registrationResults.tglreg;
txtNama.Text = newPatientResults.NamaPasien;
txtKlinik.Text = registrationResults.namaklinik;
txtDokter.Text = registrationResults.namadokter;
txtCatatan.Text = registrationResults.deskripsiresponse;
}
public void OnPlayerRegistered(RegistrationResults result, Versioning serverVersion, int playerId, bool gameStarted, bool isServerMaster, GameOptions options)
{
Log.Default.WriteLine(LogLevels.Info, "OnPlayerRegistered[{0}]:{1} => {2} {3} {4} | Version: {5}.{6}", PlayerName, result, playerId, gameStarted, isServerMaster, serverVersion == null ? -1 : serverVersion.Major, serverVersion == null ? -1 : serverVersion.Minor);
ResetTimeout();
if (result == RegistrationResults.RegistrationSuccessful)
{
PlayerId = playerId;
State = States.WaitingStartGame;
}
else
{
State = States.ApplicationStarted;
}
}
private void OnRegisteredAsPlayer(RegistrationResults result, Versioning serverVersion, int playerId, bool isServerMaster)
{
if (result == RegistrationResults.RegistrationSuccessful)
{
if (Client.IsServerMaster)
{
Client.ChangeOptions(Options);
}
else
{
Options = Client.Options;
}
IsGameNotStarted = !Client.IsGameStarted;
}
}
private void OnRegisteredAsSpectator(RegistrationResults result, Versioning serverVersion, int spectatorId)
{
if (result == RegistrationResults.RegistrationSuccessful)
{
IsRegistered = true;
PlayFieldViewModel = PlayFieldSpectatorViewModel;
OnPropertyChanged("PlayFieldViewModel");
if (ClientOptionsViewModel.Instance.AutomaticallySwitchToPartyLineOnRegistered)
{
if (ActiveTabItemIndex == ConnectionViewModel.TabIndex)
{
ActiveTabItemIndex = PartyLineViewModel.TabIndex;
}
}
}
}
private static string ParseRegistrationResultToMessage(RegistrationResults registrationResults)
{
switch (registrationResults)
{
case RegistrationResults.WrongCultureFromat:
return "has wrong format";
case RegistrationResults.JustRegistered:
return "registered successfully";
case RegistrationResults.JustUnregistered:
return "unregistered successfully";
case RegistrationResults.AlreadyRegistered:
return "wasn't registered because it already exists";
case RegistrationResults.AlreadyUnregistered:
return "wasn't unregistered because it already not exists or it's a base-culture which can't be unregistered";
default:
return registrationResults.ToString();
}
}
private void OnRegisteredAsSpectator(RegistrationResults result, Versioning serverVersion, int spectatorId)
{
if (result == RegistrationResults.RegistrationSuccessful)
{
string version = serverVersion == null ? "Unknown server version. Use at your own risk." : String.Format("Server version {0}.{1}", serverVersion.Major, serverVersion.Minor);
SetConnectionResultMessage(ChatColor.Green, "Registered as spectator {0}. {1}", spectatorId + 1, version);
}
else
{
string version = serverVersion == null ? "Unknown server version" : String.Format("Server version {0}.{1}", serverVersion.Major, serverVersion.Minor);
DescriptionAttribute attribute = EnumHelper.GetAttribute <DescriptionAttribute>(result);
Client.UnregisterAndDisconnect();
SetConnectionResultMessage(ChatColor.Red, "Registration failed: {0}. {1}", attribute == null ? result.ToString() : attribute.Description, version);
}
_isRegistered = Client.IsRegistered;
OnPropertyChanged("ConnectDisconnectLabel");
OnPropertyChanged("IsNotRegistered");
}
private async void prosesSimpan()
{
using (await MaterialDialog.Instance.LoadingDialogAsync(message: "Proses Simpan Pasien"))
{
try
{
newPatientResults = new NewPatientResults();
newPatientResults = await patientServices.postNewPatient(newPatient4);
}
catch (Exception ex)
{
await PopupNavigation.Instance.PushAsync(new DialogAlertCustom("Error", ex.Message));
}
if (!string.IsNullOrEmpty(newPatientResults.response))
{
if (newPatientResults.response.ToString() == "gagal")
{
await PopupNavigation.Instance.PushAsync(new DialogAlertCustom("Warning", newPatientResults.deskripsiresponse));
}
else
{
registrationResults = new RegistrationResults();
registrationResults = await registrationServices.postRegistrationNewPatient(newRegistration);
if (registrationResults.response.ToString() == ("ok"))
{
await Navigation.PushAsync(new RegistrationSuccessNewPatientForm(registrationResults, newPatientResults));
Navigation.RemovePage(this);
}
else
{
await PopupNavigation.Instance.PushAsync(new DialogAlertCustom("Peringatan", registrationResults.deskripsiresponse));
}
}
}
else
{
await PopupNavigation.Instance.PushAsync(new DialogAlertCustom("Warning", "Maaf Terjadi Kegagalan saat simpan, Mohon Dicoba Kembali"));
}
}
}
private void OnRegisteredAsPlayer(RegistrationResults result, Versioning serverVersion, int playerId, bool isServerMaster)
{
if (result == RegistrationResults.RegistrationSuccessful)
{
lock (_lock)
{
Console.ResetColor();
Console.SetCursorPosition(_client.Board.Width + 2 + BoardStartX, 1);
Console.Write("Registration succeeded -> {0}", playerId);
}
}
else
{
lock (_lock)
{
Console.ResetColor();
Console.SetCursorPosition(60, 1);
Console.Write("Registration failed!!! {0}. ServerVersion: {1}.{2}", result, serverVersion.Major, serverVersion.Minor);
}
}
}
public void OnPlayerRegistered(RegistrationResults result, Versioning clientVersion, int playerId, bool gameStarted, bool isServerMaster, GameOptions options)
{
throw new NotImplementedException();
}
public void OnSpectatorRegistered(RegistrationResults result, Versioning clientVersion, int spectatorId, bool gameStarted, GameOptions options)
{
throw new NotImplementedException();
}
public void OnSpectatorRegistered(RegistrationResults result, Versioning serverVersion, int spectatorId, bool gameStarted, GameOptions options)
{
Log.Default.WriteLine(LogLevels.Info, "OnSpectatorRegistered[{0}]:{1} => {2} {3} | {4}.{5}", PlayerName, result, spectatorId, gameStarted, serverVersion == null ? -1 : serverVersion.Major, serverVersion == null ? -1 : serverVersion.Minor);
}
public void OnSpectatorRegistered(RegistrationResults result, Versioning serverVersion, int spectatorId, bool gameStarted, GameOptions options)
{
ExceptionFreeAction(() => Callback.OnSpectatorRegistered(result, serverVersion, spectatorId, gameStarted, options));
}
public void OnPlayerRegistered(RegistrationResults result, Versioning serverVersion, int playerId, bool gameStarted, bool isServerMaster, GameOptions options)
{
ExceptionFreeAction(() => Callback.OnPlayerRegistered(result, serverVersion, playerId, gameStarted, isServerMaster, options));
}
private void OnClientRegistered(RegistrationResults result, Versioning serverVersion, int spectatorId)
{
ClearEntries();
}
public void OnPlayerRegistered(RegistrationResults result, Versioning clientVersion, int playerId, bool gameStarted, bool isServerMaster, GameOptions options)
{
UpdateCallCount(System.Reflection.MethodBase.GetCurrentMethod().Name);
}
private void OnRegisteredAsPlayer(RegistrationResults result, Versioning serverVersion, int playerId, bool isServerMaster)
{
ClearEntries();
AddPlayerEntry(playerId, Client.Name, Client.Team);
IsServerMaster = Client.IsServerMaster;
}
public void OnSpectatorRegistered(RegistrationResults result, Versioning clientVersion, int spectatorId, bool gameStarted, GameOptions options)
{
UpdateCallCount(System.Reflection.MethodBase.GetCurrentMethod().Name);
}
private void RegisteredAsSpectator(RegistrationResults result, Versioning serverVersion, int spectatorId)
{
RefreshMode();
}
private void OnRegisteredAsPlayer(RegistrationResults result, Versioning serverVersion, int playerId, bool isServerMaster)
{
RefreshMode();
}
private void OnRegisteredAsSpectator(RegistrationResults result, Versioning serverVersion, int spectatorId)
{
ClearEntries();
AddSpectatorEntry(spectatorId, Client.Name);
}
public virtual void RegisterSpectator(ITetriNETCallback callback, Versioning clientVersion, string spectatorName)
{
Log.Default.WriteLine(LogLevels.Debug, "RegisterSpectator {0}", spectatorName);
// TODO: check ban list
RegistrationResults result = RegistrationResults.RegistrationSuccessful;
ISpectator spectator = null;
int id = -1;
bool added = false;
// TODO: smarter compatibility check
if (clientVersion == null ||
(_serverVersion.Major != clientVersion.Major && _serverVersion.Minor != clientVersion.Minor))
{
result = RegistrationResults.IncompatibleVersion;
}
else
{
lock (SpectatorManager.LockObject)
{
if (String.IsNullOrEmpty(spectatorName) || spectatorName.Length > 20)
{
result = RegistrationResults.RegistrationFailedInvalidName;
Log.Default.WriteLine(LogLevels.Warning, "Cannot register {0} because name is invalid", spectatorName);
}
else if (SpectatorManager[spectatorName] != null || PlayerManager[spectatorName] != null)
{
result = RegistrationResults.RegistrationFailedPlayerAlreadyExists;
Log.Default.WriteLine(LogLevels.Warning, "Cannot register {0} because it already exists", spectatorName);
}
else if (SpectatorManager.SpectatorCount >= SpectatorManager.MaxSpectators)
{
result = RegistrationResults.RegistrationFailedTooManyPlayers;
Log.Default.WriteLine(LogLevels.Warning, "Cannot register {0} because too many spectators are already connected", spectatorName);
}
else
{
id = SpectatorManager.FirstAvailableId;
if (id != -1)
{
spectator = Factory.CreateSpectator(id, spectatorName, callback);
//
spectator.ConnectionLost += OnEntityConnectionLost;
//
added = SpectatorManager.Add(spectator);
}
}
}
}
if (added && id != -1 && result == RegistrationResults.RegistrationSuccessful)
{
//
spectator.ResetTimeout(); // spectator alive
//
HostSpectatorRegistered?.Invoke(spectator, id);
}
else
{
Log.Default.WriteLine(LogLevels.Info, "Register failed for spectator {0}", spectatorName);
//
callback.OnSpectatorRegistered(result, _serverVersion, -1, false, null);
}
}
