public async Task <bool> SendTask(TasksDto task)
{
var user = UserService.Instance.GetLoggedUser();
var taskRest = new TasksRest
{
Name = task.Name,
Type = task.Typ,
Email = user.Name,
Token = user.ApiToken
};
var taskJson = JsonConvert.SerializeObject(taskRest);
var contentUser = new StringContent(taskJson, Encoding.UTF8, "application/json");
var uri = new Uri($"{Ip}/Task");
try
{
var response = await _client.PutAsync(uri, contentUser);
if (!response.IsSuccessStatusCode)
{
return(false);
}
task.SyncStatus = SyncStatus.Uploaded;
await UserService.Instance.SaveTask(task);
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task <int> InsertTask(TasksDto tasksDto)
{
var task = Mapper.Map <Tasks>(tasksDto);
await _database.InsertAsync(task);
return(task.TaskId);
}
public async Task <int> UpdateTask(TasksDto taskDto)
{
var task = Mapper.Map <Tasks>(taskDto);
await _database.UpdateAsync(task);
return(task.TaskId);
}
public async Task <TasksDto> GetTask(TasksDto taskDto)
{
var task = Mapper.Map <Tasks>(taskDto);
var result = await _database.Table <Tasks>().Where(t => t.Name == task.Name).FirstOrDefaultAsync();
taskDto = Mapper.Map <TasksDto>(result);
return(taskDto);
}
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");
}
}
private async void FavoritePicker_OnSelectedIndexChanged(object sender, EventArgs e)
{
var select = FavoritePicker.Items[FavoritePicker.SelectedIndex];
var taskDto = new TasksDto
{
Name = select
};
var task = await UserService.Instance.GetTask(taskDto);
StartTaskName.Text = task.Name;
}
public async Task <int> SaveTask(TasksDto tasksDto)
{
if (tasksDto.TaskId != 0)
{
var update = await Database.UpdateTask(tasksDto);
return(update);
}
var insert = await Database.InsertTask(tasksDto);
return(insert);
}
private async void FavoritePicker_OnSelectedIndexChanged(object sender, EventArgs e)
{
var select = FavoritePicker.Items[FavoritePicker.SelectedIndex];
var taskDto = new TasksDto
{
Name = select
};
var task = await UserService.Instance.GetTask(taskDto);
TaskName.Text = task.Name;
ActivityName.Text = task.Name;
TypePickerImage.Source = ImagesService.Instance.SelectImage(task.Typ);
}
public IHttpActionResult AddTasks([FromBody] TasksDto tasksDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var tasks = Mapper.Map <TasksDto, Tasks>(tasksDto);
_uow.TasksRepository.Add(tasks);
_uow.Save();
tasksDto.Id = tasks.Id;
return(Created(new Uri(Request.RequestUri + "/" + tasksDto.Id), tasksDto));
}
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");
}
}
public async Task <bool> SendActivity(ActivitiesDto activity, TasksDto task)
{
var parts = await UserService.Instance.GetPartsOfActivityByActivityId(activity.ActivityId);
var list = parts.Select(partsOfActivityDto => new PartsOfActivityRest
{
Start = partsOfActivityDto.Start,
Stop = partsOfActivityDto.Stop,
Duration = TimeSpan.FromMilliseconds(int.Parse(partsOfActivityDto.Duration)).ToString("G", CultureInfo.InvariantCulture)
})
.ToList();
var user = UserService.Instance.GetLoggedUser();
var activityRest = new ActivitiesRest
{
Guid = activity.Guid,
Comment = activity.Comment,
EditState = EditState.EditedOnMobile,
TaskName = task.Name,
UserEmail = user.Name,
Token = user.ApiToken,
State = activity.Status,
GroupName = null,
TaskPartsList = list
};
var activityJson = JsonConvert.SerializeObject(activityRest);
var contentActivity = new StringContent(activityJson, Encoding.UTF8, "application/json");
var uri = new Uri($"{Ip}/Activity");
try
{
var response = await _client.PutAsync(uri, contentActivity);
if (!response.IsSuccessStatusCode)
{
return(false);
}
activity.SyncStatus = SyncStatus.Uploaded;
await UserService.Instance.SaveActivity(activity);
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task <bool> SendPlanned(ActivitiesDto activity, TasksDto task)
{
var user = UserService.Instance.GetLoggedUser();
var lastPart = await UserService.Instance.GetLastActivityPart(activity.ActivityId);
var lastPartRest = new PartsOfActivityRest
{
Start = lastPart.Start,
Stop = lastPart.Stop,
Duration = lastPart.Duration
};
var plannedRest = new PlannedRest
{
Comment = activity.Comment,
EditState = EditState.EditedOnMobile,
GroupName = null,
Guid = activity.Guid,
State = activity.Status,
TaskName = task.Name,
TaskPart = lastPartRest,
UserEmail = user.Name,
Token = user.ApiToken
};
var taskJson = JsonConvert.SerializeObject(plannedRest);
var contentTask = new StringContent(taskJson, Encoding.UTF8, "application/json");
var uri = new Uri($"{Ip}/Planned");
try
{
var response = await _client.PutAsync(uri, contentTask);
if (!response.IsSuccessStatusCode)
{
return(false);
}
activity.SyncStatus = SyncStatus.Uploaded;
await UserService.Instance.SaveActivity(activity);
return(true);
}
catch (Exception)
{
return(false);
}
}
public IHttpActionResult UpdateTasks([FromUri] int id, [FromBody] TasksDto tasksDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var tasksInDb = _uow.TasksRepository.GetAll().SingleOrDefault(t => t.Id == id);
if (tasksInDb == null)
{
return(NotFound());
}
Mapper.Map(tasksDto, tasksInDb);
_uow.Save();
return(Ok());
}
public async Task <IActionResult> GetUserTasks(string projectId, string listId)
{
var Users = await _context.Users.FromSql("SELECT * from AspNetUsers where AspNetUsers.Id in (select UserCards.UserId from UserCards where UserCards.TrelloCardId in (SELECT TrelloCards.Id from TrelloCards where TrelloCards.IdList = '" + listId + "'))and AspNetUsers.Id in (SELECT ProjectUsers.UserId from ProjectUsers where ProjectUsers.ProjectId = " + projectId + ")").ToListAsync();
List <TasksDto> theList = new List <TasksDto>();
foreach (var user in Users)
{
var taskList = await _context.TrelloCards.FromSql("select * from TrelloCards where TrelloCards.Id in (Select UserCards.TrelloCardId from UserCards where UserCards.UserId = " + user.Id + " )and TrelloCards.IdList in (Select TrelloLists.Id from TrelloLists where TrelloLists.Id = '" + listId + "' and TrelloLists.IdBoard in (select Projects.TrelloBoardId from Projects where Projects.Id = " + projectId + "))").Select(x => x.Name).ToListAsync();
var usersTask = new TasksDto()
{
CardNames = taskList, UserName = user.UserName
};
theList.Add(usersTask);
}
return(Ok(theList));
}
private async void AcceptButton_OnClicked(object sender, EventArgs e)
{
if (_task.Name != null)
{
if (await UserService.Instance.GetTask(_task) == null)
{
_task.TaskId = await UserService.Instance.SaveTask(_task);
_activity.TaskId = _task.TaskId;
_activity.Status = StatusType.Stop;
await UserService.Instance.SaveActivity(_activity);
await SynchronizationService.Instance.SendTask(_task);
await SynchronizationService.Instance.SendActivity(_activity, _task);
await Navigation.PushModalAsync(new NavigationPage(new MainPage()));
}
else
{
_task = await UserService.Instance.GetTask(_task);
_activity.TaskId = _task.TaskId;
_activity.Status = StatusType.Stop;
await UserService.Instance.SaveActivity(_activity);
if (_task.SyncStatus == SyncStatus.ToUpload)
{
await SynchronizationService.Instance.SendTask(_task);
}
await SynchronizationService.Instance.SendActivity(_activity, _task);
await Navigation.PushModalAsync(new NavigationPage(new MainPage()));
}
}
else
{
await DisplayAlert("Error", "Nie wprowadziłeś danych", "Ok");
}
}
private async void FavoritePicker_OnSelectedIndexChanged(object sender, EventArgs e)
{
var select = FavoritePicker.Items[FavoritePicker.SelectedIndex];
var taskDto = new TasksDto
{
Name = select
};
var task = await UserService.Instance.GetTask(taskDto);
var fav = await UserService.Instance.GetFavoriteByTaskId(task.TaskId);
if (fav != null)
{
AddFavorite.IsVisible = false;
}
TaskName.Text = task.Name;
_task.TaskId = task.TaskId;
_task.Name = task.Name;
_task.Typ = task.Typ;
ActivityName.Text = task.Name;
TypePickerImage.Source = ImagesService.Instance.SelectImage(task.Typ);
}
public async Task <bool> DeletePlanned(ActivitiesDto activity, TasksDto task)
{
var user = UserService.Instance.GetLoggedUser();
var uri = new Uri($"{Ip}/Planned/?guid={activity.Guid}&email={user.Name}&token={user.ApiToken}");
try
{
var response = await _client.DeleteAsync(uri);
if (!response.IsSuccessStatusCode)
{
return(false);
}
activity.SyncStatus = SyncStatus.Uploaded;
await UserService.Instance.SaveActivity(activity);
return(true);
}
catch (Exception)
{
return(false);
}
}
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 <TasksDto> GetTask(TasksDto tasksDto)
{
var update = await Database.GetTask(tasksDto);
return(update);
}
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 async Task <bool> GetFavorites()
{
var user = UserService.Instance.GetLoggedUser();
var uri = new Uri($"{Ip}/Favorites/?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 favorites = JsonConvert.DeserializeObject <List <FavoritesRest> >(content);
foreach (var favorite in favorites)
{
var taskDto = new TasksDto
{
Name = favorite.Task.Name,
Typ = favorite.Task.Type
};
var task = await UserService.Instance.GetTask(taskDto);
if (favorite.EditState == EditState.Delete)
{
var fav = await UserService.Instance.GetFavoriteByTaskId(task.TaskId);
await UserService.Instance.DeleteFavorite(fav);
continue;
}
if (task == null)
{
taskDto.TaskId = await UserService.Instance.SaveTask(taskDto);
}
else
{
taskDto.TaskId = task.TaskId;
var checkFav = await UserService.Instance.GetFavoriteByTaskId(taskDto.TaskId);
if (checkFav != null)
{
continue;
}
}
var favoriteDto = new FavoritesDto
{
TaskId = taskDto.TaskId,
UserId = user.UserId
};
await UserService.Instance.SaveFavorite(favoriteDto);
}
return(true);
}
catch (Exception)
{
return(false);
}
}
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);
}
}
