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; } }