private async void Load(object obj)
{
// https://github.com/rlamasb/Firebase.Xamarin
// https://github.com/williamsrz/xamarin-on-fire/blob/master/XOF.Droid/Services/FirebaseService.cs
string firebaseToken = UserSettings.GetFirebaseAuthToken();
var firebase = new FirebaseClient("https://expensetrackermvp.firebaseio.com/");
// Get one
Expense exp = await firebase.Child("Expenses").Child("1").WithAuth(firebaseToken).OnceSingleAsync<Expense>();
ExpenseCollection.Add(exp);
/*var items = await firebase
.Child("Expenses")
.OrderByKey()
.WithAuth(firebaseToken)
.OnceAsync<Expense>();
foreach (var item in items)
{
Expense exp = item.Object;
ExpenseCollection.Add(exp);
}*/
/* Using custom api
string url = GetApiServiceURL("Expenses");
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("User-Agent", "Other");
var response = httpClient.GetAsync(url).Result;
if (response.IsSuccessStatusCode)
{
var content = response.Content;
var responseContent = content.ReadAsStringAsync().Result;
JArray json = JArray.Parse(responseContent);
foreach (JToken item in json)
{
//string desc = JToken.Parse(JToken.Parse(responseContent)[0])["Description"].Value;
//Expense exp = new Expense();
//exp.Description = desc.Value<string>();
Expense e = item.ToObject<Expense>();
ExpenseCollection.Add(e);
}
}
*/
}
private async void GetRewards()
{
try
{
activityIndicator.IsRunning = true;
activityIndicator.IsVisible = true;
var firebase = new FirebaseClient("https://devex-6d4d1.firebaseio.com");
Reward = await firebase.Child("Rewards").Child(DevExMobileApp.Helpers.Settings.UserID).OnceSingleAsync <Reward>();
}
catch
{
}
}
private async void importDatabase_Click(object sender, RoutedEventArgs e)
{
var firebase = new FirebaseClient("https://votingcalculator.firebaseio.com");
getCandidates(false, false, false);
List <Voter> userList = new List <Voter>();
var helperVoters = await firebase.Child("voters").OnceAsync <Voter>();
Votes helperVotes = await firebase.Child("votes").OnceSingleAsync <Votes>();
foreach (var v in helperVoters)
{
Voter voter = new Voter
{
Name = v.Object.Name,
Surname = v.Object.Surname,
HasVoted = v.Object.HasVoted,
ValidVote = v.Object.ValidVote,
Password = v.Object.Password,
VotedCandidate = v.Object.VotedCandidate,
PESEL = v.Object.PESEL
};
userList.Add(voter);
}
DatabaseHelper dbHelper = new DatabaseHelper
{
Candidates = candidatesList,
Voters = userList,
Votes = helperVotes
};
string database = new JavaScriptSerializer().Serialize(dbHelper);
File.WriteAllText(desktopPath + "\\vcDatabase.json", database.ToString());
System.Windows.MessageBox.Show("You can find JSON database file on your desktop as 'vcDatabase.json'.");
}
public async Task <List <Person> > GetAllPersons()
{
return((await firebase
.Child("Persons")
.OnceAsync <Person>()).Select(item => new Person
{
Name = item.Object.Name,
Email = item.Object.Email,
Password = item.Object.Password
}).ToList());
}
public async Task <List <Period> > GetAllPeriods()
{
List <Period> res = (await firebase
.Child("Periods")
.OnceAsync <Period>()).Select(item => new Period
{
PeriodName = item.Object.PeriodName,
ID = item.Object.ID
}).ToList();
return(res);
}
public async Task <List <Category> > GetCategoriesAsync()
{
var categories = (await client.Child("Categories")
.OnceAsync <Category>())
.Select(c => new Category
{
CategoryID = c.Object.CategoryID,
CategoryName = c.Object.CategoryName,
ImageUrl = c.Object.ImageUrl
}).ToList();
return(categories);
}
private async void Actualizar()
{
setDatos();
FirebaseClient client = new FirebaseClient(GLOBAL.baseUrl, new FirebaseOptions
{
AuthTokenAsyncFactory = () => Task.FromResult(token)
});
await client.Child("users/" + localId + "/cars").PutAsync(Newtonsoft.Json.JsonConvert.SerializeObject(vh));
MessageBox.Show("Actualizado correctamente!", "Vehiculos", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.Close();
}
public async Task DisplayChatMessage()
{
try
{
var items = await firebase.Child("chats")
.OnceAsync <MessageContent>();
if (items.Count > 0 && handler != null)
{
handler(items.Select(x => new MessageContent
{
Email = x.Object.Email,
Message = x.Object.Message,
Phone = x.Object.Phone
}).ToList());
}
}
catch (Exception ex)
{
var z = ex.Message;
}
}
private async void Window_LoadedAsync(object sender, RoutedEventArgs e)
{
var authProvider = new FirebaseAuthProvider(new FirebaseConfig("AIzaSyDvTZmLrg8PgrXzo0Gpu7MMMr4EI2JCLlg"));
FirebaseAuthLink auth = await authProvider.SignInWithEmailAndPasswordAsync("*****@*****.**", "generic.man");
var firebase = new FirebaseClient(
"https://stuff-7ea31.firebaseio.com/",
new FirebaseOptions
{
AuthTokenAsyncFactory = () => Task.FromResult(auth.FirebaseToken)
});
await firebase.Child("members").Child("t-rex").PutAsync(new Member());
var members = await firebase.Child("members").OnceAsync <Member>();
foreach (var member in members)
{
Debug.WriteLine($"{member.Object.firstname} {member.Object.lastname}");
}
}
public async Task UpdateNews(Guid NewsId, string naslov1, string vsebina1, string url1)
{
try
{
var toUpdateNews = (await firebase.Child(ChildName).OnceAsync <Newss>()).FirstOrDefault(a => a.Object.NewsId == NewsId);
await firebase.Child(ChildName).Child(toUpdateNews.Key).PutAsync(new Newss()
{
NewsId = NewsId, Naslov = naslov1, Vsebina = vsebina1, Url = url1
});
}
catch (Exception e)
{
await DisplayAlert("Error", e.Message.ToString(), "cancel");
}
finally
{
await DisplayAlert("Success", "The news was edited successfully", "OK");
await Navigation.PopAsync();
}
}
public async Task <IActionResult> OnPost()
{
if (ModelState.IsValid)
{
await firebaseClient.Child("Curso").PostAsync(JsonSerializer.Serialize <CursoF>(CursoF));
return(RedirectToPage("Index"));
}
else
{
return(Page());
}
}
protected async override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
var firebase = new FirebaseClient(FirebaseURL);
Account ac = new Account
{
UserID = 1,
Name = "Kyaw Zin Oo",
Email = "*****@*****.**"
};
try
{
var item = await firebase.Child("account").PostAsync <Account>(ac);
}catch (Exception ex)
{
string str = ex.Message;
}
try
{
int d = Convert.ToInt32("kdd");
} catch (Exception ex) {
Exceptions except = new Exceptions
{
Date = DateTime.Now,
ClassName = "Export DB Helper",
MethodName = "GetDBHelper()",
Exception = ex.Message,
};
await firebase.Child("except").PostAsync <Exceptions>(except);
}
}
public static async Task <List <Recycler> > GetAllRecyclers()
{
try
{
return((await Firebase
.Child("Users/Recyclers")
.OnceAsync <Recycler>()).Select(item => new Recycler
{
Username = item.Object.Username,
Password = item.Object.Password,
FullName = item.Object.FullName,
TotalPoints = item.Object.TotalPoints,
EcoLevel = item.Object.EcoLevel
}).ToList());
}
catch (Exception ex)
{
await Application.Current.MainPage.DisplayAlert("Firebase Exception RDA1", ex.Message, "OK");
return(null);
}
}
private async void GetAgenda()
{
try
{
activityIndicator.IsRunning = true;
activityIndicator.IsVisible = true;
var firebase = new FirebaseClient("https://devex-6d4d1.firebaseio.com");
Agenda = await firebase.Child("Agenda").OnceSingleAsync <Agenda>();
}
catch
{
}
}
private async void eliminarVehiculo(string id)
{
if (MessageBox.Show("Seguro desea eliminar el vehiculo?", "Eliminar", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
FirebaseClient client = new FirebaseClient(GLOBAL.baseUrl, new FirebaseOptions
{
AuthTokenAsyncFactory = () => Task.FromResult(token)
});
await client.Child("users/" + localId + "/cars").Child(id).DeleteAsync();
cargarVehiculos();
}
}
public async Task <List <Toilet> > GetAllToilets()
{
return((await firebase.Child("Toilets").OnceAsync <Toilet>()).Select(item => new Toilet
{
ToiletId = item.Object.ToiletId,
Name = item.Object.Name,
Description = item.Object.Description,
Latitude = item.Object.Latitude,
Longitude = item.Object.Longitude
}).ToList());
}
private async void LoadCF()
{
progressBar.Visibility = ViewStates.Visible;
var firebase = new FirebaseClient(FirebaseURL);
var cfItems = await firebase.Child("cfids").OnceAsync <Cfid>();
foreach (var item in cfItems)
{
if (item.Object.cfid == myAttributes.cfid.ToString())
{
myCFName = item.Object.name;
break;
}
}
var myCFcompanies = await firebase.Child(myAttributes.cfid.ToString()).OnceAsync <Company>();
foreach (var company in myCFcompanies)
{
mItems.Add(company.Object.name);
}
string favoritesFileName = "fav_" + myAttributes.cfid.ToString() + "_" + myAttributes.loginid.ToString();
var myFavorites = await firebase.Child(favoritesFileName).OnceAsync <Favorite>();
List <bool> favList = new List <bool>();
foreach (var favorite in myFavorites)
{
favList.Add(favorite.Object.isFavorite);
}
cfName.Text = myCFName;
CompaniesListViewAdapter adapter = new CompaniesListViewAdapter(mContainer.Context, mItems, favList);
mListView.Adapter = adapter;
progressBar.Visibility = ViewStates.Invisible;
}
public async void Display()
{
var firebase = new FirebaseClient("https://studentappfirebase-667c5.firebaseio.com/");
var Items = await firebase.Child("StudentDetails").OnceAsync <Student>();
//await DisplayAlert("ok", Items.ToString(), "ok");
foreach (var item in Items)
{
Getstudent.Add(item.Object);
}
}
public async Task <IReadOnlyCollection <FirebaseObject <Entidade_Leitura> > > BuscarLeitura(Entidade_Leitura leitura)
{
var firebase = new FirebaseClient("https://inventorypd3.firebaseio.com/");
var leituras = await firebase
.Child(leitura.Cliente)
.Child(DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString("00"))
.OrderByKey()
.StartAt(leitura.CodigoBarras)
.LimitToFirst(1)
.OnceAsync <Entidade_Leitura>();
return(leituras);
}
public async Task <List <Person> > GetAllPersons()
{
return((await firebase
.Child("Persons")
.OnceAsync <Person>()).Select(item => new Person
{
Name = item.Object.Name,
PersonId = item.Object.PersonId,
userdata = item.Object.userdata
}).ToList());
}
public async Task <Dinosaur> getData(FirebaseClient firebase, Object data)
{
var dinos = await firebase
.Child("dinosaurs")
.OnceAsync <Dinosaur>();
foreach (var dino in dinos)
{
Console.WriteLine($"{dino.Key} is {dino.Object.Height}m high.");
}
return(null);
}
public async Task <List <InvestsModel> > GetAllNews()
{
try
{
List <InvestsModel> gn = (await firebase.Child("cities").Child("landls").OnceAsync <InvestsModel>())
.Select(item => new InvestsModel
{
id = item.Object.id,
title = item.Object.title,
image = item.Object.image,
levelname = item.Object.levelname,
shortdesc = item.Object.shortdesc,
longdesc = item.Object.longdesc,
space = item.Object.space
}).OrderByDescending(c => c.id).Take(30).ToList();
return(gn);
}
catch (Exception)
{
return(null);
}
}
public async Task <List <ListData> > GetAllLists()
{
return((await firebase
.Child("Lists")
.OnceAsync <ListData>()).Select(item => new ListData
{
ListId = item.Object.ListId,
Name = item.Object.Name,
Description = item.Object.Description
}).ToList());
}
public async Task <List <User> > GetAllPersons()
{
return((await firebase
.Child("Persons")
.OnceAsync <User>()).Select(item => new User
{
Name = item.Object.Name,
OrgName = item.Object.OrgName,
Gender = item.Object.Gender
}).ToList());
}
async Task MainAsync()
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls13;
using var services = ConfigureServices();
_currentConnection = services.GetRequiredService <Connection>();
_firebaseClient = services.GetRequiredService <FirebaseClient>();
_discordClient = services.GetRequiredService <DiscordSocketClient>();
services.GetRequiredService <CommandService>().Log += log => Task.Factory.StartNew(() => {
Console.WriteLine(log.ToString(null, true, true, DateTimeKind.Utc));
});
_discordClient.Log += log => Task.Factory.StartNew(() => {
Console.WriteLine(log.ToString(null, true, true, DateTimeKind.Utc));
});
_discordClient.Ready += () => Task.Factory.StartNew(async() => {
Console.WriteLine($"{_discordClient.CurrentUser} is connected!");
await _firebaseClient.Child("connectionHistory").PostAsync(_currentConnection);
await _firebaseClient.Child("connection").PutAsync(_currentConnection);
_firebaseClient.Child("connection").AsObservable <dynamic>().Subscribe(async(o) =>
{
if (o.Key == nameof(Connection.LastUpdatedTime))
{
if ((DateTime)o.Object > _currentConnection.LastUpdatedTime)
{
Console.WriteLine("new client detected,ready to close.");
await _discordClient.LogoutAsync();
_firebaseClient.Dispose();
Environment.Exit(0);
}
}
});
});
await _discordClient.LoginAsync(TokenType.Bot, Environment.GetEnvironmentVariable("OnigiriBotToken"));
await _discordClient.StartAsync();
await services.GetRequiredService <CommandHandlingService>().InitializeAsync();
await Task.Delay(Timeout.Infinite);
}
public async Task <ActionResult> About()
{
//Get Okta user data
var identity = (ClaimsIdentity)User.Identity;
IEnumerable <Claim> claims = identity.Claims;
var userEmail = claims.Where(x => x.Type == "email").FirstOrDefault().Value;
var userOktaId = claims.Where(x => x.Type == "sub").FirstOrDefault().Value;
var currentLoginTime = DateTime.UtcNow.ToString("MM/dd/yyyy HH:mm:ss");
//Save non identifying data to Firebase
var currentUserLogin = new LoginData()
{
TimestampUTC = currentLoginTime
};
var firebaseClient = new FirebaseClient("https://pencil-76ef8.firebaseio.com/");
var result = await firebaseClient
.Child("Users/" + userOktaId + "/Logins")
.PostAsync(currentUserLogin);
//Retrieve data from Firebase
var dbLogins = await firebaseClient
.Child("Users")
.Child(userOktaId)
.Child("Logins")
.OnceAsync <LoginData>();
var timestampList = new List <DateTime>();
//Convert JSON data to original datatype
foreach (var login in dbLogins)
{
timestampList.Add(Convert.ToDateTime(login.Object.TimestampUTC).ToLocalTime());
}
//Pass data to the view
ViewBag.CurrentUser = userEmail;
ViewBag.Logins = timestampList.OrderByDescending(x => x);
return(View());
}
public async void EmailData()
{
string uid = DependencyService.Get <IFirebaseAuthenticator>().UserId();
var currentEmail = await firebase.Child("Persons").Child(uid).Child("userinfo").OnceAsync <SignUpUserData>();
foreach (var item in currentEmail)
{
var currentEmailDetails = item.Object.Email;
txtCurrentMail.Text = currentEmailDetails;
}
}
public async Task <List <User> > GetUser()
{
return((await firebase
.Child("user")
.OnceAsync <User>()).Select(item => new User
{
Name = item.Object.Name,
Surname = item.Object.Surname,
//Age = item.Object.Age
}).ToList());
}
private static async Task <IActionResult> ProcessGet(FirebaseClient client, string firebaseId)
{
var profile = await client.Child("profile").Child(firebaseId).OnceSingleAsync <ProfileObject>();
if (profile == null)
{
return(new BadRequestObjectResult(new { message = "User with this firebase id doesn't exist" }));
}
else
{
return(new OkObjectResult(profile));
}
}
private async void GetShop()
{
try
{
activityIndicator.IsRunning = true;
activityIndicator.IsVisible = true;
var firebase = new FirebaseClient("https://devex-6d4d1.firebaseio.com");
ShopItems = await firebase.Child("KudosShop").OnceSingleAsync <List <Shop> >();
}
catch
{
}
}
private async void Display(object sender, System.EventArgs e)
{
var firebase = new FirebaseClient("https://studentappfirebase-667c5.firebaseio.com/");
var Items = await firebase.Child("StudentDetails").OnceAsync <Student>();
//await DisplayAlert("ok", Items.ToString(), "ok");
foreach (var item in Items)
{
studentstore.Add(item.Object);
}
}
