private async Task AddToQueueAsync(Models.GatewayServiceRequest.Content requestContent)
{
Models.LogMessage exceptionMsg = null;
try
{
var serializedContent = JsonConvert.SerializeObject(requestContent);
var queueItem = new Models.GatewayQueueItem {
ID = Guid.NewGuid(), JsonSerializedRequestContent = serializedContent, QueuedDateTime = DateTime.Now
};
try
{
await _queueItemRepository.InsertAsync(queueItem);
}
catch (Exception ex)
{
MvxTrace.Error("\"{0}\" in {1}.{2}\n{3}", ex.Message, "GatewayQueueItemRepository", "InsertAsync", ex.StackTrace);
throw;
}
// Always attempt to sync with the MWF Mobile Gateway service whenever items are added to the queue (providing the GatewayQueueTimerService has been started)
await UploadQueueAsync();
}
catch (Exception ex)
{
exceptionMsg = _loggingService.GetExceptionLogMessage(ex);
}
if (exceptionMsg != null)
{
await _loggingService.LogEventAsync(exceptionMsg);
}
}
public async Task VehicleDetailAsync(Vehicle vehicle)
{
if (await Mvx.Resolve <ICustomUserInteraction>().ConfirmAsync(vehicle.Registration, "Confirm your vehicle", "Confirm"))
{
var newDriver = await _currentDriverRepository.GetByIDAsync(_infoService.CurrentDriverID.Value);
if (newDriver == null)
{
return;
}
await _currentDriverRepository.DeleteAsync(newDriver);
newDriver.LastVehicleID = vehicle.ID;
try
{
await _currentDriverRepository.InsertAsync(newDriver);
}
catch (Exception ex)
{
MvxTrace.Error("\"{0}\" in {1}.{2}\n{3}", ex.Message, "CurrentDriverRepository", "InsertAsync", ex.StackTrace);
throw;
}
await this.MoveToNextAsync(vehicle);
}
}
public override void SetValue(object value)
{
var imageView = ImageView;
if (imageView == null)
{
// weak reference is garbage collected - so just return
return;
}
try
{
var assetStream = GetStream(value);
if (assetStream == null)
return;
var options = new BitmapFactory.Options {InPurgeable = true};
var bitmap = BitmapFactory.DecodeStream(assetStream, null, options);
var drawable = new BitmapDrawable(Resources.System, bitmap);
imageView.SetImageDrawable(drawable);
}
catch (Exception ex)
{
MvxTrace.Error(ex.ToLongString());
throw;
}
}
public override void Close(IMvxViewModel toClose)
{
if (_currentModalViewController != null)
{
var touchView = _currentModalViewController as IMvxTouchView;
if (touchView == null)
{
MvxTrace.Error(
"Unable to close view - modal is showing but not an IMvxTouchView");
return;
}
var viewModel = touchView.ReflectionGetViewModel();
if (viewModel != toClose)
{
MvxTrace.Error(
"Unable to close view - modal is showing but is not the requested viewmodel");
return;
}
var nav = _currentModalViewController.ParentViewController as UINavigationController;
if (nav != null)
{
nav.DismissViewController(true, () => { });
}
else
{
_currentModalViewController.DismissViewController(true, () => { });
}
_currentModalViewController = null;
return;
}
base.Close(toClose);
}
public override bool Navigate()
{
if (ViewController == null || SidebarPanelController == null)
{
return(false);
}
var navigationController = SidebarPanelController.NavigationController;
try
{
switch (Panel)
{
case MvxPanelEnum.Left:
case MvxPanelEnum.Right:
InitSidebar();
break;
case MvxPanelEnum.Center:
default:
navigationController?.PushViewController(ViewController, true);
break;
}
}
catch (Exception ex)
{
MvxTrace.Error(ex.ToString());
}
return(true);
}
private async Task GetPeopleAsync()
{
try
{
var response = await ChoosePeople(
"A00C0B20-A1E4-42C9-8157-1AE27AFA02F2",
"9EDFCF04-06AC-44DF-A3A9-A6327D646A24",
"CFE13495-8DC3-43F1-A4DA-3A78E169B03A",
mLocalStartDateTime, mLocalEndDateTime);
mBackendEmployees = response.Data.OrderBy(ee => !ee.IsInTalentPool).ToList();
var employeesUi = new ObservableCollection <EmployeeUI>(ConvertToEmployeesUi(mBackendEmployees, ItemSelectedAction));
RequestMainThreadAction(() =>
{
Employees = employeesUi;
AvailablePeopleCount = Employees.Count;
});
RefreshUi();
WasViewModelInitialized = true;
}
catch (Exception ex)
{
MvxTrace.Error(ex.ToString);
}
}
public override bool TryCopy(string from, string to, bool overwrite)
{
try
{
using (var isf = IsolatedStorageFile.GetUserStoreForApplication())
{
if (!isf.FileExists(from))
{
MvxTrace.Error("Error during file copy {0} : {1}. File does not exist!", from, to);
return(false);
}
isf.CopyFile(from, to, overwrite);
return(true);
}
}
catch (ThreadAbortException)
{
throw;
}
catch (Exception exception)
{
MvxTrace.Trace("Error masked during file copy {0} : {1} : {2}", from, to, exception.ToLongString());
return(false);
}
}
public async void DiscardEncounter(EncounterTemplate encounterTemplate)
{
try
{
var result = await _dialogService.ConfirmAction("Are you sure ?", "Delete this Encounter");
if (result)
{
if (_dashboardService.CanRemoveEncounter(encounterTemplate.Id, Client.Id,
encounterTemplate.EncounterTypeId))
{
// validate Encounter
_dashboardService.RemoveEncounter(encounterTemplate.Id);
Parent.Modules = _dashboardService.LoadModules();
}
else
{
if (Terms.PreTest == encounterTemplate.EncounterTypeId)
{
_dialogService.Alert("Please Delete Testing Encounters first", "Encounter");
}
if (Terms.Testing == encounterTemplate.EncounterTypeId)
{
_dialogService.Alert("Please Delete Referral and Linkage Encounters first", "Encounter");
}
}
}
}
catch (Exception e)
{
MvxTrace.Error(e.Message);
_dialogService.Alert(e.Message, "Delete this Encounter");
}
}
public IMvxBundle Read(Bundle bundle)
{
if (bundle == null)
{
return(null);
}
var extras = bundle.GetString(ExtrasKey);
if (string.IsNullOrEmpty(extras))
{
return(null);
}
try
{
var converter = Mvx.Resolve <IMvxNavigationSerializer>();
var data = converter.Serializer.DeserializeObject <Dictionary <string, string> >(extras);
return(new MvxBundle(data));
}
catch (Exception exception)
{
MvxTrace.Error("Problem getting the saved state - will return null - from {0}",
extras);
return(null);
}
}
public virtual async Task <bool> Run()
{
try
{
MvxTrace.Trace("Executing {0}", MigrationName);
var result = 0;
var commands = GetCommands();
foreach (var command in commands)
{
MvxTrace.Trace("Executing command: '{0}'", command);
try
{
var commandResult = await Connection.ExecuteAsync(command);
MvxTrace.Trace("Executed command {0}. Rows affected {1}", command, commandResult);
result = result + commandResult;
}
catch (Exception ex)
{
await Connection.ExecuteAsync("ROLLBACK;");
MvxTrace.Error("Command execution error: {0}", ex.Message);
throw ex;
}
}
MvxTrace.Trace("{0} completed. Rows affected {1}", MigrationName, result);
return(result > 0);
}
catch (Exception ex)
{
MvxTrace.Error("{0} error: {1}", MigrationName, ex.Message);
return(false);
}
}
public override bool TryMove(string from, string to, bool overwrite)
{
try
{
var fullFrom = FullPath(from);
var fullTo = FullPath(to);
if (!System.IO.File.Exists(fullFrom))
{
MvxTrace.Error("Error during file move {0} : {1}. File does not exist!", from, to);
return(false);
}
if (System.IO.File.Exists(fullTo))
{
if (overwrite)
{
System.IO.File.Delete(fullTo);
}
else
{
return(false);
}
}
System.IO.File.Move(fullFrom, fullTo);
return(true);
}
catch (Exception exception)
{
MvxTrace.Error("Error during file move {0} : {1} : {2}", from, to, exception.ToLongString());
return(false);
}
}
public MvxImageView(Context context, IAttributeSet attrs)
: base(context, attrs)
{
if (!Mvx.TryResolve(out _imageHelper))
{
MvxTrace.Error(
"No IMvxImageHelper registered - you must provide an image helper before you can use a MvxImageView");
}
else
{
_imageHelper.ImageChanged += ImageHelperOnImageChanged;
}
var typedArray = context.ObtainStyledAttributes(attrs,
MvxAndroidBindingResource.Instance
.ImageViewStylableGroupId);
int numStyles = typedArray.IndexCount;
for (var i = 0; i < numStyles; ++i)
{
int attributeId = typedArray.GetIndex(i);
if (attributeId == MvxAndroidBindingResource.Instance.SourceBindId)
{
ImageUrl = typedArray.GetString(attributeId);
}
}
typedArray.Recycle();
}
public virtual IMvxViewModel Load(Intent intent, IMvxBundle savedState, Type viewModelTypeHint)
{
if (intent == null)
{
MvxTrace.Error("Null Intent seen when creating ViewModel");
return(null);
}
if (intent.Action == Intent.ActionMain)
{
MvxTrace.Trace("Creating ViewModel for ActionMain");
var loaderService = Mvx.Resolve <IMvxViewModelLoader>();
var viewModelRequest = MvxViewModelRequest.GetDefaultRequest(viewModelTypeHint);
var viewModel = loaderService.LoadViewModel(viewModelRequest, savedState);
return(viewModel);
}
if (intent.Extras == null)
{
MvxTrace.Error(
"Null Extras seen on Intent when creating ViewModel - this should not happen - have you tried to navigate to an MvvmCross View directly?");
return(null);
}
IMvxViewModel mvxViewModel;
if (TryGetEmbeddedViewModel(intent, out mvxViewModel))
{
MvxTrace.Trace("Embedded ViewModel used");
return(mvxViewModel);
}
MvxTrace.Trace("Loading new ViewModel from Intent with Extras");
return(CreateViewModelFromIntent(intent, savedState));
}
public object ReadValue(Type t, string input, string fieldOrParameterName)
{
object enumValue = null;
try
{
enumValue = Enum.Parse(t, input, true);
}
catch (Exception)
{
MvxTrace.Error("Failed to parse enum parameter {0} from string {1}",
fieldOrParameterName,
input);
}
if (enumValue == null)
{
try
{
// we set enumValue to 0 here - just have to hope that's the default
enumValue = Enum.ToObject(t, 0);
}
catch (Exception)
{
MvxTrace.Error("Failed to create default enum value for {0} - will return null",
fieldOrParameterName);
}
}
return(enumValue);
}
private static string GetPropertyText(MemberExpression memberExpression, string endOfOwnerDelimeter)
{
if (memberExpression == null)
{
throw new ArgumentException("WrongExpressionMessage (memberExpression is null)", "expression");
}
var member = memberExpression.Member as PropertyInfo;
if (member == null)
{
throw new ArgumentException(String.Format("WrongExpressionMessage (memberExpression.Member is not PropertyInfo but {0})", memberExpression.Member), "expression");
}
var text = memberExpression.ToString();
var endOfOwnerPosition = text.IndexOf(endOfOwnerDelimeter);
if (endOfOwnerPosition < 0)
{
MvxTrace.Error("Failed to convert text - cannot find expected text in the Expression: {0}", text);
throw new MvxException("Failed to convert text - cannot find expected text in the Expression: {0}", text);
}
text = text.Substring(endOfOwnerPosition + endOfOwnerDelimeter.Length);
return(text);
}
public async Task RunMigrations()
{
// TODO run migrations in a transaction, otherwise, if and error is found, the app could stay in a horrible state
if (settings.DatabaseVersion < migrations.Count)
{
var connection = new SQLiteAsyncConnection(() => sqlite.GetConnectionWithLock());
while (settings.DatabaseVersion < migrations.Count)
{
var nextVersion = settings.DatabaseVersion + 1;
var success = await migrations[nextVersion - 1].UseConnection(connection).Run();
if (success)
{
settings.DatabaseVersion = nextVersion;
}
else
{
MvxTrace.Error("Migration process stopped after error found at {0}", migrations[nextVersion - 1].GetType().Name);
break;
}
}
}
}
public override void Close(IMvxViewModel toClose)
{
if (this._currentModalViewController != null)
{
var touchView = this._currentModalViewController as IMvxIosView;
if (touchView == null)
{
MvxTrace.Error(
"Unable to close view - modal is showing but not an IMvxIosView");
return;
}
var viewModel = touchView.ReflectionGetViewModel();
if (viewModel != toClose)
{
MvxTrace.Error(
"Unable to close view - modal is showing but is not the requested viewmodel");
return;
}
this._currentModalViewController.DismissViewController(true, () => { });
this._currentModalViewController = null;
return;
}
base.Close(toClose);
}
protected async Task UpdateVehicleListAsync()
{
if (!_reachability.IsConnected())
{
_toast.Show("No internet connection!");
return;
}
this.ProgressMessage = "Updating Vehicles.";
this.IsBusy = true;
try
{
IDictionary <string, IEnumerable <Models.BaseVehicle> > vehicleViewVehicles;
try
{
var vehicleViews = await _gatewayService.GetVehicleViewsAsync();
vehicleViewVehicles = new Dictionary <string, IEnumerable <Models.BaseVehicle> >(vehicleViews.Count());
foreach (var vehicleView in vehicleViews)
{
vehicleViewVehicles.Add(vehicleView.Title, await _gatewayService.GetVehiclesAsync(vehicleView.Title));
}
}
catch (TaskCanceledException)
{
// Although we have used reachability to determine that there is an available network connection,
// it is still possible for the data fetch to fail which triggers a TaskCanceledException.
_toast.Show("Connection failure!");
return;
}
var vehiclesAndTrailers = vehicleViewVehicles.SelectMany(vvv => vvv.Value).DistinctBy(v => v.ID);
var vehicles = vehiclesAndTrailers.Where(bv => !bv.IsTrailer).Select(bv => new Models.Vehicle(bv));
if (vehicles != null && vehicles.Any())
{
await _repositories.VehicleRepository.DeleteAllAsync();
try
{
await _repositories.VehicleRepository.InsertAsync(vehicles);
}
catch (Exception ex)
{
MvxTrace.Error("\"{0}\" in {1}.{2}\n{3}", ex.Message, "VehicleRepository", "InsertAsync", ex.StackTrace);
throw;
}
}
}
finally
{
this.IsBusy = false;
}
}
public MvxUnityViewPresenter(MonoBehaviour applicationDelegate)
{
_applicationDelegate = applicationDelegate;
_uiCamera = NGUITools.FindCameraForLayer(LayerMask.NameToLayer("UI"));
if (_uiCamera == null)
{
MvxTrace.Error("Cannot find Camera for UI layer");
}
}
public void Bind(IMvxViewModel viewModel, IMvxBundle parameterValues = null, IMvxBundle savedState = null)
{
var controllerAware = viewModel as IControllerAware;
if (controllerAware != null)
{
var viewModelType = viewModel.GetType();
var name = viewModelType.FullName.Replace("ViewModel", "Controller");
Type controllerType = GetControllerTypeForViewModel(_getCreateableTypes(), viewModel);
if (controllerType == null)
{
throw new ArgumentException(string.Format("Controller for view model {0} cannot be found.", viewModelType));
}
try
{
var controller = (IMvxController)Mvx.IocConstruct(controllerType);
controllerAware.AttachController(controller);
var viewModelAware = controller as IViewModelAware;
if (viewModelAware != null)
{
viewModelAware.AttachViewModel(viewModel);
}
try
{
CallControllerInitMethods(controller, parameterValues);
if (savedState != null)
{
CallReloadStateMethods(controller, savedState);
}
}
catch (Exception ex)
{
MvxTrace.Error("MvxControllers: Problem initialising controller of type {0} - problem {1}",
controllerType.Name, ex.ToLongString());
throw;
}
controller.WaitForInitialize();
}
catch (Exception ex)
{
MvxTrace.Error("MvxControllers: Problem creating controller of type {0} - problem {1}",
controllerType,
ex.ToLongString());
throw;
}
}
}
public async Task UpdateVehicleListAsync()
{
this.IsBusy = true;
try
{
if (!_reachability.IsConnected())
{
_toast.Show("No internet connection!");
}
else
{
var vehicleViews = await _gatewayService.GetVehicleViewsAsync();
var vehicleViewVehicles = new Dictionary <string, IEnumerable <Models.BaseVehicle> >(vehicleViews.Count());
foreach (var vehicleView in vehicleViews)
{
vehicleViewVehicles.Add(vehicleView.Title, await _gatewayService.GetVehiclesAsync(vehicleView.Title));
}
var vehiclesAndTrailers = vehicleViewVehicles.SelectMany(vvv => vvv.Value).DistinctBy(v => v.ID);
var vehicles = vehiclesAndTrailers.Where(bv => !bv.IsTrailer).Select(bv => new Models.Vehicle(bv));
if (vehicles != null)
{
await _vehicleRepository.DeleteAllAsync();
try
{
await _vehicleRepository.InsertAsync(vehicles);
}
catch (Exception ex)
{
MvxTrace.Error("\"{0}\" in {1}.{2}\n{3}", ex.Message, "VehicleRepository", "InsertAsync", ex.StackTrace);
throw;
}
Vehicles = _originalVehicleList = await _vehicleRepository.GetAllAsync();
//Recalls the filter text if there is text in the search field.
if (VehicleSearchText != null)
{
this.FilterList();
}
}
}
await UpdateSafetyProfilesAsync();
}
finally
{
this.IsBusy = false;
}
}
public object ReadValue(string input, string fieldOrParameterName)
{
object result;
if (!TryParse(input, out result))
{
MvxTrace.Error("Failed to parse {0} parameter {1} from string {2}",
this.GetType().Name, fieldOrParameterName, input);
}
return(result);
}
/// <summary>
/// Natives the modal view controller disappeared on its own.
/// </summary>
public override void NativeModalViewControllerDisappearedOnItsOwn()
{
if (_currentModalViewController != null)
{
MvxTrace.Error("How did a modal disappear when we didn't have one showing?");
}
else
{
_currentModalViewController = null;
}
}
public override void NativeModalViewControllerDisappearedOnItsOwn()
{
if (_currentModalViewController != null)
{
MvxTrace.Error("How did a modal disappear when we didn't have one showing?");
return;
}
// clear our local reference to avoid back confusion
_currentModalViewController = null;
}
public T Get <T>(string key) where T : class
{
try
{
return(JsonConvert.DeserializeObject <T>(m_Data[key]));
}
catch (Exception ex)
{
MvxTrace.Error(ex.StackTrace);
return(null);
}
}
private void Save()
{
try
{
string fileContent = JsonConvert.SerializeObject(m_Data);
m_FileStore.WriteFile(Path.Combine(m_PlatformInfo.BaseDirectory, m_FileName), fileContent);
}
catch (Exception ex)
{
MvxTrace.Error(ex.StackTrace);
}
}
private Task InsertLogMessage(LogMessage logMessage)
{
try
{
return(_loggedRepository.InsertAsync(logMessage));
}
catch (Exception ex)
{
MvxTrace.Error("\"{0}\" in {1}.{2}\n{3}", ex.Message, "LogMessageRepository", "InsertAsync", ex.StackTrace);
throw;
}
}
protected async Task UpdateSafetyProfilesAsync()
{
ProgressMessage = "Updating Safety Check Profiles.";
var safetyProfileRepository = _repositories.SafetyProfileRepository;
this.IsBusy = true;
try
{
// First check if we have a internet connection. If we do go and get the latest safety checks from Blue Sphere.
if (_reachability.IsConnected())
{
IEnumerable <SafetyProfile> safetyProfiles = null;
try
{
safetyProfiles = await _gatewayService.GetSafetyProfilesAsync();
}
catch (TaskCanceledException)
{
// Although we have used reachability to determine that there is an available network connection,
// it is still possible for the data fetch to fail which triggers a TaskCanceledException.
}
if (safetyProfiles != null)
{
await safetyProfileRepository.DeleteAllAsync();
try
{
await safetyProfileRepository.InsertAsync(safetyProfiles);
}
catch (Exception ex)
{
MvxTrace.Error("\"{0}\" in {1}.{2}\n{3}", ex.Message, "SafetyProfileRepository", "InsertAsync", ex.StackTrace);
throw;
}
}
}
}
finally
{
this.IsBusy = false;
}
var profiles = await safetyProfileRepository.GetAllAsync();
if (profiles.Count() == 0)
{
await Mvx.Resolve <ICustomUserInteraction>().AlertAsync("No Profiles Found.");
}
}
// This is the main entry point of the application.
static void Main(string[] args)
{
// if you want to use a different Application Delegate class from "AppDelegate"
// you can specify it here.
try
{
UIApplication.Main(args, null, "AppDelegate");
}
catch (Exception ex)
{
MvxTrace.Error(ex.ToString());
}
}
public MvxImageView(Context context)
: base(context)
{
if (!Mvx.TryResolve(out _imageHelper))
{
MvxTrace.Error(
"No IMvxImageHelper registered - you must provide an image helper before you can use a MvxImageView");
}
else
{
_imageHelper.ImageChanged += ImageHelperOnImageChanged;
}
}
