private HistoryItem defaultActivityDTOAssembler(ActEntry actEntry)
{
//When the display name is not set use the GBST list to get a localized
if (actEntry.Template.DisplayName == null)
{
var actEntryNameElement = _listCache.GetGbstListElements("Activity Name", false).FirstOrDefault(e => e.Rank == actEntry.Template.Code);
string displayName;
if (actEntryNameElement == null)
{
_logger.LogWarn("No entry was found in GBST 'Activity Name' for code {0} (by rank). Using code value as a display name so there is something to show.", actEntry.Template.Code);
displayName = Convert.ToString(actEntry.Template.Code);
}
else
{
displayName = actEntryNameElement.Title;
}
actEntry.Template.DisplayName = StringToken.FromKeyString("HISTORY_ACTIVITY_NAME_{0}".ToFormat(actEntry.Template.Code), displayName);
}
return(new HistoryItem
{
DatabaseIdentifier = actEntry.ActEntryRecord.DatabaseIdentifier(),
Id = actEntry.Id,
Type = actEntry.Type,
Title = actEntry.Template.DisplayName,
Who = actEntry.Who,
ImpersonatedBy = actEntry.ImpersonatedBy,
When = actEntry.When,
Detail = actEntry.AdditionalInfo
});
}
public IEnumerable <StringToken> LoadDataIntoStringTokens()
{
var csvHandler = new CsvFileHandler <KeyObject, ObjectMap>();
var items = csvHandler.ReadFile(FileName);
return(items.Select(x => StringToken.FromKeyString(x.Key, x.Identifier)));
}
public AjaxContinuation Post(ChangePasswordModel model)
{
var user = _userService.GetUserByLogin(model.UserName);
var notification = new Notification();
if (user == null)
{
notification.RegisterMessage(StringToken.FromKeyString("User Name", "User name does not exist!"));
}
else
{
try
{
user.ChangePassword(_passwordService, model.OldPassword, model.Password);
}
catch (Exception ex)
{
notification.RegisterMessage(StringToken.FromKeyString("Password", ex.Message));
}
}
return
(notification.IsValid()
? AjaxContinuation.ForNavigateWholePage("/account/logoff")
: AjaxContinuation.ForError(notification));
}
public void writes_the_validation_results_activator_requirement()
{
var request = requestFor <LoFiTarget>();
theNotification.RegisterMessage(StringToken.FromKeyString("Test", "Test"));
theModifier.Modify(request);
}
public void create_for_input_where_it_is_null()
{
var key = StringToken.FromKeyString("Something");
var node = MenuNode.ForInput <FakeInput>(key);
node.UrlInput.ShouldBeNull();
var chain1 = new RoutedChain("something");
chain1.AddToEnd(ActionCall.For <FakeController>(x => x.FromInput(null)));
chain1.Route.AddHttpMethodConstraint("GET");
var chain2 = new RoutedChain("something");
chain2.AddToEnd(ActionCall.For <FakeController>(x => x.FromInput(null)));
chain2.Route.AddHttpMethodConstraint("POST");
resolve(node, graph =>
{
graph.AddChain(chain1);
graph.AddChain(chain2);
});
node.BehaviorChain.ShouldBeTheSameAs(chain1);
}
public void GetHashCode_depends_on_the_localization_key()
{
var token1 = StringToken.FromKeyString("something");
var token2 = StringToken.FromKeyString("something");
var token3 = StringToken.FromKeyString("else");
// FakeToken is namespaced
var token4 = new FakeToken("something");
var token5 = new FakeToken("something");
var token6 = new FakeToken("else");
token1.GetHashCode().ShouldEqual(token2.GetHashCode());
token2.GetHashCode().ShouldEqual(token1.GetHashCode());
token3.GetHashCode().ShouldNotEqual(token1.GetHashCode());
token1.GetHashCode().ShouldNotEqual(token3.GetHashCode());
token4.GetHashCode().ShouldEqual(token5.GetHashCode());
token5.GetHashCode().ShouldEqual(token4.GetHashCode());
token6.GetHashCode().ShouldNotEqual(token4.GetHashCode());
token4.GetHashCode().ShouldNotEqual(token6.GetHashCode());
// Namespace matters here
token1.GetHashCode().ShouldNotEqual(token4.GetHashCode());
token3.GetHashCode().ShouldNotEqual(token6.GetHashCode());
}
public void set_the_text_by_localized_StringToken()
{
var token = StringToken.FromKeyString("KEY", "the localized string");
new HtmlTag("div").TextIfEmpty(token)
.Text().ShouldBe(token.ToString());
}
public void set_localized_attr_value_by_string_token()
{
var token = StringToken.FromKeyString("KEY", "the text of this string token");
new HtmlTag("span").Attr("title", token)
.Attr("title").ShouldBe(token.ToString());
}
public void set_localized_tag_text_by_string_token()
{
var token = StringToken.FromKeyString("KEY", "the text of this string token");
new HtmlTag("a").Text(token)
.Text().ShouldBe(token.ToString());
}
public void equals_is_namespace_aware()
{
var token1 = StringToken.FromKeyString("something");
var token2 = StringToken.FromKeyString("something");
var token3 = StringToken.FromKeyString("else");
// FakeToken is namespaced
var token4 = new FakeToken("something");
var token5 = new FakeToken("something");
var token6 = new FakeToken("else");
token1.ShouldEqual(token2);
token2.ShouldEqual(token1);
token3.ShouldNotEqual(token1);
token1.ShouldNotEqual(token3);
token4.ShouldEqual(token5);
token5.ShouldEqual(token4);
token6.ShouldNotEqual(token4);
token4.ShouldNotEqual(token6);
// Namespace matters here
token1.ShouldNotEqual(token4);
token3.ShouldNotEqual(token6);
}
public void should_stop_chain_and_put_notification_in_request_and_execute_failure_handler_if_validation_fails()
{
var input = new SampleInputModel();
var notification = new Notification(typeof(SampleInputModel));
notification.RegisterMessage <SampleInputModel>(m => m.Field, StringToken.FromKeyString("REQUIRED"));
MockFor <IFubuRequest>()
.Expect(request => request.Get <SampleInputModel>())
.Return(input);
MockFor <IValidationProvider>()
.Expect(provider => provider.Validate(input))
.Return(notification);
MockFor <IFubuRequest>()
.Expect(request => request.Set(notification));
MockFor <IValidationFailureHandler>()
.Expect(handler => handler.Handle(typeof(SampleInputModel)));
ClassUnderTest
.Invoke();
VerifyCallsFor <IFubuRequest>();
VerifyCallsFor <IValidationFailureHandler>();
MockFor <IActionBehavior>()
.AssertWasNotCalled(inner => inner.Invoke());
}
public void writes_the_ajax_continuation_when_validation_fails()
{
theNotification.RegisterMessage(StringToken.FromKeyString("Test"));
ClassUnderTest.Invoke();
MockFor <IAjaxValidationFailureHandler>().AssertWasCalled(x => x.Handle(theNotification));
}
public void for_intput_with_model()
{
var key = StringToken.FromKeyString("Something");
var input = new FakeInput()
{
Name = "something"
};
var node = MenuNode.ForInput(key, input);
node.UrlInput.ShouldBeTheSameAs(input);
var chain1 = new BehaviorChain();
chain1.AddToEnd(ActionCall.For <FakeController>(x => x.FromInput(null)));
chain1.Route = new RouteDefinition("something");
chain1.Route.AddHttpMethodConstraint("GET");
var chain2 = new BehaviorChain();
chain2.AddToEnd(ActionCall.For <FakeController>(x => x.FromInput(null)));
chain2.Route = new RouteDefinition("something");
chain2.Route.AddHttpMethodConstraint("POST");
resolve(node, graph =>
{
graph.AddChain(chain1);
graph.AddChain(chain2);
});
node.BehaviorChain.ShouldBeTheSameAs(chain1);
}
public void create_for_action_with_lambda()
{
var key = StringToken.FromKeyString("Something");
var node = MenuNode.ForAction <FakeController>(key, x => x.GetFake(), x => x.Category = "Test");
node.Category.ShouldEqual("Test");
}
public void create_for_input_with_lamba()
{
var key = StringToken.FromKeyString("Something");
var node = MenuNode.ForInput <FakeInput>(key, x => x.Category = "Test");
node.Category.ShouldEqual("Test");
}
public void allow_creation_is_true_should_get_new_entity_values_on_grid_model()
{
var model = harnessFor <CanCreateNewGrid>().BuildGridModel(null);
model.NewEntityText.ShouldEqual(StringToken.FromKeyString("CREATE_NEW_" + typeof(Case).Name.ToUpper()).ToString());
model.NewEntityUrl.ShouldEqual("some url");
}
public void create_for_action()
{
var key = StringToken.FromKeyString("Something");
var node = MenuNode.ForAction <FakeController>(key, x => x.GetFake());
var chain1 = new BehaviorChain();
chain1.AddToEnd(ActionCall.For <FakeController>(x => x.GetFake()));
chain1.Route = new RouteDefinition("something");
chain1.Route.AddHttpMethodConstraint("GET");
var chain2 = new BehaviorChain();
chain2.AddToEnd(ActionCall.For <FakeController>(x => x.GetFake()));
chain2.Route = new RouteDefinition("something");
chain2.Route.AddHttpMethodConstraint("POST");
resolve(node, graph =>
{
graph.AddChain(chain1);
graph.AddChain(chain2);
graph.AddChain(new BehaviorChain());
graph.AddChain(new BehaviorChain());
graph.AddChain(new BehaviorChain());
graph.AddChain(new BehaviorChain());
});
node.BehaviorChain.ShouldBeTheSameAs(chain1);
}
public void renders_the_template()
{
var theValue = TemplateValue.For("field", "FirstName");
var theTemplate = new Template(StringToken.FromKeyString("Test", "{field} is required"), theValue);
theTemplate.Render().ShouldBe("FirstName is required");
}
public void add_roles_by_key()
{
var key = StringToken.FromKeyString("Menu1");
var graph = buildGraph(x =>
{
x.Navigation(r =>
{
r.ForMenu(key);
r.Add += MenuNode.ForAction <OneController>("something", c => c.Go());
r.Add += MenuNode.ForAction <OneController>("else", c => c.Query(null));
r.Add += MenuNode.ForAction <OneController>("different", c => c.Report());
});
x.ApplyConvention <NavigationRootPolicy>(policy =>
{
policy.ForKey(key);
policy.RequireRole("role1");
policy.RequireRole("role2");
});
});
// positive cases
graph.BehaviorFor <OneController>(c => c.Go()).Authorization.AllowedRoles().ShouldHaveTheSameElementsAs("role1", "role2");
graph.BehaviorFor <OneController>(c => c.Query(null)).Authorization.AllowedRoles().ShouldHaveTheSameElementsAs("role1", "role2");
graph.BehaviorFor <OneController>(c => c.Report()).Authorization.AllowedRoles().ShouldHaveTheSameElementsAs("role1", "role2");
graph.BehaviorFor <TwoController>(c => c.Go()).Authorization.AllowedRoles().Any().ShouldBeFalse();
graph.BehaviorFor <ThreeController>(c => c.Go()).Authorization.AllowedRoles().Any().ShouldBeFalse();
}
public void valid()
{
var otherAccessor = ReflectionHelper.GetAccessor <IsValidTarget>(x => x.Other);
theContext.Notification.RegisterMessage(otherAccessor, StringToken.FromKeyString("Test", "Test"));
new IsValid().Matches(theAccessor, theContext).ShouldBeTrue();
}
public ClassValidationModelRules()
{
Property(x => x.GreaterThanZero).GreaterThanZero();
Property(x => x.GreaterOrEqualToZero).GreaterOrEqualToZero();
Property(x => x.LongerThanTen).MinimumLength(10);
Property(x => x.NoMoreThanFiveCharacters).MaximumLength(5);
Property(x => x.AtLeastFiveButNotTen).RangeLength(5, 10);
Property(x => x.GreaterThanFive).MinValue(5);
Property(x => x.LessThanFifteen).MaxValue(15);
Property(x => x.Email).Email();
Property(x => x.Required).Required();
Property(x => x.Regex).RegEx("[a-zA-Z0-9]+$");
Property(x => x.Custom).Rule <UniqueUsernameRule>();
Property(x => x.Password)
.Matches(x => x.ConfirmPassword)
.ReportErrorsOn(x => x.Password)
.ReportErrorsOn(x => x.ConfirmPassword);
Property(x => x.Email)
.Matches(x => x.ConfirmEmail)
.ReportErrorsOn(x => x.ConfirmEmail)
.UseToken(StringToken.FromKeyString("Test:Keys", "Emails must match"));
}
public void SetUp()
{
LocalizationManager.Stub();
theNotification = new Notification(typeof(SampleInputModel));
theNotification.RegisterMessage <SampleInputModel>(m => m.Field, StringToken.FromKeyString("Field", "Message"));
}
public void positive_case_of_setting_hide_if_type()
{
var node = MenuNode.ForCreatorOf <Address>(StringToken.FromKeyString("something"));
node.HideIf(typeof(FakeConditional));
node.HideIfConditional.ShouldEqual(typeof(FakeConditional));
}
public void positive_case_of_setting_is_enabled_type()
{
var node = MenuNode.ForCreatorOf <Address>(StringToken.FromKeyString("something"));
node.IsEnabledBy(typeof(FakeConditional));
node.IsEnabledBy().ShouldEqual(typeof(FakeConditional));
}
public void create_by_chain_by_itself()
{
var key = StringToken.FromKeyString("Something");
var chain = new BehaviorChain();
var node = MenuNode.ForChain(key, chain);
node.BehaviorChain.ShouldBeTheSameAs(chain);
}
public void get_headers_returns_the_one_vlaue()
{
StringToken token = StringToken.FromKeyString("HeaderText");
theColumn.HeaderFrom(token);
theColumn.Headers().Single().ShouldEqual(token.ToString());
}
public void get_header_with_a_string_token()
{
StringToken token = StringToken.FromKeyString("HeaderText");
theColumn.HeaderFrom(token);
theColumn.GetHeader().ShouldEqual(token.ToString());
}
public void find_missing_text_if_the_key_does_not_have_default_text_and_it_is_the_default_culture()
{
var token = StringToken.FromKeyString("KEY1");
ClassUnderTest.FindMissingText(token, theDefaultCulture).ShouldEqual("en-US_KEY1");
MockFor <ILocalizationStorage>().AssertWasCalled(x => x.WriteMissing("KEY1", "en-US_KEY1", theDefaultCulture));
}
public IEnumerable <StringToken> FindTokens()
{
yield return(StringToken.FromKeyString("X", "x"));
yield return(StringToken.FromKeyString("Y", "y"));
yield return(StringToken.FromKeyString("Z", "z"));
}
// SAMPLE: ConventionalKeyUsage
public static StringToken TemplateHeader <T>()
where T : ICustomTemplate
{
var templateType = typeof(T);
var defaultValue = breakUpPascalCasing(templateType.Name);
var tokenKey = "Template:{0}:Header".ToFormat(templateType.FullName);
return(StringToken.FromKeyString(tokenKey, defaultValue));
}
