private static ICaptchaManager GetCaptchaManager(IParameterContainer parameterContainer)
{
int numberOfCaptcha;
if (parameterContainer.TryGet(MultipleParameterKey, out numberOfCaptcha))
return CaptchaManagers.GetOrAdd(numberOfCaptcha, CreateCaptchaManagerByNumber);
//If not found parameter return default manager.
return CaptchaUtils.CaptchaManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="MathBuildInfoModel"/> class.
/// </summary>
public MathBuildInfoModel(IParameterContainer parameterContainer, string tokenParameterName, string mathParamterName, bool isRequired,
string requiredMessage, string refreshButtonText, string inputText,
HtmlHelper htmlHelper, string inputElementId, string tokenElementId,
string imageElementId, string imageUrl, string refreshUrl, string tokenValue)
: base(parameterContainer,
tokenParameterName, requiredMessage, isRequired, refreshButtonText, inputText, htmlHelper,
inputElementId, imageElementId, tokenElementId, refreshUrl, imageUrl, tokenValue)
{
Validate.ArgumentNotNullOrEmpty(mathParamterName, "mathParamterName");
MathParamterName = mathParamterName;
}
private void ApplyParameterSpecifications(IParameterContainer parameterContainer)
{
if (parameterContainer.HasEmbeddedParameters)
{
IParameterSpecification[] specs = parameterContainer.GetEmbeddedParameters();
for (int i = 0; i < specs.Length; i++)
{
ApplyParameterSpecification(specs[i]);
}
}
}
/// <summary>
/// Creates a <see cref="IUpdateInfoModel" /> for create a new captcha.
/// </summary>
/// <param name="controller">
/// The specified <see cref="ControllerBase" />.
/// </param>
/// <param name="parameterContainer">
/// The specified <see cref="IParameterContainer" />.
/// </param>
/// <returns>
/// An instance of <see cref="IUpdateInfoModel" />.
/// </returns>
public virtual IUpdateInfoModel GenerateNew(ControllerBase controller, IParameterContainer parameterContainer)
{
Validate.ArgumentNotNull(controller, "controller");
Validate.ArgumentNotNull(parameterContainer, "parameterContainer");
KeyValuePair <string, ICaptchaValue> captchaPair = CreateCaptchaPair(parameterContainer, null);
StorageProvider.Add(captchaPair);
var urlHelper = new UrlHelper(controller.ControllerContext.RequestContext);
string imgUrl = ImageUrlFactory(urlHelper, captchaPair);
return(new DefaultUpdateInfoModel(TokenElementName, captchaPair.Key, imgUrl, ImageElementName));
}
private static ICaptchaManager GetCaptchaManager(IParameterContainer parameterContainer)
{
int numberOfCaptcha;
if (parameterContainer.TryGet(MultipleParameterKey, out numberOfCaptcha))
{
return(CaptchaManagers.GetOrAdd(numberOfCaptcha, CreateCaptchaManagerByNumber));
}
//If not found parameter return default manager.
return(CaptchaUtils.CaptchaManager);
}
/// <summary>
/// Creates a <see cref="IBuildInfoModel" /> for create a new captcha.
/// </summary>
/// <param name="htmlHelper">
/// The specified <see cref="HtmlHelper" />.
/// </param>
/// <param name="parameterContainer">
/// The specified <see cref="IParameterContainer" />.
/// </param>
/// <returns>
/// An instance of <see cref="IBuildInfoModel" />.
/// </returns>
public virtual IBuildInfoModel GenerateNew(HtmlHelper htmlHelper, IParameterContainer parameterContainer)
{
Validate.ArgumentNotNull(htmlHelper, "htmlHelper");
Validate.ArgumentNotNull(parameterContainer, "parameterContainer");
KeyValuePair <string, ICaptchaValue> captchaPair = CreateCaptchaPair(parameterContainer, null);
StorageProvider.Add(captchaPair);
var urlHelper = new UrlHelper(htmlHelper.ViewContext.RequestContext);
string imgUrl = ImageUrlFactory(urlHelper, captchaPair);
string refreshUrl = RefreshUrlFactory(urlHelper, captchaPair);
return(CreateBuildInfo(htmlHelper, parameterContainer, captchaPair, imgUrl, refreshUrl));
}
/// <summary>
/// Creates an <see cref="IBuildInfoModel" /> for the specified <see cref="KeyValuePair{TKey,TValue}" />.
/// </summary>
/// <param name="htmlHelper">
/// The specified <see cref="HtmlHelper" />.
/// </param>
/// <param name="parameterContainer">
/// The specified <see cref="IParameterContainer" />.
/// </param>
/// <param name="captchaPair">
/// The specified <see cref="KeyValuePair{TKey,TValue}" />.
/// </param>
/// <param name="imgUrl">The specified image url.</param>
/// <param name="refreshUrl">The specified refresh url.</param>
/// <returns>
/// An instance of <see cref="IBuildInfoModel" />.
/// </returns>
protected virtual IBuildInfoModel CreateBuildInfo(HtmlHelper htmlHelper, IParameterContainer parameterContainer,
KeyValuePair <string, ICaptchaValue> captchaPair, string imgUrl,
string refreshUrl)
{
string requiredText = null;
string refreshText;
string inputText;
parameterContainer.TryGet(RefreshTextAttribute, out refreshText, "Refresh");
bool findInputText = parameterContainer.TryGet(InputTextAttribute, out inputText);
bool isRequired = parameterContainer.IsContains(IsRequiredAttribute);
if (isRequired)
{
parameterContainer.TryGet(RequiredMessageAttribute, out requiredText, "This is a required field.");
}
IBuildInfoModel buildInfo;
if (parameterContainer.IsContains(MathCaptchaAttribute))
{
buildInfo = new MathBuildInfoModel(parameterContainer, TokenParameterName, MathCaptchaAttribute, isRequired, requiredText,
refreshText, findInputText ? inputText : "The answer is", htmlHelper,
InputElementName, TokenElementName,
ImageElementName, imgUrl, refreshUrl, captchaPair.Key);
}
else
{
buildInfo = new DefaultBuildInfoModel(parameterContainer, TokenParameterName, requiredText, isRequired,
refreshText, findInputText ? inputText : "Input symbols",
htmlHelper,
InputElementName, ImageElementName, TokenElementName, refreshUrl,
imgUrl,
captchaPair.Key);
}
//If it a partial view.
if (parameterContainer.IsContains(PartialViewNameAttribute))
{
ViewDataDictionary viewData;
parameterContainer.TryGet(PartialViewDataAttribute, out viewData);
string scriptPartialView;
parameterContainer.TryGet(ScriptPartialViewNameAttribute, out scriptPartialView);
return(new PartialBuildInfoModel(htmlHelper, buildInfo,
parameterContainer.Get <string>(PartialViewNameAttribute),
scriptPartialView, viewData));
}
return(buildInfo);
}
public static void ProcessDynamicFilterParameters(
SqlString sqlFragment,
IParameterContainer container,
HqlSqlWalker walker)
{
if (walker.EnabledFilters.Count == 0 &&
(!HasDynamicFilterParam(sqlFragment)) &&
(!(HasCollectionFilterParam(sqlFragment))))
{
return;
}
Dialect.Dialect dialect = walker.SessionFactoryHelper.Factory.Dialect;
string symbols = new StringBuilder().Append(ParserHelper.HqlSeparators)
.Append(dialect.OpenQuote)
.Append(dialect.CloseQuote)
.ToString();
StringTokenizer tokens = new StringTokenizer(sqlFragment.ToString(), symbols, true);
StringBuilder result = new StringBuilder();
foreach (string token in tokens)
{
if (token.StartsWith(ParserHelper.HqlVariablePrefix))
{
string filterParameterName = token.Substring(1);
string[] parts = StringHelper.ParseFilterParameterName(filterParameterName);
FilterImpl filter = ( FilterImpl )walker.EnabledFilters[parts[0]];
Object value = filter.GetParameter(parts[1]);
IType type = filter.FilterDefinition.GetParameterType(parts[1]);
String typeBindFragment = StringHelper.Join(
",",
ArrayHelper.FillArray("?", type.GetColumnSpan(walker.SessionFactoryHelper.Factory))
);
string bindFragment = (value != null && value is ICollection)
? StringHelper.Join(",", ArrayHelper.FillArray(typeBindFragment, (( ICollection )value).Count))
: typeBindFragment;
//result.Append( bindFragment );
result.Append(token);
container.AddEmbeddedParameter(new DynamicFilterParameterSpecification(parts[0], parts[1], type));
}
else
{
result.Append(token);
}
}
container.Text = result.ToString();
}
public static void ProcessDynamicFilterParameters(
SqlString sqlFragment,
IParameterContainer container,
HqlSqlWalker walker)
{
if (walker.EnabledFilters.Count == 0 &&
(!HasDynamicFilterParam(sqlFragment)) &&
(!(HasCollectionFilterParam(sqlFragment))))
{
return;
}
container.Text = sqlFragment.ToString(); // dynamic-filters are processed altogether by Loader
}
public static ObservableCollection<Parameter> parseParameterXmlList(XmlNodeList parameterData, IParameterContainer component, XmlNode skip)
{
ObservableCollection<Parameter> parameterList = new ObservableCollection<Parameter>();
foreach (XmlNode node in parameterData)
{
if (node == skip)
continue;
Parameter p = new Parameter();
if (component is Element)
p.Semantic = DataItemsTools.getParameterSemantic(node, component as Element, p);
else
p.Semantic = ParameterSemantic.NONE;
foreach (XmlAttribute attr in node.Attributes)
{
if (attr.Name == "Name")
{
p.Name = attr.Value;
}
else if (attr.Name == "Default")
{
p.Values = attr.Value;
}
else if (attr.Name == "Count")
{
p.Count = int.Parse(attr.Value);
}
}
p.Type = ParameterTypeName.TypeFromString(node.Name);
if (p.Type == ParameterType.SEQUENCEPARAMETER)
{
p.Type = ParameterType.SEQUENCEPARAMETER;
p.Params = parseParameterXmlList(node.ChildNodes, component);
}
else if (p.Type == ParameterType.COMPOUNDPARAMETER)
{
p.Type = ParameterType.COMPOUNDPARAMETER;
p.Params = parseParameterXmlList(node.ChildNodes, component);
}
else
{
}
p.ParentComponent = component;
parameterList.Add(p);
}
return parameterList;
}
/// <summary>
/// Creates a new <see cref="IDrawingModel" /> for drawing a captcha.
/// </summary>
/// <param name="parameterContainer">
/// The specified <see cref="IParameterContainer" />.
/// </param>
/// <returns>
/// An instance of <see cref="IDrawingModel" />.
/// </returns>
public virtual IDrawingModel GetDrawingModel(IParameterContainer parameterContainer)
{
Validate.ArgumentNotNull(parameterContainer, "parameterContainer");
string token;
if (!parameterContainer.TryGet(TokenParameterName, out token) || string.IsNullOrEmpty(token))
{
throw new KeyNotFoundException("The key is to generate not found.");
}
ICaptchaValue captchaValue = StorageProvider.GetValue(token, TokenType.Drawing);
if (captchaValue == null)
{
throw new ArgumentException("The key is to generate incorrect.");
}
return(DrawingModelFactory(parameterContainer, captchaValue));
}
/// <summary>
/// Generates a specified <see cref="KeyValuePair{TKey,TValue}" /> for a captcha.
/// </summary>
/// <param name="parameterContainer">
/// The specified <see cref="IParameterContainer" />.
/// </param>
/// <param name="oldValue">The old value if any.</param>
/// <returns>
/// An instance of <see cref="KeyValuePair{TKey,TValue}" />.
/// </returns>
protected virtual KeyValuePair <string, ICaptchaValue> CreateCaptchaPair(IParameterContainer parameterContainer,
ICaptchaValue oldValue)
{
if (parameterContainer.IsContains(MathCaptchaAttribute))
{
return(MathCaptchaPairFactory());
}
int length;
if (oldValue != null)
{
length = oldValue.CaptchaText.Length;
}
else if (!parameterContainer.TryGet(LengthAttribute, out length))
{
throw new ArgumentException("Parameter is not specified for the length of the captcha.");
}
if (length <= 0)
{
throw new ArgumentException("The length parameter can not be <= 0.");
}
return(PlainCaptchaPairFactory(length));
}
/// <summary>
/// Determines whether the intelligent captcha is valid.
/// </summary>
/// <param name="captchaManager">The specified captcha manager.</param>
/// <param name="controller">
/// The specified <see cref="ControllerBase" />.
/// </param>
/// <param name="parameterContainer">
/// The specified <see cref="IParameterContainer" />.
/// </param>
/// <returns>
/// <c>True</c> if the intelligent captcha is valid; <c>false</c> not valid; <c>null</c> is not intelligent captcha.
/// </returns>
public virtual bool?IsValid(ICaptchaManager captchaManager, ControllerBase controller, IParameterContainer parameterContainer)
{
Validate.ArgumentNotNull(captchaManager, "captchaManager");
Validate.ArgumentNotNull(controller, "controller");
ValueProviderResult tokenValue = controller
.ValueProvider
.GetValue(captchaManager.TokenElementName + PolicyType);
if (tokenValue == null || string.IsNullOrEmpty(tokenValue.AttemptedValue))
{
return(null);
}
if (!RemoveTokenValue(controller, tokenValue.AttemptedValue))
{
return(null);
}
ValueProviderResult validationVal = controller.ValueProvider.GetValue(ValidationInputName);
return(captchaManager.StorageProvider.Remove(tokenValue.AttemptedValue) && validationVal != null &&
Reverse(validationVal.AttemptedValue) == tokenValue.AttemptedValue);
}
/// <summary>
/// The has any pointer type.
/// </summary>
/// <param name="params">
/// The params.
/// </param>
/// <returns>
/// The has any pointer type.
/// </returns>
private bool HasAnyPointerType(IParameterContainer @params)
{
if (@params != null)
{
return @params.Parameters.Any(x => x.Type.Text.Contains("*"));
}
return false;
}
private void ApplyParameterSpecifications(IParameterContainer parameterContainer)
{
if ( parameterContainer.HasEmbeddedParameters)
{
IParameterSpecification[] specs = parameterContainer.GetEmbeddedParameters();
for ( int i = 0; i < specs.Length; i++ )
{
ApplyParameterSpecification( specs[i] );
}
}
}
public static void ProcessDynamicFilterParameters(
SqlString sqlFragment,
IParameterContainer container,
HqlSqlWalker walker)
{
if ( walker.EnabledFilters.Count == 0
&& ( ! HasDynamicFilterParam( sqlFragment ) )
&& ( ! ( HasCollectionFilterParam( sqlFragment ) ) ) )
{
return;
}
container.Text = sqlFragment.ToString(); // dynamic-filters are processed altogether by Loader
}
public static void ProcessDynamicFilterParameters(
SqlString sqlFragment,
IParameterContainer container,
HqlSqlWalker walker)
{
if ( walker.EnabledFilters.Count == 0
&& ( ! HasDynamicFilterParam( sqlFragment ) )
&& ( ! ( HasCollectionFilterParam( sqlFragment ) ) ) )
{
return;
}
Dialect.Dialect dialect = walker.SessionFactoryHelper.Factory.Dialect;
string symbols = new StringBuilder().Append( ParserHelper.HqlSeparators )
.Append( dialect.OpenQuote)
.Append( dialect.CloseQuote)
.ToString();
StringTokenizer tokens = new StringTokenizer( sqlFragment.ToString(), symbols, true );
StringBuilder result = new StringBuilder();
foreach (string token in tokens)
{
if ( token.StartsWith( ParserHelper.HqlVariablePrefix ) )
{
string filterParameterName = token.Substring( 1 );
string[] parts = StringHelper.ParseFilterParameterName( filterParameterName );
FilterImpl filter = ( FilterImpl ) walker.EnabledFilters[parts[0]];
Object value = filter.GetParameter( parts[1] );
IType type = filter.FilterDefinition.GetParameterType( parts[1] );
String typeBindFragment = StringHelper.Join(
",",
ArrayHelper.FillArray( "?", type.GetColumnSpan( walker.SessionFactoryHelper.Factory ) )
);
string bindFragment = ( value != null && value is ICollection)
? StringHelper.Join( ",", ArrayHelper.FillArray( typeBindFragment, ( ( ICollection ) value ).Count ) )
: typeBindFragment;
//result.Append( bindFragment );
result.Append(token);
container.AddEmbeddedParameter( new DynamicFilterParameterSpecification( parts[0], parts[1], type ) );
}
else
{
result.Append( token );
}
}
container.Text = result.ToString();
}
/// <summary>
/// Checks that all method parameters are verified.
/// </summary>
/// <param name="element">The method to check.</param>
private void CheckMethodParameterVerification(CsElement element)
{
Param.AssertNotNull(element, "element");
IParameterContainer parameterContainer = element as IParameterContainer;
Debug.Assert(parameterContainer != null, "The element does not contain parameters.");
// If there are no parameters, don't do anything.
if (parameterContainer.Parameters.Count > 0)
{
// Get the list of param check tokens.
List <ParamTokens> paramCheckTokens = GetParamCheckTokens(element);
// Find each parameter.
foreach (Parameter parameter in parameterContainer.Parameters)
{
Node <CsToken> paramTokenNode = null;
foreach (ParamTokens paramTokens in paramCheckTokens)
{
bool found = false;
foreach (Node <CsToken> tokenNode in paramTokens.TokenNodes)
{
if (parameter.Name == tokenNode.Value.Text)
{
paramTokenNode = paramTokens.ParamTokenNode;
found = true;
break;
}
}
if (found)
{
break;
}
}
if (paramTokenNode == null)
{
CsElement parent = element.FindParentElement();
if ((parameter.Modifiers & ParameterModifiers.Out) == 0 &&
(element.Declaration.Name != "Ignore" || (parent != null && parent.Declaration.Name != "Param")))
{
this.AddViolation(element, Rules.ParametersMustBeVerified, parameter.Name);
}
}
else
{
if ((parameter.Modifiers & ParameterModifiers.Out) != 0)
{
this.AddViolation(
element, paramTokenNode.Value.LineNumber, Rules.OutParametersMustNotBeVerified, parameter.Name);
}
else
{
// Get the param statement type.
if (paramTokenNode != null && paramTokenNode.Next != null)
{
Node <CsToken> paramCheckTypeNode = paramTokenNode.Next.Next;
if (paramCheckTypeNode != null && paramCheckTypeNode.Value.CsTokenType == CsTokenType.Other)
{
if (element.ActualAccess == AccessModifierType.Private ||
element.ActualAccess == AccessModifierType.Internal ||
element.ActualAccess == AccessModifierType.ProtectedInternal)
{
if (paramCheckTypeNode.Value.Text.StartsWith("Require", StringComparison.Ordinal))
{
Rules type = Rules.PrivateMethodsMustUseAsserts;
/*if (this.autoUpdate)
* {
* if (this.ChangeStatement(document, paramToken, true))
* {
* type = ViolationID.ParamCheckPrivateRequireWarning;
* }
* }*/
this.AddViolation(element, paramTokenNode.Value.LineNumber, type);
}
}
else
{
if (paramCheckTypeNode.Value.Text.StartsWith("Assert", StringComparison.Ordinal))
{
Rules type = Rules.PublicMethodsMustUseRequires;
/*if (this.autoUpdate)
* {
* if (this.ChangeStatement(document, paramToken, false))
* {
* type = ViolationID.ParamCheckPublicAssertWarning;
* }
* }*/
this.AddViolation(element, paramTokenNode.Value.LineNumber, type);
}
}
}
}
}
}
}
}
}
/// <summary>
/// The save.
/// </summary>
/// <param name="parameters">
/// The parameters.
/// </param>
private void Save(IParameterContainer parameters)
{
Debug.Assert(parameters != null, "parameters is null");
this.Save(parameters.Parameters, this.headerWriter, SavingOptions.UseFullyQualifiedNames);
}
/// <summary>
/// Initializes a new instance of the <see cref="ContainerSensorParameters"/> class.
/// </summary>
/// <param name="sensorName">The name to use for this sensor.</param>
/// <param name="sensorType">The type of sensor these parameters will create.</param>
/// <param name="trimName">Whether to trim trailing underscores when doing parameter name lookups.</param>
protected ContainerSensorParameters(string sensorName, string sensorType, bool trimName) : base(sensorName, sensorType)
{
container = PSObjectUtilities.Instance.GetContainer();
container.Initialize(this);
this.trimName = trimName;
}
/// <summary>
/// Determines whether the intelligent captcha is valid.
/// </summary>
/// <param name="captchaManager">The specified captcha manager.</param>
/// <param name="controller">
/// The specified <see cref="ControllerBase" />.
/// </param>
/// <param name="parameterContainer">
/// The specified <see cref="IParameterContainer" />.
/// </param>
/// <returns>
/// <c>True</c> if the intelligent captcha is valid; <c>false</c> not valid; <c>null</c> is not intelligent captcha.
/// </returns>
public virtual bool?IsValid(ICaptchaManager captchaManager, ControllerBase controller, IParameterContainer parameterContainer)
{
Validate.ArgumentNotNull(captchaManager, "captchaManager");
Validate.ArgumentNotNull(controller, "controller");
ValueProviderResult tokenValue = controller
.ValueProvider
.GetValue(captchaManager.TokenElementName + PolicyType);
if (tokenValue == null || string.IsNullOrEmpty(tokenValue.AttemptedValue))
{
return(null);
}
DateTime?dateTime = GetTokenValue(controller, tokenValue.AttemptedValue);
if (dateTime == null)
{
return(null);
}
return(captchaManager.StorageProvider.Remove(tokenValue.AttemptedValue) && DateTime.UtcNow - dateTime.Value > MinResponseTime);
}
/// <summary>
/// Makes the specified captcha "intelligent".
/// </summary>
/// <param name="captchaManager">The specified captcha manager.</param>
/// <param name="captcha">
/// The specified <see cref="ICaptcha" />.
/// </param>
/// <param name="parameterContainer">
/// The specified <see cref="IParameterContainer" />.
/// </param>
/// <returns>
/// An instance of <see cref="ICaptcha" />.
/// </returns>
public virtual ICaptcha MakeIntelligent(ICaptchaManager captchaManager, ICaptcha captcha, IParameterContainer parameterContainer)
{
Validate.ArgumentNotNull(captchaManager, "captchaManager");
Validate.ArgumentNotNull(captcha, "captcha");
if (captcha.BuildInfo.HtmlHelper.ViewData[DefaultCaptchaManager.CaptchaNotValidViewDataKey] != null)
{
return(captcha);
}
var captchaDecorator = captcha as IntelligentCaptchaDecorator;
if (captchaDecorator != null && captchaDecorator.PolicyType.Equals(PolicyType))
{
return(captcha);
}
SaveTokenValue(captcha);
var tokenName = captchaManager.TokenElementName + PolicyType;
return(new IntelligentCaptchaDecorator(captcha, c => RenderMarkup(c, tokenName), RenderScript, PolicyType));
}
/// <summary>
/// The save.
/// </summary>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="writer">
/// The writer.
/// </param>
/// <param name="savingOptions">
/// The saving Options.
/// </param>
private void Save(IParameterContainer parameters, IndentedTextWriter writer, SavingOptions savingOptions)
{
this.Save(parameters.Parameters, writer, savingOptions);
}
/// <summary>
/// Makes the specified captcha "intelligent".
/// </summary>
/// <param name="captchaManager">The specified captcha manager.</param>
/// <param name="captcha">
/// The specified <see cref="ICaptcha" />.
/// </param>
/// <param name="parameterContainer">
/// The specified <see cref="IParameterContainer" />.
/// </param>
/// <returns>
/// An instance of <see cref="ICaptcha" />.
/// </returns>
public virtual ICaptcha MakeIntelligent(ICaptchaManager captchaManager, ICaptcha captcha, IParameterContainer parameterContainer)
{
Validate.ArgumentNotNull(captchaManager, "captchaManager");
Validate.ArgumentNotNull(captcha, "captcha");
if (captcha.BuildInfo.HtmlHelper.ViewData[DefaultCaptchaManager.CaptchaNotValidViewDataKey] != null)
{
return(captcha);
}
var captchaDecorator = captcha as IntelligentCaptchaDecorator;
if (captchaDecorator != null && captchaDecorator.PolicyType.Equals(PolicyType))
{
return(captcha);
}
var tokenName = captchaManager.TokenElementName + PolicyType;
var markup = new StringBuilder(RenderMarkup(captcha, tokenName));
var script = new StringBuilder();
foreach (IIntelligencePolicy intelligencePolicy in Policies)
{
ICaptcha cp = intelligencePolicy.MakeIntelligent(captchaManager, captcha, parameterContainer);
markup.AppendLine(cp.RenderMarkup().ToHtmlString());
script.AppendLine(cp.RenderScript().ToHtmlString());
}
return(new IntelligentCaptchaDecorator(captcha, captcha1 => markup.ToString(), captcha1 => script.ToString(),
PolicyType));
}
public void SetIParameterContainer(IParameterContainer iparametercontainer)
{
this.iparametercontainer = iparametercontainer;
}
/// <summary>
/// Creates a new <see cref="IDrawingModel" /> for drawing a captcha.
/// </summary>
/// <param name="parameterContainer">
/// The specified <see cref="IParameterContainer" />.
/// </param>
/// <param name="captchaValue">
/// The specified <see cref="ICaptchaValue" />.
/// </param>
/// <returns>
/// An instance of <see cref="IDrawingModel" />.
/// </returns>
private static IDrawingModel CreateDrawingModel(IParameterContainer parameterContainer,
ICaptchaValue captchaValue)
{
return(new DefaultDrawingModel(captchaValue.CaptchaText));
}
/// <summary>
/// Determines whether the intelligent captcha is valid.
/// </summary>
/// <param name="captchaManager">The specified captcha manager.</param>
/// <param name="controller">
/// The specified <see cref="ControllerBase" />.
/// </param>
/// <param name="parameterContainer">
/// The specified <see cref="IParameterContainer" />.
/// </param>
/// <returns>
/// <c>True</c> if the intelligent captcha is valid; <c>false</c> not valid; <c>null</c> is not intelligent captcha.
/// </returns>
public virtual bool?IsValid(ICaptchaManager captchaManager, ControllerBase controller, IParameterContainer parameterContainer)
{
Validate.ArgumentNotNull(captchaManager, "captchaManager");
Validate.ArgumentNotNull(controller, "controller");
ValueProviderResult tokenValue = controller
.ValueProvider
.GetValue(captchaManager.TokenElementName + PolicyType);
if (tokenValue == null || string.IsNullOrEmpty(tokenValue.AttemptedValue))
{
return(null);
}
var captchaValue = captchaManager.StorageProvider.GetValue(tokenValue.AttemptedValue, TokenType.Drawing);
if (captchaValue == null)
{
return(null);
}
foreach (IIntelligencePolicy intelligencePolicy in Policies)
{
bool?valid = intelligencePolicy.IsValid(captchaManager, controller, parameterContainer);
if (valid == null)
{
return(null);
}
if (!valid.Value)
{
return(false);
}
captchaManager.StorageProvider.Remove(tokenValue.AttemptedValue);
captchaManager.StorageProvider.Add(new KeyValuePair <string, ICaptchaValue>(tokenValue.AttemptedValue, captchaValue));
}
captchaManager.StorageProvider.Remove(tokenValue.AttemptedValue);
return(true);
}
public static ObservableCollection<Parameter> parseParameterXmlList(XmlNodeList parameterData, IParameterContainer component)
{
return parseParameterXmlList(parameterData, component, null);
}
