private async Task PostAccidentAsync()
{
var client = new AutoResolveWebserviceClient<AccidentViewModel>("api/accidents");
var response = await client.PostAsync(parentVm.Accident);
if (response.IsSuccessStatusCode)
{
await DisplayAlert("Thanks, we got that!", "Accident Created", "Ok");
}
}
public async Task<CustomerViewModel> PostCustomerAsync(CustomerViewModel customerViewModel)
{
using (var client = new AutoResolveWebserviceClient<CustomerViewModel>("api/customer"))
{
var response = await client.PostAsync(customerViewModel);
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
var model = JsonConvert.DeserializeObject<CustomerViewModel>(content);
await DisplayAlert("Thanks, we got that!", "Customer Created", "Ok");
return model;
}
throw new HttpRequestException();
}
}
public async Task<CustomerViewModel> GetCustomerAsync(int id)
{
using (var client = new AutoResolveWebserviceClient<CustomerViewModel>("api/customers"))
{
var response = await client.GetAsync(id);
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
var model = JsonConvert.DeserializeObject<CustomerViewModel>(content);
return model;
}
throw new HttpRequestException("Couldn't get request");
}
}
private async Task<string> GetToken(string requestString)
{
using (var accountClient = new AutoResolveWebserviceClient<object>("https://axiapp.co.uk/", "token"))
{
var response = await accountClient.PostPlainTextAsync(requestString);
LatestResponseCode = response.StatusCode.ToString();
if (response.IsSuccessStatusCode)
{
JObject jObject = JObject.Parse(await response.Content.ReadAsStringAsync());
LatestTokenExpiry = (DateTime)jObject[".expires"];
LatestTokenFromServer = (string)jObject["access_token"];
return LatestTokenFromServer;
//nothing
}
LatestError = await response.Content.ReadAsStringAsync();
}
{
}
return "";
}
public async Task<bool> Register(RegistrationViewModel model)
{
if (model != null)
{
using (
var accountClient = new AutoResolveWebserviceClient<object>("https://axiapp.co.uk/",
"api/account/register"))
{
var response = await accountClient.PostAsync(model);
LatestResponseCode = response.StatusCode.ToString();
if (!response.IsSuccessStatusCode)
{
LatestError = await response.Content.ReadAsStringAsync();
}
return response.IsSuccessStatusCode;
}
}
return false;
}
public void Dispose()
{
Client = null;
}
public ExternallNotificationService(AutoResolveWebserviceClient<NotificationDTO> client)
{
Client = client;
}
private void StartTimer()
{
BackgroundColor = Color.White;
Device.StartTimer(new TimeSpan(0, 0, 1), () =>
{
if (vm.TimerStatus)
{
// do something every 60 seconds
if (vm.SecondCount > 0)
{
vm.SecondCount--;
return true; // runs again, or false to stop
}
//timer has expired
//
bool areWeAuthorisedToSendRequest = false;
var wait = Task.Factory.StartNew(async () =>
{
areWeAuthorisedToSendRequest = await App.CheckForValidAccountAndTokenAndRefreshIfExpired();
}).Result;
if (areWeAuthorisedToSendRequest)
{
var client = new AutoResolveWebserviceClient<NotificationDTO>("api/notifications");
client.AddBearerTokenHeader(App.parentViewModel.CurrentAccount.LatestBearerToken);
var waitAgain = Task.Factory.StartNew(async () =>
{
await App.CreateCustomerDeviceAndAPIIfNoKey();
await App.CreateAccidentDeviceAndAPIIfNoKey(DateTime.Now);
}).Result;
ISendExternallNotifier notificationService = new ExternallNotificationService(client);
//email notifier
if (!String.IsNullOrWhiteSpace(App.parentViewModel.Customer.EmergencyEmailContact))
{
if (App.UserSettings.IsEmailNotification)
{
var args = new NotificationArgs();
args.Args.Add(App.parentViewModel.Customer.EmergencyEmailContact);
var not = new NotificationDTO
{
Accident = App.CurrentServerSideAccident,
NotificationType = NotificationType.AccidentEmail,
//todo:replace with new accident url
Id = 0
};
Task.Factory.StartNew(async () =>
{
var result = await notificationService.SendNotification(not);
vm.TimerStatus = false;
});
}
}
//sms notifier
if (App.UserSettings.IsSMSNotification)
{
if (!String.IsNullOrWhiteSpace(App.parentViewModel.Customer.EmergencySMSContact))
{
var args = new NotificationArgs();
args.Args.Add(App.parentViewModel.Customer.EmergencySMSContact);
args.Args.Add(App.parentViewModel.Customer.FirstName);
args.Args.Add(App.parentViewModel.Customer.LastName);
var not = new NotificationDTO
{
Accident = App.CurrentServerSideAccident,
NotificationType = NotificationType.AccidentSMS,
//todo:replace with new accident url
Id = 0
};
Task.Factory.StartNew(async () =>
{
var result = await notificationService.SendNotification(not);
vm.TimerStatus = false;
});
}
vm.TimerStatus = false;
return false;
}
}
else
{
DisplayAlert("Cannot validate with API",
"Axiapp is having problems contacting the API, please sign in again using the sign in page", "OK");
}
}
//do nothing, it was cancelled
vm.TimerStatus = false;
return false;
});
}
public static async Task<HttpResponseMessage> UpdateWitnessDeviceAndAPIIfNoKey(WitnessViewModel vm)
{
Context.WitnessRepository.AddOrUpdate(vm);
if (await App.CheckForValidAccountAndTokenAndRefreshIfExpired())
{
if (parentViewModel.Customer.Id != 0)
{
//create in API
using (var otherDriverClient = new AutoResolveWebserviceClient<WitnessViewModel>("api/otherdrivers/" + vm.Id))
{
otherDriverClient.AddBearerTokenHeader(parentViewModel.CurrentAccount.LatestBearerToken);
var response = await otherDriverClient.PutAsync(vm);
if (response.IsSuccessStatusCode)
{
//nothing
}
else
{
var error = await response.Content.ReadAsStringAsync();
SetLatestAPIErrorMessage(error);
}
return response;
}
}
}
return null;
}
public static async Task<HttpResponseMessage> CreateWitnessDeviceAndAPIIfNoKey(WitnessViewModel vm)
{
vm.Accident = App.CurrentServerSideAccident;
var isThereExistingWitness =
parentViewModel.Witnessses.FirstOrDefault(x => x.Client_Id == vm.Client_Id);
Context.WitnessRepository.AddOrUpdate(vm);
if (isThereExistingWitness == null)
{
parentViewModel.Witnessses.Add(vm);
}
else
{
isThereExistingWitness = vm;
}
if (await App.CheckForValidAccountAndTokenAndRefreshIfExpired())
{
if (vm.Id == 0)
{
using (
var witnessClient = new AutoResolveWebserviceClient<WitnessViewModel>("api/witnesses")
)
{
witnessClient.AddBearerTokenHeader(parentViewModel.CurrentAccount.LatestBearerToken);
var response = await witnessClient.PostAsync(vm);
if (response.IsSuccessStatusCode)
{
var previousClientSideID = vm.Client_Id;
var content = await response.Content.ReadAsStringAsync();
var pagedResult = JsonConvert.DeserializeObject<StandardPagedResultV1>(content);
var driver =
JsonConvert.DeserializeObject<WitnessViewModel>(
JsonConvert.SerializeObject(pagedResult.Data));
driver.Client_Id = previousClientSideID;
var current =
parentViewModel.Witnessses.FirstOrDefault(x => x.Client_Id == previousClientSideID);
current = driver;
parentViewModel.Witnessses.Add(Context.WitnessRepository.AddOrUpdate(current));
}
else
{
var error = await response.Content.ReadAsStringAsync();
SetLatestAPIErrorMessage(error);
}
return response;
}
}
}
return null;
}
public static async Task CreateAccidentDeviceAndAPIIfNoKey(DateTime accidentDate)
{
parentViewModel.Accident = Context.AccidentRepository.AddOrUpdate(parentViewModel.Accident);
if (await App.CheckForValidAccountAndTokenAndRefreshIfExpired())
{
if (parentViewModel.Accident.Id == 0)
{
try
{
using (var accidentClient = new AutoResolveWebserviceClient<AccidentViewModel>("api/accidents"))
{
accidentClient.AddBearerTokenHeader(parentViewModel.CurrentAccount.LatestBearerToken);
parentViewModel.Accident.AccidentDateTime = accidentDate;
var response = await accidentClient.PostAsync(parentViewModel.Accident);
if (response.IsSuccessStatusCode)
{
var previousClientSideId = parentViewModel.Accident.Client_Id;
var content = await response.Content.ReadAsStringAsync();
var newAccidentModel = JsonConvert.DeserializeObject<AccidentViewModel>(content);
parentViewModel.Accident = newAccidentModel;
parentViewModel.Accident.Client_Id = previousClientSideId; //MUST RESET THIS
parentViewModel.Accident = Context.AccidentRepository.AddOrUpdate(parentViewModel.Accident);
}
else
{
var error = await response.Content.ReadAsStringAsync();
SetLatestAPIErrorMessage(error);
}
}
}
catch (Exception ex)
{
throw new Exception("CreateAccidentDeviceAndAPIIfNoKey Failed", ex);
}
}
//end accidents
}
}
public static async Task UpdateAccidentDeviceAndAPI()
{
parentViewModel.Accident = Context.AccidentRepository.AddOrUpdate(parentViewModel.Accident);
if (await App.CheckForValidAccountAndTokenAndRefreshIfExpired())
{
if (parentViewModel.Accident.Id != 0)
{
using (var accidentClient = new AutoResolveWebserviceClient<AccidentViewModel>("api/accidents/" + parentViewModel.Accident.Id))
{
accidentClient.AddBearerTokenHeader(parentViewModel.CurrentAccount.LatestBearerToken);
var response = await accidentClient.PutAsync(parentViewModel.Accident);
if (response.IsSuccessStatusCode)
{
//nothing
}
else
{
var error = await response.Content.ReadAsStringAsync();
SetLatestAPIErrorMessage(error);
}
}
}
}
}
public static async Task UpdateCustomerSettingsDeviceAndAPI()
{
UserSettings = Context.CustomerSettingsRepository.AddOrUpdate(UserSettings);
if (await App.CheckForValidAccountAndTokenAndRefreshIfExpired())
{
if (UserSettings.Id != 0)
{
//create in API
using (var customerSettingsClient = new AutoResolveWebserviceClient<CustomerSettingsViewModel>("api/customersettings/" + UserSettings.Id))
{
customerSettingsClient.AddBearerTokenHeader(parentViewModel.CurrentAccount.LatestBearerToken);
var response = await customerSettingsClient.PutAsync(UserSettings);
if (response.IsSuccessStatusCode)
{
//nothing
}
else
{
var error = await response.Content.ReadAsStringAsync();
SetLatestAPIErrorMessage(error);
}
}
}
}
}
public static async Task CreateCustomerSettingsDeviceAndAPIIfNoKey()
{
UserSettings.Customer = App.CurrentServerSideCustomer;
UserSettings = Context.CustomerSettingsRepository.AddOrUpdate(UserSettings);
if (await App.CheckForValidAccountAndTokenAndRefreshIfExpired())
{
if (UserSettings.Id == 0)
{
//create in API
using (var customerSettingsClient = new AutoResolveWebserviceClient<CustomerSettingsViewModel>("api/customersettings"))
{
customerSettingsClient.AddBearerTokenHeader(parentViewModel.CurrentAccount.LatestBearerToken);
var response = await customerSettingsClient.PostAsync(UserSettings);
if (response.IsSuccessStatusCode)
{
var previousClientSideId = UserSettings.Client_Id;
//save with new ID
var content = await response.Content.ReadAsStringAsync();
var pagedResult = JsonConvert.DeserializeObject<StandardPagedResultV1>(content);
var customerSettings =
JsonConvert.DeserializeObject<CustomerSettingsViewModel>(
JsonConvert.SerializeObject(pagedResult.Data));
UserSettings = customerSettings;
UserSettings.Client_Id = previousClientSideId;
UserSettings = Context.CustomerSettingsRepository.AddOrUpdate(UserSettings);
//end customer settings
}
else
{
var error = await response.Content.ReadAsStringAsync();
SetLatestAPIErrorMessage(error);
}
}
}
}
}
async Task CreateCustomerDeviceAndAPIIfNoKey()
{
parentViewModel.Customer = Context.CustomerRepository.AddOrUpdate(parentViewModel.Customer);
if (await App.CheckForValidAccountAndTokenAndRefreshIfExpired())
{
if (parentViewModel.Customer.Id == 0)
{
//create in API
using (var customerClient = new AutoResolveWebserviceClient<CustomerViewModel>("api/customers"))
{
customerClient.AddBearerTokenHeader(parentViewModel.CurrentAccount.LatestBearerToken);
parentViewModel.Customer.Email = parentViewModel.CurrentAccount.Email;
var response = await customerClient.PostAsync(parentViewModel.Customer);
if (response.IsSuccessStatusCode)
{
var previousClientSideId = UserSettings.Client_Id;
//save with new ID
var content = await response.Content.ReadAsStringAsync();
var pagedResult = JsonConvert.DeserializeObject<StandardPagedResultV1>(content);
var customer =
JsonConvert.DeserializeObject<CustomerViewModel>(
JsonConvert.SerializeObject(pagedResult.Data));
parentViewModel.Customer = customer;
//need to save a second time after the update to have fresh data
parentViewModel.Customer.Client_Id = previousClientSideId;
parentViewModel.Customer = Context.CustomerRepository.AddOrUpdate(parentViewModel.Customer);
parentViewModel.Accident.Customer = parentViewModel.Customer.Resource_uri;
//end customer
}
else
{
var error = await response.Content.ReadAsStringAsync();
SetLatestAPIErrorMessage(error);
}
}
}
}
}
private void Button_OnClicked(object sender, EventArgs e)
{
SaveMyData();
Task.Factory.StartNew(async () =>
{
try
{
var client = new AutoResolveWebserviceClient<NotificationDTO>("api/notifications");
client.AddBearerTokenHeader(App.parentViewModel.CurrentAccount.LatestBearerToken);
ISendExternallNotifier notificationService = new ExternallNotificationService(client);
var args = new NotificationArgs();
args.Args.Add(vm.Email);
var not = new NotificationDTO
{
Accident = App.CurrentServerSideAccident,
NotificationType = NotificationType.AccidentPDF,
//todo:replace with new accident url
Id = 0
};
var result = await notificationService.SendNotification(not);
}
catch (Exception)
{
DisplayAlert("The PDF couldn't send (is there signal?)", "Sorry couldn't send the pdf", "OK");
}
});
Navigation.PushAsync(new DamageToMyCar());
}
