public void Delete(PartsOfActivityDto dto)
{
var obj = Mapper.Map <PartsOfActivity>(dto);
var result = Db.PartsOfActivity.Find(obj.PartsOfActivityId);
base.Delete(result);
}
public async Task <int> UpdatePartOfActivity(PartsOfActivityDto partOfActivityDto)
{
var partOfActivity = Mapper.Map <PartsOfActivity>(partOfActivityDto);
await _database.UpdateAsync(partOfActivity);
return(partOfActivity.PartId);
}
public void Add(PartsOfActivityDto dto)
{
var result = Mapper.Map <PartsOfActivity>(dto);
result.ActivityId = result.Activity.ActivityId;
result.Activity = null;
base.Add(result);
}
private async void PlanTaskStartButton_OnClicked(object sender, EventArgs e)
{
if (ActivityName != null)
{
var start = PlanTaskStartTime.Time + " " + PlanTaskStartDate.Date.ToString("dd/MM/yyyy");
var time = DateTime.ParseExact(start, "HH:mm:ss dd/MM/yyyy", null);
if (time < DateTime.Now)
{
await DisplayAlert("Error", "Wprowadzona data jest wcześniejsza niż obecna", "Ok");
return;
}
var newTask = new TasksDto
{
Name = ActivityName.Text,
Typ = _typSelected
};
if (await UserService.Instance.GetTask(newTask) == null)
{
newTask.TaskId = await UserService.Instance.SaveTask(newTask);
}
else
{
newTask = await UserService.Instance.GetTask(newTask);
}
var newActivity = new ActivitiesDto
{
Guid = Guid.NewGuid().ToString(),
UserId = UserService.Instance.GetLoggedUser().UserId,
TaskId = newTask.TaskId,
GroupId = 1,
Status = StatusType.Planned,
Comment = ActivityDescription.Text,
};
newActivity.ActivityId = await UserService.Instance.SaveActivity(newActivity);
var part = new PartsOfActivityDto
{
ActivityId = newActivity.ActivityId,
Start = start,
Stop = "",
Duration = "0"
};
part.PartId = await UserService.Instance.SavePartOfActivity(part);
DependencyService.Get <INotificationService>().LoadNotifications(newTask.Name, "Naciśnij aby rozpocząć aktywność", part.ActivityId,
DateTime.ParseExact(part.Start, "HH:mm:ss dd/MM/yyyy", null));
await SynchronizationService.Instance.SendPlanned(newActivity, newTask);
await Navigation.PushModalAsync(new NavigationPage(new MainPage()));
}
else
{
await DisplayAlert("Error", "Nie podałeś nazwy aktywności", "Ok");
}
}
public void Edit(PartsOfActivityDto dto)
{
var obj = Mapper.Map <PartsOfActivity>(dto);
var result = Db.PartsOfActivity.Find(obj.PartsOfActivityId);
result.ActivityId = obj.ActivityId;
result.Duration = obj.Duration;
result.Start = obj.Start;
result.Stop = obj.Stop;
base.Edit(result);
}
public async Task <int> SavePartOfActivity(PartsOfActivityDto partsOfActivityDto)
{
if (partsOfActivityDto.PartId != 0)
{
var update = await Database.UpdatePartOfActivity(partsOfActivityDto);
return(update);
}
var insert = await Database.InsertPartOfActivity(partsOfActivityDto);
return(insert);
}
private async void StartTaskButton_OnClicked(object sender, EventArgs e)
{
if (StartTaskName.Text != null)
{
var newTask = new TasksDto
{
Name = StartTaskName.Text,
Typ = _typSelected
};
var task = await UserService.Instance.GetTask(newTask);
if (task == null)
{
newTask.TaskId = await UserService.Instance.SaveTask(newTask);
}
else
{
newTask = await UserService.Instance.GetTask(newTask);
}
var newActivity = new ActivitiesDto
{
Guid = Guid.NewGuid().ToString(),
TaskId = newTask.TaskId,
UserId = UserService.Instance.GetLoggedUser().UserId,
Status = StatusType.Start,
Comment = StartTaskDescription.Text
};
newActivity.ActivityId = await UserService.Instance.SaveActivity(newActivity);
var date = DateTime.Now.ToString("HH:mm:ss dd/MM/yyyy");
var part = new PartsOfActivityDto
{
ActivityId = newActivity.ActivityId,
Start = date,
Stop = "",
Duration = "0"
};
part.PartId = await UserService.Instance.SavePartOfActivity(part);
StopwatchesService.Instance.AddStopwatch(part.PartId);
await Navigation.PushModalAsync(new NavigationPage(new MainPage()));
}
else
{
await DisplayAlert("Error", "Nie podałeś nazwy aktywności", "Ok");
}
}
private async void FastTaskButton_OnClicked(object sender, EventArgs e)
{
if (_activeTasksList.Count == 0)
{
ActiveTasks.IsVisible = true;
}
var activity = new ActivitiesDto
{
Guid = Guid.NewGuid().ToString(),
Status = StatusType.Start,
UserId = UserService.Instance.GetLoggedUser().UserId,
GroupId = 1,
TaskId = 0
};
activity.ActivityId = await UserService.Instance.SaveActivity(activity);
var now = DateTime.Now;
var part = new PartsOfActivityDto
{
ActivityId = activity.ActivityId,
Start = now.ToString("HH:mm:ss dd/MM/yyyy"),
Stop = "",
Duration = "0"
};
part.PartId = await UserService.Instance.SavePartOfActivity(part);
StopwatchesService.Instance.AddStopwatch(part.PartId);
var t = TimeSpan.FromMilliseconds(0);
var item = new MainPageListItem
{
MyImageSource = ImageChoice(activity.Status),
Name = "Nowa Aktywność " + activity.ActivityId,
ActivityId = activity.ActivityId,
PartId = part.PartId,
Duration = $"{t.Hours:D2}:{t.Minutes:D2}:{t.Seconds:D2}",
Time = 0
};
_activeTasksList.Add(item);
UpdateList();
_listTimer.Start();
}
protected override async void OnHandleIntent(Intent intent)
{
var id = intent.Extras.GetInt("Id", -1);
_activity = await Services.UserService.Instance.GetActivity(id);
_activity.Status = StatusType.Start;
_part = await Services.UserService.Instance.GetLastActivityPart(id);
_now = DateTime.Now;
var date = _now.ToString("HH:mm:ss dd/MM/yyyy");
_part.Start = date;
await Services.UserService.Instance.SavePartOfActivity(_part);
await Services.UserService.Instance.SaveActivity(_activity);
StopwatchesService.Instance.AddStopwatch(_part.PartId);
}
private async void ResumeButton_OnClicked(object sender, EventArgs e)
{
_activity.Status = StatusType.Start;
var part = new PartsOfActivityDto
{
ActivityId = _activity.ActivityId,
Start = DateTime.Now.ToString("HH:mm:ss dd/MM/yyyy"),
Stop = "",
Duration = "0"
};
part.PartId = await UserService.Instance.SavePartOfActivity(part);
StopwatchesService.Instance.AddStopwatch(part.PartId);
_part = part;
await UserService.Instance.SaveActivity(_activity);
_timer.Start();
UpdateButtons();
}
private async Task Initial()
{
_activity = await UserService.Instance.GetActivity(_initItem.ActivityId);
_part = await UserService.Instance.GetLastActivityPart(_activity.ActivityId);
if (_initItem.TaskId != 0)
{
_task = await UserService.Instance.GetTaskById(_activity.TaskId);
var fav = await UserService.Instance.GetFavoriteByTaskId(_initItem.TaskId);
if (fav != null)
{
AddFavorite.IsVisible = false;
}
}
else
{
_task = new TasksDto
{
Name = _initItem.Name,
Typ = "Inne"
};
}
TypePickerImage.Source = ImagesService.Instance.SelectImage(_task.Typ);
TaskDate.Text = _part.Start;
_startTime = _initItem.Time;
var t = TimeSpan.FromMilliseconds(_startTime + StopwatchesService.Instance.GetStopwatchTime(_part.PartId));
var answer = $"{t.Hours:D2}:{t.Minutes:D2}:{t.Seconds:D2}";
TaskDuration.Text = answer;
UpdateButtons();
_timer.Elapsed += UpdateTime;
_timer.Interval = 1000;
_timer.Start();
}
public async Task DeletePartOfActivity(PartsOfActivityDto partsOfActivityDto)
{
await Database.DeletePartOfActivity(partsOfActivityDto);
}
private async Task StartupResumeAsync(ActivitiesDto start)
{
var task = await UserService.Instance.GetTaskById(start.TaskId) ?? new TasksDto
{
Name = "Nowa Aktywność " + start.ActivityId
};
var result = await DisplayAlert("Error", "Masz niezapauzowaną aktywność " + task.Name + ".\n " +
"Czy była ona aktywna od zamknięcia aplikacji? \n" +
"Jeżeli wybierzesz nie, czas aktywności może być niewłaściwy \n" +
"Jeżeli wybierzesz tak, czas końca aktywności będzie czasem zatwierdzenia tego komunikatu",
"Tak", "Nie");
if (!result)
{
var result4 = await DisplayAlert("Error",
"Czy chcesz żeby aktywność była kontynuowana?", "Tak", "Nie");
if (!result4)
{
start.Status = StatusType.Pause;
await UserService.Instance.SaveActivity(start);
return;
}
var part2 = new PartsOfActivityDto
{
Start = DateTime.Now.ToString("HH:mm:ss dd/MM/yyyy"),
ActivityId = start.ActivityId,
Duration = "0"
};
part2.PartId = await UserService.Instance.SavePartOfActivity(part2);
StopwatchesService.Instance.AddStopwatch(part2.PartId);
await UserService.Instance.SaveActivity(start);
return;
}
var part = await UserService.Instance.GetLastActivityPart(start.ActivityId);
part.Stop = DateTime.Now.ToString("HH:mm:ss dd/MM/yyyy");
var time = (long)(DateTime.Now - DateTime.ParseExact(part.Start, "HH:mm:ss dd/MM/yyyy", null))
.TotalMilliseconds;
part.Duration = time.ToString();
await UserService.Instance.SaveActivity(start);
await UserService.Instance.SavePartOfActivity(part);
var result3 = await DisplayAlert("Error",
"Czy chcesz żeby aktywność była kontynuowana?", "Tak", "Nie");
if (!result3)
{
start.Status = StatusType.Pause;
await UserService.Instance.SaveActivity(start);
return;
}
var part3 = new PartsOfActivityDto
{
Start = DateTime.Now.ToString("HH:mm:ss dd/MM/yyyy"),
ActivityId = start.ActivityId,
Duration = "0"
};
part3.PartId = await UserService.Instance.SavePartOfActivity(part3);
StopwatchesService.Instance.AddStopwatch(part3.PartId);
}
public async Task <bool> GetActivities()
{
var user = UserService.Instance.GetLoggedUser();
var uri = new Uri($"{Ip}/Activity/?email={user.Name}&token={user.ApiToken}");
try
{
var response = await _client.GetAsync(uri);
if (!response.IsSuccessStatusCode)
{
return(false);
}
var content = await response.Content.ReadAsStringAsync();
var activities = JsonConvert.DeserializeObject <List <ActivitiesRest> >(content);
foreach (var activity in activities)
{
var find = false;
var guids = await UserService.Instance.GetActivitiesByStatus(StatusType.Stop);
foreach (var item in guids)
{
if (item.Guid != activity.Guid)
{
continue;
}
find = true;
if (activity.EditState == EditState.EditedOnWeb)
{
item.Comment = activity.Comment;
item.GroupId = int.Parse(activity.GroupName);
item.SyncStatus = SyncStatus.Received;
var taskDto = new TasksDto
{
Name = activity.TaskName
};
var task = await UserService.Instance.GetTask(taskDto);
if (task == null)
{
taskDto.TaskId = await UserService.Instance.SaveTask(taskDto);
}
else
{
taskDto.TaskId = task.TaskId;
}
item.TaskId = taskDto.TaskId;
item.ActivityId = await UserService.Instance.SaveActivity(item);
var parts = await UserService.Instance.GetPartsOfActivityByActivityId(item.ActivityId);
if (activity.TaskPartsList.Count == parts.Count)
{
var i = 0;
foreach (var part in parts)
{
part.Start = activity.TaskPartsList[i].Start;
part.Stop = activity.TaskPartsList[i].Stop;
var t = TimeSpan.Parse(activity.TaskPartsList[i].Duration,
CultureInfo.InvariantCulture)
.TotalMilliseconds;
var time = (int)t;
part.Duration = time.ToString();
await UserService.Instance.SavePartOfActivity(part);
i++;
}
}
else if (activity.TaskPartsList.Count < parts.Count)
{
var i = 0;
foreach (var part in parts)
{
if (i >= activity.TaskPartsList.Count)
{
await UserService.Instance.DeletePartOfActivity(part);
}
else
{
part.Start = activity.TaskPartsList[i].Start;
part.Stop = activity.TaskPartsList[i].Stop;
var t = TimeSpan
.Parse(activity.TaskPartsList[i].Duration, CultureInfo.InvariantCulture)
.TotalMilliseconds;
var time = (int)t;
part.Duration = time.ToString();
await UserService.Instance.SavePartOfActivity(part);
}
i++;
}
}
else if (activity.TaskPartsList.Count > parts.Count)
{
var i = 0;
foreach (var part in parts)
{
if (i >= parts.Count)
{
var t = TimeSpan
.Parse(activity.TaskPartsList[i].Duration, CultureInfo.InvariantCulture)
.TotalMilliseconds;
var time = (int)t;
var newPart = new PartsOfActivityDto
{
ActivityId = item.ActivityId,
Start = activity.TaskPartsList[i].Start,
Stop = activity.TaskPartsList[i].Stop,
Duration = time.ToString()
};
await UserService.Instance.SavePartOfActivity(newPart);
}
else
{
part.Start = activity.TaskPartsList[i].Start;
part.Stop = activity.TaskPartsList[i].Stop;
var t = TimeSpan
.Parse(activity.TaskPartsList[i].Duration, CultureInfo.InvariantCulture)
.TotalMilliseconds;
var time = (int)t;
part.Duration = time.ToString();
await UserService.Instance.SavePartOfActivity(part);
}
i++;
}
}
}
break;
}
if (find)
{
continue;
}
var taskDto2 = new TasksDto
{
Name = activity.TaskName
};
var task2 = await UserService.Instance.GetTask(taskDto2);
if (task2 == null)
{
taskDto2.TaskId = await UserService.Instance.SaveTask(taskDto2);
}
else
{
taskDto2.TaskId = task2.TaskId;
}
var activityDto = new ActivitiesDto
{
Guid = activity.Guid,
Comment = activity.Comment,
Status = activity.State,
GroupId = 0,
SyncStatus = SyncStatus.Received,
UserId = user.UserId,
TaskId = taskDto2.TaskId
};
activityDto.ActivityId = await UserService.Instance.SaveActivity(activityDto);
foreach (var parts in activity.TaskPartsList)
{
var t = TimeSpan.Parse(parts.Duration, CultureInfo.InvariantCulture)
.TotalMilliseconds;
var time = (int)t;
var part = new PartsOfActivityDto
{
ActivityId = activityDto.ActivityId,
Start = parts.Start,
Stop = parts.Stop,
Duration = time.ToString()
};
await UserService.Instance.SavePartOfActivity(part);
}
}
return(true);
}
catch (Exception)
{
return(false);
}
}
public bool AddActivity(ActivityMobileDto activityMobileDto)
{
if (activityMobileDto.State == State.Planned)
{
return(false);
}
TaskDto tmpTask = null;
int idAct;
try
{
tmpTask = _taskRepositories.Get(activityMobileDto.TaskName);
}
catch (Exception e)
{
}
if (tmpTask == null)
{
tmpTask = new TaskDto()
{
Description = "",
Name = activityMobileDto.TaskName,
Activities = new List <ActivityDto>(),
Favorites = new List <FavoritesDto>(),
Type = ""
};
_taskRepositories.Add(tmpTask);
}
var tmpActivity = new ActivityDto
{
Comment = activityMobileDto.Comment,
Guid = activityMobileDto.Guid,
State = activityMobileDto.State,
EditState = activityMobileDto.EditState,
User = _userRepositories.Get(activityMobileDto.UserEmail),
Task = _taskRepositories.Get(activityMobileDto.TaskName),
Group = _groupRepositories.Get(1),
PartsOfActivity = new List <PartsOfActivityDto>()
};
try
{
idAct = _activityRepositories.Add(tmpActivity);
}
catch (Exception)
{
return(false);
}
foreach (var part in activityMobileDto.TaskPartsList)
{
var tmpPart = new PartsOfActivityDto
{
Start = DateTime.ParseExact(part.Start, "HH:mm:ss dd/MM/yyyy", CultureInfo.InvariantCulture),
Stop = DateTime.ParseExact(part.Start, "HH:mm:ss dd/MM/yyyy", CultureInfo.InvariantCulture),
Duration = TimeSpan.ParseExact(part.Duration, "G", CultureInfo.InvariantCulture),
Activity = _activityRepositories.Get(idAct)
};
try
{
_partsOfActivityRepositories.Add(tmpPart);
}
catch (Exception)
{
return(false);
}
}
return(true);
}
public async Task <bool> GetPlanned()
{
var user = UserService.Instance.GetLoggedUser();
var uri = new Uri($"{Ip}/Planned/?email={user.Name}&token={user.ApiToken}");
try
{
var response = await _client.GetAsync(uri);
if (!response.IsSuccessStatusCode)
{
return(false);
}
var content = await response.Content.ReadAsStringAsync();
var plannedList = JsonConvert.DeserializeObject <List <PlannedRest> >(content);
foreach (var plan in plannedList)
{
var guids = await UserService.Instance.GetActivitiesByStatus(StatusType.Planned);
if (guids.Any(item => item.Guid == plan.Guid))
{
continue;
}
var taskDto = new TasksDto
{
Name = plan.TaskName,
SyncStatus = SyncStatus.Received
};
var task = await UserService.Instance.GetTask(taskDto);
if (task == null)
{
taskDto.TaskId = await UserService.Instance.SaveTask(taskDto);
}
else
{
taskDto = task;
}
var plannedDto = new ActivitiesDto
{
Comment = plan.Comment,
Guid = plan.Guid,
SyncStatus = SyncStatus.Received,
TaskId = taskDto.TaskId,
UserId = user.UserId,
Status = StatusType.Planned
};
plannedDto.ActivityId = await UserService.Instance.SaveActivity(plannedDto);
var part = new PartsOfActivityDto
{
ActivityId = plannedDto.ActivityId,
Start = plan.TaskPart.Start
};
await UserService.Instance.SavePartOfActivity(part);
}
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task DeletePartOfActivity(PartsOfActivityDto partsOfActivityDto)
{
var partOfActivity = Mapper.Map <PartsOfActivity>(partsOfActivityDto);
await _database.DeleteAsync(partOfActivity);
}
public bool AddPlanned(PlannedMobileDto plannedMobileDto)
{
if (plannedMobileDto.State != State.Planned)
{
return(false);
}
TaskDto tmpTask = null;
int idAct;
try
{
tmpTask = _taskRepositories.Get(plannedMobileDto.TaskName);
}
catch (Exception e)
{
}
if (tmpTask == null)
{
tmpTask = new TaskDto()
{
Description = "",
Name = plannedMobileDto.TaskName,
};
_taskRepositories.Add(tmpTask);
}
var tmpActivity = new ActivityDto
{
Comment = plannedMobileDto.Comment,
Guid = plannedMobileDto.Guid,
State = plannedMobileDto.State,
EditState = plannedMobileDto.EditState,
User = _userRepositories.Get(plannedMobileDto.UserEmail),
Task = _taskRepositories.Get(plannedMobileDto.TaskName),
Group = _groupRepositories.Get(1)
};
try
{
idAct = _activityRepositories.Add(tmpActivity);
}
catch (Exception)
{
return(false);
}
try
{
var tmpPart = new PartsOfActivityDto
{
Start = DateTime.ParseExact(plannedMobileDto.TaskPart.Start, "HH:mm:ss dd/MM/yyyy", CultureInfo.InvariantCulture),
Stop = DateTime.MaxValue,
Duration = TimeSpan.Zero,
Activity = _activityRepositories.Get(idAct)
};
_partsOfActivityRepositories.Add(tmpPart);
}
catch (Exception)
{
return(false);
}
return(true);
}
