public RoutePlan GenerateRoute(RouteFilter requestModel)
{
var routePlan = _mapper.Map <RoutePlan>(requestModel);
const double hoursLimit = AvailableHoursPerDay * 0.8;
var startVisitPlaceDate = requestModel.StartDate;
while (requestModel.StartDate.Date <= requestModel.EndDate.Date)
{
var dayActivity = new DayActivity(requestModel.StartDate);
var hoursLeft = AvailableHoursPerDay;
var place = GetRandomPlace(requestModel.City, requestModel.PlaceTypes);
while (place.RecomendedTime.Hours <= hoursLeft)
{
place.SetVisitTime(startVisitPlaceDate);
dayActivity.Places.Add(place);
startVisitPlaceDate = place.EndDateTime;
if (hoursLeft <= hoursLimit)
{
dayActivity.Places.Add(place);
hoursLeft -= place.RecomendedTime.Hours;
}
place = GetPlaceNearby(place.Name, requestModel.PlaceTypes, startVisitPlaceDate);
}
routePlan.SchedulePerDay.Add(dayActivity);
}
return(routePlan);
}
////////////////// Day Task Task////////////////////////////////////
public string AddDayTask(DayActivity dayTask)
{
// string recentAddedEnterdTask = 0; // used it to find the total time used (Spended)by currently running task when user enter the new task
try
{
lock (collisionLock)
{
if (dayTask.DayTaskTrackId != null) //update record
{
database.Update(dayTask);
return(dayTask.DayTaskTrackId);
}
else
{ // enter as new entry
dayTask.DayTaskTrackId = Guid.NewGuid().ToString();
int i = database.Insert(dayTask);
if (i > 0)
{
return(dayTask.DayTaskTrackId);
}
else
{
return(null);
}
}
}
}
catch (Exception ex)
{
//todo
MessagingCenter.Send((App)Xamarin.Forms.Application.Current, AppConstant.ErrorEvent, ex.ToString());
return(null);
}
}
public DayActivityTest()
{
_dummyDbContext = new DummyDBContext();
_dayActivityWithAttendances = _dummyDbContext.DayActivity3;
_dayActivityWithoutAttendances = _dummyDbContext.DayActivity9;
_attendance6 = _dummyDbContext.Attendance6;
}
/// <summary>
/// deleted task base on task track id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public int DeleteTaskBaseOnId(string id)
{
int isDeleteRecord = 0;
DayActivity taskToBeDeleted = databaseHelper.GetDayTaskByTrackId(id);
List <DayActivity> allTasks = databaseHelper.GetAllDayTasksBaseOnDayMonth(taskToBeDeleted.CreatedAt); //date
int tasksToBeDeletedTaskIndex = allTasks.FindIndex(x => x.DayTaskTrackId == id);
isDeleteRecord = allTasks.Count;
if (tasksToBeDeletedTaskIndex == 0)
{ // if task was top most in list
isDeleteRecord = databaseHelper.DeleteDayTaskByTrackId(id);
}
else if (tasksToBeDeletedTaskIndex == allTasks.Count - 1)
{// if bottom most task is about to delete
DayActivity prevTask = allTasks[tasksToBeDeletedTaskIndex - 1];
prevTask.SpentTime = null;
string isUpdated = databaseHelper.AddDayTask(prevTask);
if (isUpdated != null)
{
isDeleteRecord = databaseHelper.DeleteDayTaskByTrackId(id);
}
}
else
{// if any inbetween item is about to delete
DayActivity prevTask = allTasks[tasksToBeDeletedTaskIndex - 1];
DayActivity afterTask = allTasks[tasksToBeDeletedTaskIndex + 1];
prevTask.SpentTime = AppUtil.AppUtil.CalculateSpendedTime(Convert.ToDateTime(prevTask.TaskStartedAt), Convert.ToDateTime(afterTask.TaskStartedAt));
string isUpdated = databaseHelper.AddDayTask(prevTask);
if (isUpdated != null)
{
isDeleteRecord = databaseHelper.DeleteDayTaskByTrackId(id);
}
}
return(isDeleteRecord);
}
/// <summary>
/// when user menually specify the position for task to add in list then this method invoke to maintain the desire sequence of user
/// </summary>
/// <param name="position"></param>
public void ArrangeTask(string date, string position = "Up")
{
DayActivity task = CurrentSelectedDayTask; //selected task from the list (to which up/down new task added)
List <DayActivity> allTasks = databaseHelper.GetAllDayTasksBaseOnDayMonth(date);
int selectedTaskIndex = allTasks.FindIndex(x => x.DayTaskTrackId == CurrentSelectedDayTask.DayTaskTrackId);
DayActivity recentAddedTask = databaseHelper.GetLatestInsertedDayTask();
int recentTaskIndex = allTasks.FindIndex(x => x.DayTaskTrackId == recentAddedTask.DayTaskTrackId);
allTasks.RemoveAt(recentTaskIndex);
if (position.Equals("Up"))
{
allTasks.Insert(selectedTaskIndex, recentAddedTask);
}
else if (position.Equals("Down"))
{
allTasks.Insert(selectedTaskIndex + 1, recentAddedTask);
}
else
{
}
int r = databaseHelper.DeleteAllDayTasksBaseOnDayMonth(date);
if (r > 0)
{
databaseHelper.InsertedGroupOfDayTaskk(allTasks);
}
}
public ActionResult <DayActivity> RemoveActivity(DateTime date, int activityId, TimeOfDay timeOfDay)
{
CustomDay dayToEdit = _customDayRepository.GetByDate(date);
if (dayToEdit == null)
{
return(NotFound());
}
else
{
DayActivity dayActivityToRemove = _dayActivityRepository.GetCustomDayActivity(date, timeOfDay, activityId);
if (dayActivityToRemove == null)
{
return(NotFound());
}
else
{
try
{
dayToEdit.RemoveDayActivity(dayActivityToRemove);
_customDayRepository.SaveChanges();
return(Ok(dayActivityToRemove));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
}
}
private void btnSave_Click(object sender, EventArgs e)
{
try
{
DayActivity activity = new DayActivity
{
System_Created = DateTime.Now,
};
if (!string.IsNullOrEmpty(this.lblId.Text))
{
activity = this.View_QueryResults
.Where(x => x.Id == int.Parse(this.lblId.Text))
.FirstOrDefault();
}
activity.Date = this.date.Value.Date;
activity.Name = this.txtName.Text;
activity.Description = this.txtDescription.Text;
activity.Duration_Hours = decimal.Parse(this.txtDuration.Text);
activity.SystemUpdateDateTime = DateTime.Now;
this.View_SaveRecord(activity);
this.View_GetDatesForCurrentPeriod(this.periodPicker.Value.Date);
this.WindowInputChanges(ModifierState.Save);
}
catch (System.FormatException)
{
MessageBox.Show("Duration should contain a valid decimal number",
"Invalid input, Please try again", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
public ActionResult <DayActivity> RemoveActivity(string templateName, int weekNr, int dayNr, int activityId, TimeOfDay timeOfDay)
{
Day dayToEdit = _dayRepository.GetByWeekAndDay(templateName, weekNr, dayNr);
if (dayToEdit == null)
{
return(NotFound());
}
else
{
DayActivity dayActivityToRemove = _dayActivityRepository.GetTemplateDayActivity(templateName, weekNr, dayNr, timeOfDay, activityId);
if (dayActivityToRemove == null)
{
return(NotFound());
}
else
{
try
{
dayToEdit.RemoveDayActivity(dayActivityToRemove);
_dayRepository.SaveChanges();
return(Ok(dayActivityToRemove));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
}
}
public ActionResult <DayActivity> AddActivity(DateTime date, DayActivityDTO model)
{
CustomDay customDayToEdit = _customDayRepository.GetByDate(date);
if (customDayToEdit == null)
{
return(NotFound());
}
else
{
Activity activity = _activityRepository.GetById(model.ActivityId);
if (activity == null)
{
return(NotFound());
}
else
{
try
{
DayActivity dayActivityToAdd = new DayActivity(customDayToEdit, activity, model.TimeOfDay);
customDayToEdit.AddDayActivity(dayActivityToAdd);
_customDayRepository.SaveChanges();
return(Ok(dayActivityToAdd));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
}
}
public ActionResult <Attendance> Remove(DateTime date, TimeOfDay timeOfDay, int activityId, int userId)
{
DayActivity dayActivity = _dayActivityRepository.GetCustomDayActivity(date, timeOfDay, activityId);
if (dayActivity == null)
{
return(NotFound());
}
else
{
Attendance attendanceToRemove = _attendanceRepository.GetForUser(date, timeOfDay, activityId, userId);
if (attendanceToRemove == null)
{
return(NotFound());
}
else
{
try
{
dayActivity.RemoveAttendance(attendanceToRemove);
_dayActivityRepository.SaveChanges();
return(Ok(attendanceToRemove));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
}
}
public ActionResult <Attendance> Add(DateTime date, TimeOfDay timeOfDay, int activityId, int userId)
{
DayActivity dayActivity = _dayActivityRepository.GetCustomDayActivity(date, timeOfDay, activityId);
if (dayActivity == null)
{
return(NotFound());
}
else
{
User user = _userRepository.GetById(userId);
if (user == null)
{
return(NotFound());
}
else
{
try
{
Attendance attendanceToAdd = new Attendance(dayActivity, user);
dayActivity.AddAttendance(attendanceToAdd);
_dayActivityRepository.SaveChanges();
return(Ok(attendanceToAdd));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
}
}
public ActionResult <DayActivity> AddActivity(string templateName, int weekNr, int dayNr, DayActivityDTO model)
{
Day dayToEdit = _dayRepository.GetByWeekAndDay(templateName, weekNr, dayNr);
Activity activity = _activityRepository.GetById(model.ActivityId);
DayActivity dayActivityToAdd = new DayActivity(dayToEdit, activity, model.TimeOfDay);
dayToEdit.AddDayActivity(dayActivityToAdd);
_dayRepository.SaveChanges();
return(dayActivityToAdd);
}
/// <summary>
/// update the day task
/// </summary>
/// <param name="dayTask"></param>
/// <returns></returns>
public string UpDateDayTask(DayActivity dayTask)
{
string isUpdatededTask = databaseHelper.AddDayTask(dayTask);
if (isUpdatededTask != null)
{
return(isUpdatededTask);
}
return(null);
}
string prevSelectedTaskTitle; //previously selected task title in case of edit request
public AddDayActivityPopupViewModel(INavigation nav)
{
StartTime = DateTime.Now;
taskList = new ObservableCollection <string>();
tasktypesList = new List <string>();
navigation = nav;
isDayTaskEditRequest = false;
_newDayTask = new DayActivity();
// CurrentSelectedDayTask = new DayTask();
TasktypesList = AppUtil.AppUtil.TaskksTypesList();
}
/// <summary>
/// Add task from Stats page
/// </summary>
/// <param name="dayTask"></param>
/// <param name="position"></param>
public AddDayTaskPopupPageView(DayActivity dayTask, string position = "Up")
{
InitializeComponent();
addDayTaskPopupViewModel = new AddDayActivityPopupViewModel(Navigation);
BindingContext = addDayTaskPopupViewModel;
SelectedDayTask = dayTask;
insertedTaskPosition = position;
isDayTaskEditRequest = false;
addDayTaskPopupViewModel.SelectedTask = "Select Task";
addDayTaskPopupViewModel.SelectedTaskType = "Select Task Type";
}
public ActionResult <CustomDay> Edit(DateTime date, CustomDayDTO model)
{
CustomDay dayToEdit = _customDayRepository.GetByDate(date);
if (dayToEdit == null)
{
return(NotFound());
}
else
{
if (!dayToEdit.WeekNr.Equals(model.TemplateName) || (dayToEdit.WeekNr != model.WeekNr) || (dayToEdit.DayNr != model.DayNr))
{
try
{
Day templateDayChosen = _dayRepository.GetByWeekAndDay(model.TemplateName, model.WeekNr, model.DayNr);
dayToEdit.TemplateName = templateDayChosen.TemplateName;
dayToEdit.WeekNr = templateDayChosen.WeekNr;
dayToEdit.DayNr = templateDayChosen.DayNr;
dayToEdit.DayActivities = new List <DayActivity>();
dayToEdit.Helpers = new List <Helper>();
foreach (DayActivity dayActivity in templateDayChosen.DayActivities)
{
DayActivity dayActivityToAdd = new DayActivity(dayToEdit, dayActivity.Activity, dayActivity.TimeOfDay);
dayToEdit.AddDayActivity(dayActivityToAdd);
}
foreach (Helper helper in templateDayChosen.Helpers)
{
Helper helperToAdd = new Helper(dayToEdit, helper.User);
dayToEdit.AddHelper(helperToAdd);
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
try
{
dayToEdit.Date = model.Date;
dayToEdit.PreDish = model.PreDish;
dayToEdit.MainDish = model.MainDish;
dayToEdit.Dessert = model.Dessert;
_customDayRepository.SaveChanges();
return(Ok(dayToEdit));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
};
}
}
/// <summary>
/// retrieve and return the most lastly inserted dAY task
/// </summary>
/// <returns></returns>
public DayActivity GetLastlyAddedDayTask()
{
DayActivity task = databaseHelper.GetLatestInsertedDayTask();
if (task != null)
{
return(task);
}
else
{
return(null);
}
}
/// <summary>
/// retrieve and return the dAY task base on specific track id
/// </summary>
/// <param name="trackId"></param>
/// <returns></returns>
public DayActivity GetDayTaskByTrackId(string trackId)
{
DayActivity task = databaseHelper.GetDayTaskByTrackId(trackId);
if (task != null)
{
return(task);
}
else
{
return(null);
}
}
/// <summary>
/// List item selected handler
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DayTaskList_ItemSelected(object sender, SelectedItemChangedEventArgs e)
{
if (e.SelectedItem == null)
{
isAnyItemSelected = false;
return; //ItemSelected is called on deselection, which results in SelectedItem being set to null
}
else
{
isAnyItemSelected = true;
var selectedTask = ((ListView)sender).SelectedItem;
selectedDayTask = (DayActivity)selectedTask;
}
}
public void RemoveActivity_Succeeds()
{
DateTime date = DateTime.Today;
int activityId = 2;
TimeOfDay timeOfDay = TimeOfDay.AVOND;
_customDayRepository.Setup(c => c.GetByDate(date)).Returns(_dummyDBContext.CustomDay1);
_dayActivityRepository.Setup(d => d.GetCustomDayActivity(date, timeOfDay, activityId)).Returns(_dummyDBContext.DayActivity2);
ActionResult <DayActivity> actionResult = _controller.RemoveActivity(date, activityId, timeOfDay);
var response = actionResult?.Result as OkObjectResult;
DayActivity dayActivity = response?.Value as DayActivity;
Assert.Equal("Koken", dayActivity.Activity.Name);
_customDayRepository.Verify(a => a.SaveChanges(), Times.Once);
}
/// <summary>
/// Retrieve task from DB bases on id
/// populate it to view
/// </summary>
/// <param name="id"></param>
public void RetrieveAndPopulateTaskToViewBaseOnId(string id)
{
try
{
DayActivity dayTask = databaseHelper.GetDayTaskByTrackId(id);
CurrentSelectedDayTask = dayTask;
SelectedTaskType = dayTask.TaskType;
SelectedTask = dayTask.TaskTitle;
prevSelectedTaskTitle = dayTask.TaskTitle;
isDayTaskEditRequest = true;
StartTime = Convert.ToDateTime(dayTask.TaskStartedAt);
}
catch (Exception ex)
{
MessagingCenter.Send((App)Xamarin.Forms.Application.Current, AppConstant.ErrorEvent, ex.ToString());
}
}
/// <summary>
/// find range items from list to add the new item(day task)
/// </summary>
public void SaveTask()
{
try
{
DayActivity dayTask = PrepareDayTaskModel();
bool isFoundFlage = false;
List <DayActivity> allTasks = databaseHelper.GetAllDayTasksBaseOnDayMonth(dayTask.CreatedAt);
DateTime st = new DateTime(Convert.ToDateTime(dayTask.CreatedAt).Year, Convert.ToDateTime(dayTask.CreatedAt).Month, Convert.ToDateTime(dayTask.CreatedAt).Day, Convert.ToDateTime(dayTask.CreatedAt).Hour, Convert.ToDateTime(dayTask.CreatedAt).Minute, Convert.ToDateTime(dayTask.CreatedAt).Second, Convert.ToDateTime(dayTask.TaskStartedAt).Kind);
if (allTasks.Count > 0)
{ // if there are more than one item in the list then this block invoke
isFoundFlage = true;
//find the rang items(time range) in between item/task need to move to mainain the sequence
for (int i = 0; i < allTasks.Count; i++)
{
if (DateTime.Compare(Convert.ToDateTime(Convert.ToDateTime(dayTask.TaskStartedAt).ToString("hh:mm:ss tt")), Convert.ToDateTime(Convert.ToDateTime(allTasks[i].TaskStartedAt).ToString("hh:mm:ss tt"))) < 0)
{ //if appropriate range item found then add task between it
SaveDayTask(allTasks[i], dayTask, "Up");
isFoundFlage = false;
break;
}
}
if (isFoundFlage)
{
//if no appropriate range item found and there are more than one item in the list then
//needs to append task at bottom of list
SaveDayTask(allTasks[allTasks.Count - 1], dayTask, "Down");
isFoundFlage = false;
}
}
else if (allTasks.Count == 0)
{ //if there is not item in current day then add it as a first day task
string isUpdated = databaseHelper.AddDayTask(dayTask);
if (isUpdated != null)
{
Settings.LatestInsertedDayTaskTrackId = isUpdated;
OpenTaskStatsViewPageHandler(DateTime.Now.ToString("yyyy-MM-dd"), null);
}
}
}
catch (Exception ex)
{
MessagingCenter.Send((App)Xamarin.Forms.Application.Current, AppConstant.ErrorEvent, ex.ToString());
}
}
public void RemoveActivity_Succeeds()
{
string templateName = "eerste_week_eerste_dag";
int weekNr = 1;
int dayNr = 1;
int activityId = 1;
TimeOfDay timeOfDay = TimeOfDay.VOLLEDIG;
_dayRepository.Setup(d => d.GetByWeekAndDay(templateName, weekNr, dayNr)).Returns(_dummyDBContext.Day1);
_dayActivityRepository.Setup(d => d.GetTemplateDayActivity(templateName, weekNr, dayNr, timeOfDay, activityId)).Returns(_dummyDBContext.DayActivity1);
ActionResult <DayActivity> actionResult = _controller.RemoveActivity(templateName, weekNr, dayNr, activityId, timeOfDay);
var response = actionResult?.Result as OkObjectResult;
DayActivity dayActivity = response?.Value as DayActivity;
Assert.Equal(TimeOfDay.VOLLEDIG, dayActivity.TimeOfDay);
_dayRepository.Verify(d => d.SaveChanges(), Times.Once());
}
public void UpdateWindow(int rowIndex)
{
try
{
int id = int.Parse(this.recordGrid.Rows[rowIndex].Cells[DailyActivityController.ID_INDEX].Value.ToString());
DayActivity dailyActivity = this.View_QueryResults
.Where(x => x.Id == id)
.FirstOrDefault();
this.lblId.Text = dailyActivity.Id.ToString();
this.date.Value = dailyActivity.Date.Date;
this.txtName.Text = dailyActivity.Name;
this.txtDescription.Text = dailyActivity.Description;
this.txtDuration.Text = dailyActivity.Duration_Hours.ToString();
}
catch (ArgumentOutOfRangeException) { /*Skip*/ }
catch (Exception ex)
{
throw ex;
}
}
public void AddActivityToDay_Succeeds()
{
DateTime date = DateTime.Today;
DayActivityDTO dayActivityDTO = new DayActivityDTO()
{
ActivityId = 2,
TimeOfDay = TimeOfDay.VOORMIDDAG,
Attendances = null
};
_customDayRepository.Setup(c => c.GetByDate(date)).Returns(_dummyDBContext.CustomDay1);
_activityRepository.Setup(a => a.GetById(dayActivityDTO.ActivityId)).Returns(_dummyDBContext.Activity2);
ActionResult <DayActivity> actionResult = _controller.AddActivity(date, dayActivityDTO);
var response = actionResult?.Result as OkObjectResult;
DayActivity dayActivity = response?.Value as DayActivity;
Assert.Equal(TimeOfDay.VOORMIDDAG, dayActivity.TimeOfDay);
_customDayRepository.Verify(a => a.SaveChanges(), Times.Once);
}
public ActionResult <CustomDay> Add(CustomDayDTO model)
{
Day templateDayChosen = _dayRepository.GetByWeekAndDay(model.TemplateName, model.WeekNr, model.DayNr);
if (templateDayChosen == null)
{
return(NotFound());
}
else
{
try
{
CustomDay customDayToCreate = new CustomDay(templateDayChosen.TemplateName, templateDayChosen.WeekNr, templateDayChosen.DayNr, model.Date, model.PreDish, model.MainDish, model.Dessert);
if (_customDayRepository.GetByDate(customDayToCreate.Date) != null)
{
return(BadRequest("A day for this date already exists"));
}
foreach (DayActivity dayActivity in templateDayChosen.DayActivities)
{
DayActivity dayActivityToAdd = new DayActivity(customDayToCreate, dayActivity.Activity, dayActivity.TimeOfDay);
customDayToCreate.AddDayActivity(dayActivityToAdd);
}
foreach (Helper helper in templateDayChosen.Helpers)
{
Helper helperToAdd = new Helper(customDayToCreate, helper.User);
customDayToCreate.AddHelper(helperToAdd);
}
_customDayRepository.Add(customDayToCreate);
_customDayRepository.SaveChanges();
return(Ok(customDayToCreate));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
}
/// <summary>
/// Formalize the new day task
/// </summary>
/// <returns></returns>
public DayActivity PrepareDayTaskModel()
{
try
{
DayActivity dayTask = new DayActivity();
dayTask.TaskTitle = CurrentSelectedTaskk.Title;
dayTask.TaskType = CurrentSelectedTaskk.TaskType;
dayTask.IsSelected = false;
dayTask.DayTaskTrackId = null;
dayTask.TaskStartedAt = AppUtil.AppUtil.CurrrentDateTimeInSqliteSupportedFormate();
dayTask.SpentTime = null;
dayTask.UpdatedAt = AppUtil.AppUtil.CurrrentDateTimeInSqliteSupportedFormate(); //
DateTime currentDateTime = new DateTime(CurrentSelectedDate.Year, CurrentSelectedDate.Month, CurrentSelectedDate.Day, DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second, DateTimeKind.Local);
dayTask.CreatedAt = currentDateTime.ToString("yyyy-MM-dd hh:mm:ss");
dayTask.BGColor = CurrentSelectedTaskk.BGColor;
dayTask.RefTaskTrackId = CurrentSelectedTaskk.TaskTrackId;
return(dayTask);
}
catch (Exception ex)
{
MessagingCenter.Send((App)Xamarin.Forms.Application.Current, AppConstant.ErrorEvent, ex.ToString());
return(null);
}
}
public DayActivity GetDayTaskByTrackId(string trackId)
{
try
{
lock (collisionLock)
{
if (trackId != null)
{
DayActivity task = database.Table <DayActivity>().First(x => x.DayTaskTrackId == trackId);
return(task);
}
else
{
return(null);
}
}
}
catch (Exception ex)
{
MessagingCenter.Send((App)Xamarin.Forms.Application.Current, AppConstant.ErrorEvent, ex.ToString());
return(null);
}
}
/// <summary>
/// formalize the models for carocel page list
/// find the days in particular month which indicate the count of carocel pages to be in stats page
/// </summary>
/// <param name="d"></param>
public void GetAndSetDayForMonth(string d)
{
try
{
CarocelModel PrepareCarocelModel = new CarocelModel();
DateTime FirstDate = new DateTime(CurrentSelectedDate.Year, CurrentSelectedDate.Month, 1); //first date of selected month
int daysInMonth = DateTime.DaysInMonth(CurrentSelectedDate.Year, CurrentSelectedDate.Month); // days in selected month ;// count of carocel page
for (int i = 1; i <= daysInMonth; i++)
{
string date = "" + CurrentSelectedDate.Year + "-" + CurrentSelectedDate.Month + "-" + i; // date s of month--->in the following patteren -> year-month-day (day = 1 to end of months)
_AllTasksForDay = databaseHelper.GetAllDayTasksBaseOnDayMonth(date); // fetch task for every invidual date of month
PrepareCarocelModel.ModelTaskForDayList.Clear();
PrepareCarocelModel.CurrentDateForCurrentCarocel = Convert.ToDateTime(date);
string e = DateTime.Now.ToString("yyyy-M-d");
if (Convert.ToDateTime(date).CompareTo(Convert.ToDateTime(e)) == 0)
{ // if current day date then enable list
PrepareCarocelModel.IsEnableCell = true;
}
else
{ //disable the list
PrepareCarocelModel.IsEnableCell = false;
}
PrepareCarocelModel.MonthAndDate = Convert.ToDateTime(date).ToString("d MMMM");
for (int j = 0; j < _AllTasksForDay.Count; j++)
{ // formalize the every task to populate on UI
DayActivity dt = _AllTasksForDay[j];
dt.TaskStartedAt = Convert.ToDateTime(dt.TaskStartedAt).ToString("h:mm:ss tt"); // change format of date Time like 10:23:02 AM/PM
if (dt.SpentTime != null)
{
dt.SpentTime = AppUtil.AppUtil.FormatTheSpendedTime(dt.SpentTime); // change the format of spended time like 2h and 20m and 44s
}
PrepareCarocelModel.ModelTaskForDayList.Add(dt);
}
//Add the newly formalized model to main Croucel list
CarocelModel carocelModel = new CarocelModel();
List <DayActivity> DeepCopyOfAllDayTaskList = PrepareCarocelModel.ModelTaskForDayList.Take(PrepareCarocelModel.ModelTaskForDayList.Count).ToList(); // take() return the deep copy of every invidual items
foreach (DayActivity dayTask in DeepCopyOfAllDayTaskList)
{
carocelModel.ModelTaskForDayList.Add(dayTask);
}
carocelModel.MonthAndDate = PrepareCarocelModel.MonthAndDate;
carocelModel.CurrentDateForCurrentCarocel = Convert.ToDateTime(PrepareCarocelModel.CurrentDateForCurrentCarocel);
if (carocelModel.ModelTaskForDayList.Count > 0)
{
carocelModel.IsShowError = false;
carocelModel.IsShowList = true;
}
else
{
carocelModel.IsShowError = true;
carocelModel.IsShowList = false;
}
carocelModel.IsEnableCell = PrepareCarocelModel.IsEnableCell;
TaskForDayList.Add(carocelModel);
}
}
catch (Exception ex)
{
MessagingCenter.Send((App)Xamarin.Forms.Application.Current, AppConstant.ErrorEvent, ex.ToString());
}
}
/// <summary>
/// add new Day Task on appropriate position
/// </summary>
/// <param name="task">task to up or down new task will be added</param>
/// <param name="newTask">new item that is going to b added</param>
/// <param name="position">up/down of selected position</param>
/// <returns></returns>
public string SaveDayTask(DayActivity task, DayActivity newTask, string position = "Up")
{
try
{
DayActivity prevTask, afterTask;
List <DayActivity> allTasks = databaseHelper.GetAllDayTasksBaseOnDayMonth(task.CreatedAt);
CurrentSelectedDayTask = task; //selected task from the list (to which up/down new task to be added) // CurrentSelectedDayTask = task;
string taskId = null;
if (position.Equals("Up")) //add task above the selected task
{
int selectedTaskIndex = allTasks.FindIndex(x => x.DayTaskTrackId == task.DayTaskTrackId);
if (selectedTaskIndex > 0)
{
prevTask = allTasks[selectedTaskIndex - 1];
if (DateTime.Compare(Convert.ToDateTime(Convert.ToDateTime(newTask.TaskStartedAt).ToString("hh:mm:ss tt")), Convert.ToDateTime(Convert.ToDateTime(prevTask.TaskStartedAt).ToString("hh:mm:ss tt"))) > 0 && DateTime.Compare(Convert.ToDateTime(Convert.ToDateTime(newTask.TaskStartedAt).ToString("hh:mm:ss tt")), Convert.ToDateTime(Convert.ToDateTime(task.TaskStartedAt).ToString("hh:mm:ss tt"))) < 0)
{
//in up between of two items
prevTask.SpentTime = AppUtil.AppUtil.CalculateSpendedTime(Convert.ToDateTime(Convert.ToDateTime(prevTask.TaskStartedAt).ToString("hh:mm:ss tt")), Convert.ToDateTime(Convert.ToDateTime(newTask.TaskStartedAt).ToString("hh:mm:ss tt")));
databaseHelper.AddDayTask(prevTask);
newTask.SpentTime = AppUtil.AppUtil.CalculateSpendedTime(Convert.ToDateTime(Convert.ToDateTime(newTask.TaskStartedAt).ToString("hh:mm:ss tt")), Convert.ToDateTime(Convert.ToDateTime(task.TaskStartedAt).ToString("hh:mm:ss tt")));
taskId = databaseHelper.AddDayTask(newTask);
}
else
{
Application.Current.MainPage.DisplayAlert(AppConstant.SelectePositionToAddTaskTitleText, AppConstant.CurrentTaskIsInProgressText, "OK");
}
}
else if (selectedTaskIndex == 0) // add task at top most of list
{
if (DateTime.Compare(Convert.ToDateTime(Convert.ToDateTime(Convert.ToDateTime(newTask.TaskStartedAt).ToString("hh:mm:ss tt"))), Convert.ToDateTime(Convert.ToDateTime(task.TaskStartedAt).ToString("hh:mm:ss tt"))) < 0)
{
//inserted top most
newTask.SpentTime = AppUtil.AppUtil.CalculateSpendedTime(Convert.ToDateTime(Convert.ToDateTime(newTask.TaskStartedAt).ToString("hh:mm:ss tt")), Convert.ToDateTime(Convert.ToDateTime(task.TaskStartedAt).ToString("hh:mm:ss tt")));
taskId = databaseHelper.AddDayTask(newTask);
}
else
{
Application.Current.MainPage.DisplayAlert(AppConstant.SelectePositionToAddTaskTitleText, AppConstant.CurrentTaskIsInProgressText, "OK");
}
}
else
{
//todo
}
}
else if (position.Equals("Down")) // add task bottom of selected task
{
int selectedTaskIndex = allTasks.FindIndex(x => x.DayTaskTrackId == task.DayTaskTrackId);
if (selectedTaskIndex < allTasks.Count - 1)
{
afterTask = allTasks[selectedTaskIndex + 1];
if (DateTime.Compare(Convert.ToDateTime(Convert.ToDateTime(newTask.TaskStartedAt).ToString("hh:mm:ss tt")), Convert.ToDateTime(Convert.ToDateTime(task.TaskStartedAt).ToString("hh:mm:ss tt"))) > 0 && DateTime.Compare(Convert.ToDateTime(Convert.ToDateTime(newTask.TaskStartedAt).ToString("hh:mm:ss tt")), Convert.ToDateTime(Convert.ToDateTime(afterTask.TaskStartedAt).ToString("hh:mm:ss tt"))) < 0)
{
//below of selected one task
//blow Inbetween of` two items
task.SpentTime = AppUtil.AppUtil.CalculateSpendedTime(Convert.ToDateTime(Convert.ToDateTime(task.TaskStartedAt).ToString("hh:mm:ss tt")), Convert.ToDateTime(Convert.ToDateTime(newTask.TaskStartedAt).ToString("hh:mm:ss tt")));
databaseHelper.AddDayTask(task);
newTask.SpentTime = AppUtil.AppUtil.CalculateSpendedTime(Convert.ToDateTime(Convert.ToDateTime(newTask.TaskStartedAt).ToString("hh:mm:ss tt")), Convert.ToDateTime(Convert.ToDateTime(afterTask.TaskStartedAt).ToString("hh:mm:ss tt")));
taskId = databaseHelper.AddDayTask(newTask);
}
else
{
Application.Current.MainPage.DisplayAlert(AppConstant.SelectePositionToAddTaskTitleText, AppConstant.CurrentTaskIsInProgressText, "OK");
}
}
else if (selectedTaskIndex == allTasks.Count - 1) // inserted most bottom of list
{
if (DateTime.Compare(Convert.ToDateTime(Convert.ToDateTime(newTask.TaskStartedAt).ToString("hh:mm:ss tt")), Convert.ToDateTime(task.TaskStartedAt)) > 0)
{
DayActivity lastRecord = allTasks[selectedTaskIndex];
lastRecord.SpentTime = AppUtil.AppUtil.CalculateSpendedTime(Convert.ToDateTime(Convert.ToDateTime(lastRecord.TaskStartedAt).ToString("hh:mm:ss tt")), Convert.ToDateTime(Convert.ToDateTime(newTask.TaskStartedAt).ToString("hh:mm:ss tt")));
string isUpdated = databaseHelper.AddDayTask(lastRecord);
if (isUpdated != null)
{
taskId = databaseHelper.AddDayTask(newTask);
Helpers.Settings.LatestInsertedDayTaskTrackId = taskId;
}
}
else
{
Application.Current.MainPage.DisplayAlert(AppConstant.SelectePositionToAddTaskTitleText, AppConstant.CurrentTaskIsInProgressText, "OK");
}
}
else
{
//todo
}
}
if (taskId != null)
{ //if task inserted then arrange the position of new task (up/down) to maintain the Sequence of list
ArrangeTask(task.CreatedAt, position);
OpenTaskStatsViewPageHandler(CurrentSelectedDate.ToString("yyyy-MM-dd"), null); //open the Day Task page
return(taskId);
}
return(taskId);
}
catch (Exception ex)
{
MessagingCenter.Send((App)Xamarin.Forms.Application.Current, AppConstant.ErrorEvent, ex.ToString());
return("");
}
}
