public async Task <ActionResult <DiaryEntry> > PostDiaryEntry(DiaryEntry diaryEntry)
{
_context.DiaryEntries.Add(diaryEntry);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetDiaryEntry), new { id = diaryEntry.Id }, diaryEntry));
}
public async Task <IActionResult> PutDiaryEntry(int id, DiaryEntry diaryEntry)
{
if (id != diaryEntry.Id)
{
return(BadRequest());
}
_context.Entry(diaryEntry).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DiaryEntryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
void SeedDiaries()
{
try
{
var diary = new Diary()
{
CurrentDate = DateTime.Today,
UserName = "******",
};
foreach (var food in _ctx.Foods.Take(1000).ToList().OrderBy(m => Guid.NewGuid()).Take(15))
{
var entry = new DiaryEntry()
{
Diary = diary,
Quantity = 1.5,
};
entry.FoodItem = food;
entry.Measure = food.Measures.First();
diary.Entries.Add(entry);
}
_ctx.Diaries.Add(diary);
_ctx.SaveChanges();
}
catch (Exception ex)
{
throw ex;
}
}
// GET: Diary/Diary/Diary
public ActionResult Diary(Guid?c, DateTime date)
{
ViewBag.Class = c;
List <AgreedDay> ads = db.AgreedDays.Where(d => (d.Date.Day == date.Day && d.Date.Month == date.Month && d.Date.Year == date.Year) && d.ClassId == c).ToList();
List <ToddlerCard> tcs = new List <ToddlerCard>();
foreach (AgreedDay ad in ads)
{
Toddler t = db.Toddlers.Find(ad.ToddlerId);
if (t != null)
{
DiaryEntry de = db.DiaryEntries.Where(en => (en.Date.Day == date.Day && en.Date.Month == date.Month && en.Date.Year == date.Year) && en.ToddlerId == t.Id && en.Status != DiaryEntryStatus.Other && en.Status != DiaryEntryStatus.VideoMessage).OrderByDescending(en => en.Date).FirstOrDefault();
ToddlerCard tc;
if (de != null)
{
tc = new ToddlerCard {
Name = t.FirstName, ToddlerId = t.Id, Status = de.Status
};
}
else
{
tc = new ToddlerCard {
Name = t.FirstName, ToddlerId = t.Id, Status = DiaryEntryStatus.NotArrived
};
}
tcs.Add(tc);
}
}
return(View(tcs));
}
public HttpResponseMessage Delete(DateTime date, int id)
{
try
{
string username = _identityService.CurrentUser;
DiaryEntry diaryEntry = TheRepository.GetDiaryEntry(username, date, id);
if (diaryEntry == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
if (TheRepository.DeleteDiaryEntry(id) && TheRepository.SaveAll())
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
catch (Exception exception)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, exception));
}
}
static void Main(string[] args)
{
var input = "";
UdpClient udpClient = new UdpClient();
udpClient.Connect("127.0.0.1", RemotePort);
while (!string.Equals(input, "EXIT", StringComparison.InvariantCultureIgnoreCase))
{
Console.WriteLine("Write any sentence to add it to the diary. Write \"Exit\" to exit:");
input = Console.ReadLine();
if (!string.Equals(input, "EXIT", StringComparison.InvariantCultureIgnoreCase))
{
var diaryEntry = new DiaryEntry
{
Date = DateTime.UtcNow,
Text = input
};
var byteContent = SerializationUtils.ToByteArray(diaryEntry);
udpClient.Send(byteContent, byteContent.Length);
Console.Clear();
}
}
}
// todo: refactor
// todo: error handling
public static void AddOrUpdate(DiaryEntry entry)
{
try
{
var request = (HttpWebRequest)WebRequest.Create(ResourceUri);
request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
request.ContentType = "application/json";
request.Method = "POST";
using (var streamWriter = new StreamWriter(request.GetRequestStream()))
{
var json = JsonConvert.SerializeObject(entry);
streamWriter.Write(json);
streamWriter.Flush();
streamWriter.Close();
}
// todo: some response should actually be sent
using (var response = (HttpWebResponse)request.GetResponse())
using (var stream = response.GetResponseStream())
using (var reader = new StreamReader(stream))
{
var asd = reader.ReadToEnd();
}
}
catch (Exception e)
{
// todo: smth
}
}
public DiaryEntry Parse(DiaryEntryModel model)
{
try
{
var entry = new DiaryEntry();
if (model.Quantity != default(double))
{
entry.Quantity = model.Quantity;
}
if (!string.IsNullOrWhiteSpace(model.MeasureUrl))
{
var uri = new Uri(model.MeasureUrl);
var measureId = int.Parse(uri.Segments.Last());
var measure = _repo.GetMeasure(measureId);
entry.Measure = measure;
entry.FoodItem = measure.Food;
}
return(entry);
}
catch
{
return(null);
}
}
public void CRUD_One_DiaryEntry_And_Fetch_Runs_Successfully()
{
var connectionManager = new ConnectionManager(DbFile.GetConnectionString("testdb.db"));
var repository = new DiaryEntryRepository(connectionManager);
var dateCreated = DateTime.Parse("2017/03/12 13:12:21");
var entry = new DiaryEntry
{
Title = "New DiaryEntry",
DateCreated = dateCreated.Ticks
};
repository.InsertOne(entry);
var insertedEntity = repository.GetOne(1);
Assert.IsNotNull(entry);
Assert.That(entry.Title, Is.EqualTo("New DiaryEntry"));
Assert.That(new DateTime(entry.DateCreated), Is.EqualTo(dateCreated));
insertedEntity.Title = "Modified DiaryEntry";
repository.UpdateOne(insertedEntity);
var updatedEntity = repository.GetOne(1);
Assert.That(updatedEntity.Title, Is.EqualTo("Modified DiaryEntry"));
repository.DeleteOne(updatedEntity);
var deletedEntity = repository.GetOne(insertedEntity.Id);
Assert.IsNull(deletedEntity);
}
public void StartEntry(DiaryEntry entry)
{
CurrentDiaryEntry = entry;
for (int i = active.Count - 1; i >= 0; i--)
{
active[i].SetActive(false);
disabled.Add(active[i]);
active.RemoveAt(i);
}
if (entry.IsDoneReading)
{
ButtonEntry.SetActive(false);
Content.transform.parent.GetComponent <RectTransform>().offsetMin = new Vector2(0, 6);
foreach (Entry e in entry.Entries)
{
SpawnEntry(e);
}
}
else
{
PhoneManager.instance.InteractButtons(false);
ButtonEntry.SetActive(true);
Content.transform.parent.GetComponent <RectTransform>().offsetMin = new Vector2(0, 36);
index = -1;
}
}
public DiaryEntry Parse(DiaryEntryModel diaryEntry)
{
try
{
if (diaryEntry == null)
{
throw new ArgumentNullException(nameof(diaryEntry));
}
var entry = new DiaryEntry();
if (diaryEntry.Quantity != default(double))
{
entry.Quantity = diaryEntry.Quantity;
}
var uri = new Uri(diaryEntry.MeasureUrl);
var measureId = int.Parse(uri.Segments.Last());
var measure = _countingKsRepository.GetMeasure(measureId);
entry.FoodItem = measure.Food;
entry.Measure = measure;
return(entry);
}
catch
{
return(null);
}
}
private async Task OnAddEntryAsync()
{
DiaryEntry entry = new DiaryEntry();
SelectedEntry = entry;
await this.page?.Navigation.PushAsync(new DiaryEntryPage(new EntryViewModel(entry, this.page)));
}
public void DeleteEntry(DiaryEntry entryToDelete)
{
if (DiaryEntries != null)
{
DiaryEntries.Remove(entryToDelete);
}
}
public ViewModel_DiaryEntry(DiaryEntry page)
{
Entry = page;
CurrentState = PageState.COMPLETED;//When loading a diary entry from save file, it becomes a completed diary entry
BindCommands();
}
public async Task DeleteEntry(DiaryEntry entry)
{
await InitializeAsync();
await entriesTable.DeleteAsync(entry);
await SynchronizeEntriesAsync();
}
public static void MapTo(this DiaryEntry entry, CandidateDiaryEntryEntity entity)
{
entity.title = entry.Title;
entity.description = entry.Description;
entity.startTime = entry.StartTime;
entity.endTime = entry.EndTime;
entity.totalHours = entry.TotalHours;
}
public async Task PostEntry(DiaryEntry entry)
{
await InitializeAsync();
await entriesTable.InsertAsync(entry);
await SynchronizeEntriesAsync();
}
void ICandidatesRepository.CreateDiaryEntry(Guid diaryId, DiaryEntry entry)
{
using (var dc = CreateContext())
{
dc.CandidateDiaryEntryEntities.InsertOnSubmit(entry.Map(diaryId));
dc.SubmitChanges();
}
}
public ActionResult DeleteConfirmed(int id)
{
DiaryEntry diaryEntry = db.Entries.Find(id);
db.Entries.Remove(diaryEntry);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Delete an entry in the Azure DB.
/// </summary>
/// <param name="entry"></param>
/// <returns></returns>
public async Task DeleteEntryAsync(DiaryEntry entry)
{
await InitializeAsync();
await diaryTable.DeleteAsync(entry);
await SynchronizeAsync();
}
public EntryViewModel(DiaryEntry diaryEntry, Page page) : base(page)
{
this.diaryEntry = diaryEntry;
CanSave = false;
Title = "Diary Entry";
Icon = "blog.png";
azureService = azureService ?? Locator.Current.GetService <IMyDiaryService>();
}
private DiaryEntry CreateDiaryEntry()
{
var diaryEntry = DiaryEntry.NewDefault();
diaryEntry.Id = 1;
diaryEntry.Date = new DateTime(2018, 2, 13);
return(diaryEntry);
}
public void AddNewEntry(DiaryEntry newEntry)
{
if (DiaryEntries == null)
{
DiaryEntries = new ObservableCollection <DiaryEntry>();
}
DiaryEntries.Add(newEntry);
}
public async Task Should_Delete_Entry()
{
// Arrange
await DatabaseContext.Database.EnsureDeletedAsync();
var diaryEntry = await _controller.CreateNewEntry(new DiaryEntryCreateModel
{
Description = "Testdescription",
EventAt = new DateTime(2021, 1, 16, 10, 0, 0),
Images = new List <DiaryImageCreateModel>
{
new DiaryImageCreateModel
{
ImageFileName = "Testimages One",
ImageFile = new byte[] { 1, 2, 3 }
},
new DiaryImageCreateModel
{
ImageFileName = "Testimages Two",
ImageFile = new byte[] { 4, 5, 6, 7 }
},
}
});
// Act - Save
var result = (OkObjectResult)await _controller.GetById(diaryEntry.Id);
var savedDiaryEntry = (DiaryEntryViewModel)result.Value;
// Assert
Assert.IsFalse(savedDiaryEntry.IsArchived);
// Act - Delete
var deleteResult = (OkResult)await _controller.DeleteEntry(diaryEntry.Id);
// Assert
var failResult = (BadRequestObjectResult)await _controller.GetById(diaryEntry.Id);
Assert.IsNotNull(result);
Assert.AreEqual("ERROR_DIARY_ENTRY_NOT_FOUND", failResult.Value);
DiaryEntry diaryEntryInDatabase = await DatabaseContext
.Set <DiaryEntry>()
.FirstOrDefaultAsync(x => x.Id == diaryEntry.Id);
Assert.IsNull(diaryEntryInDatabase);
foreach (var diaryImageId in diaryEntry.Images.Select(x => x.Id))
{
var diaryImageInDatabase = await DatabaseContext
.Set <DiaryImage>()
.FirstOrDefaultAsync(x => x.Id == diaryImageId);
Assert.IsNull(diaryImageInDatabase);
}
}
/// <summary>
/// Update an existing entry in the Azure DB.
/// </summary>
/// <param name="entry"></param>
/// <returns></returns>
public async Task UpdateEntryAsync(DiaryEntry entry)
{
Debug.Assert(entry.Id != null);
await InitializeAsync();
await diaryTable.UpdateAsync(entry);
await SynchronizeAsync();
}
/// <summary>
/// Add a new entry to the Azure DB.
/// </summary>
/// <param name="entry"></param>
/// <returns></returns>
public async Task AddEntryAsync(DiaryEntry entry)
{
Debug.Assert(entry.Id == null);
await InitializeAsync();
await diaryTable.InsertAsync(entry);
await SynchronizeAsync();
}
public static DiaryEntry AddEntry(this IEnumerable <DiaryEntry> diary, DiaryEntry newEntry)
{
ICollection <DiaryEntry> diaryList = (ICollection <DiaryEntry>)diary;
if (newEntry != null)
{
diaryList.Add(newEntry);
}
return(newEntry);
}
public DiaryEntryModel Create(DiaryEntry entry)
{
return(new DiaryEntryModel
{
Url = _urlHelper.Link("Diary Entry", new { id = entry.Id, diaryid = entry.Diary.CurrentDate.ToString("yyyy-MM-dd") }),
Quantity = entry.Quantity,
FoodDescription = entry.FoodItem?.Description,
Measure = Create(entry.Measure)
});
}
public DiaryEntryModel Create(DiaryEntry entry)
{
return(new DiaryEntryModel()
{
Url = _urlHelper.Link("DiaryEntries", new { diaryid = entry.Diary.CurrentDate.ToString("yyyy-MM-dd"), id = entry.Id }),
Quantity = entry.Quantity,
FoodDescription = entry.FoodItem.Description,
MeasureDescription = entry.Measure.Description,
MeasureUrl = _urlHelper.Link("Measures", new { foodid = entry.FoodItem.Id, id = entry.Measure.Id })
});
}
public void RemoveDiary(DiaryEntry diaryEntry, List <DiaryEntry> diaryEntries)
{
try
{
diaryEntries.Remove(diaryEntry);
}
catch (Exception ex)
{
_errorManager.LogError(ex);
}
}
public Reminder(string description, DateTime time, bool delivered, bool done, ReminderPriority priority, DiaryEntry entry, bool abs, bool mus, bool tag, bool not)
{
Description = description;
Time = time;
Delivered = delivered;
Done = done;
this.priority = priority;
this.entry = entry;
Abs = abs;
Not = not;
Tag = tag;
Mus = mus;
}
private void AddEntry(Canvas canvas, TimeOfDay when)
{
if (when == TimeOfDay.None)
return;
//editingNote = false;
// Get the date and time corresponding to the canvas which was clicked on.
DateTime date = GetDateForDayInSelectedWeek(GetDayForCanvas(canvas));
DateTime listboxTime = GetTimefromListbox();
// Get any existing diary entry.
DiaryEntry entry = diaryEntryCollection.GetEntry(date, when);
//Reset Check boxes
priorityCheck.IsChecked = false;
c_abs.IsChecked = false;
c_mus.IsChecked = false;
c_not.IsChecked = false;
c_tag.IsChecked = false;
if (entry == null)
{
// No existing entry - create one!
log.Write("Null entry - Creating an entry!");
// ResetKeyboard();
enteredText = diaryEntryCanvas.Text;
// Reset annotations
// underline = false;
// asterisk = false;
// circle = false;
// Initialise new entry
newEntry = new DiaryEntry();
newEntry.Time = when;
newEntry.Date = date;
newEntry.TimeSelected = listboxTime;
newEntry.Text = diaryEntryCanvas.Text;
//Console.WriteLine("This is what is is in diaryEntryCanvas.text when renderEntry is called from line 480: " + diaryEntryCanvas.Text);
//Console.WriteLine("This is what is is in newEntry.text when renderEntry is called from line 480: " + newEntry.Text);
TabAddEntry.IsSelected = true;
RenderEntry();
}
else
{
// An entry exists for this date - let's edit it!
//ResetKeyboard();
diaryEntryCanvas.Text = entry.Text;
if (entry.Reminder.Priority == ReminderPriority.High)
{
priorityCheck.IsChecked = true;
}
//enteredText = entry.Text;
//oldText = entry.Text;
// Reset annotations
//underline = entry.Underline;
//asterisk = entry.Asterisk;
//circle = entry.Circle;
// Initialise new entry
newEntry = entry;
newEntry.Text = entry.Text;
newEntry.Time = entry.Time;
newEntry.Date = entry.Date;
newEntry.TimeSelected = entry.TimeSelected;
newEntry.Abs = entry.Abs;
newEntry.Mus = entry.Mus;
newEntry.Tag = entry.Tag;
newEntry.Not = entry.Not;
//UpdateAnnotationButtons();
TabAddEntry.IsSelected = true;
//RenderEntry();
log.Write("Add entry loaded");
}
}
/// <summary>
/// Renders the given diary entry in the appropriate area of the diary.
/// </summary>
private void RenderDiaryEntry(DiaryEntry entry)
{
Canvas canvas = GetCanvasForDay(entry.Date.DayOfWeek);
//ClearOldEntry(canvas);
log.Write("The canvas in RenderDiaryEntry is: " + canvas.ToString());
int y = 0;
switch (entry.Time)
{
case TimeOfDay.Morning: y = MORNING_OFFSET_Y; break;
case TimeOfDay.Afternoon: y = AFTERNOON_OFFSET_Y; break;
case TimeOfDay.Evening: y = EVENING_OFFSET_Y; break;
case TimeOfDay.Day: y = FOUR_OFFSET_Y; break;
default: y = MORNING_OFFSET_Y; break;
}
log.Write("Canvas is: " + canvas.Name.ToString());
entry.Render(canvas, REMINDER_OFFSET_X, y, REMINDER_WIDTH, REMINDER_HEIGHT, false);
}
