/// <summary>
/// Approves a section. Returns true if the section has been approved by everyone.
/// </summary>
/// <param name="username">Username approving</param>
/// <param name="sectionId">Section to approve</param>
/// <returns>Whether section has been approved by all or not</returns>
public async Task <Boolean> ApproveSection(string username, string sectionId)
{
DocumentReference docRef = db.Collection("sections").Document(sectionId);
CollectionReference userRef = db.Collection("users");
DocumentSnapshot snapshot = await docRef.GetSnapshotAsync();
if (snapshot.Exists)
{
Section section = snapshot.ConvertTo <Section>();
if (!section.ApprovedBy.Contains(username))
{
section.ApprovedBy.Add(username);
await docRef.UpdateAsync("ApprovedBy", FieldValue.ArrayUnion(username));
}
QuerySnapshot userSnapshots = await userRef.GetSnapshotAsync();
if (userSnapshots.Count <= section.ApprovedBy.Count())
{
await docRef.UpdateAsync("ApprovedAt", Timestamp.GetCurrentTimestamp());
return(true);
}
}
return(false);
}
public IEnumerator TestCreateViaArrayUnion() {
DocumentReference doc = TestDocument();
var data = new Dictionary<string, object> { { "array", FieldValue.ArrayUnion(1L, 2L) } };
yield return AwaitSuccess(doc.SetAsync(data));
yield return AssertExpectedDocument(
doc, new Dictionary<string, object> { { "array", new List<object> { 1L, 2L } } });
}
public void TakeTeacherAttendance(IList <string> teacherIds, DateTime date)
{
string d = date.ToString("MM/dd/yyyy");
foreach (string teacherId in Teachers.Keys)
{
DocumentReference dr = db.Collection("teachers").Document(teacherId);
DocumentSnapshot snapshot = Teachers[teacherId];
try
{
snapshot.GetValue <string[]>("attended");
if (teacherIds.Contains(teacherId))
{
dr.UpdateAsync("attended", FieldValue.ArrayUnion(d)).Wait();
}
else
{
dr.UpdateAsync("attended", FieldValue.ArrayRemove(d)).Wait();
}
}
catch
{
if (teacherIds.Contains(teacherId))
{
Dictionary <string, object> update = new Dictionary <string, object>
{
{ "attended", new string[] { d } }
};
dr.SetAsync(update, SetOptions.MergeAll).Wait();
}
}
}
}
public async Task updates_existing_document()
{
var sut = CrossFirebaseFirestore.Current;
var pokemon = PokemonFactory.CreateSquirtle();
var path = $"testing/{pokemon.Id}";
var document = sut.GetDocument(path);
await document.SetDataAsync(pokemon);
Assert.Equal(pokemon, (await document.GetDocumentSnapshotAsync <Pokemon>()).Data);
var update = new Dictionary <object, object> {
{ "name", "Cool Squirtle" },
{ "moves", FieldValue.ArrayUnion("Bubble-Blast") },
{ "first_sighting_location.latitude", 13.37 }
};
await document.UpdateDataAsync(update);
var snapshot = await document.GetDocumentSnapshotAsync <Pokemon>();
Assert.Equal("Cool Squirtle", snapshot.Data.Name);
Assert.True(snapshot.Data.Moves.Contains("Bubble-Blast"));
Assert.Equal(13.37, snapshot.Data.FirstSightingLocation.Latitude);
}
public async void AddFoodRecord(string userId, string item, string money, string bookDate)
{
DocumentReference docRef = _db.Collection(userId).Document(bookDate);
DocumentSnapshot docShot = await _db.Collection(userId).Document(bookDate).GetSnapshotAsync();
Dictionary <string, object> record = new Dictionary <string, object> {
{ "Id", Guid.NewGuid().ToString("N") },
{ "Name", item },
{ "Money", money.Contains(".") ? float.Parse(money) : Convert.ToInt32(money) }
};
if (docShot.Exists)
{
if (docShot.GetValue <List <Dictionary <string, object> > > ("list").Count > 0)
{
await docRef.UpdateAsync("list", FieldValue.ArrayUnion(record));
}
else
{
await docRef.SetAsync(new { list = new List <Dictionary <string, object> > ()
{
record
} });
}
}
else
{
await docRef.SetAsync(new { list = new List <Dictionary <string, object> > ()
{
record
} });
}
}
private static void AddAssetRefToEdge(WriteBatch batch, DocumentReference assetRef, DocumentReference edgeRef)
{
Console.WriteLine($"Associating asset ({assetRef.Id}) to edge ({edgeRef.Id})");
batch.Update(edgeRef, new Dictionary <string, object> {
{ nameof(EdgeData.AssetRefs), FieldValue.ArrayUnion(assetRef) },
{ nameof(EdgeData.LastUpdate), Timestamp.GetCurrentTimestamp() }
});
}
//----------------------------------------------------
/**
* Adds a user request to a team
*/
public static async Task AddUserRequestToTeamAsync(string userId, Team team)
{
await CrossCloudFirestore.Current
.Instance
.GetCollection("Team")
.GetDocument(team.Id)
.UpdateDataAsync("member_request", FieldValue.ArrayUnion(userId));
}
public static async Task AddNotificationToUserAsync(string userId, string notification_id)
{
await CrossCloudFirestore.Current
.Instance
.GetCollection("User")
.GetDocument(userId)
.UpdateDataAsync("notifications", FieldValue.ArrayUnion(notification_id));
}
/**
* Adds a team to a user
*/
public static async Task AddTeamToUserAsync(string userId, Team team)
{
await CrossCloudFirestore.Current
.Instance
.GetCollection("User")
.GetDocument(userId)
.UpdateDataAsync("team", FieldValue.ArrayUnion(team.Id));
}
public IEnumerator TestRemoveViaSetMergeArrayRemove() {
DocumentReference doc = TestDocument();
var data = new Dictionary<string, object> { { "array", FieldValue.ArrayUnion(1L, 2L, 3L) } };
yield return AwaitSuccess(doc.SetAsync(data));
data = new Dictionary<string, object> { { "array", FieldValue.ArrayRemove(1L, 3L) } };
AwaitSuccess(doc.SetAsync(data, SetOptions.MergeAll));
yield return AssertExpectedDocument(
doc, new Dictionary<string, object> { { "array", new List<object> { 2L } } });
}
async void Update_Array_Elements()
{
DocumentReference docref = db.Collection("Add_Aray").Document("myDoc");
DocumentSnapshot snap = await docref.GetSnapshotAsync();
if (snap.Exists)
{
await docref.UpdateAsync("My Array", FieldValue.ArrayUnion(123, "abcd", 456));
}
}
public void ArrayUnion()
{
var sentinel = FieldValue.ArrayUnion("a", "b");
var value = ValueSerializer.Serialize(SerializationContext.Default, sentinel);
Assert.Equal(SentinelKind.ArrayUnion, SentinelValue.GetKind(value));
var array = SentinelValue.GetArrayValue(value);
var expected = CreateArray(CreateValue("a"), CreateValue("b")).ArrayValue;
Assert.Equal(expected, array);
}
private static async Task UpdateDocumentArray(string project)
{
FirestoreDb db = FirestoreDb.Create(project);
// [START fs_update_document_array]
DocumentReference washingtonRef = db.Collection("cities").Document("DC");
// Atomically add a new region to the "regions" array field.
await washingtonRef.UpdateAsync("Regions", FieldValue.ArrayUnion("greater_virginia"));
// Atomically remove a region from the "regions" array field.
await washingtonRef.UpdateAsync("Regions", FieldValue.ArrayRemove("east_coast"));
// [END fs_update_document_array]
Console.WriteLine("Updated the Regions array of the DC document in the cities collection.");
}
public IEnumerator TestRemoveObjectsViaUpdateArrayRemove() {
DocumentReference doc = TestDocument();
var data = new Dictionary<string, object> {
{ "array",
FieldValue.ArrayUnion(1L, new Dictionary<string, object> { { "a", "value" } }, 3L) }
};
yield return AwaitSuccess(doc.SetAsync(data));
data = new Dictionary<string, object> {
{ "array", FieldValue.ArrayRemove(new Dictionary<string, object> { { "a", "value" } }) }
};
AwaitSuccess(doc.UpdateAsync(data));
yield return AssertExpectedDocument(
doc, new Dictionary<string, object> { { "array", new List<object> { 1L, 3L } } });
}
// GET: Klant/Create
public async Task <IActionResult> Create(string documentId, Product product)
{
db = FirestoreDatabase.LoadDatabase();
// Fetch 'Klanten' collection
CollectionReference klantenColl = db.Collection("Klanten");
DocumentReference document = klantenColl.Document(documentId);
DocumentSnapshot klantMetNaam = await document.GetSnapshotAsync();
if (product.ProductId != null)
{
await document.UpdateAsync("products", FieldValue.ArrayUnion(product));
return(RedirectToAction(documentId, "Klant/Producten"));
}
return(View(product));
}
public void EditStudent(string studentId, string newClassName, string newStudentName, string newStudentPhone, string newGrade,
string newParentName, string newParentPhone, DateTime newBirthday)
{
DocumentReference dr = db.Collection("students").Document(studentId);
Dictionary <string, object> update = new Dictionary <string, object>
{
{ "studentName", newStudentName },
{ "studentPhone", newStudentPhone },
{ "grade", newGrade },
{ "parentName", newParentName },
{ "parentPhone", newParentPhone },
{ "birthday", newBirthday.ToString("MM/dd/yyyy").Substring(0, 5) }
};
dr.SetAsync(update, SetOptions.MergeAll).Wait();
var w = dr.GetSnapshotAsync();
w.Wait();
Students[studentId] = w.Result;
if (CurrentClass != newClassName)
{
//Remove student from current class
DocumentReference curClass = db.Collection("classes").Document(Classes[CurrentClass]);
curClass.UpdateAsync("students", FieldValue.ArrayRemove(studentId)).Wait();
//add student to new class
DocumentReference newClass = db.Collection("classes").Document(Classes[newClassName]);
try
{
newClass.UpdateAsync("students", FieldValue.ArrayUnion(studentId)).Wait();
}
catch
{
Dictionary <string, object> fields = new Dictionary <string, object>
{
{ "students", new string[] { studentId } }
};
newClass.SetAsync(fields).Wait();
}
}
}
public async Task UpdateSection(string username, Section section)
{
DocumentReference docRef = db.Collection("sections").Document(section.Id);
string[] approvedBy = new string[] { username };
Dictionary <string, object> updates = new Dictionary <string, object> {
{ "Title", section.Title },
{ "Text", section.Text },
{ "ApprovedBy", approvedBy },
{ "ApprovedAt", null }
};
await docRef.UpdateAsync(updates);
await docRef.UpdateAsync("History", FieldValue.ArrayUnion(new HistoryItem {
Action = 1,
ActionBy = username,
ActionAt = Timestamp.GetCurrentTimestamp()
}));
}
//aggiunge un elemento al carrello
public async Task <WriteResult> AddProductToCart(Product pProduct, string pUserUId, int pQuantitySelect)
{
FirestoreDb db = CreateInstanceDB();
FirebaseApp wApp = CreateFirebaseApp();
//per prima cosa viene recuperato il record User a cui è associato
//un elemento di tipo Map relativo al carrello
DocumentReference wDocRef = db.Collection("user").Document(pUserUId);
DocumentSnapshot snapshot = await wDocRef.GetSnapshotAsync();
Dictionary <string, object> wMapCart = new Dictionary <string, object>();
wMapCart.Add("quantita", pQuantitySelect);
wMapCart.Add("uidProdotto", pProduct.UId);
WriteResult wWResult = await wDocRef.UpdateAsync("carrello", FieldValue.ArrayUnion(wMapCart));
return(wWResult);
}
public void TakeAttendance(IList <string> studentIds, DateTime date)
{
string d = date.ToString("MM/dd/yyyy");
// Make sure that takeAttendance is the last call that happens!!!!!
// go through all students in this class
// if they are in the list, add their attendance
// if not, remove their attendance
foreach (string studentId in Students.Keys)
{
DocumentReference dr = db.Collection("students").Document(studentId);
DocumentSnapshot snapshot = Students[studentId];
try
{
snapshot.GetValue <string[]>("attended");
if (studentIds.Contains(studentId))
{
dr.UpdateAsync("attended", FieldValue.ArrayUnion(d)).Wait();
}
else
{
dr.UpdateAsync("attended", FieldValue.ArrayRemove(d)).Wait();
}
}
catch
{
if (studentIds.Contains(studentId))
{
Dictionary <string, object> update = new Dictionary <string, object>
{
{ "attended", new string[] { d } }
};
dr.SetAsync(update, SetOptions.MergeAll).Wait();
}
}
}
CurrentClass = "";
}
public void AddTeacher(string teacherName, string teacherPhone, DateTime birthday)
{
teacherName = teacherName ?? "";
teacherPhone = teacherPhone ?? "";
string bday = birthday.ToString("MM/dd/yyyy").Substring(0, 5);
Dictionary <string, object> teacher = new Dictionary <string, object>
{
{ "teacherName", teacherName },
{ "phone", teacherPhone },
{ "birthday", bday }
};
// check if there is a teacher with this name and birthday?
var w = db.Collection("teachers").AddAsync(teacher);
w.Wait();
DocumentReference dr = w.Result;
string teacherId = dr.Id;
DocumentReference classDoc = db.Collection("classes").Document(Classes[CurrentClass]);
try
{
classDoc.UpdateAsync("teachers", FieldValue.ArrayUnion(teacherId)).Wait();
}
catch
{
Dictionary <string, object> t = new Dictionary <string, object>
{
{ "teachers", new string[] { teacherId } }
};
classDoc.SetAsync(t, SetOptions.MergeAll).Wait();
}
var wa = dr.GetSnapshotAsync();
wa.Wait();
Teachers.Add(teacherId, wa.Result);
teacherList.Add(new KeyValuePair <string, string>(teacherId, teacherName));
teacherList.Sort((a, b) => a.Value.CompareTo(b.Value));
}
public void EditTeacher(string teacherId, string newClassName, string newTeacherName, string newTeacherPhone, DateTime newBirthday)
{
DocumentReference dr = db.Collection("teachers").Document(teacherId);
Dictionary <string, object> update = new Dictionary <string, object>
{
{ "teacherName", newTeacherName },
{ "phone", newTeacherPhone },
{ "birthday", newBirthday.ToString("MM/dd/yyyy").Substring(0, 5) }
};
dr.SetAsync(update, SetOptions.MergeAll).Wait();
var w = dr.GetSnapshotAsync();
w.Wait();
Teachers[teacherId] = w.Result;
if (CurrentClass != newClassName)
{
//Remove student from current class
DocumentReference curClass = db.Collection("classes").Document(Classes[CurrentClass]);
curClass.UpdateAsync("teachers", FieldValue.ArrayRemove(teacherId)).Wait();
//add student from current class
DocumentReference newClass = db.Collection("classes").Document(Classes[newClassName]);
try
{
newClass.UpdateAsync("teachers", FieldValue.ArrayUnion(teacherId)).Wait();
}
catch
{
Dictionary <string, object> t = new Dictionary <string, object>
{
{ "teachers", new string[] { teacherId } }
};
newClass.SetAsync(t, SetOptions.MergeAll).Wait();
}
}
}
public async void AddRecord(string userId, int questionNumber, string className)
{
try {
DocumentReference docRef = _db.Collection("records").Document(userId);
Dictionary <string, object> record = new Dictionary <string, object> {
{ "QuestionNumber", questionNumber },
{ "Answer", "" },
{ "ClassName", className }
};
DocumentSnapshot document = docRef.GetSnapshotAsync().Result;
if (document.Exists)
{
if (document.GetValue <List <Dictionary <string, object> > > ("list").Count > 0)
{
await docRef.UpdateAsync("list", FieldValue.ArrayUnion(record));
}
else
{
await docRef.SetAsync(new { list = new List <Dictionary <string, object> > ()
{
record
} });
}
}
else
{
await docRef.SetAsync(new { list = new List <Dictionary <string, object> > ()
{
record
} });
}
} catch (Exception ex) {
Bot.PushMessage(ex.StackTrace);
// Bot.Notify (new Exception (new Error (ErrCode.D001, Bot.UserInfo.userId, ex.Message).Message));
}
}
public async Task <TwiMLResult> SmsWebhook(SmsRequest request, int numMedia)
{
// Is this number in our database?
var accountsRef = _db.Collection("accounts");
var query = accountsRef.WhereEqualTo("PhoneNumber", request.From);
var querySnapshot = await query.GetSnapshotAsync();
DocumentSnapshot?document;
if (querySnapshot.Count == 0)
{
await accountsRef.Document(Guid.NewGuid().ToString())
.SetAsync(new Dictionary <string, object>()
{
{ "PhoneNumber", request.From }
});
var snapshot = await query.GetSnapshotAsync();
document = snapshot.Documents[0];
}
else
{
document = querySnapshot.Documents[0];
}
// Save the message body if there is one
if (request.Body != null)
{
await document.Reference.UpdateAsync("Messages", FieldValue.ArrayUnion(new Dictionary <string, object>()
{
{ "Text", request.Body },
{ "Timestamp", Timestamp.GetCurrentTimestamp() }
}));
}
var filenames = await SaveMedia(numMedia);
var phone = _context.Phones.FirstOrDefault(x => x.PhoneNumber == request.From);
if (phone == null)
{
phone = new Phone
{
PhoneNumber = request.From,
Images = new List <Models.Image>()
};
_context.Phones.Add(phone);
}
foreach (var(image, thumbnail) in filenames)
{
if (phone.Images == null)
{
phone.Images = new List <Models.Image>();
}
phone.Images.Add(new Models.Image
{
Name = image,
ThumbnailName = thumbnail
});
}
_context.SaveChanges();
var response = new MessagingResponse();
var messageBody = numMedia == 0 ? "Send us an image!" :
$"Thanks for sending us {numMedia} file(s)!";
response.Message(messageBody);
return(TwiML(response));
}
public async Task <WriteResult> AddMenuCategory(String RestaurantID, String MenuCategory)
{
WriteResult writeResult = await Root.Collection("restaurants").Document(RestaurantID).UpdateAsync("MenuCategories", FieldValue.ArrayUnion(MenuCategory));
return(writeResult);
}
public async Task <WriteResult> AddFoods(String RestaurantID, Food food)
{
WriteResult writeResult = await Root.Collection("restaurants").Document(RestaurantID).UpdateAsync("Foods", FieldValue.ArrayUnion(food));
return(writeResult);
}
public void AddStudent(string studentName, string studentPhone, string grade, string parentName, string parentPhone, DateTime birthday)
{
// make sure that no fields are null
studentName = studentName ?? "";
studentPhone = studentPhone ?? "";
grade = grade ?? "";
parentName = parentName ?? "";
parentPhone = parentPhone ?? "";
string bday = birthday.ToString("MM/dd/yyyy").Substring(0, 5);
Dictionary <string, object> student = new Dictionary <string, object>
{
{ "studentName", studentName },
{ "studentPhone", studentPhone },
{ "grade", grade },
{ "parentName", parentName },
{ "parentPhone", parentPhone },
{ "birthday", bday }
};
// check if there is a student with this name and birthday
var q = db.Collection("students")
.WhereEqualTo("studentName", studentName)
.WhereEqualTo("birthday", bday)
.GetSnapshotAsync();
q.Wait();
if (q.Result.Count != 0)
{
return;
}
// add the student
var w = db.Collection("students").AddAsync(student);
w.Wait();
DocumentReference dr = w.Result;
string studentId = dr.Id;
// add them to their class
DocumentReference classDoc = db.Collection("classes").Document(Classes[CurrentClass]);
try
{
classDoc.UpdateAsync("students", FieldValue.ArrayUnion(studentId)).Wait();
}
catch
{
Dictionary <string, object> fields = new Dictionary <string, object>
{
{ "students", new string[] { studentId } }
};
classDoc.SetAsync(fields).Wait();
}
var wa = dr.GetSnapshotAsync();
wa.Wait();
// Update students lists
Students.Add(studentId, wa.Result);
studentList.Add(new KeyValuePair <string, string>(studentId, studentName));
studentList.Sort((a, b) => a.Value.CompareTo(b.Value));
}
