public void CommandResultToFeatureVm_Should_Return_FeatureVm()
{
string id = "good";
string idMessage = MessagesModel.ItemMessage + id;
string name = "bad";
string nameMessage = MessagesModel.ItemMessage + name;
string ticket = "ugly";
string ticketMessage = MessagesModel.ItemMessage + ticket;
FeatureCommandResult result = new FeatureCommandResult();
result.InvalidId = id;
result.InvalidName = name;
result.InvalidTicket = ticket;
FeatureVm actual = FeatureModelHelper.CommandResultToFeatureVm(result);
Assert.AreEqual(idMessage, actual.IdMessage.Message);
Assert.AreEqual(MessagesModel.ItemError, actual.IdMessage.Error);
Assert.AreEqual(MessagesModel.ItemGroupError, actual.IdMessage.GroupError);
Assert.AreEqual(nameMessage, actual.NameMessage.Message);
Assert.AreEqual(MessagesModel.ItemError, actual.NameMessage.Error);
Assert.AreEqual(MessagesModel.ItemGroupError, actual.NameMessage.GroupError);
Assert.AreEqual(ticketMessage, actual.TicketMessage.Message);
Assert.AreEqual(MessagesModel.ItemError, actual.TicketMessage.Error);
Assert.AreEqual(MessagesModel.ItemGroupError, actual.TicketMessage.GroupError);
}
private void ViewModelToControl(FeatureVm vm)
{
this.FeatureName.Text = vm.Name;
this.FeatureTicket.Text = vm.Ticket;
this.FeatureOwner.SelectedValue = vm.UserId;
this.FeatureActive.Checked = vm.IsActive;
this.FeatureEnabled.Checked = vm.IsEnabled;
}
private void ControlToViewModel(FeatureVm vm)
{
vm.Id = Guid.NewGuid().ToString();
vm.DateAdded = DateTime.Now;
vm.Name = this.FeatureName.Text;
vm.Ticket = this.FeatureTicket.Text;
vm.UserId = this.FeatureOwner.SelectedValue;
vm.IsActive = this.FeatureActive.Checked;
vm.IsEnabled = this.FeatureEnabled.Checked;
}
private void ControlToViewModel(FeatureVm vm)
{
vm.Id = this.FeatureId.Text;
DateTime date = DateTime.Parse(this.FeatureDateAdded.Text);
vm.Name = this.FeatureName.Text;
vm.Ticket = this.FeatureTicket.Text;
vm.UserId = this.FeatureOwner.SelectedValue;
vm.IsActive = this.FeatureActive.Checked;
vm.IsEnabled = this.FeatureEnabled.Checked;
}
protected void SubmitForm(object sender, EventArgs e)
{
this.ControlToViewModel(this.Vm);
this.Vm = this.model.EditFeature(this.Vm);
if (this.Vm.Valid)
{
this.Navigate(PagesModel.Features);
}
this.ViewModelToControl(this.Vm);
}
public FeatureVm GetFeatureById(GetFeatureByIdQuery query)
{
if (query == null)
{
throw new ArgumentNullException(string.Format(MessagesModel.NullValueError, "query"));
}
GetFeatureQueryResult result = this.queryDispatcher.Dispatch <GetFeatureByIdQuery, GetFeatureQueryResult, Feature>(query);
FeatureVm vm = FeatureModelHelper.QueryResultToFeatureVm(result);
return(vm);
}
private void BindFormValues()
{
string id = Request.QueryString["id"];
GetFeatureByIdQuery query = new GetFeatureByIdQuery(id);
this.Vm = this.model.GetFeatureById(query);
this.FeatureId.Text = this.Vm.Id;
this.FeatureName.Text = this.Vm.Name;
this.FeatureTicket.Text = this.Vm.Ticket;
this.FeatureOwner.SelectedValue = this.Vm.UserId;
this.FeatureActive.Checked = this.Vm.IsActive;
this.FeatureEnabled.Checked = this.Vm.IsEnabled;
this.FeatureDateAdded.Text = this.Vm.DateAdded.ToShortDateString();
}
//TODO: Decide what happens if we happen to have a duplicate key here.
public FeatureVm EditFeature(FeatureVm vm)
{
if (vm == null)
{
throw new ArgumentNullException(string.Format(MessagesModel.NullValueError, "vm"));
}
EditFeatureCommand command = new EditFeatureCommand(vm.Id, vm.DateAdded, vm.Name, vm.UserId, vm.Ticket, vm.IsActive, vm.IsEnabled, vm.StrategyId);
FeatureCommandResult result = this.commandDispatcher.Dispatch <EditFeatureCommand, FeatureCommandResult, Feature>(command);
vm = FeatureModelHelper.CommandResultToFeatureVm(result);
return(vm);
}
protected FeatureVm GetFeatureVm(string id = null, DateTime?date = null, string name = null, string userId = null, string ticket = null)
{
string defaultId = id ?? "id1";
DateTime defaultDate = date ?? DateTime.Now;
string defaultName = name ?? "Feature 1";
string defaultUserId = userId ?? "tester";
string defaultTicket = ticket ?? "";
FeatureVm vm = new FeatureVm();
vm.Id = defaultId;
vm.DateAdded = defaultDate;
vm.Name = defaultName;
vm.UserId = defaultUserId;
vm.Ticket = defaultTicket;
return(vm);
}
public static FeatureVm CommandResultToFeatureVm(FeatureCommandResult result)
{
if (result == null)
{
throw new ArgumentNullException(string.Format(MessagesModel.NullValueError, "result"));
}
FeatureVm vm = new FeatureVm();
vm.Valid = result.Valid;
vm.Message = MessagesModel.FormError;
if (!string.IsNullOrWhiteSpace(result.Message))
{
vm.Message = result.Message;
}
vm.MessageStyle = MessagesModel.MessageStyles.Error;
if (!string.IsNullOrWhiteSpace(result.InvalidId))
{
vm.IdMessage.Message = MessagesModel.ItemMessage + result.InvalidId;
vm.IdMessage.Error = MessagesModel.ItemError;
vm.IdMessage.GroupError = MessagesModel.ItemGroupError;
}
if (!string.IsNullOrWhiteSpace(result.InvalidName))
{
vm.NameMessage.Message = MessagesModel.ItemMessage + result.InvalidName;
vm.NameMessage.Error = MessagesModel.ItemError;
vm.NameMessage.GroupError = MessagesModel.ItemGroupError;
}
if (!string.IsNullOrWhiteSpace(result.InvalidTicket))
{
vm.TicketMessage.Message = MessagesModel.ItemMessage + result.InvalidTicket;
vm.TicketMessage.Error = MessagesModel.ItemError;
vm.TicketMessage.GroupError = MessagesModel.ItemGroupError;
}
return(vm);
}
public static FeatureVm QueryResultToFeatureVm(GetFeatureQueryResult result)
{
if (result == null)
{
throw new ArgumentNullException(string.Format(MessagesModel.NullValueError, "result"));
}
FeatureVm vm = new FeatureVm();
vm.DateAdded = result.DateAdded;
vm.Id = result.Id;
vm.Name = result.Name;
vm.Ticket = result.Ticket;
vm.UserId = result.UserId;
vm.IsActive = result.IsActive;
vm.IsEnabled = result.IsEnabled;
vm.StrategyId = result.StrategyId;
return(vm);
}
public void QueryResultToFeatureVm_Should_Return_FeatureVm()
{
string id = "1";
string name = "Test Feature";
string userId = "testuser";
string ticket = "T1";
bool active = true;
bool enabled = true;
int strategyId = 0;
GetFeatureQueryResult result = new GetFeatureQueryResult(id, name, userId, ticket, active, enabled, strategyId);
FeatureVm actual = FeatureModelHelper.QueryResultToFeatureVm(result);
Assert.AreEqual(id, actual.Id);
Assert.AreEqual(name, actual.Name);
Assert.AreEqual(userId, actual.UserId);
Assert.AreEqual(ticket, actual.Ticket);
Assert.AreEqual(active, actual.IsActive);
Assert.AreEqual(enabled, actual.IsEnabled);
Assert.AreEqual(strategyId, actual.StrategyId);
}
public ActionResult List(string searchWord = "", int pageNumber = 0)
{
var model = new FeatureVm();
var features = new List <Feature>();
if (string.IsNullOrWhiteSpace(searchWord))
{
features = service.Uow.Features.GetActives();
}
else
{
features = service.Uow.Features.GetBySearchWord(searchWord);
}
var maxPage = Math.Ceiling(features.Count / Convert.ToDouble(PageUtil.PanelFeatureShownCount));
model.Features = features.OrderBy(o => o.Name).Skip(pageNumber * PageUtil.PanelFeatureShownCount).Take(PageUtil.PanelFeatureShownCount).ToList();
model.SearchWord = searchWord;
model.PageNumber = pageNumber;
model.ShownCount = PageUtil.PanelFeatureShownCount;
model.MaxPage = maxPage;
return(View(model));
}
public void QueryResultToFeatureEditVm_Should_Throw_Exception_When_Result_Is_Null()
{
GetFeatureQueryResult result = null;
FeatureVm actual = FeatureModelHelper.QueryResultToFeatureVm(result);
}
public void EditFeature_Should_Throws_Exception_When_Command_Null()
{
FeatureVm vm = null;
var actual = this.Sut.EditFeature(vm);
}
