public static async Task ProcessQuotes(List <string> authors, int maxQuoteLength, string firebaseHost) { // Get max page numbers for every author PagingSpider pagingSpider = new PagingSpider(authors); pagingSpider.Run(); // Convert the result to PagingEntity objects var pagingEntities = pagingSpider.CollectionEntityPipeline.ToEntityList <PagingEntity>(); // Get all quotes from all pages for the author QuoteSpider quoteSpider = new QuoteSpider(pagingEntities.ToList()) { ThreadNum = 4 }; quoteSpider.Run(); // Convert the result to FirebaseQuote objects var firebaseQuotes = quoteSpider.CollectionEntityPipeline.ToFirebaseQuotes(maxQuoteLength); // Delete all existing quotes from firebase, then upload all quotes var firebaseService = new FirebaseService(firebaseHost); await firebaseService.ReUpload(firebaseQuotes, batchSize : 50); }
async void Login_Clicked(object sender, System.EventArgs e) { //NavigationPage nav = new NavigationPage(new MyTabbedPage()); try { var user = await DependencyService.Get <IFirebaseAuthenticator>().LoginWithEmailPasswordAsync(emailEntry.Text, passwordEntry.Text); if (user != null) { GeneralHelper.IsNotFirstLogin = true; SettingsService.LastUsedEmail = emailEntry.Text; SettingsService.LastUsedPassword = passwordEntry.Text; FirebaseService.User = user; FirebaseService _firebaseService = new FirebaseService(); if (GeneralHelper.NotificationToken != null) { await _firebaseService.SendToken(GeneralHelper.NotificationToken); } await Navigation.PushModalAsync(new NavigationPage(new MyTabbedPage())); } } catch (Exception ex) { await DisplayAlert("Uyarı", ex.Message, "Tamam"); } }
private async Task <bool> CanSaveCategoryAsync() { if (Category == null) { return(false); } if (Category.CategoryName == "" || Category.CategoryName == null) { return(false); } if (States.Count == 0) { return(false); } if (States.FirstOrDefault(x => x.StateName == "") != null) { return(false); } if (!CanCreateState()) { return(false); } return(await FirebaseService.IsCategoryNameAwailableAsync(Category)); }
private async Task ShowItemsAsync() { List <ItemModel> items = new List <ItemModel>(); Category.Items = new ObservableCollection <ItemModel>(); if (SearchItem.ItemName != "") { items = await FirebaseService.GetItemsAsync(SearchItem, 20, null); } else if (VisibleState == States[0]) { items = await FirebaseService.GetItemsAsync(Category, 20, null); } else { items = await FirebaseService.GetItemsAsync(VisibleState, 20, null); } foreach (var item in items) { var state = States.FirstOrDefault(x => x.StateID == item.StateID); item.State = state; } Category.Items = new ObservableCollection <ItemModel>(items); }
private async void ViewLeaves() { try { //Todo----Optimize below code to run in lesser time. //todo----add suitable catch statement for this try. IsBusy = true; IsVisible = false; ActivityIndicatorTitle = "Please wait while data is being loaded."; ListItems = new ObservableCollection <CalendarItem>(); var x = await FirebaseService.GetAll(_month, _year); foreach (var item in x) { ListItems.Add(item); } } finally { IsBusy = false; Title = string.Join("\t", Title, string.Concat("(", _month, ' ', _year, ")")); } }
async Task ExecuteLoadStoriesCommand() { if (IsBusy) { return; } IsBusy = true; try { Stories.Clear(); var stories = await FirebaseService.GetItemsAsync(true); foreach (var story in stories) { Stories.Add(story); } } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }
public LoginPage() { NavigationPage.SetHasNavigationBar(this, false); NavigationPage.SetHasBackButton(this, false); InitializeComponent(); service = new FirebaseService(); }
public static async System.Threading.Tasks.Task <IActionResult> Run([HttpTrigger] HttpRequest req, ILogger log) { log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}"); var firebaseService = new FirebaseService(); var appCenterService = new AppCenterService(new HttpClient()); var openWeatherService = new OpenWeatherService(new HttpClient()); var notificacoes = await firebaseService.ObterNotificacoes(); foreach (var notificacao in notificacoes) { var cidade = await openWeatherService.ObterClimaTempo(notificacao.Cidade); if (notificacao.DeveNotificarTemperaturaMinima(cidade.Principal.TemperaturaMinima)) { await appCenterService.AdicionarNotificacao( new[] { notificacao.IdDispositivo }, "ClimaTempo", "A temperatura caiu!", $"Cidade de {notificacao.Cidade} com temperatura atual de {cidade.Principal.TemperaturaMinima}°."); } if (notificacao.DeveNotificarVentoVelocidadeMinima(Convert.ToDouble(cidade.Vento.Velocidade))) { await appCenterService.AdicionarNotificacao( new[] { notificacao.IdDispositivo }, "ClimaTempo", "A velocidade do vendo caiu!", $"Cidade de {notificacao.Cidade} com velocidade atual do vendo em {cidade.Vento.Velocidade}."); } } return(new OkObjectResult("OK")); }
/*****************************************************************/ // METHODS /*****************************************************************/ #region Methods /// <summary> /// Verify phone no. /// </summary> /// <param name="callBack">Callback for PCL</param> /// <param name="phoneNo">Phone no. to verify</param> /// <returns></returns> public Task <FirebaseResponse> VerifyPhoneNo(IFirebaseServiceCallBack callBack, string phoneNo) { this.FirebaseServiceCallBack = callBack; try { // Check if phone no. is white listed WhiteListedPhoneNo = FirebaseService.CheckForTestPhoneNo(phoneNo); // Verify phone no. PhoneAuthProvider.Instance.VerifyPhoneNumber( phoneNo, 60, TimeUnit.Seconds, Activity, this ); // Return response return(new Task <FirebaseResponse>(() => new FirebaseResponse(true))); } catch (Exception mes) { // Return exception return(new Task <FirebaseResponse>(() => new FirebaseResponse(mes.Message))); } }
private async Task CadastrarCommandAsync() { if (IsBusy) { return; } try { IsBusy = true; var userService = new FirebaseService(); Result = await userService.RegistrarUsuario(Username, Password, Telefone, Email); if (Result) { await Application.Current.MainPage.DisplayAlert("Sucesso", "Usuário Registrado", "Ok"); await Application.Current.MainPage.Navigation.PopToRootAsync(); } else { await Application.Current.MainPage.DisplayAlert("Erro", "Falha ao registrar usuário", "Ok"); } } catch (Exception ex) { await Application.Current.MainPage.DisplayAlert("Erro", ex.Message, "Ok"); } finally { IsBusy = false; } }
private async void Login() { try { ActivityIndicatorTitle = "Logging In. Please wait."; IsBusy = true; User userObject = PrismApplicationBase.Current.Container.Resolve(typeof(User)) as User; userObject.UserID = _userId; userObject.Password = _password; userObject.UserName = await FirebaseService.GetUserNameAsync(_userId); if (!string.IsNullOrEmpty(await FirebaseService.LoginAsync(userObject))) { await NavigationService.NavigateAsync("MainPage"); } else { await DialogService.DisplayAlertAsync("Log in failed !", "Incorrect ID or password. Please try again.", "OK"); } } finally { IsBusy = false; } }
private async Task LoginCommandAsync() { if (IsBusy) { return; } try { IsBusy = true; var userService = new FirebaseService(); Result = await userService.LoginUsuario(Username, Password); if (Result) { MessagingCenter.Send <User>(this.User, "SucessoLogin"); } else { await Application.Current.MainPage.DisplayAlert("Erro", "Usuário/Senha inválido(s)", "Ok"); } } catch (Exception ex) { await Application.Current.MainPage.DisplayAlert("Erro", ex.Message, "Ok"); } finally { IsBusy = false; } }
private async Task RegistrarCommandAsync() { if (IsBusy) { return; } try { IsBusy = true; var firebaseService = new FirebaseService(); Result = await firebaseService.AdicionarCatastrofe(this.Registrar); if (Result) { await Application.Current.MainPage.DisplayAlert("Sucesso", "Desastre registrada com sucesso", "Ok"); MessagingCenter.Send(this.Registrar, "Registrar"); } else { await Application.Current.MainPage.DisplayAlert("Erro", "Falha ao registrar catástrofe", "Ok"); } } catch (Exception ex) { await Application.Current.MainPage.DisplayAlert("Erro", ex.Message, "Ok"); } finally { IsBusy = false; } }
public async Task <bool> PublishNew() { //get workouts from sheets var ws = new SheetService(); var workouts = (await ws.GetWorkouts()).EmptyIfNull().Where(wo => wo.Show == true); //get social calendars from sheets var socialCalendarIds = await ws.GetSocialCalendars(); var extraCalendars = Mapper.Map <List <CalenderViewModel> >((await GetCalendarList()).Items); //factor out the all but social calendars var socialCalendars = extraCalendars.Where(cal => socialCalendarIds.EmptyIfNull().Select(s => s.CalendarID).Contains(cal.Id)); var retVal = new List <CalenderViewModel>(); retVal.AddRange(Mapper.Map <List <CalenderViewModel> >(workouts)); retVal.AddRange(socialCalendars); var x = await retVal.ForkJoin(async cal => await GetThisWeekEventViewModels(cal)); //todo: get items. //publish to firebase var fbSvc = new FirebaseService(); await fbSvc.Publish(retVal, retVal.SelectMany(cal => cal.Items)); return(retVal != null && retVal.Count > 0); }
public UsersController(MyContext context, IOptions <AppSettings> settings) { this._context = context; this.apikey = settings.Value.FirebaseApiKey; this.jwtService = new TokenService(this._context, settings); this.telBot = new TelegramBot(); this.auth = new AuthService(context); this.firebase = new FirebaseService(context, settings); }
private async Task <bool> CanSetCategoryNameAsync() { if (Category.CategoryName == "" || Category.CategoryName == null) { return(false); } return(await FirebaseService.IsCategoryNameAwailableAsync(Category)); }
public LoginController(MyContext context, IOptions <AppSettings> settings) { this._context = context; this.apikey = settings.Value.FirebaseApiKey; this.currentConferenceId = settings.Value.CurrentConferenceID; this.jwtService = new TokenService(this._context, settings); this.telBot = new TelegramBot(); this.fbService = new FirebaseService(context, settings); this.auth = new AuthService(context); }
public void Test1() { FirebaseService firebaseService = new FirebaseService(); var activities = firebaseService.OnceAsync <List <DayProgram> >("DayPrograms").Result[0]; Activity activita = activities[(int)DateTime.Today.DayOfWeek] .Where(activity => activity.Start <= DateTime.Now.TimeOfDay).LastOrDefault(); Assert.AreEqual("sleeping", activita.Name); Assert.AreEqual(TimeSpan.FromMinutes(1335), activita.Start); }
protected async override Task AddItems() { IEnumerable <IElement> elementsCollection = null; elementsCollection = new FirebaseService().GetUserFavorites(this.CurrentPosition, this.PageSize, user_id); foreach (IElement element in elementsCollection) { this.MyItems.Add(element); } }
public ShoppingListViewModel() { var service = new FirebaseService(); Task <IReadOnlyCollection <FirebaseObject <ShoppingItem> > > items = service.GetShoppingListItems(); ShoppingItems = new ObservableCollection <ShoppingItem>(); foreach (var firebaseObject in items.Result) { ShoppingItems.Add(firebaseObject.Object); } }
public MasterDetailView(Usuario usuario) { InitializeComponent(); firebaseService = new FirebaseService(); Produtos = new ObservableCollection <ProdutoItemViewModel>(); netService = new NetService(); this.usuario = usuario; this.Master = new MasterView(usuario); this.Detail = new NavigationPage(new ConsultaProdutosView(usuario)); carregarProdutos(); // popularProdutos(); }
private async Task <bool> CanSetItemNameAsync(ItemModel target) { if (target == null) { return(false); } if (target.ItemName == "") { return(false); } return(await FirebaseService.IsItemNameAwailableAsync(target)); }
private async Task GetCategoryAsync(string categoryID) { if (!IsNewCategory) { await DialogService.DisplayPopupAsync(); Category = await FirebaseService.GetCategoryAsync(categoryID); States = new ObservableCollection <StateModel>(await FirebaseService.GetStatesAsync(categoryID)); await DialogService.PopAsync(); } }
public MovieDetails(Movie movie, BackablePage moviesPage) { this.currentMovie = movie; this.moviesPage = moviesPage; BindingContext = movie; FirebaseService firebaseService = new FirebaseService(); IsFavourite = firebaseService.CheckIfIsFavourite(AccountManager.GetAccountId(), currentMovie).Result; InitializeComponent(); }
public SongDetails(Song song, BackablePage songsPage) { this.currentSong = song; this.songsPage = songsPage; BindingContext = song; FirebaseService firebaseService = new FirebaseService(); IsFavourite = firebaseService.CheckIfIsFavourite(AccountManager.GetAccountId(), currentSong).Result; InitializeComponent(); }
public BookDetails(Book book, BackablePage booksPage) { this.currentBook = book; this.booksPage = booksPage; BindingContext = book; FirebaseService firebaseService = new FirebaseService(); IsFavourite = firebaseService.CheckIfIsFavourite(AccountManager.GetAccountId(), currentBook).Result; InitializeComponent(); }
protected override void OnCreate(Bundle savedInstanceState) { TabLayoutResource = Resource.Layout.Tabbar; ToolbarResource = Resource.Layout.Toolbar; base.OnCreate(savedInstanceState); Xamarin.Essentials.Platform.Init(this, savedInstanceState); XF.Material.Droid.Material.Init(this, savedInstanceState); Forms.SetFlags("CollectionView_Experimental"); global::Xamarin.Forms.Forms.Init(this, savedInstanceState); LoadApplication(new App()); FirebaseService.Init(this); }
async void Handle_Clicked(object sender, System.EventArgs e) { FirebaseService firebaseService = new FirebaseService(); var result = await firebaseService.PostSurvey(_survey.Key, ((Choice)ChoiceList.SelectedItem).Key); if (result) { await DisplayAlert("Başarılı", "Anket oyunuz gönderilmiştir.", "Tamam"); } else { await DisplayAlert("Başarısız", "Anket oyunuz gönderilemedi.", "Tamam"); } }
private async Task SaveCategoryAsync() { if (!await CanSaveCategoryAsync()) { return; } await DialogService.DisplayPopupAsync(); var parameters = new NavigationParameters(); if (IsUpdated) { parameters.Add("IsUpdated", true); } if (IsNewCategory) { var categoryID = await FirebaseService.InsertCategoryAsync(Category); for (int i = States.Count - 1; i >= 0; i--) { States[i].CategoryID = categoryID; await FirebaseService.InsertStateAsync(States[i]); } } else { await FirebaseService.UpdateCategoryAsync(Category); foreach (var state in States) { if (state.StateID == null) { await FirebaseService.InsertStateAsync(state); } else { await FirebaseService.UpdateStateAsync(state); } } foreach (var state in DeletedStates) { await FirebaseService.DeleteStateAsync(state); } } await DialogService.PopAsync(); await NavigationService.GoBackAsync(parameters); }
private async Task RefreshCategoriesAsync() { await DialogService.DisplayPopupAsync(); var categoriesList = await FirebaseService.GetCategoriesAsync(20, null); if (categoriesList == null) { categoriesList = new List <CategoryModel>(); } Categories = new ObservableCollection <CategoryModel>(categoriesList); await DialogService.PopAsync(); }