public async Task <ActionResult <NoteItem> > Post(NoteItem note)
{
noteRepository.UserEmail = currentUserService.GetCurrentUserEmail();
await noteRepository.Add(note);
return(CreatedAtAction("Get", new { id = note.Id }, note));
}
/// <summary>
/// Converts a BitwardenItemDTO to a NoteItem
/// </summary>
/// <param name="dto">The BitwardenItemDTO that should be convertet</param>
/// <returns>The convertet NoteItem</returns>
private static NoteItem ConvertNoteItem(BitwardenItemDTO dto)
{
var noteItem = new NoteItem();
noteItem = (NoteItem)ConvertBasic(noteItem, dto);
return(noteItem);
}
public IActionResult Create(NoteItem item)
{
_context.Notes.Add(item);
_context.SaveChanges();
return(CreatedAtRoute("GetNote", new { id = item.Id }, item));
}
public async Task <bool> StoreNote(NoteItem note)
{
if (note == null)
{
throw new ArgumentNullException(nameof(note));
}
await Task.Delay(500);
NoteItem storedNote;
if (!string.IsNullOrEmpty(note.Id))
{
storedNote = _notes.FirstOrDefault(n => n.Id == note.Id);
if (storedNote == null)
{
return(false);
}
storedNote.Title = note.Title;
storedNote.Content = note.Content;
storedNote.LastEdited = DateTime.Now;
NoteEdited?.Invoke(this, new NoteEvent(storedNote.Clone()));
}
else
{
storedNote = note;
storedNote.Id = (_notes.Last().Id + 1); // todo: replace with Snowflake ID...
_notes.Add(storedNote);
NoteAdded?.Invoke(this, new NoteEvent(storedNote.Clone()));
}
return(true);
}
public async Task <BaseResult> SubmitNote(NoteItem noteItem)
{
BaseResult Result = new BaseResult();
if (Preferences.Get("token", null) == null)
{
GetToken();
}
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Preferences.Get("token", null));
var uri = new Uri(string.Format(Constants.submit_note, Preferences.Get("sessionid", null), "app_unique_id"));
var json = JsonConvert.SerializeObject(noteItem);
var postbody = new StringContent(json, Encoding.UTF8, "application/json");
try
{
var response = await _client.PostAsync(uri, postbody);
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
Result = JsonConvert.DeserializeObject <BaseResult>(content);
MessagingCenter.Send(this, "SubmiteNote", Result);
}
}
catch (Exception ex)
{
Debug.WriteLine(@"\tERROR {0}", ex.Message);
}
return(Result);
}
public async Task <ActionResult <NoteItem> > PostNoteItem(NoteItem item)
{
_context.NoteItems.Add(item);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetNoteItem), new { id = item.Id }, item));
}
internal async void Init(string noteItemId)
{
this._currentNoteItem = await _notesService.GetNote(noteItemId);
RaisePropertyChanged(nameof(Title));
RaisePropertyChanged(nameof(Content));
}
public async Task <IActionResult> PutNoteItem([FromRoute] int id, [FromBody] NoteItem noteItem)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != noteItem.id)
{
return(BadRequest());
}
_context.Entry(noteItem).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!NoteItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
// DELETE api/Todo/5
public HttpResponseMessage DeleteNoteItem(int id)
{
NoteItem noteItem = db.NoteItems.Find(id);
if (noteItem == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
if (db.Entry(noteItem.Project).Entity.UserId != User.Identity.Name)
{
// Trying to delete a record that does not belong to the user
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
NoteItemDto todoItemDto = new NoteItemDto(noteItem);
db.NoteItems.Remove(noteItem);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
return(Request.CreateResponse(HttpStatusCode.OK, todoItemDto));
}
// POST api/Todo
public HttpResponseMessage PostNoteItem(NoteItemDto noteItemDto)
{
if (ModelState.IsValid)
{
Project project = db.Projects.Find(noteItemDto.TodoListId);
if (project == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
if (project.UserId != User.Identity.Name)
{
// Trying to add a record that does not belong to the user
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
NoteItem todoItem = noteItemDto.ToEntity();
// Need to detach to avoid loop reference exception during JSON serialization
db.Entry(project).State = EntityState.Detached;
db.NoteItems.Add(todoItem);
db.SaveChanges();
noteItemDto.TodoItemId = todoItem.NoteItemId;
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, noteItemDto);
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = noteItemDto.TodoItemId }));
return(response);
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
private void SetUpTuneByArray(float startIndex, NoteData[] indexItems)
{
var noteNum = indexItems.Length;
for (var i = 0; i < noteNum; i++)
{
var noteData = indexItems[i];
var index = noteData.index;
NoteItem parentNode = null;
var notesLength = noteData.notes.Length;
for (var j = 0; j < notesLength; j++)
{
var child = noteData.notes[j];
var xId = child.x;
var state = child.state;
var offset = child.offset;
var note = CreateOneNote((float)index + offset, xId, state);
noteItems.Add(note);
// 連結子ノーツを親ノーツに追加
switch (state)
{
case NoteState.KillUnit:
// 横連結ノーツの場合
if (notesLength > 1)
{
if (j == 0)
{
var lastChild = noteData.notes[notesLength - 1];
note.hasLine = true;
note.lineLength = lastChild.x - xId;
parentNode = note;
}
else if (j == notesLength - 1)
{
parentNode?.AddChildNote(note);
}
}
break;
case NoteState.KillLinkStart:
parentNode = note;
break;
case NoteState.KillLinkEnd:
parentNode?.AddChildNote(note);
break;
default:
break;
}
}
}
}
public ItemViewModel(NoteItemRepository repository)
{
this.repository = repository;
Item = new NoteItem()
{
DateCreated = DateTime.Now
};
}
public async Task UpdateItem(NoteItem item)
{
await CreateConnection();
await connection.UpdateAsync(item);
OnItemUpdated?.Invoke(this, item);
}
public async Task AddItem(NoteItem item)
{
await CreateConnection();
await connection.InsertAsync(item);
OnItemAdded?.Invoke(this, item);
}
public void DestroyNote(NoteItem note)
{
if (note.Instance)
{
Object.DestroyImmediate(note.Instance, true);
note.Instance = null;
}
}
private async void submiteNote()
{
NoteItem note = new NoteItem {
fromWhom = from.Text, toWhom = receiver.Text, created = DateTime.Now.ToString().Substring(0, 10), noteBody = noteBody.Text, userID = Preferences.Get("userID", null)
};
await App.serviceUtil.SubmitNote(note);
}
public void DestroyNote(NoteItem note)
{
if (note.Instance)
{
Object.DestroyImmediate(note.Instance, true);
note.Instance = null;
}
}
public void InitDragAndDrop(FrameworkElement item, MouseButtonEventArgs e)
{
startPosition = e.GetPosition((IInputElement)e.OriginalSource);
originalSource = e.OriginalSource;
NoteItemViewModel noteItemViewModel = GetNoteItemViewModelFrom(item);
NoteItem noteItem = noteItemViewModel.NoteItem;
ViewModelLocator.ApplicationViewModel.DraggingObject = noteItem;
}
public void EndDialogue()
{
_dialogPanel.SetActive(false);
NoteItem note = _talkingTo.GetComponent <NoteItem>();
if (note != null)
{
_notePad.AddNote(note);
}
}
public void CreateNote(CubeLaneItem item)
{
NoteItem note = new NoteItem();
note.StartTime = DateTime.Now;
note.EndTime = DateTime.Now + TimeSpan.FromMilliseconds(NoteTimeToLive);
note.Parent = item;
note.Instance = (GameObject)Instantiate(item.StartPosition);
(note.Instance.renderer as MeshRenderer).material.color = item.LaneColor;
Notes.Add(note);
}
public NoteViewItem(NoteItem noteItem)
{
_noteItem = noteItem;
Title = noteItem.Title;
Content = noteItem.Content;
Created = noteItem.Created;
LastEdited = noteItem.LastEdited;
DeleteNoteCommand = new RelayCommand(DeleteNoteCommandHandler);
}
public void CreateNote(CubeLaneItem item)
{
NoteItem note = new NoteItem();
note.StartTime = DateTime.Now;
note.EndTime = DateTime.Now + TimeSpan.FromMilliseconds(NoteTimeToLive);
note.Parent = item;
note.Instance = (GameObject)Instantiate(item.StartPosition);
(note.Instance.renderer as MeshRenderer).material.color = item.LaneColor;
Notes.Add(note);
}
/// <summary>
/// After the correct note is hit play music for a while
/// </summary>
/// <param name="note"></param>
void UpdateFadeDelay(NoteItem note)
{
if (note.Parent.FadeDelay < DateTime.Now)
{
note.Parent.FadeDelay = DateTime.Now + TimeSpan.FromMilliseconds(NoteTimeToLive);
}
else
{
note.Parent.FadeDelay += TimeSpan.FromMilliseconds(NoteTimeToLive / 2);
}
}
public async Task AddOrUpdate(NoteItem item)
{
if (item.Id == 0)
{
await AddItem(item);
}
else
{
await UpdateItem(item);
}
}
public Task <int> SaveItemAsync(NoteItem item)
{
if (item.ID != 0)
{
return(Database.UpdateAsync(item));
}
else
{
return(Database.InsertAsync(item));
}
}
public async Task <IActionResult> PostNoteItem([FromBody] NoteItem noteItem)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.NoteItem.Add(noteItem);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetNoteItem", new { id = noteItem.id }, noteItem));
}
private NoteItem CreateOneNote(float index, int xId, NoteState state)
{
var note = new NoteItem();
// ノートに時間情報を付与する
note.timeMsec = GetNoteTimeFromIndex(index);
// 位置IDを付与
note.xId = xId;
// stateを付与
note.state = state;
return(note);
}
public async Task <IActionResult> Put(int id, NoteItem noteItem)
{
noteItem.Id = id;
if (id != noteItem.Id)
{
return(BadRequest());
}
await _noteItemRepository.UpdateAsync(noteItem);
return(NoContent());
}
public async Task <IActionResult> PutNoteItem(long id, NoteItem item)
{
if (id != item.Id)
{
return(BadRequest());
}
_context.Entry(item).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(NoContent());
}
public IActionResult Create([FromBody] NoteItem item)
{
if (item == null)
{
return(BadRequest());
}
m_context.NoteItems.Add(item);
m_context.SaveChanges();
return(CreatedAtRoute("GetNote", new { ID = item.ID }, item));
}
public async Task <IActionResult> Put(Guid id, NoteItem note)
{
if (id != note.Id)
{
return(BadRequest());
}
noteRepository.UserEmail = currentUserService.GetCurrentUserEmail();
await noteRepository.Update(note);
return(NoContent());
}
public void AddNote(NoteItem note)
{
if (!collectedNotes.Contains(note))
{
collectedNotes.Add(note);
note.OnPickup();
if (NoteAdded != null)
{
NoteAdded(this, new NoteItemEventArgs(note));
}
}
}
public void CreateNote(CubeLaneItem item)
{
NoteItem note = new NoteItem();
note.StartTime = DateTime.Now;
note.EndTime = DateTime.Now + TimeSpan.FromMilliseconds(NoteTimeToLive);
note.Parent = item;
note.Instance = (GameObject)Instantiate(item.StartPosition);
(note.Instance.renderer as MeshRenderer).material.color = item.LaneColor;
if (0 == Random.Range(0, 10))
{
note.UseLower = true;
note.Instance.transform.rotation = Quaternion.Euler(0, 15, 0);
}
Notes.Add(note);
}
/// <summary>
/// After the correct note is hit play music for a while
/// </summary>
/// <param name="note"></param>
void UpdateFadeDelay(NoteItem note)
{
if (note.Parent.FadeDelay < DateTime.Now)
{
note.Parent.FadeDelay = DateTime.Now + TimeSpan.FromMilliseconds(NoteTimeToLive);
}
else
{
note.Parent.FadeDelay += TimeSpan.FromMilliseconds(NoteTimeToLive / 2);
}
}
