public async Task getNearbyToilets(ParseGeoPoint location, Boolean shouldSkip)
{
if (currentLocation.Latitude != location.Latitude || currentLocation.Longitude != location.Longitude)
{
//New location, so empty data
_parseToilets.Clear();
currentLocation = location;
}
var query = new ParseQuery<Toilet>();
query = query.WhereNear("Location", location);
query = query.Limit(20);
if (shouldSkip)
{
query = query.Skip(skipCount);
skipCount += 20;
}
IEnumerable<Toilet> result = await query.FindAsync();
if (shouldSkip)
{
result.ToList().ForEach(_parseToilets.Add);
} else
{
_parseToilets.Clear();
result.ToList().ForEach(_parseToilets.Add);
}
foreach (Toilet toilet in _parseToilets)
{
toilet.searchLocationPoint = location;
}
}
public async Task<IEnumerable<PUser>> GetCurrentCompanyUsers(ParseQuery<ParseUser> query = null)
{
IEnumerable<ParseUser> currentCompanyUsers;
if (query == null)
{
var currentUser = await UserUtility.GetCurrentParseUser();
if (currentUser == null)
return new List<PUser>();
currentCompanyUsers = await ParseUser.Query.WhereEqualTo("CompanyId", currentUser["CompanyId"].ToString()).FindAsync();
}
else
currentCompanyUsers = await query.FindAsync();
if (currentCompanyUsers == null)
return new List<PUser>();
return currentCompanyUsers
.Select(user => new PUser
{
Id = user.ObjectId,
Email = user["email"]?.ToString(),
UserName = user["username"]?.ToString(),
Role = (user["Role"]?.ToString() == UserRole.Admin) ? "Admin" : "Employee"
});
}
public async Task<RepositoryResponse<List<City>>> GetCities()
{
var response = new RepositoryResponse<List<City>>
{
Data = new List<City>()
};
try
{
ParseQuery<ParseObject> query = new ParseQuery<ParseObject>("City");
IEnumerable<ParseObject> result = await query.FindAsync();
foreach(ParseObject res in result)
{
response.Data.Add(new City(){ ID = res.ObjectId, NAME = res.Get<String>("Name")});
}
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Error = ex;
}
return response;
}
public async Task GetWorkout(string name)
{
var query = new ParseQuery<Workout>().WhereEqualTo("name", name);
IEnumerable<Workout> result = await query.FindAsync();
if (result.ToList().Count > 0)
_workout = result.ElementAt(0);
await GetExercises();
}
public async Task<IEnumerable<House>> GetHousesAsync(MapFilter mapFilter)
{
var query = new ParseQuery<House>();
//
// if (mapFilter == MapFilter.RecentlyAdded) {
// query = query.WhereGreaterThanOrEqualTo("createdAt",DateTime.Today.AddDays(-3));
// }
if (mapFilter == MapFilter.Top5) {
var houses = await query.FindAsync ();
return houses.GroupBy (x => x.Likes).OrderByDescending(x=>x.Key).Take (5).SelectMany (x => x);
}
var results = await query.FindAsync ();
return results;
}
public async Task<IEnumerable<ITag>> FetchTags(int pageSize, int offset)
{
using (var tokenSource = new CancellationTokenSource(Constants.FetchTagsTimeout))
{
var query = new ParseQuery<ParseTag>().OrderBy(p => p.Text);
if (pageSize > 0 && offset >= 0)
{
query = query.Limit(pageSize).Skip(offset);
}
var result = await query.FindAsync(tokenSource.Token).ConfigureAwait(false);
return result.Select(p => new Tag(p) as ITag);
}
}
public async Task<IEnumerable<ITag>> FindTags(string searchQuery, int pageSize, int offset)
{
using (var tokenSource = new CancellationTokenSource(Constants.FindTagsTimeout))
{
var parseQuery = new ParseQuery<ParseTag>().Where(t => t.Text.StartsWith(searchQuery.Trim())).OrderBy(t => t.Text);
if (pageSize > 0 && offset >= 0)
{
parseQuery = parseQuery.Limit(pageSize).Skip(offset);
}
var result = await parseQuery.FindAsync(tokenSource.Token).ConfigureAwait(false);
return result.Select(s => new Tag(s) as ITag);
}
}
public async Task<IList<Site>> GetNearbySites(double latitude, double longitude, double distanceRadians = 0)
{
if (distanceRadians == 0) distanceRadians = 0.5;
var pos = new ParseGeoPoint(latitude, longitude);
var sitesQuery = new ParseQuery<ApParseSite>()
.WhereWithinDistance("location", pos, new ParseGeoDistance(distanceRadians))
.Limit(100);
var sites = await sitesQuery.FindAsync();
return sites
.Select(s => ConvertToSite(s, pos))
.OrderByDescending(s => s.DistanceKm)
.ToList();
}
/// <summary>
/// Constructs a ParseObject whose id is already known by fetching data
/// from the server.
/// </summary>
/// <param name="objectId">ObjectId of the ParseObject to fetch.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The ParseObject for the given objectId.</returns>
public Task <T> GetAsync(string objectId, CancellationToken cancellationToken)
{
ParseQuery <T> singleItemQuery = new ParseQuery <T>(className).WhereEqualTo("objectId", objectId);
singleItemQuery = new ParseQuery <T>(singleItemQuery, includes: includes, selectedKeys: selectedKeys, limit: 1);
return(singleItemQuery.FindAsync(cancellationToken).OnSuccess(t =>
{
T first = t.Result.FirstOrDefault();
if (first == null)
{
throw new ParseException(ParseException.ErrorCode.ObjectNotFound, "Object with the given objectId not found.");
}
return first;
}));
}
public async void getObject()
{
Console.WriteLine("I reached line 32");
var query = new ParseQuery<TVShowForParse>();
IEnumerable<TVShowForParse> result = await query.FindAsync();
Console.WriteLine("I reached line 37 with count "+result.Count());
foreach (var listItem in result)
{
Console.WriteLine("Show name "+listItem.Name +" with ID "+listItem.TMDBID);
}
}
// RETRIEVE USER TASKS
public async Task GetUserTasks() {
// Get current user's tasks
ParseQuery<ParseObject> userTaskQuery = new ParseQuery<ParseObject>("UserTask").WhereEqualTo("owner", ParseUser.CurrentUser);
IEnumerable<ParseObject> poUserTasks = await userTaskQuery.FindAsync();
// Add each task to UserTasks collection (which will be viewed in WebView)
foreach (var poUserTask in poUserTasks) {
UserTask toAdd = new UserTask() {
Title = poUserTask.Get<string>("title"),
Description = poUserTask.Get<string>("description"),
DueDate = poUserTask.Get<DateTime>("dueDate")
};
UserTasks.Add(toAdd);
UserTasks.OrderBy(x => x.DueDate);
}
}
protected async void BindContactGridView()
{
List<Contact> listOfContacts = new List<Contact>();
var query = new ParseQuery<ParseObject>("Contacts");
IEnumerable<ParseObject> results = await query.FindAsync();
foreach (var item in results)
{
Contact newContact = new Contact();
newContact.FirstName = item.Get<string>("FirstName");
newContact.LastName = item.Get<string>("LastName");
newContact.EmailAddress = item.Get<string>("EmailAddress");
newContact.Message = item.Get<string>("Message");
listOfContacts.Add(newContact);
}
gvContacts.DataSource = listOfContacts;
gvContacts.DataBind();
}
//public async List<Contact> readContacts()
//{
// List<Contact> listOfContacts = new List<Contact>();
// var query = from myContacts in ParseObject.GetQuery("Contacts")
// orderby myContacts.Get<DateTime>("updatedAt") descending
// select myContacts;
// IEnumerable<ParseObject> results = await query.FindAsync();
// foreach (var item in results)
// {
// Contact newContact = new Contact();
// newContact.FirstName = item.Get<string>("FirstName");
// newContact.LastName = item.Get<string>("LastName");
// newContact.EmailAddress = item.Get<string>("EmailAddress");
// newContact.Message = item.Get<string>("Message");
// listOfContacts.Add(newContact);
// }
// return listOfContacts;
//}
public async void readContacts()
{
List<Contact> listOfContacts = new List<Contact>();
//var query = from myContacts in ParseObject.GetQuery("Contacts")
// orderby myContacts.Get<DateTime>("updatedAt") descending
// select myContacts;
ParseQuery<ParseObject> query = new ParseQuery<ParseObject>("Contacts");
IEnumerable<ParseObject> results = await query.FindAsync();
foreach (var item in results)
{
Contact newContact = new Contact();
newContact.FirstName = item.Get<string>("FirstName");
newContact.LastName = item.Get<string>("LastName");
newContact.EmailAddress = item.Get<string>("EmailAddress");
newContact.Message = item.Get<string>("Message");
listOfContacts.Add(newContact);
}
}
public async Task<IList<Site>> GetSites(string searchText, double latitude = 0, double longitude = 0)
{
var sitesQuery = new ParseQuery<ApParseSite>()
.OrderByDescending(x => x.UseCount)
.Limit(100);
if (!string.IsNullOrEmpty(searchText))
{
var lowerSearchText = searchText.ToLower();
sitesQuery = sitesQuery.Where(s => s.Search.Contains(lowerSearchText));
}
else
{
sitesQuery = sitesQuery.WhereGreaterThan("UseCount", 1000);
}
var allSites = (await sitesQuery.FindAsync())
.Select(s => ConvertToSite(s, new ParseGeoPoint(latitude, longitude)));
// Remove duplicates
var siteIds = new HashSet<long>();
var sites = new List<Site>();
foreach (var site in allSites)
{
if (site.SiteId.HasValue)
{
if (!siteIds.Contains(site.SiteId.Value))
{
siteIds.Add(site.SiteId.Value);
sites.Add(site);
}
}
}
return sites
.OrderByDescending(s => s.DistanceKm)
.ThenBy(s => s.UseCount)
.ToList();
}
protected async void BindSurveyGridView()
{
List<Survey> listOfSurveys = new List<Survey>();
var query = new ParseQuery<ParseObject>("Survey");
IEnumerable<ParseObject> results = await query.FindAsync();
foreach (var item in results)
{
Survey newSurvey = new Survey();
newSurvey.Email = item.Get<string>("EmailAddress");
newSurvey.Food = item.Get<string>("Food");
newSurvey.Value = item.Get<string>("Value");
newSurvey.FavoriteDish = item.Get<string>("FavoriteDish");
newSurvey.LeastFavoriteDish = item.Get<string>("LeastFavoriteDish");
newSurvey.Critique = item.Get<string>("Critique");
newSurvey.AddToMenu = item.Get<string>("AddToMenu");
listOfSurveys.Add(newSurvey);
}
gvSurvey.DataSource = listOfSurveys;
gvSurvey.DataBind();
}
public async Task<RepositoryResponse<User>> RegisterUser(User user)
{
var response = new RepositoryResponse<User> { };
try
{
var userObject = new ParseUser()
{
Username = user.USERNAME,
Password = user.PASSWORD
};
userObject["Name"] = user.NAME;
DependencyRepository DependencyContext = new DependencyRepository();
RepositoryResponse<ParseObject> Dependency = await DependencyContext.GetDependencyById(user.ID_DEPENDENCY);
ParseQuery<ParseObject> query = new ParseQuery<ParseObject>("Dependency");
IEnumerable<ParseObject> result = await query.FindAsync();
var relation = userObject.GetRelation<ParseObject>("ID_Dependency");
relation.Add(Dependency.Data);
await userObject.SignUpAsync();
response.Success = true;
response.Data = userObject.ToUser();
// Register was successful.
}
catch (Exception ex)
{
response.Success = false;
response.Error = ex;
}
return response;
}
public async Task<ActionResult> ClientUserList()
{
var query = new ParseQuery<ParseObject>("ClientUser");
IEnumerable<ParseObject> clientUsers = await query.FindAsync();
int count = await query.CountAsync();
List<ClientUser> _clientUsers = new List<ClientUser>();
foreach (ParseObject p in clientUsers)
{
ClientUser clientUser = new ClientUser();
clientUser.ClientUserId = p.ObjectId;
clientUser.firstName = p.Get<string>("firstName");
clientUser.lastName = p.Get<string>("lastName");
clientUser.emailAddress = p.Get<string>("emailAddress");
clientUser.phoneNumber = p.Get<string>("phoneNumber");
clientUser.birthday = p.Get<DateTime>("birthday");
clientUser.address = p.Get<string>("address");
_clientUsers.Add(clientUser);
}
ViewBag.count = count;
return View(_clientUsers);
}
IEnumerator fetchUserPartners()
{
if (fetchingFinished)
{
Debug.Log("fetch Partners");
fetchingFinished = false;
partnerList = new List<ParseUser>(getUserList(ParseUser.CurrentUser, UserValues.PARTNERS));
foreach (ParseUser partner in partnerList)
{
Task userFetchTask = partner.FetchIfNeededAsync();
while (!userFetchTask.IsCompleted) yield return null;
}
bool partnerAdded = false;
ParseQuery<ParseUser> query = new ParseQuery<ParseUser>().WhereEqualTo(UserValues.PARTNERS, ParseUser.CurrentUser);
List<ParseUser> newPartners = new List<ParseUser>();
Task queryTask = query.FindAsync().ContinueWith(t =>
{
IEnumerable<ParseUser> users = t.Result;
foreach (ParseUser user in users)
{
if (!listContainsPartner(partnerList, user))
{
partnerAdded = true;
partnerList.Add(user);
newPartners.Add(user);
Debug.Log("added partner " + (string)user[UserValues.NICK]);
}
}
});
while (!queryTask.IsCompleted) yield return null;
if (partnerAdded)
{
ParseUser.CurrentUser[UserValues.PARTNERS] = partnerList;
Task updateUserTask = ParseUser.CurrentUser.SaveAsync();
while (!updateUserTask.IsCompleted) yield return null;
}
currentPartnerList = partnerList;
fillUserPartners(newPartners);
StartCoroutine(fetchNewMessagePartners());
fetchingFinished = true;
//CancelInvoke("updateMessagesAllUsers");
//InvokeRepeating("updateMessagesAllUsers", 0, longIntervalTime);
}
}
private async Task<IEnumerable<TVEpisodeForParse>> GetParseEpisodeObject()
{
var query = new ParseQuery<TVEpisodeForParse>().WhereEqualTo("userEmail", ParseUser.CurrentUser.Email).WhereEqualTo("tmdbIDShow" , Intent.GetStringExtra("TMDBID"));
IEnumerable<TVEpisodeForParse> result = await query.FindAsync();
Console.WriteLine("Count of returned list is "+result.Count());
return result;
}
public async Task<List<CrueltySpotCategory>> GetAllAsync()
{
var query = new ParseQuery<CrueltySpotCategory>();
var result = await query.FindAsync();
return result.ToList();
}
// kitchen sink handler for text input
public void handleCommand(string entry)
{
string entryRaw = entry.Trim();
entry = entryRaw.ToLower();
if (entry == "") {
textController.showPrompt ();
return;
}
if (state == "login" || state == "signup") {
if (entry == "new") {
startState("signup");
} else {
storage.Add (entryRaw);
startState(state + "2");
}
} else if (state == "login2") {
string username = storage[0].ToString();
storage.Clear();
ParseUser.LogInAsync (username, entry).ContinueWith(t =>
{
// Could do better error handling here and actually inspect the error.
if (t.IsFaulted || t.IsCanceled) {
textController.addLines ("The login failed. Either the password was wrong or the user does not exist.");
startState ("login");
} else {
startState ("main");
}
});
} else if (state == "signup2") {
string username = storage[0].ToString();
storage.Clear();
var user = new ParseUser()
{
Username = username,
Password = entry
};
user.SignUpAsync().ContinueWith(t => {
// Could do better error handling here and actually inspect the error.
if (t.IsFaulted || t.IsCanceled) {
textController.addLines ("The signup failed. That username may already exist.");
startState ("signup");
} else {
startState ("main");
}
});
} else { // if (state == "main") {
var dimensions = new Dictionary<string, string> {
{"command", entry},
{"room", state}
};
ParseAnalytics.TrackEventAsync("command", dimensions);
if (entry == "logout") {
textController.addLines("Logging you out.. see ya later!\n");
ParseUser.LogOut();
startState("login");
} else if (entry == "help") {
textController.addLines ("Available commands:");
textController.addLines ("help display this list");
textController.addLines ("look show the description for this room");
textController.addLines ("score display your score");
textController.addLines ("health display your health");
textController.addLines ("leaderboard show the top 10 scores");
textController.addLines ("go perform the only action available currently");
textController.addLines ("createobject test object creation");
textController.addLines ("logout end your session");
textController.showPrompt();
} else if (entry == "createobject") {
// Example of creating a simple parse object
var obj = ParseObject.Create ("TestObject");
obj["foo"] = "bar";
obj.SaveAsync().ContinueWith(t => {
if (t.IsFaulted || t.IsCanceled) {
textController.addLines ("Object creation failed.");
textController.showPrompt ();
} else {
textController.addLines ("TestObject created with id " + obj.ObjectId + "\n");
textController.showPrompt();
}
});
} else if (entry == "look") {
textController.addLines(roomData["description"].ToString());
textController.showPrompt();
} else if (entry == "eat me") {
textController.addLines("Auto-cannibalism is not the answer.");
textController.showPrompt();
} else if (entry == "score") {
textController.addLines("Your score is: " + ParseUser.CurrentUser.Get<int>("score").ToString());
textController.showPrompt();
} else if (entry == "health") {
textController.addLines("Your health is: " + ParseUser.CurrentUser.Get<int>("health").ToString());
textController.showPrompt();
} else if (entry == "leaderboard") {
var query = new ParseQuery<ParseObject>("Leaderboard").OrderByDescending("score").Limit(10);
query.FindAsync().ContinueWith(t => {
if (t.IsCanceled || t.IsFaulted) {
textController.addLines("Leaderboard listing failed.");
textController.showPrompt();
} else {
textController.addLines ("\nLeaderboard:\n-----------\n");
IEnumerable<ParseObject> results = t.Result;
foreach (ParseObject leader in results) {
textController.addLines (leader.Get<int>("score").ToString() + " (" + leader.Get<string>("username") + ")");
}
textController.addLines ("\n");
textController.showPrompt();
}
});
} else {
ParseCloud.CallFunctionAsync<IDictionary<string, object>>("postMain", new Dictionary<string, object>(){
{"entry", entry}, {"entryRaw", entryRaw}
}).ContinueWith(t => {
if (t.IsCanceled || t.IsFaulted) {
textController.addLines("I do not know the command '" + entry + "'.\nOkay, what do you want to do now?");
textController.showPrompt();
} else {
ParseUser.CurrentUser.FetchAsync();
IDictionary<string, object> result = t.Result;
textController.addLines(result["say"].ToString());
if (result.Keys.Contains("achievement")) {
achievementController.addAchievement(result["achievement"].ToString());
}
if (result.Keys.Contains("setRoom") && result["setRoom"].ToString() != state) {
state = result["setRoom"].ToString();
getState();
} else {
textController.showPrompt();
}
}
});
}
}
}
public async Task<IEnumerable<IProduct>> FetchStoreProducts(string storeID, int pageSize, int offset, bool includeInvisible = false)
{
using (var tokenSource = new CancellationTokenSource(Constants.FetchProductsTimeout))
{
var store = ParseObject.CreateWithoutData<ParseStore>(storeID);
var query = new ParseQuery<ParseProduct>().Where(p => p.Store == store).OrderBy(p => p.LowercaseName);
query = addProductIncludedFields(query);
if (!includeInvisible)
{
query = addProductVisibilityConditions(query);
}
if (pageSize > 0 && offset >= 0)
{
query = query.Limit(pageSize).Skip(offset);
}
var result = await query.FindAsync();
return result.Select(p => new Product(p) as IProduct);
}
}
public async Task<List<Ticket>> parseTickets(ParseQuery<ParseObject> query)
{
List<Ticket> tickets = new List<Ticket>();
Ticket t;
foreach (ParseObject obj in await query.FindAsync())
{
t = new Ticket();
t.Created = obj.CreatedAt.Value.ToLocalTime();
string val;
obj.TryGetValue<string>("subject", out val);
t.Title = val;
obj.TryGetValue<string>("location", out val);
t.Location = val;
obj.TryGetValue<string>("description", out val);
t.Description = val;
obj.TryGetValue<string>("status", out val);
t.Status = val;
obj.TryGetValue<string>("subCategory", out val);
t.SubCategory = val;
tickets.Add(t);
t.ObjectId = obj.ObjectId;
}
return tickets;
}
private async Task ReceiveTrakkedShowsOnCreate()
{
var query = new ParseQuery<TVShowForParse>();
_trakkedShowsEnumerable = await query.FindAsync();
string items = "";
foreach (var listItem in _trakkedShowsEnumerable)
{
items += listItem.Name + ", ";
}
SupportActionBar.Title = "Shows followed are :" + items;
setUpTabLayout();
}
private async Task RetrieveTrakkedShows()
{
var query = new ParseQuery<TVShowForParse>();
_trakkedShowsEnumerable = await query.FindAsync();
var items = _trakkedShowsEnumerable.Aggregate("",
(current, listItem) => current + (listItem.Name + ", "));
SupportActionBar.Title = "Shows followed are :" + items;
_adapter.UpdateList(_trakkedShowsEnumerable);
_adapter.NotifyDataSetChanged();
}
private async Task RetrieveTrakkedShowsList()
{
var query = new ParseQuery<TVShowForParse>();
_trakkedShowsEnumerable = await query.FindAsync();
}
IEnumerator updateNews()
{
IEnumerable<ParseObject> news = null;
ParseQuery<ParseObject> query = new ParseQuery<ParseObject>("News").OrderByDescending("release").WhereLessThanOrEqualTo("release",DateTime.Now);
Task task = query.FindAsync().ContinueWith(t =>
{
news = t.Result;
});
while (!task.IsCompleted) yield return null;
int count = 0;
foreach (ParseObject topic in news)
{
count++;
}
if (count != contentPanel.childCount)
{
clearList();
foreach (ParseObject topic in news)
{
GameObject newsEntry = Instantiate(listEntry) as GameObject;
newsEntry.GetComponent<RectTransform>().SetParent(contentPanel, false);
foreach (RectTransform item in newsEntry.GetComponent<RectTransform>())
{
if (item.gameObject.name.Equals("Image"))
{
foreach (RectTransform subItem in item.GetComponent<RectTransform>())
{
if (subItem.gameObject.name.Equals("Image"))
{
if (topic.ContainsKey("image"))
StartCoroutine(loadImage(subItem.GetComponent<Image>(), topic));
}
}
}
if (item.gameObject.name.Equals("Text"))
{
foreach (RectTransform subItem in item.GetComponent<RectTransform>())
{
if (subItem.gameObject.name.Equals("Headline"))
{
subItem.GetComponent<Text>().text = topic.Get<string>("headline");
}
if (subItem.gameObject.name.Equals("Text"))
{
subItem.GetComponent<Text>().text = topic.Get<string>("text");
}
}
}
}
}
}
}
public async Task<RepositoryResponse<Notification>> AddNotification(Notification notification)
{
var response = new RepositoryResponse<Notification> { };
try
{
var Noti = Parse.ParseObject.Create("Notification");
#region Add Dependency Relationship
DependencyRepository DependencyContext = new DependencyRepository();
RepositoryResponse<ParseObject> Dependency = await DependencyContext.GetDependencyById(notification.ID_DEPENDENCY);
ParseQuery<ParseObject> query = new ParseQuery<ParseObject>("Dependency");
IEnumerable<ParseObject> result = await query.FindAsync();
#endregion
#region Add City Relationship
CityRepository CityContext = new CityRepository();
RepositoryResponse<ParseObject> City = await CityContext.GetCityById(notification.ID_CITY);
query = new ParseQuery<ParseObject>("City");
result = await query.FindAsync();
#endregion
var relation = Noti.GetRelation<ParseObject>("ID_Dependency");
relation.Add(Dependency.Data);
relation = Noti.GetRelation<ParseObject>("ID_City");
relation.Add(City.Data);
var message = string.Format("{0} > {1}: {2}", Dependency.Data["Name"].ToString(), City.Data["Name"].ToString(), notification.NOTIFICATION_TEXT);
Noti.Add("NotificationText", message);
await Noti.SaveAsync();
await Noti.SaveAsync();
var push = new ParsePush();
push.Query = from installation in ParseInstallation.Query
where installation.Get<string>("City").Contains(notification.ID_CITY)
select installation;
push.Alert = message;
await push.SendAsync();
notification.ID = Noti.ObjectId;
response.Data = notification;
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Error = ex;
}
return response;
}
public async Task getParseObjectTask ()
{
ParseObject gameScore = new ParseObject ("GameScore");
gameScore ["score"] = 1337;
gameScore ["playerName"] = "Sean Plott";
await gameScore.SaveAsync ();
var query = new ParseQuery<TVShowForParse> ()
.WhereEqualTo ("showName", "Breaking Bad");
IEnumerable<TVShowForParse> result = await query.FindAsync ();
List<TVShowForParse> list = result.ToList ();
Console.WriteLine ("my list size is " + list.Count + " and at 0 is " + list [0].Get<string> ("imdbID"));
var user = new ParseUser () {
Username = "******",
Password = "******",
Email = "*****@*****.**"
};
// other fields can be set just like with ParseObject
user ["phone"] = "415-392-0202";
await user.SignUpAsync ();
}
public IEnumerator RetrieveParseData()
{
var playerDataQuery = new ParseQuery<ParseObject>("PlayerData").WhereEqualTo("username", ParseUser.CurrentUser.Username);
var queryTask = playerDataQuery.FindAsync();
while (!queryTask.IsCompleted)
yield return null;
IEnumerable<ParseObject> obj = queryTask.Result;
foreach(var player in obj)
{
Debug.LogWarning("retrieved 1 player data profile");
//Debug.Log(player.Get<int>("magnets").ToString());
InterpretParseProfile(player.Get<byte[]>("profile"));
InterpretParseInventoryList(NakedArmorInventory, player.Get<byte[]>("NakedArmoryList"));
InterpretParseInventoryList(MainInventory, player.Get<byte[]>("InventoryList"));
InterpretParseInventoryList(ArmoryInventory, player.Get<byte[]>("ArmoryList"));
//InterpretParseInventoryList(DepositBox, player.Get<byte[]>("DepositBox"));
InterpretParseInventoryList(playerShopInventory, player.Get<byte[]>("PlayerShopList"));
InterpretParseQuestLog(player.Get<byte[]>("questLog"));
//InterpretParseJukeBox(player.Get<byte[]>("JukeBoxList"));
PlayerName = player.Get<string>("playername");
Coins = player.Get<int>("coins");
Magnets = player.Get<int>("magnets");
CitizenPoints = player.Get<int>("citizenpoints");
shopTill = player.Get<int>("shopTill");
BankCoins = player.Get<int>("bankcoins");
hasDoneTutorial = player.Get<bool>("hasDoneTutorial");
parseObjectID = player.Get<string>("parseObjectID");
}
if(hasDoneTutorial)
GameManager.Instance.newGame = false;
else
GameManager.Instance.newGame = true;
ParseQuery<ParseObject> query = ParseObject.GetQuery("PlayerData");
query.GetAsync(parseObjectID).ContinueWith(t =>
{
playerData = t.Result;
});
GUIManager.Instance.IntroGUI.StartGame();
}
private async Task DownloadTrakkedShows()
{
var query = new ParseQuery<TVShowForParse>();
var myListOfShows = await query.FindAsync();
var mySingleton = ParseTVShowListSingleton.Instance;
mySingleton.SetParseTVShows(myListOfShows);
}