public Task DeletePerson(PersonModel person, PersonGroupModel group)
{
try
{
var tcs = new TaskCompletionSource <bool>();
Client.DeletePersonWithPersonGroupId(group.Id, person.Id, error =>
{
tcs.FailTaskIfErrored(error.ToException());
if (group.People.Contains(person))
{
group.People.Remove(person);
}
tcs.SetResult(true);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task AddPersonFace(PersonModel person, PersonGroupModel group, FaceImageModel face, UIImage photo, string userData = null)
{
try
{
var tcs = new TaskCompletionSource <bool>();
var faceRect = face.FaceRectangle.ToMPOFaceRect();
using (var jpgData = photo.AsJPEG(.8f))
{
Client.AddPersonFaceWithPersonGroupId(group.Id, person.Id, jpgData, userData, faceRect, (result, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
tcs.FailTaskByCondition(string.IsNullOrEmpty(result.PersistedFaceId), "AddPersistedFaceResult returned invalid face Id");
face.Id = result.PersistedFaceId;
person.Faces.Add(face);
tcs.SetResult(true);
}).Resume();
}
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task <PersonModel> CreatePerson(string personName, PersonGroupModel group, string userData = null)
{
try
{
var tcs = new TaskCompletionSource <PersonModel>();
Client.CreatePersonWithPersonGroupId(group.Id, personName, userData, (result, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
tcs.FailTaskByCondition(string.IsNullOrEmpty(result.PersonId), "CreatePersonResult returned invalid person Id");
var person = new PersonModel
{
Name = personName,
Id = result.PersonId,
UserData = userData
};
group.People.Add(person);
tcs.SetResult(person);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task <List <PersonModel> > ListPersonsInPersonGroup(PersonGroupModel group)
{
try
{
var tcs = new TaskCompletionSource <List <PersonModel> >();
Client.ListPersonsWithPersonGroupId(group.Id, (groupPeople, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
var people = new List <PersonModel>(
groupPeople.Select(p => p.ToPerson())
);
group.People.AddRange(people);
tcs.SetResult(people);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task<PersonGroupModel> CreatePersonGroup(string groupName, string userData = null)
{
try
{
var tcs = new TaskCompletionSource<PersonGroupModel>();
var personGroupId = Guid.NewGuid().ToString();
Client.CreatePersonGroupWithId(personGroupId, groupName, userData, error =>
{
tcs.FailTaskIfErrored(error.ToException());
var group = new PersonGroupModel
{
Name = groupName,
Id = personGroupId,
UserData = userData
};
Groups.Add(group);
tcs.SetResult(group);
}).Resume();
return tcs.Task;
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public override void CommitEditingStyle(UITableView tableView, UITableViewCellEditingStyle editingStyle, Foundation.NSIndexPath indexPath)
{
switch (editingStyle)
{
case UITableViewCellEditingStyle.Delete:
this.ShowHUD("Deleting Group");
Task.Run(async() =>
{
PersonGroupModel pg = Groups[indexPath.Row];
await PersonGroupClient.Shared.DeletePersonGroup(pg.Id);
BeginInvokeOnMainThread(() =>
{
// remove the item from the underlying data source
Groups.RemoveAt(indexPath.Row);
// delete the row from the table
tableView.DeleteRows(new NSIndexPath[] { indexPath }, UITableViewRowAnimation.Fade);
this.ShowSimpleHUD("Group deleted");
});
});
break;
case UITableViewCellEditingStyle.None:
Console.WriteLine("CommitEditingStyle:None called");
break;
}
}
public IHttpActionResult Update(PersonGroupModel model)
{
using (var scope = _contextScopeFactory.CreateReadOnly())
{
var personGroup = _personGroupService.Update(model);
return(Ok(personGroup));
}
}
public PersonGroupModel Add(PersonGroupModel model)
{
var entity = _mapper.Map <PersonGroup>(model);
_personGroupRepository.Add(entity);
_personGroupRepository.Save();
return(model);
}
public override void RowSelected(UITableView tableView, NSIndexPath indexPath)
{
PersonGroupModel pg = Groups[indexPath.Row];
GroupDetailViewController uiview = Storyboard.InstantiateViewController("GroupDetailViewController") as GroupDetailViewController;
uiview.Group = pg;
NavigationController.PushViewController(uiview, true);
}
public PersonGroupModel Update(PersonGroupModel model)
{
var entity = _personGroupRepository.GetById(model.Id);
entity.Name = model.Name;
entity.Gift = model.Gift;
entity.Description = model.Description;
_personGroupRepository.Edit(entity);
_personGroupRepository.Save();
return(model);
}
public async Task <List <PersonGroupModel> > GetAttendancesAsync(RecordFilterModel filter)
{
var date = (filter.Date ?? DateTime.Now).Date;
var rawData = await(
from grp in _dbContext.PersonGroup
join per in _dbContext.Person on grp.Id equals per.GroupId
join obj in _dbContext.Object on per.Key equals obj.PersonKey into persons
from perObj in persons.DefaultIfEmpty()
where (perObj == null || (perObj.CreateDate >= date && perObj.CreateDate <= date.AddDays(1)))
select new
{
Group = grp,
Person = per,
Record = perObj
}).ToListAsync();
var result = new List <PersonGroupModel>();
foreach (var data in rawData)
{
var group = result.FirstOrDefault(x => x.Id == data.Group.Id);
if (group is null)
{
group = new PersonGroupModel(data.Group);
result.Add(group);
}
var person = group.Records.FirstOrDefault(x => x.Id == data.Person.Id);
if (person is null)
{
group.Records.Add(new RecordModel(data.Person, data.Record?.CreateDate));
}
else if (data.Record?.CreateDate != null && person.CreateDate < data.Record.CreateDate)
{
person.CreateDate = data.Record.CreateDate;
}
}
return(result);
}
public Task TrainPersonGroup(PersonGroupModel personGroup)
{
try
{
var tcs = new TaskCompletionSource<bool>();
Client.TrainPersonGroupWithPersonGroupId(personGroup.Id, error =>
{
tcs.FailTaskIfErrored(error.ToException());
tcs.SetResult(true);
}).Resume();
return tcs.Task;
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task <List <FaceImageModel> > GetPersonFaces(PersonModel person, PersonGroupModel group)
{
try
{
person.Faces.Clear();
if (person.FaceIds != null)
{
var tcs = new TaskCompletionSource <List <FaceImageModel> >();
foreach (var faceId in person.FaceIds)
{
Client.GetPersonFaceWithPersonGroupId(group.Id, person.Id, faceId, (mpoFace, error) =>
{
tcs.FailTaskIfErrored(error.ToException());
var face = mpoFace.ToFace();
person.Faces.Add(face);
if (person.Faces.Count == person.FaceIds.Count)
{
tcs.SetResult(person.Faces);
}
}).Resume();
}
return(tcs.Task);
}
return(Task.FromResult(default(List <FaceImageModel>)));
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public Task UpdatePerson(PersonModel person, PersonGroupModel group, string personName, string userData = null)
{
try
{
var tcs = new TaskCompletionSource <bool>();
Client.UpdatePersonWithPersonGroupId(group.Id, person.Id, personName, userData, error =>
{
tcs.FailTaskIfErrored(error.ToException());
person.Name = personName;
person.UserData = userData;
tcs.SetResult(true);
}).Resume();
return(tcs.Task);
}
catch (Exception ex)
{
Log.Error(ex.Message);
throw;
}
}
public PersonGroupAddedEvent(ILogger logger, PersonGroupModel personGroupModel)
: base(logger)
{
PersonGroupModel = personGroupModel;
}
public AddPersonGroupCommand(User userLoggedIn, PersonGroupModel personGroupModel)
: base(userLoggedIn)
{
PersonGroupModel = personGroupModel;
}
