public async Task <ActionResult> Edit(int id)
{
SqlQuery groupQuery = new SqlQuery
{
Filter = "id = " + id,
Related = "contact_by_contact_group_relationship"
};
Task <DatabaseResourceWrapper <Contact> > contactsTask = databaseApi.GetRecordsAsync <Contact>("contact", new SqlQuery());
Task <DatabaseResourceWrapper <ContactGroup> > contactGroupTask = databaseApi.GetRecordsAsync <ContactGroup>("contact_group", groupQuery);
await Task.WhenAll(contactsTask, contactGroupTask);
var contactGroup = contactGroupTask.Result.Records.FirstOrDefault();
ContactGroupViewModel model = new ContactGroupViewModel
{
ContactGroup = contactGroup,
Contacts = contactsTask.Result.Records
.Select(x => new ContactContactGroupViewModel
{
ContactId = x.Id.Value,
ContactName = string.Format("{0} {1}", x.FirstName, x.LastName),
InGroup = contactGroup.Contacts.Any(y => y.Id == x.Id)
})
.ToList()
};
return(View(model));
}
public async Task <ActionResult> Create(ContactGroupViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
IEnumerable <ContactGroup> records = (await databaseApi.CreateRecordsAsync("contact_group", new List <ContactGroup> {
model.ContactGroup
}, new SqlQuery())).Records;
List <ContactContactGroup> relationshipModel = model.Contacts
.Where(x => x.InGroup)
.Select(x => new ContactContactGroup
{
ContactId = x.ContactId,
ContactGroupId = records.Select(y => y.Id).FirstOrDefault()
})
.ToList();
if (relationshipModel.Count > 0)
{
await databaseApi.CreateRecordsAsync("contact_group_relationship", relationshipModel, new SqlQuery());
}
return(RedirectToAction("List"));
}
public IActionResult CreateContactGroup()
{
ContactGroupViewModel contactGroupViewModel = new ContactGroupViewModel
{
EditMode = EditMode.Create
};
return(View("CreateContactGroup", contactGroupViewModel));
}
public async Task CreateContactGroup_WhenCalledWithInvalidModel_AssertPublishAsyncWasNotCalledOnCommandBus()
{
Controller sut = CreateSut(false);
ContactGroupViewModel model = CreateModel();
await sut.CreateContactGroup(model);
_commandBusMock.Verify(m => m.PublishAsync(It.IsAny <ICreateContactGroupCommand>()), Times.Never);
}
public async Task CreateContactGroup_WhenCalledWithValidModel_ReturnsRedirectToActionResult()
{
Controller sut = CreateSut();
ContactGroupViewModel model = CreateModel();
IActionResult result = await sut.CreateContactGroup(model);
Assert.That(result, Is.TypeOf <RedirectToActionResult>());
}
public async Task CreateContactGroup_WhenCalledWithValidModel_ReturnsRedirectToActionResultWhereActionNameIsEqualToCountries()
{
Controller sut = CreateSut();
ContactGroupViewModel model = CreateModel();
RedirectToActionResult result = (RedirectToActionResult)await sut.CreateContactGroup(model);
Assert.That(result.ActionName, Is.EqualTo("ContactGroups"));
}
public async Task CreateContactGroup_WhenCalledWithInvalidModel_ReturnsViewResultWhereViewNameIsEqualToCreateContactGroup()
{
Controller sut = CreateSut(false);
ContactGroupViewModel model = CreateModel();
ViewResult result = (ViewResult)await sut.CreateContactGroup(model);
Assert.That(result.ViewName, Is.EqualTo("CreateContactGroup"));
}
public async Task <ActionResult> Edit(ContactGroupViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
SqlQuery contactsInGroupQuery = new SqlQuery
{
Filter = "contact_group_id = " + model.ContactGroup.Id
};
ContactContactGroup tmp;
Dictionary <int, ContactContactGroup> relationshipsInDb =
(await databaseApi.GetRecordsAsync <ContactContactGroup>("contact_group_relationship", contactsInGroupQuery))
.Records
.ToDictionary(x => x.ContactId.Value, x => x);
Dictionary <int, ContactContactGroup> relationshipsInModel =
model.Contacts
.Where(x => x.InGroup)
.ToDictionary(x => x.ContactId, x => new ContactContactGroup
{
ContactGroupId = model.ContactGroup.Id,
ContactId = x.ContactId
});
List <ContactContactGroup> relationshipsToDelete =
relationshipsInDb.Values
.Where(relationship => !relationshipsInModel.TryGetValue(relationship.ContactId.Value, out tmp))
.ToList();
List <ContactContactGroup> relationshipsToAdd =
relationshipsInModel.Values
.Where(relationship => !relationshipsInDb.TryGetValue(relationship.ContactId.Value, out tmp))
.ToList();
List <Task> tasks = new List <Task>();
tasks.Add(databaseApi.UpdateRecordsAsync("contact_group", new List <ContactGroup> {
model.ContactGroup
}, new SqlQuery()));
if (relationshipsToAdd.Count > 0)
{
tasks.Add(databaseApi.CreateRecordsAsync("contact_group_relationship", relationshipsToAdd, new SqlQuery()));
}
if (relationshipsToDelete.Count > 0)
{
tasks.Add(databaseApi.DeleteRecordsAsync("contact_group_relationship", relationshipsToDelete, new SqlQuery()));
}
await Task.WhenAll(tasks);
return(RedirectToAction("List"));
}
public async Task UpdateContactGroup_WhenCalledWithInvalidModel_ReturnsViewResult()
{
Controller sut = CreateSut(modelIsValid: false);
ContactGroupViewModel model = CreateModel();
IActionResult result = await sut.UpdateContactGroup(model);
Assert.That(result, Is.TypeOf <ViewResult>());
}
public async Task CreateContactGroup_WhenCalledWithValidModel_AssertPublishAsyncWasCalledOnCommandBus()
{
Controller sut = CreateSut();
ContactGroupViewModel model = CreateModel();
await sut.CreateContactGroup(model);
_commandBusMock.Verify(m => m.PublishAsync(It.Is <ICreateContactGroupCommand>(command =>
command.Number == model.Number &&
string.CompareOrdinal(command.Name, model.Name) == 0)),
Times.Once);
}
public async Task CreateContactGroup_WhenCalledWithInvalidModel_ReturnsViewResultWhereModelIsEqualToInvalidModel()
{
Controller sut = CreateSut(false);
ContactGroupViewModel model = CreateModel();
ViewResult result = (ViewResult)await sut.CreateContactGroup(model);
Assert.That(result.Model, Is.TypeOf <ContactGroupViewModel>());
ContactGroupViewModel contactGroupViewModel = (ContactGroupViewModel)result.Model;
Assert.That(contactGroupViewModel, Is.EqualTo(model));
}
public async Task <IActionResult> UpdateContactGroup(ContactGroupViewModel contactGroupViewModel)
{
NullGuard.NotNull(contactGroupViewModel, nameof(contactGroupViewModel));
if (ModelState.IsValid == false)
{
return(View("UpdateContactGroup", contactGroupViewModel));
}
IUpdateContactGroupCommand command = _contactViewModelConverter.Convert <ContactGroupViewModel, UpdateContactGroupCommand>(contactGroupViewModel);
await _commandBus.PublishAsync(command);
return(RedirectToAction("ContactGroups", "Contact"));
}
public async Task <IActionResult> UpdateContactGroup(int number)
{
IGetContactGroupQuery query = new GetContactGroupQuery
{
Number = number
};
IContactGroup contactGroup = await _queryBus.QueryAsync <IGetContactGroupQuery, IContactGroup>(query);
ContactGroupViewModel contactGroupViewModel = _contactViewModelConverter.Convert <IContactGroup, ContactGroupViewModel>(contactGroup);
contactGroupViewModel.EditMode = EditMode.Edit;
return(View("UpdateContactGroup", contactGroupViewModel));
}
// GET: /ContactList/ContactGroup/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Pseez.DomainClasses.Models.PseezEnt.Contact.ContactGroup contactGroup = _contactGroupService.FindById((int)id);
if (contactGroup == null)
{
return(HttpNotFound());
}
ContactGroupViewModel contactGroupViewModel = contactGroup.MapModelToViewModel();
return(PartialView("_Details", contactGroupViewModel));
}
public ActionResult Create([Bind(Include = "Name,Description,ContactListName")] ContactGroupViewModel contactGroupViewModel)
{
if (ModelState.IsValid)
{
ContactGroup contactGroup = contactGroupViewModel.MapViewModelToModel();
//IContactListService _contactListService = new EfContactListService(_uow);
contactGroup.ContactListId = _contactListService.Find(r => r.Name == contactGroupViewModel.ContactListName).Id;
_contactGroupService.Add(contactGroup);
_uow.SaveChanges();
return(Json(new { success = true }));
}
ViewBag.ContactListNames = new SelectList(_contactListService.GetAll(), "Name", "Name");
return(PartialView("_Create", contactGroupViewModel));
}
public void CreateContactGroup_WhenCalledWithoutModel_ReturnsViewResultWhereModelIsContactGroupViewModel()
{
Controller sut = CreateSut();
ViewResult result = (ViewResult)sut.CreateContactGroup();
Assert.That(result.Model, Is.TypeOf <ContactGroupViewModel>());
ContactGroupViewModel contactGroupViewModel = (ContactGroupViewModel)result.Model;
Assert.That(contactGroupViewModel, Is.Not.Null);
Assert.That(contactGroupViewModel.Number, Is.EqualTo(default(int)));
Assert.That(contactGroupViewModel.Name, Is.Null);
Assert.That(contactGroupViewModel.EditMode, Is.EqualTo(EditMode.Create));
}
public ActionResult Edit([Bind(Include = "Id,Name,Description")] ContactGroupViewModel contactGroupViewModel)
{
if (ModelState.ContainsKey("ContactListName"))
{
ModelState["ContactListName"].Errors.Clear();
}
if (ModelState.IsValid)
{
ContactGroup contactGroup = _contactGroupService.FindById(contactGroupViewModel.Id);
contactGroup.Name = contactGroupViewModel.Name;
contactGroup.Description = contactGroupViewModel.Description;
_uow.SaveChanges();
return(Json(new { success = true }));
}
return(PartialView("_Edit", contactGroupViewModel));
}
public async Task UpdateContactGroup_WhenCalledWithNumber_ReturnsViewResultWhereModelIsContactGroupViewModel()
{
int number = _fixture.Create <int>();
string name = _fixture.Create <string>();
IContactGroup contactGroup = _fixture.BuildContactGroupMock(number, name).Object;
Controller sut = CreateSut(contactGroup);
ViewResult result = (ViewResult)await sut.UpdateContactGroup(_fixture.Create <int>());
Assert.That(result.Model, Is.TypeOf <ContactGroupViewModel>());
ContactGroupViewModel contactGroupViewModel = (ContactGroupViewModel)result.Model;
Assert.That(contactGroupViewModel, Is.Not.Null);
Assert.That(contactGroupViewModel.Number, Is.EqualTo(number));
Assert.That(contactGroupViewModel.Name, Is.EqualTo(name));
Assert.That(contactGroupViewModel.EditMode, Is.EqualTo(EditMode.Edit));
}
public async Task <ActionResult> Create()
{
List <ContactContactGroupViewModel> contacts = (await databaseApi.GetRecordsAsync <Contact>("contact", new SqlQuery()))
.Records
.Select(x => new ContactContactGroupViewModel
{
ContactId = x.Id.Value,
ContactName = string.Format("{0} {1}", x.FirstName, x.LastName),
InGroup = false
}).ToList();
ContactGroupViewModel model = new ContactGroupViewModel
{
ContactGroup = new ContactGroup(),
Contacts = contacts
};
return(View(model));
}
//Contructs the Initial GroupMembership after a refresh/
public void ConstructGroupMemberships(Contact contact)
{
var toggleGroupsToAdd = new List <GroupMembershipViewModel>();
//First add the Toggle Groups
foreach (var tG in AppCore.Settings.ToggleGroups.OrderBy(tG => tG))
{
ContactGroup contactGroup = AppCore.Model.ContactGroups.ValueOrDefault(tG);
ContactGroupViewModel contactGroupViewModel;
if (contactGroup == null)
{
contactGroupViewModel = new ContactGroupViewModel()
{
Name = tG, CannotBeDeleted = false
}
}
; //If group is not found in Model, this means the group just exists in th toggle settings. Id must be null.
else
{
contactGroupViewModel = new ContactGroupViewModel(contactGroup);
}
toggleGroupsToAdd.Add(new GroupMembershipViewModel()
{
MembershipLinkId = null, //This means the contact has not joined this group yet
ContactGroup = contactGroupViewModel,
Joined = false,
GroupMembershipChipType = GroupMembershipChipType.Group,
Contact = this
});
}
//Then add the other groups which the contact has joined
var groupsToAdd = new List <GroupMembershipViewModel>();
foreach (var groupMembership in contact.GroupMemberships)
{
var gMVM = toggleGroupsToAdd.FirstOrDefault(g => g.ContactGroup.Name == groupMembership.GroupName);
if (gMVM != null)
{
gMVM.Joined = true;
}
else
{
if (!AppCore.Model.ContactGroups.TryGetValue(groupMembership.GroupName, out ContactGroup contactGroup))
{
contactGroup = new ContactGroup(groupMembership.GroupName, false, new List <GroupGoogleAccounts>());
}
groupsToAdd.Add(new GroupMembershipViewModel()
{
MembershipLinkId = groupMembership.MembershipLinkId,
ContactGroup = new ContactGroupViewModel(contactGroup),
Joined = true,
GroupMembershipChipType = GroupMembershipChipType.Group,
Contact = this
});
}
}
//Finally add the remaining groups not joined by the contact
foreach (ContactGroup contactGroup in AppCore.Model.ContactGroups.Where(g => !toggleGroupsToAdd.Any(tG => tG.ContactGroup.Name == g.Key) && !groupsToAdd.Any(g2 => g2.ContactGroup.Name == g.Key)).Select(e => e.Value))
{
groupsToAdd.Add(new GroupMembershipViewModel()
{
Contact = this,
ContactGroup = new ContactGroupViewModel(contactGroup),
GroupMembershipChipType = GroupMembershipChipType.Group,
Joined = false
});
}
var groupsToAddSorted = groupsToAdd.OrderBy(g => g.ContactGroup.Name);
toggleGroupsToAdd.AddRange(groupsToAddSorted);
this.GroupMemberships.Clear();
this.GroupMemberships.AddRange(toggleGroupsToAdd);
}
public static ContactGroup MapViewModelToModel(this ContactGroupViewModel entity)
{
return(Mapper.Map <ContactGroupViewModel, ContactGroup>(entity));
}
