public async Task <int> InsertActivity(ActivitiesDto activityDto)
{
var activity = Mapper.Map <Activities>(activityDto);
await _database.InsertAsync(activity);
return(activity.ActivityId);
}
public FillInformationPage(ActivitiesDto item)
{
_activity = item;
InitializeComponent();
Init();
AddItemsToPicker();
AddToFavoritesList();
}
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 async Task <int> SaveActivity(ActivitiesDto activitiesDto)
{
if (activitiesDto.ActivityId != 0)
{
var update = await Database.UpdateActivity(activitiesDto);
return(update);
}
var insert = await Database.InsertActivity(activitiesDto);
return(insert);
}
public ActivitiesDto UpdateActivity(ActivitiesDto objActivitiesDto)
{
Activities objActivities = _mapper.Map <Activities>(objActivitiesDto);
Activities objActivitiesData = _context.Activities.Find(objActivitiesDto.ActivityId);
objActivities.ModifiedDateTime = DateTime.Now;
objActivities.ModifiedBy = 1;
_context.Entry(objActivitiesData).CurrentValues.SetValues(objActivities);
_context.SaveChanges();
return(_mapper.Map <ActivitiesDto>(_context.Activities.
SingleOrDefault(x => x.ActivityId == objActivitiesDto.ActivityId)));
}
public ActivitiesDto CreateActivity(ActivitiesDto objActivitiesDto)
{
Activities objActivities = _mapper.Map <Activities>(objActivitiesDto);
objActivities.CreatedDateTime = DateTime.Now;
objActivities.CreatedBy = 1;
_context.Activities.Add(objActivities);
_context.SaveChanges();
return(_mapper.Map <ActivitiesDto>(_context.Activities.
SingleOrDefault(x => x.ActivityId == objActivitiesDto.ActivityId)));
}
public LeadDto CreateLead(LeadDto objLeadDto)
{
using (var transaction = _context.Database.BeginTransaction())
{
try
{
Leads objLeads = _mapper.Map <Leads>(objLeadDto);
objLeads.CreatedDateTime = DateTime.Now;
objLeads.CreatedBy = 1;
_context.Leads.Add(objLeads);
_context.SaveChanges();
foreach (var product in objLeadDto.ProductList)
{
ProductListDto objProductListDto = product;
ProductList objProductList = _mapper.Map <ProductList>(objProductListDto);
objProductList.ReferenceId = objLeads.LeadId;
objProductList.Source = 1;
objProductList.ProductId = product.ProductId;
objProductList.CreatedBy = 1;
objProductList.CreatedDateTime = DateTime.Now;
_context.ProductList.Add(objProductList);
}
foreach (var activity in objLeadDto.Activities)
{
ActivitiesDto objActivitiesDto = activity;
Activities objActivities = _mapper.Map <Activities>(objActivitiesDto);
objActivities.ReferenceId = objLeads.LeadId;
objActivities.Source = 1;
objActivities.CreatedBy = 1;
objActivities.CreatedDateTime = DateTime.Now;
_context.Activities.Add(objActivities);
}
_context.SaveChanges();
transaction.Commit();
return(_mapper.Map <LeadDto>(_context.Leads.
SingleOrDefault(x => x.LeadId == objLeads.LeadId)));
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
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 IActionResult GetRatingByUser(string userName, string movieId)
{
var rating = rDs.getRatingByUser(userName, movieId);
var bookmark = bDs.isBookmarked(userName, movieId);
var favorite = fDs.isFav(userName, movieId);
bool isBookmark = bookmark != null ? true : false;
bool isFav = favorite != null ? true : false;
var activities = new ActivitiesDto();
activities.Rating = rating?.Rating;
activities.isBookmarked = isBookmark;
activities.isFav = isFav;
return(Ok(activities));
}
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);
}
}
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);
}
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 LeadDto UpdateLead(LeadDto objLeadDto)
{
using (var transaction = _context.Database.BeginTransaction())
{
try
{
Leads objLeads = _mapper.Map <Leads>(objLeadDto);
Leads objLeadsData = _context.Leads.Find(objLeadDto.LeadId);
objLeads.ModifiedDateTime = DateTime.Now;
objLeads.ModifiedBy = 1;
_context.Entry(objLeadsData).CurrentValues.SetValues(objLeads);
#region productlist update
foreach (var product in objLeadDto.ProductList)
{
if (product.ProductListId == 0)
{
ProductListDto objProductListDto = product;
ProductList objProductList = _mapper.Map <ProductList>(objProductListDto);
objProductList.ReferenceId = objLeadDto.LeadId;
objProductList.Source = 1;
objProductList.ProductId = product.ProductId;
objProductList.CreatedBy = 1;
objProductList.CreatedDateTime = DateTime.Now;
_context.ProductList.Add(objProductList);
}
else
{
ProductList objProductListdata = _context.ProductList.Find(product.ProductListId);
ProductListDto objProductListDto = product;
ProductList objProductList = _mapper.Map <ProductList>(objProductListDto);
objProductList.ModifiedBy = 1;
objProductList.ModifiedDateTime = DateTime.Now;
_context.Entry(objProductListdata).CurrentValues.SetValues(objProductList);
}
}
#endregion
#region activities update
foreach (var activities in objLeadDto.Activities)
{
if (activities.ActivityId == 0)
{
ActivitiesDto objActivitiesDto = activities;
Activities objActivities = _mapper.Map <Activities>(objActivitiesDto);
objActivities.ReferenceId = objLeadDto.LeadId;
objActivities.Source = 1;
objActivities.CreatedBy = 1;
objActivities.CreatedDateTime = DateTime.Now;
_context.Activities.Add(objActivities);
}
else
{
Activities objActivitiesdata = _context.Activities.Find(activities.ActivityId);
ActivitiesDto objActivitiesDto = activities;
Activities objActivities = _mapper.Map <Activities>(objActivitiesDto);
objActivities.ModifiedBy = 1;
objActivities.ModifiedDateTime = DateTime.Now;
_context.Entry(objActivitiesdata).CurrentValues.SetValues(objActivities);
}
}
#endregion
_context.SaveChanges();
transaction.Commit();
return(_mapper.Map <LeadDto>(_context.Leads.
SingleOrDefault(x => x.LeadId == objLeadDto.LeadId)));
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
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 ActivitiesDto SaveActivity([FromBody] ActivitiesDto model)
{
return(_activitiesService.CreateActivity(model));
}
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 ActivitiesDto Update([FromBody] ActivitiesDto model)
{
return(_activitiesService.UpdateActivity(model));
}
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);
}
}
