public ActionConfirmation Delete(int id)
{
SupportTeam supportTeamToDelete = _supportTeamRepository.Get(id);
if (supportTeamToDelete != null)
{
_supportTeamRepository.Delete(supportTeamToDelete);
try
{
_supportTeamRepository.DbContext.CommitChanges();
return(ActionConfirmation.CreateSuccessConfirmation(
"The support team was successfully deleted."));
}
catch
{
_supportTeamRepository.DbContext.RollbackTransaction();
return(ActionConfirmation.CreateFailureConfirmation(
"A problem was encountered preventing the support team from being deleted. " +
"Another item likely depends on this supportTeam."));
}
}
else
{
return(ActionConfirmation.CreateFailureConfirmation(
"The support team could not be found for deletion. It may already have been deleted."));
}
}
public void CannotUpdateInvalidSupportTeamFromForm()
{
// Establish Context
var supportTeamFromForm = new SupportTeam();
var viewModelToExpect = new SupportTeamFormViewModel();
var testUser = new Person();
testUser.SetAssignedIdTo(1);
_authenticationProvider.Expect(r => r.GetLoggedInUser()).Return("user1");
_personManagementService.Expect(r => r.GetByUserName("user1")).Return(testUser);
supportTeamManagementService.Expect(r => r.UpdateWith(supportTeamFromForm, 0))
.Return(ActionConfirmation.CreateFailureConfirmation("not updated"));
supportTeamManagementService.Expect(r => r.CreateFormViewModelFor(supportTeamFromForm))
.Return(viewModelToExpect);
// Act
ViewResult result =
supportTeamsController.Edit(supportTeamFromForm).AssertViewRendered();
// Assert
result.ViewData.Model.ShouldNotBeNull();
(result.ViewData.Model as SupportTeamFormViewModel).ShouldNotBeNull();
}
public ActionResult Create(SupportTeam supportTeam)
{
try
{
if (ViewData.ModelState.IsValid)
{
supportTeam.LastUpdateTimeStamp = DateTime.Now;
supportTeam.LastUpdateUser = GetCurrentUser().Id;
ActionConfirmation saveOrUpdateConfirmation =
_supportTeamManagementService.SaveOrUpdate(supportTeam);
if (saveOrUpdateConfirmation.WasSuccessful)
{
TempData[ControllerEnums.GlobalViewDataProperty.PageMessage.ToString()] =
saveOrUpdateConfirmation.Message;
return(RedirectToAction("Search"));
}
}
else
{
supportTeam = null;
}
}
catch (PreconditionException pce)
{
TempData[ControllerEnums.GlobalViewDataProperty.PageMessage.ToString()] =
pce.Message;
}
SupportTeamFormViewModel viewModel =
_supportTeamManagementService.CreateFormViewModelFor(supportTeam);
return(View(viewModel));
}
private void TransferFormValuesTo(SupportTeam supportTeamToUpdate, SupportTeam supportTeamFromForm)
{
supportTeamToUpdate.TeamName = supportTeamFromForm.TeamName;
supportTeamToUpdate.PhoneNumber = supportTeamFromForm.PhoneNumber;
supportTeamToUpdate.SupervisorId = supportTeamFromForm.SupervisorId;
supportTeamToUpdate.LastUpdateTimeStamp = supportTeamFromForm.LastUpdateTimeStamp;
supportTeamToUpdate.LastUpdateUser = supportTeamFromForm.LastUpdateUser;
}
public ActionResult DeleteConfirmed(int id)
{
SupportTeam supportTeam = db.MySupportTeam.Find(id);
db.MySupportTeam.Remove(supportTeam);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public SupportTeamFormViewModel CreateFormViewModelFor(SupportTeam supportTeam)
{
var viewModel = new SupportTeamFormViewModel {
SupportTeam = supportTeam
};
LoadViewModel(viewModel);
return(viewModel);
}
public ActionResult Edit([Bind(Include = "Id,FullName,Email,Phone,Title,PerMinuteCost")] SupportTeam supportTeam)
{
if (ModelState.IsValid)
{
db.Entry(supportTeam).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(supportTeam));
}
public ActionResult Create([Bind(Include = "Id,FullName,Email,Phone,Title,PerMinuteCost")] SupportTeam supportTeam)
{
if (ModelState.IsValid)
{
db.MySupportTeam.Add(supportTeam);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(supportTeam));
}
public SupportTeam ToEntity()
{
var steam = new SupportTeam
{
ID = ID,
Text = Text,
Value = Value,
Color = Color,
Show = Show,
};
return steam;
}
public void CannotSaveOrUpdateInvalidSupportTeam()
{
// Establish Context
var invalidSupportTeam = new SupportTeam();
// Act
ActionConfirmation confirmation =
supportTeamManagementService.SaveOrUpdate(invalidSupportTeam);
// Assert
confirmation.ShouldNotBeNull();
confirmation.WasSuccessful.ShouldBeFalse();
confirmation.Value.ShouldBeNull();
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SupportTeam supportTeam = db.MySupportTeam.Find(id);
if (supportTeam == null)
{
return(HttpNotFound());
}
return(View(supportTeam));
}
public void CanCompareSupportTeams()
{
var instance = new SupportTeam {
TeamName = "Team 1", PhoneNumber = "123-4567", SupervisorId = 1
};
var instanceToCompareTo = new SupportTeam
{
TeamName = "Team 1",
PhoneNumber = "123-4567",
SupervisorId = 1
};
instance.ShouldEqual(instanceToCompareTo);
}
public void CanSaveOrUpdateValidSupportTeam()
{
// Establish Context
SupportTeam validSupportTeam =
SupportTeamInstanceFactory.CreateValidTransientSupportTeam();
// Act
ActionConfirmation confirmation =
supportTeamManagementService.SaveOrUpdate(validSupportTeam);
// Assert
confirmation.ShouldNotBeNull();
confirmation.WasSuccessful.ShouldBeTrue();
confirmation.Value.ShouldNotBeNull();
confirmation.Value.ShouldEqual(validSupportTeam);
}
public void CanShowSupportTeam()
{
// Establish Context
SupportTeam supportTeam =
SupportTeamInstanceFactory.CreateValidTransientSupportTeam();
supportTeamManagementService.Expect(r => r.Get(1))
.Return(supportTeam);
// Act
ViewResult result = supportTeamsController.Show(1).AssertViewRendered();
// Assert
result.ViewData.Model.ShouldNotBeNull();
(result.ViewData.Model as SupportTeam).ShouldNotBeNull();
(result.ViewData.Model as SupportTeam).ShouldEqual(supportTeam);
}
public void CanGetSupportTeam()
{
// Establish Context
SupportTeam supportTeamToExpect =
SupportTeamInstanceFactory.CreateValidTransientSupportTeam();
supportTeamRepository.Expect(r => r.Get(1))
.Return(supportTeamToExpect);
// Act
SupportTeam supportTeamRetrieved =
supportTeamManagementService.Get(1);
// Assert
supportTeamRetrieved.ShouldNotBeNull();
supportTeamRetrieved.ShouldEqual(supportTeamToExpect);
}
public void CanDeleteSupportTeam()
{
// Establish Context
var supportTeamToDelete = new SupportTeam();
supportTeamRepository.Expect(r => r.Get(1))
.Return(supportTeamToDelete);
// Act
ActionConfirmation confirmation =
supportTeamManagementService.Delete(1);
// Assert
confirmation.ShouldNotBeNull();
confirmation.WasSuccessful.ShouldBeTrue();
confirmation.Value.ShouldBeNull();
}
public List <SupportTeam> GetSupportTeam()
{
List <SupportTeam> st_list = new List <SupportTeam>();
DataTable dt = new DAL().GetSupportTeam();
if (dt != null)
{
for (int i = 0; i < dt.Rows.Count; i++)
{
SupportTeam qr = new SupportTeam();
qr.Team_name = dt.Rows[i]["Team_name"].ToString();
//qr.alias = dt.Rows[i]["alias"].ToString();
st_list.Add(qr);
}
}
return(st_list);
}
private async Task ReadTeamStatus(SupportTeam team, PerformContext context)
{
var number = await TaskQueue.Enqueue(async() =>
{
using (var helper = new ATHelper(team.ConnectionString))
{
await helper.OpenAsync();
return(await helper.GetForwardedPhoneNumber());
}
});
context.WriteLine($"Team {team.Name} is forwarding to '{number}'.");
var state = await db.ForwardingStates.Where(s => s.TeamId == team.Id).OrderByDescending(s => s.When)
.FirstOrDefaultAsync();
if (state?.RawPhoneNumber == number)
{
context.WriteLine("No state change, completed check.");
return;
}
context.WriteLine($"Change detected from '{state?.RawPhoneNumber}' to '{number}'.");
var newState = new ForwardingState
{
Team = team,
When = DateTimeOffset.Now,
RawPhoneNumber = number,
DetectedPhoneNumber = db.UserPhoneNumbers.FirstOrDefault(p => p.Value == number)
};
db.ForwardingStates.Add(newState);
await db.SaveChangesAsync();
var prevStateId = state?.Id;
await db.Teams.Where(t => t.Id == team.Id).SelectMany(t => t.Members).Select(m => m.User)
.SelectMany(u => u.ApiKeys).Where(a => a.CallbackUrl != null).ForEachAsync(apiKey =>
{
context.WriteLine($"Scheduling notification to {apiKey.CallbackUrl}.");
BackgroundJob.Enqueue <IPublisher>(p =>
p.NotifyStateChange(prevStateId, newState.Id, apiKey.CallbackUrl, null));
});
}
public ActionConfirmation SaveOrUpdate(SupportTeam supportTeam)
{
if (supportTeam.IsValid())
{
_supportTeamRepository.SaveOrUpdate(supportTeam);
ActionConfirmation saveOrUpdateConfirmation = ActionConfirmation.CreateSuccessConfirmation(
"The support team was successfully saved.");
saveOrUpdateConfirmation.Value = supportTeam;
return(saveOrUpdateConfirmation);
}
else
{
_supportTeamRepository.DbContext.RollbackTransaction();
return(ActionConfirmation.CreateFailureConfirmation(
"The support team could not be saved due to missing or invalid information."));
}
}
public void CanCreateFormViewModelForSupportTeam()
{
// Establish Context
var viewModelToExpect = new SupportTeamFormViewModel();
SupportTeam supportTeam =
SupportTeamInstanceFactory.CreateValidTransientSupportTeam();
supportTeamRepository.Expect(r => r.Get(1))
.Return(supportTeam);
// Act
SupportTeamFormViewModel viewModelRetrieved =
supportTeamManagementService.CreateFormViewModelFor(1);
// Assert
viewModelRetrieved.ShouldNotBeNull();
viewModelRetrieved.SupportTeam.ShouldNotBeNull();
viewModelRetrieved.SupportTeam.ShouldEqual(supportTeam);
}
public void CannotUpdateWithInvalidSupportTeamFromForm()
{
// Establish Context
var invalidSupportTeamFromForm = new SupportTeam();
// Intentionally empty to ensure successful transfer of values
var supportTeamFromDb = new SupportTeam();
supportTeamRepository.Expect(r => r.Get(1))
.Return(supportTeamFromDb);
// Act
ActionConfirmation confirmation =
supportTeamManagementService.UpdateWith(invalidSupportTeamFromForm, 1);
// Assert
confirmation.ShouldNotBeNull();
confirmation.WasSuccessful.ShouldBeFalse();
confirmation.Value.ShouldBeNull();
}
public void CanCreateValidSupportTeamFromForm()
{
// Establish Context
var supportTeamFromForm = new SupportTeam();
var testUser = new Person();
testUser.SetAssignedIdTo(1);
_authenticationProvider.Expect(r => r.GetLoggedInUser()).Return("user1");
_personManagementService.Expect(r => r.GetByUserName("user1")).Return(testUser);
supportTeamManagementService.Expect(r => r.SaveOrUpdate(supportTeamFromForm))
.Return(ActionConfirmation.CreateSuccessConfirmation("saved"));
// Act
RedirectToRouteResult redirectResult =
supportTeamsController.Create(supportTeamFromForm)
.AssertActionRedirect().ToAction("Search");
// Assert
supportTeamsController.TempData[ControllerEnums.GlobalViewDataProperty.PageMessage.ToString()].ToString()
.ShouldEqual("saved");
}
public ActionConfirmation UpdateWith(SupportTeam supportTeamFromForm, int idOfSupportTeamToUpdate)
{
SupportTeam supportTeamToUpdate =
_supportTeamRepository.Get(idOfSupportTeamToUpdate);
TransferFormValuesTo(supportTeamToUpdate, supportTeamFromForm);
if (supportTeamToUpdate.IsValid())
{
ActionConfirmation updateConfirmation = ActionConfirmation.CreateSuccessConfirmation(
"The support team was successfully updated.");
updateConfirmation.Value = supportTeamToUpdate;
return(updateConfirmation);
}
else
{
_supportTeamRepository.DbContext.RollbackTransaction();
return(ActionConfirmation.CreateFailureConfirmation(
"The support team could not be saved due to missing or invalid information."));
}
}
public void CanGetAllSupportTeams()
{
// Establish Context
IList <SupportTeam> supportTeamsToExpect = new List <SupportTeam>();
SupportTeam supportTeam =
SupportTeamInstanceFactory.CreateValidTransientSupportTeam();
supportTeamsToExpect.Add(supportTeam);
supportTeamRepository.Expect(r => r.GetAll(Arg <string> .Is.Anything, Arg <string> .Is.Anything))
.Return(supportTeamsToExpect);
// Act
IList <SupportTeam> supportTeamsRetrieved =
supportTeamManagementService.GetAll();
// Assert
supportTeamsRetrieved.ShouldNotBeNull();
supportTeamsRetrieved.Count.ShouldEqual(1);
supportTeamsRetrieved[0].ShouldNotBeNull();
supportTeamsRetrieved[0].ShouldEqual(supportTeam);
}
public void CanUpdateWithValidSupportTeamFromForm()
{
// Establish Context
SupportTeam validSupportTeamFromForm =
SupportTeamInstanceFactory.CreateValidTransientSupportTeam();
// Intentionally empty to ensure successful transfer of values
var supportTeamFromDb = new SupportTeam();
supportTeamRepository.Expect(r => r.Get(1))
.Return(supportTeamFromDb);
// Act
ActionConfirmation confirmation =
supportTeamManagementService.UpdateWith(validSupportTeamFromForm, 1);
// Assert
confirmation.ShouldNotBeNull();
confirmation.WasSuccessful.ShouldBeTrue();
confirmation.Value.ShouldNotBeNull();
confirmation.Value.ShouldEqual(supportTeamFromDb);
confirmation.Value.ShouldEqual(validSupportTeamFromForm);
}
public SupportTeamFormViewModel CreateFormViewModelFor(int supportTeamId)
{
SupportTeam supportTeam = _supportTeamRepository.Get(supportTeamId);
return(CreateFormViewModelFor(supportTeam));
}
public ActionResult Show(int id)
{
SupportTeam supportTeam = _supportTeamManagementService.Get(id);
return(View(supportTeam));
}
