///<summary>Inserts one TaskNote into the database. Provides option to use the existing priKey.</summary>
internal static long Insert(TaskNote taskNote, bool useExistingPK)
{
if (!useExistingPK && PrefC.RandomKeys)
{
taskNote.TaskNoteNum = ReplicationServers.GetKey("tasknote", "TaskNoteNum");
}
string command = "INSERT INTO tasknote (";
if (useExistingPK || PrefC.RandomKeys)
{
command += "TaskNoteNum,";
}
command += "TaskNum,UserNum,DateTimeNote,Note) VALUES(";
if (useExistingPK || PrefC.RandomKeys)
{
command += POut.Long(taskNote.TaskNoteNum) + ",";
}
command +=
POut.Long(taskNote.TaskNum) + ","
+ POut.Long(taskNote.UserNum) + ","
+ DbHelper.Now() + ","
+ "'" + POut.String(taskNote.Note) + "')";
if (useExistingPK || PrefC.RandomKeys)
{
Db.NonQ(command);
}
else
{
taskNote.TaskNoteNum = Db.NonQ(command, true);
}
return(taskNote.TaskNoteNum);
}
private void saveTask()
{
if (note != null)
{
updateTask();
}
else
{
Document document = new Document();
document.setOwner(user.getUsername());
document.setDocument(txtNote.Text);
DocumentDTOImplementation.getInstance().save(document);
Note noteTemp = new Note();
noteTemp.setAuthor(user.getFullName());
noteTemp.setDocumentId(document.getId());
noteTemp.setLastModified(DateTime.Now);
noteTemp.setTitle(txtTitle.Text);
NoteDTOImplementation.getInstance().save(noteTemp);
TaskNote task = new TaskNote();
task.status = (Status)Enum.Parse(typeof(Status), statusComboBox.SelectedItem.ToString());
task.priority = (Priority)Enum.Parse(typeof(Priority), priorityComboBox.SelectedItem.ToString());
task.noteId = noteTemp.getId();
task.dueDate = dueDatePicker.Value;
TaskDTOImplementation.getInstance().save(task);
if (notebook != null)
{
notebook.addNote(noteTemp.getId());
NotebookDTOImplementation.getInstance().update(notebook, DatabaseConstants.COLUMN_NOTESID);
}
}
MessageBox.Show("Task and Note were added succesfully", "Task Added Successfully");
}
public void Remove_RecomputePlanedExecutionTimeForEachTaskInHierarchyTest()
{
TestHelper.ClearDatabase(options);
TaskManager manager = new TaskManager(options);
int count = 5;
int sec = 10;
TaskNote[] tasks = new TaskNote[count];
for (int i = 0; i < tasks.Length; i++)
{
tasks[i] = new TaskNote {
Name = i.ToString(), PlanedExecutionTime = new TimeSpan(0, 0, sec).Ticks
}
}
;
manager.Add(tasks[0]);
manager.Add(tasks[1], tasks[0]);
manager.Add(tasks[2], tasks[1]);
manager.Add(tasks[3], tasks[2]);
manager.Add(tasks[4], tasks[3]);
for (int i = count - 1; i > 0; i--)
{
manager.Remove(tasks[i].Id);
tasks[i] = null;
tasks[0] = manager.Find(tasks[0].Id);
Assert.Equal(GetSec(i * sec), (int)tasks[0].CalculatedPlanedExecutionTime);
}
}
public void Add_CollectSubtasksPlanedExecutionTimeTest()
{
TestHelper.ClearDatabase(options);
TaskManager manager = new TaskManager(options);
int count = 5;
int sec = 10;
TaskNote[] tasks = new TaskNote[count];
for (int i = 0; i < tasks.Length; i++)
{
tasks[i] = new TaskNote {
Name = i.ToString(), PlanedExecutionTime = new TimeSpan(0, 0, sec).Ticks
}
}
;
manager.Add(tasks[0]);
manager.Add(tasks[1], tasks[0]);
manager.Add(tasks[2], tasks[1]);
manager.Add(tasks[3], tasks[2]);
manager.Add(tasks[4], tasks[3]);
// Refresh and assert
for (int i = 0; i < tasks.Length; i++)
{
tasks[i] = manager.Find(tasks[i].Id);
Assert.Equal(GetSec((tasks.Length - i) * sec), (int)tasks[i].CalculatedPlanedExecutionTime);
}
}
public void Remove_Test()
{
TestHelper.ClearDatabase(options);
TaskManager manager = new TaskManager(options);
int count = 5;
TaskNote[] tasks = new TaskNote[count];
for (int i = 0; i < tasks.Length; i++)
{
tasks[i] = new TaskNote {
Name = i.ToString()
}
}
;
manager.Add(tasks[0]);
manager.Add(tasks[1], tasks[0]);
manager.Add(tasks[2], tasks[1]);
manager.Add(tasks[3], tasks[2]);
manager.Add(tasks[4], tasks[3]);
Assert.Throws <NonTerminalException>(() => manager.Remove(tasks[0].Id));
for (int i = count - 1; i > 0; i--)
{
manager.Remove(tasks[i].Id);
Assert.Null(manager.Find(tasks[i].Id));
Assert.Empty(manager.GetDescendants(tasks[i - 1].Id));
}
manager.Remove(tasks[0].Id);
Assert.Null(manager.Find(tasks[0].Id));
}
public async Task <DbResponse <TaskNote> > CompleteTaskAsync(string taskId)
{
TaskNote taks = await GetTaskAsync(taskId);
DbResponse <TaskNote> result = new DbResponse <TaskNote>();
if (taks == null)
{
result.IsSuccessed = false;
result.Errors = new[] { "Task not found" };
}
else if (taks.IsComplete)
{
result.IsSuccessed = false;
result.Errors = new[] { "Task already completed" };
}
else
{
taks.IsComplete = true;
await m_DbContext.SaveChangesAsync();
result.IsSuccessed = true;
}
return(result);
}
public async Task <TaskNoteResponse> UpdateAsync(int id, TaskNote taskNote)
{
var existingtaskNote = await taskNoteRepository.FindByIdAsync(id);
if (existingtaskNote == null)
{
return(new TaskNoteResponse("taskNote not found"));
}
existingtaskNote.Header = taskNote.Header;
existingtaskNote.Description = taskNote.Description;
existingtaskNote.Priority = taskNote.Priority;
existingtaskNote.CreationTime = taskNote.CreationTime;
existingtaskNote.Complete = taskNote.Complete;
try
{
taskNoteRepository.Update(existingtaskNote);
await unitOfWork.CompleteAsync();
return(new TaskNoteResponse(existingtaskNote));
}
catch (Exception ex)
{
return(new TaskNoteResponse($"taskNote update error: {ex.Message}"));
}
}
///<summary>Inserts one TaskNote into the database. Returns the new priKey.</summary>
internal static long Insert(TaskNote taskNote)
{
if(DataConnection.DBtype==DatabaseType.Oracle) {
taskNote.TaskNoteNum=DbHelper.GetNextOracleKey("tasknote","TaskNoteNum");
int loopcount=0;
while(loopcount<100){
try {
return Insert(taskNote,true);
}
catch(Oracle.DataAccess.Client.OracleException ex){
if(ex.Number==1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated")){
taskNote.TaskNoteNum++;
loopcount++;
}
else{
throw ex;
}
}
}
throw new ApplicationException("Insert failed. Could not generate primary key.");
}
else {
return Insert(taskNote,false);
}
}
public async Task <ActionResult> UpdateTask([FromBody] TaskInputDto task, int employeeId)
{
var temp = Db.Set <LTRegistrator.Domain.Entities.Task>().SingleOrDefault(t => t.Id == task.Id && t.Name == task.Name);
if (temp != null)
{
foreach (var item in task.TaskNotes)
{
var note = Db.Set <TaskNote>().FirstOrDefault(tn => tn.Day == item.Day && tn.TaskId == task.Id);
if (note != null && note.Hours != item.Hours)
{
note.Hours = item.Hours;
Db.Set <TaskNote>().Update(note);
await Db.SaveChangesAsync();
}
if (note == null)
{
TaskNote taskNote = new TaskNote
{
TaskId = task.Id,
Day = item.Day,
Hours = item.Hours
};
Db.Set <TaskNote>().Add(taskNote);
await Db.SaveChangesAsync();
}
}
return(Ok());
}
return(NotFound());
}
///<summary>Inserts one TaskNote into the database. Provides option to use the existing priKey.</summary>
public static long Insert(TaskNote taskNote,bool useExistingPK){
if(!useExistingPK && PrefC.RandomKeys) {
taskNote.TaskNoteNum=ReplicationServers.GetKey("tasknote","TaskNoteNum");
}
string command="INSERT INTO tasknote (";
if(useExistingPK || PrefC.RandomKeys) {
command+="TaskNoteNum,";
}
command+="TaskNum,UserNum,DateTimeNote,Note) VALUES(";
if(useExistingPK || PrefC.RandomKeys) {
command+=POut.Long(taskNote.TaskNoteNum)+",";
}
command+=
POut.Long (taskNote.TaskNum)+","
+ POut.Long (taskNote.UserNum)+","
+ DbHelper.Now()+","
+"'"+POut.String(taskNote.Note)+"')";
if(useExistingPK || PrefC.RandomKeys) {
Db.NonQ(command);
}
else {
taskNote.TaskNoteNum=Db.NonQ(command,true);
}
return taskNote.TaskNoteNum;
}
///<summary>Inserts one TaskNote into the database. Returns the new priKey.</summary>
public static long Insert(TaskNote taskNote)
{
if (DataConnection.DBtype == DatabaseType.Oracle)
{
taskNote.TaskNoteNum = DbHelper.GetNextOracleKey("tasknote", "TaskNoteNum");
int loopcount = 0;
while (loopcount < 100)
{
try {
return(Insert(taskNote, true));
}
catch (Oracle.ManagedDataAccess.Client.OracleException ex) {
if (ex.Number == 1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated"))
{
taskNote.TaskNoteNum++;
loopcount++;
}
else
{
throw ex;
}
}
}
throw new ApplicationException("Insert failed. Could not generate primary key.");
}
else
{
return(Insert(taskNote, false));
}
}
private void ActionOnStatusChange(TaskNote task, Commands command)
{
if (command == Commands.Nothing)
{
return;
}
else if (command == Commands.Start)
{
task.StartExecutionDate = DateTime.Now;
}
else if (command == Commands.Pause)
{
task.ExecutionTime += (DateTime.Now - task.StartExecutionDate).Ticks;
}
else if (command == Commands.Resume)
{
task.StartExecutionDate = DateTime.Now;
}
else if (command == Commands.Finish)
{
task.FinishDate = DateTime.Now;
task.ExecutionTime += (DateTime.Now - task.StartExecutionDate).Ticks;
}
else if (command == Commands.Clear)
{
task.CreationDate = DateTime.Now;
task.FinishDate = default(DateTime);
task.StartExecutionDate = default(DateTime);
task.ExecutionTime = default(TimeSpan).Ticks;
}
}
public void GetRoots()
{
TestHelper.ClearDatabase(options);
TaskNote[] tasks = new TaskNote[4];
TaskTreeManager manager = new TaskTreeManager(options);
for (int i = 0; i < tasks.Length; i++)
{
tasks[i] = new TaskNote {
Name = (i + 1).ToString() + "t"
}
}
;
manager.Add(tasks[0]);
manager.Add(tasks[1]);
manager.Add(tasks[2]);
manager.Add(tasks[3], tasks[0]);
List <TaskNote> roots = manager.GetRoots();
Assert.Equal(3, roots.Count);
foreach (TaskNote root in roots)
{
Assert.NotNull(root);
}
}
}
public override void Remove(int id)
{
using (TaskContext db = new TaskContext(options))
{
TaskNote task = db.TaskNotes.Include(t => t.TaskTreeNode).Where(t => t.Id == id).FirstOrDefault();
if (task == null)
{
throw new NotFoundException("Task is not found in database", id);
}
if (db.TaskTreeNodes.Where(note => note.AncestorId == id).FirstOrDefault() != null)
{
throw new NonTerminalException("You can not remove non-terminal task", id);
}
TaskNote ancestor = db.TaskTreeNodes.Include(t => t.Ancestor).Where(t => t.DescendantId == id).SingleOrDefault()?.Ancestor;
if (ancestor != null)
{
CalculateExecutionTimeForAncestor(ancestor, 0, task.CalculatedExecutionTime);
CalculatePlanedExecutionTimeForAncestor(ancestor, 0, task.CalculatedPlanedExecutionTime);
db.TaskTreeNodes.Remove(task.TaskTreeNode);
}
db.TaskNotes.Remove(task);
db.SaveChanges();
}
}
public void Update_OnClearAndOnFinishDateChanges()
{
TestHelper.ClearDatabase(options);
TaskManager manager = new TaskManager(options);
TaskNote task = new TaskNote();
manager.Add(task);
Assert.Equal(DateTime.Now.Date, task.CreationDate.Date);
Assert.Equal(default(DateTime), task.FinishDate);
task.Status = Statuses.InProgress;
manager.Update(task);
task.Status = Statuses.Done;
manager.Update(task);
task = manager.Find(task.Id);
Assert.Equal(DateTime.Now.Date, task.FinishDate.Date);
task.CreationDate = new DateTime(1, 1, 1);
task.Status = Statuses.ToDo;
manager.Update(task);
task = manager.Find(task.Id);
Assert.Equal(DateTime.Now.Date, task.CreationDate.Date);
Assert.Equal(default(DateTime), task.FinishDate);
}
public IActionResult Create(TaskModel model)
{
try
{
TaskNote task = new TaskNote
{
Name = model.Name,
Description = model.Description,
Performers = model.Performers,
PlanedExecutionTime = model.GetPlanedExecutionTime()
};
if (model.AncestorId != default(int))
{
manager.Add(task, model.AncestorId);
}
else
{
manager.Add(task);
}
}
catch (InvalidOperationException ex)
{
return(View("Error", ex.Message));
}
return(Redirect("~/Home/Index"));
}
public async Task <bool> CreateAsync(TaskNote task)
{
await m_DbContext.Tasks.AddAsync(task);
int changes = await m_DbContext.SaveChangesAsync();
return(changes > 0);
}
public TaskNoteModel PrepareTaskNoteModel(TaskNote taskNote)
{
return(new TaskNoteModel
{
CreatedBy = taskNote.User.FullName,
CreatedOn = taskNote.CreatedOn,
Note = taskNote.Note
});
}
private void UpdateDb(TaskNote task)
{
using (TaskContext db = new TaskContext(options))
{
TaskNote curTask = db.TaskNotes.FirstOrDefault(t => t.Id == task.Id);
db.Entry(curTask).CurrentValues.SetValues(task);
db.SaveChanges();
}
}
/**
* Updating the task in the database
*
* @task : the task that will get updated
* @columns : the database columns that will be updated
*
* return true if and only if the update operation was done successfully
**/
public bool update(TaskNote task, params String[] columns)
{
try {
return(taskDAO.update(task, columns));
} catch (Exception e) {
Logging.logInfo(true, e.Message);
}
return(false);
}
public void setCurrentTask(TaskNote tn)
{
if (currentTask != null)
{
currentTask.setCurrent(false);
}
currentTask = tn;
currentTask.setCurrent();
}
private void IsSubtasksCompletable(TaskNote task)
{
List <TaskNote> subtasks = GetDescendants(task.Id);
foreach (TaskNote subtask in subtasks)
{
IsSubtasksCompletable(subtask);
}
ValidateStatusChange(task.Status, Statuses.Done);
}
public void remomeCurrentTask()
{
if (currentChild != null && currentTask != null)
{
DBWorker.removeCurrentTask(currentChild.getChild(), currentTask.getTask());
currentChild.getChild().currentTasks.Remove(currentTask.getTask().DBId);
Destroy(currentTask.gameObject);
currentTask = null;
}
}
private void ConnectDescendatToAncestor(int descendatId, TaskNote ancestor)
{
using (TaskContext db = new TaskContext(options))
{
db.TaskTreeNodes.Add(new TaskTreeNode {
AncestorId = ancestor.Id, DescendantId = descendatId
});
db.SaveChanges();
}
}
public async Task <ActionResult> AddTask([FromRoute] int projectId, int employeeId, [FromBody] TaskInputDto task)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var templateTypeProject = Db.Set <Project>().FirstOrDefault(p => p.TemplateType == TemplateType.HoursPerProject && p.Id == projectId && !p.SoftDeleted);
if (templateTypeProject == null)
{
return(NotFound());
}
var employeeProject = Db.Set <ProjectEmployee>().Where(pe => pe.ProjectId == projectId && pe.EmployeeId == employeeId).FirstOrDefault();
var nameTask = Db.Set <LTRegistrator.Domain.Entities.Task>().Where(t => (t.Name == task.Name || t.Name == templateTypeProject.Name) && t.ProjectId == projectId && t.EmployeeId == employeeId).FirstOrDefault();
if (nameTask == null && templateTypeProject != null && task != null && templateTypeProject.Name == task.Name && employeeProject != null)
{
using (var transaction = Db.Database.BeginTransaction())
{
try
{
LTRegistrator.Domain.Entities.Task newTask = new LTRegistrator.Domain.Entities.Task
{
EmployeeId = employeeId,
ProjectId = projectId,
Name = task.Name
};
Db.Set <LTRegistrator.Domain.Entities.Task>().Add(newTask);
foreach (var item in task.TaskNotes)
{
TaskNote taskNote = new TaskNote
{
TaskId = newTask.Id,
Day = item.Day,
Hours = item.Hours
};
Db.Set <TaskNote>().Add(taskNote);
}
await Db.SaveChangesAsync();
transaction.Commit();
return(Ok());
}
catch (Exception ex)
{
transaction.Rollback();
}
}
}
return(BadRequest());
}
///<summary>Updates one TaskNote in the database.</summary>
internal static void Update(TaskNote taskNote)
{
string command = "UPDATE tasknote SET "
+ "TaskNum = " + POut.Long(taskNote.TaskNum) + ", "
+ "UserNum = " + POut.Long(taskNote.UserNum) + ", "
+ "DateTimeNote= " + POut.DateT(taskNote.DateTimeNote) + ", "
+ "Note = '" + POut.String(taskNote.Note) + "' "
+ "WHERE TaskNoteNum = " + POut.Long(taskNote.TaskNoteNum);
Db.NonQ(command);
}
public void Update_ValidateStatusChange()
{
TestHelper.ClearDatabase(options);
TaskManager manager = new TaskManager(options);
TaskNote task = new TaskNote {
Name = "1t"
};
Statuses[] validChanges =
{
Statuses.InProgress,
Statuses.ToDo,
Statuses.InProgress,
Statuses.Pause,
Statuses.InProgress,
Statuses.Done,
Statuses.ToDo
};
Assert.Equal(Statuses.ToDo, task.Status);
manager.Add(task);
// Must be valid and dont throw exceptions
for (int i = 0; i < validChanges.Length; i++)
{
task.Status = validChanges[i];
manager.Update(task);
}
task.Status = Statuses.Pause;
Assert.Throws <StatusException>(() => manager.Update(task));
task.Status = Statuses.Done;
Assert.Throws <StatusException>(() => manager.Update(task));
task.Status = Statuses.InProgress;
manager.Update(task);
task.Status = Statuses.Pause;
manager.Update(task);
task.Status = Statuses.ToDo;
manager.Update(task);
task.Status = Statuses.Done;
Assert.Throws <StatusException>(() => manager.Update(task));
task.Status = Statuses.InProgress;
manager.Update(task);
task.Status = Statuses.Done;
manager.Update(task);
task.Status = Statuses.Pause;
Assert.Throws <StatusException>(() => manager.Update(task));
}
public void addTaskToCurrent(TaskNote tn)
{
TaskNote taskNote = (TaskNote)Instantiate(taskNotePrefab, tasksLayout);
taskNote.transform.localScale = new Vector3(1, 1, 1);
taskNote.setTask(tn.getTask());
currentChild.getChild().currentTasks.Add(taskNote.getTask().DBId);
DBWorker.addCurrentTask(currentChild.getChild(), tn.getTask());
showAddTask(false);
}
public override void Update(TaskNote newTask)
{
using (TaskContext db = new TaskContext(options))
{
if (db.TaskNotes.Where(t => t.Id == newTask.Id).SingleOrDefault() == null)
{
throw new NotFoundException("Task is not found in database", newTask.Id);
}
UpdateLogic(newTask);
}
}
public void Update_ThrowsNotFoundExceptionTest()
{
TestHelper.ClearDatabase(options);
TaskManager manager = new TaskManager(options);
TaskNote task = new TaskNote {
Name = "1t"
};
Action act = () => manager.Update(task);
Assert.Throws <NotFoundException>(act);
}
void Awake()
{
//FileWorker.readLevelFromFileForNote ("Components\\Levels\\test.cglvl", ref taskNote);
Task[] tasks = DBWorker.loadAllTasks();
//currentTask.setTask (tasks [0]);
for (int i = 0; i < tasks.Length; i++)
{
TaskNote taskNote = (TaskNote)Instantiate(taskNotePrefab, tasksLayout);
taskNote.transform.localScale = new Vector3(1, 1, 1);
taskNote.setTask(tasks [i]);
//taskNote.GetComponent <Button> ().buttonPresed += taskChoised;
}
}
public void taskChoised(TaskNote taskNote)
{
currentTaskView.setTask((taskNote == null ? null : taskNote.getTask()));
if (currentTask != null)
{
currentTask.setCurrent(false);
}
currentTask = taskNote;
if (currentTask != null)
{
currentTask.setCurrent();
}
}
///<summary>Converts a DataTable to a list of objects.</summary>
public static List<TaskNote> TableToList(DataTable table){
List<TaskNote> retVal=new List<TaskNote>();
TaskNote taskNote;
for(int i=0;i<table.Rows.Count;i++) {
taskNote=new TaskNote();
taskNote.TaskNoteNum = PIn.Long (table.Rows[i]["TaskNoteNum"].ToString());
taskNote.TaskNum = PIn.Long (table.Rows[i]["TaskNum"].ToString());
taskNote.UserNum = PIn.Long (table.Rows[i]["UserNum"].ToString());
taskNote.DateTimeNote= PIn.DateT (table.Rows[i]["DateTimeNote"].ToString());
taskNote.Note = PIn.String(table.Rows[i]["Note"].ToString());
retVal.Add(taskNote);
}
return retVal;
}
/// <summary>
/// Saves a note in a task
/// </summary>
/// <param name="note">
/// A <see cref="INote"/>
/// </param>
public override void SaveNote(TaskNote note)
{
Debug.WriteLine ("SaveNote : " + note.Text);
HmNote hmNote = new HmNote (this.task);
hmNote.Text = note.Text;
notes.Clear ();
notes.Add (hmNote);
this.backend.UpdateTask (this);
}
protected override void OnRemoveNote(TaskNote note)
{
rtmBackend.DeleteNote (this, note as RtmNote);
base.OnRemoveNote (note);
}
protected override void OnRemoveNote(TaskNote note)
{
var sqNote = note as SqliteNote;
var command = string.Format ("DELETE FROM Notes WHERE ID='{0}'", sqNote.Id);
backend.Database.ExecuteScalar (command);
base.OnRemoveNote (note);
}
void SaveNote(TaskNote note)
{
var sqNote = note as SqliteNote;
var text = backend.SanitizeText (sqNote.Text);
var command = string.Format ("UPDATE Notes SET Text='{0}' WHERE ID='{1}'", text, sqNote.Id);
backend.Database.ExecuteScalar (command);
}
///<summary>Updates one TaskNote in the database. Uses an old object to compare to, and only alters changed fields. This prevents collisions and concurrency problems in heavily used tables. Returns true if an update occurred.</summary>
public static bool Update(TaskNote taskNote,TaskNote oldTaskNote){
string command="";
if(taskNote.TaskNum != oldTaskNote.TaskNum) {
if(command!=""){ command+=",";}
command+="TaskNum = "+POut.Long(taskNote.TaskNum)+"";
}
if(taskNote.UserNum != oldTaskNote.UserNum) {
if(command!=""){ command+=",";}
command+="UserNum = "+POut.Long(taskNote.UserNum)+"";
}
if(taskNote.DateTimeNote != oldTaskNote.DateTimeNote) {
if(command!=""){ command+=",";}
command+="DateTimeNote = "+POut.DateT(taskNote.DateTimeNote)+"";
}
if(taskNote.Note != oldTaskNote.Note) {
if(command!=""){ command+=",";}
command+="Note = '"+POut.String(taskNote.Note)+"'";
}
if(command==""){
return false;
}
command="UPDATE tasknote SET "+command
+" WHERE TaskNoteNum = "+POut.Long(taskNote.TaskNoteNum);
Db.NonQ(command);
return true;
}
///<summary>Updates one TaskNote in the database.</summary>
public static void Update(TaskNote taskNote){
string command="UPDATE tasknote SET "
+"TaskNum = "+POut.Long (taskNote.TaskNum)+", "
+"UserNum = "+POut.Long (taskNote.UserNum)+", "
+"DateTimeNote= "+POut.DateT (taskNote.DateTimeNote)+", "
+"Note = '"+POut.String(taskNote.Note)+"' "
+"WHERE TaskNoteNum = "+POut.Long(taskNote.TaskNoteNum);
Db.NonQ(command);
}
/// <summary>
/// Deletes a note from a task
/// </summary>
/// <param name="note">
/// A <see cref="INote"/>
/// </param>
public override void DeleteNote(TaskNote note)
{
Debug.WriteLine ("DeleteNote : " + note.Text);
foreach(HmNote hmNote in notes) {
if(string.Equals (hmNote.Text, note.Text)) {
hmNote.Text = null;
notes.Remove(hmNote);
break;
}
}
this.backend.UpdateTask (this);
}
