public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
try
{
String localeId = GetLocaleId(context);
if (localeId == null && setup.UseBrowser)
{
localeId = GetUserLanguage(context.Request);
}
if (localeId != null)
{
CultureInfo culture = CultureInfo.CreateSpecificCulture(localeId);
Thread.CurrentThread.CurrentCulture = culture;
Thread.CurrentThread.CurrentUICulture = culture;
}
}
catch
{
if (setup.FailOnError)
{
throw;
}
}
return(true);
}
/// <summary>
/// Executa o filtro.
/// </summary>
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (!Enabled)
return true;
UserAgent ua = null;
var uaString = context.UnderlyingContext.Request.UserAgent;
if (uaString != null)
{
ua = (UserAgent) cache[uaString];
if (ua == null)
cache[uaString] = ua = new UserAgent(uaString);
}
if (IsValid(ua))
return true;
if (!logged)
{
Log.Error("Tentativa de acesso através de browser não suportado: {0}", uaString);
logged = true;
}
controller.PropertyBag["invalidGecko"] = true;
if (!Redirect)
return true;
throw new Exception("redir: " + Redirect);
//RedirectToNotice(controller);
//return false;
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
// Read previous authenticated principal from session
// (could be from cookie although with more work)
User user = (User) context.Session["user"];
// Sets the principal as the current user
context.CurrentUser = user;
// Checks if it is OK
if (context.CurrentUser == null || !context.CurrentUser.Identity.IsAuthenticated)
{
// Not authenticated, redirect to login
NameValueCollection parameters = new NameValueCollection();
parameters.Add("ReturnUrl", context.Url);
controller.Redirect("login", "index", parameters);
// Prevent request from continue
return false;
}
// Everything is ok
return true;
}
/// <summary>
/// Initializes a new instance of the <see cref="FilterDescriptor"/> class.
/// </summary>
/// <param name="filterType">Type of the filter.</param>
/// <param name="when">The flag that defines when it should run.</param>
/// <param name="executionOrder">The execution order.</param>
/// <param name="attribute">The attribute.</param>
public FilterDescriptor(Type filterType, ExecuteEnum when, int executionOrder, FilterAttribute attribute)
{
this.filterType = filterType;
this.when = when;
this.executionOrder = executionOrder;
this.attribute = attribute;
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
Employee _employee = context.Session["logonUser"] as Employee;
// Sets the principal as the current user
// Checks if it is OK
if (_employee == null)
{
// Not authenticated, redirect to login
NameValueCollection parameters = new NameValueCollection();
parameters.Add("backUrl", context.Url);
//HttpContext.Current.Response.Write("/Background/Home");
//HttpContext.Current.Response.End();
controller.Redirect("Home", "Login", parameters);
// Prevent request from continue
return(false);
}
else
{
string _moduleCn = controller.Name;
if (!string.IsNullOrEmpty(controller.AreaName))
{
_moduleCn = controller.AreaName;
}
_moduleCn = _moduleCn.ToLower();
int _permission = -1;
if (_moduleCn.Equals("essential"))
{
_permission = Convert.ToInt32(PermissionType.Essential, 2); //系统配置
}
if (_moduleCn.Equals("student"))
{
_permission = Convert.ToInt32(PermissionType.Student, 2); //学生管理
}
if (_moduleCn.Equals("article"))
{
_permission = Convert.ToInt32(PermissionType.Article, 2); //网站内容
}
if (_permission > 0)
{
int _authority = _employee.Permission.Value & _permission;
if (_authority == 0)
{
// Not authenticated, redirect to login
NameValueCollection parameters = new NameValueCollection();
parameters.Add("backUrl", context.Url);
controller.Redirect("Home", "Login", parameters);
// Prevent request from continue
return(false);
}
}
}
// Everything is ok
return(true);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext ctx, Controller c)
{
if (!controllersToSkip.IsMatch(GetControllerName(c)))
if (ctx.CurrentUser == null || !ctx.CurrentUser.Identity.IsAuthenticated)
return TryAutoLogin();
return true;
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
User user = (User)context.Session["logonUser"];
if (user == null)
{
return false;
}
return true;
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (context.Params["printable"] != null)
{
controller.LayoutName = "printabletheme";
}
return(true);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (context.Params["printable"] != null)
{
controller.LayoutName = "printabletheme";
}
return true;
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (context.Request.Headers["mybadheader"] != null)
{
context.Response.Write("Denied!");
return false;
}
return true;
}
public virtual bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (!PerformAuthentication(context))
{
context.Response.Redirect("account", "authentication");
return false;
}
return true;
}
/// <summary>
/// Constructs a FilterAttribute associating
/// the filter type and when the filter should be invoked.
/// </summary>
/// <param name="when"></param>
/// <param name="filterType"></param>
public FilterAttribute(ExecuteEnum when, Type filterType)
{
if (!typeof(IFilter).IsAssignableFrom(filterType))
{
throw new ArgumentException("The specified filter does not implement IFilter");
}
_filterType = filterType;
_when = when;
}
public virtual bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (!PerformAuthentication(context))
{
context.Response.Redirect("account", "authentication");
return false;
}
return true;
}
/// <summary>
/// Constructs a FilterAttribute associating
/// the filter type and when the filter should be invoked.
/// </summary>
/// <param name="when">When to execute the filter</param>
/// <param name="filterType">The filter implementation</param>
public FilterAttribute(ExecuteEnum when, Type filterType)
{
if (!typeof(IFilter).IsAssignableFrom(filterType))
{
throw new ArgumentException("The specified type does not implement IFilter");
}
this.filterType = filterType;
this.when = when;
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (context.CurrentUser == null || !context.CurrentUser.Identity.IsAuthenticated)
{
context.Response.Redirect("admin", "login");
return(false);
}
return(true);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (context.Request.Headers["HTTP_X_MOZ"].Equals("prefetch"))
{
Trace.Write("prefetch detected: sending 403 Forbidden");
context.Response.StatusCode = 403;
return(false);
}
return(true);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (context.CurrentUser == null || !context.CurrentUser.Identity.IsAuthenticated)
{
context.Response.Redirect("admin", "login");
return false;
}
return true;
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
_userAddFilter.Perform(exec,context,controller);
if (Thread.CurrentPrincipal!=null && Thread.CurrentPrincipal.Identity.IsAuthenticated){
log.Debug("authenticated");
return true;
}
log.Debug("not authenticated");
controller.Redirect("intro","index");
return false;
}
public override bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (context.CurrentUser.Identity.IsAuthenticated)
{
return(true);
}
base.PerformAuthentication(context);
return(true);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (context.Request.Headers["mybadheader"] != null)
{
context.Response.Write("Denied!");
return(false);
}
return(true);
}
/// <summary>
/// Implementors should perform they filter logic and
/// return <c>true</c> if the action should be processed.
/// </summary>
/// <param name="exec">When this filter is being invoked</param>
/// <param name="context">Current context</param>
/// <param name="controller">The controller instance</param>
/// <returns>
/// <c>true</c> if the action
/// should be invoked, otherwise <c>false</c>
/// </returns>
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (context.Request.Headers["HTTP_X_MOZ"].Equals("prefetch"))
{
Trace.Write("prefetch detected: sending 403 Forbidden");
context.Response.StatusCode = 403;
return false;
}
return true;
}
public override bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (context.CurrentUser.Identity.IsAuthenticated)
{
return true;
}
base.PerformAuthentication(context);
return true;
}
public bool Perform(ExecuteEnum exec,IRailsEngineContext context,Castle.MonoRail.Framework.Controller controller)
{
U_UserInfo u = context.Session["logonUser"] as U_UserInfo;
if (u == null) {
Hashtable p = new Hashtable();
p.Add("backUrl",context.Request.Uri.AbsoluteUri);
controller.Redirect("/login",p);
return false;
}
return true;
}
public static int Save(Instructor instructorToSave)
{
int result = 0;
ExecuteEnum queryId = ExecuteEnum.INSERT_ITEM;
//notes: check for valid PersonId - if exists, UPDATE, else INSERT
// 10 = INSERT_ITEM
// 20 = UPDATE_ITEM
if (instructorToSave.InstructorId > 0)
{
queryId = ExecuteEnum.UPDATE_ITEM;
}
using (SqlConnection myConnection = new SqlConnection(AppConfiguration.ConnectionString))
{
using (SqlCommand myCommand = new SqlCommand("usp_ExecuteInstructor", myConnection))
{
myCommand.CommandType = CommandType.StoredProcedure;
myCommand.Parameters.AddWithValue("@QueryId", queryId);
myCommand.Parameters.AddWithValue("@InstructorId", instructorToSave.InstructorId);
myCommand.Parameters.AddWithValue("@PersonId", instructorToSave.PersonId);
myCommand.Parameters.AddWithValue("@EntityTypeId", instructorToSave.EntityTypeId);
if (instructorToSave.HireDate != DateTime.MinValue)
{
myCommand.Parameters.AddWithValue("@HireDate", instructorToSave.HireDate.ToShortDateString());
}
if (instructorToSave.TermDate != DateTime.MinValue)
{
myCommand.Parameters.AddWithValue("@TermDate", instructorToSave.TermDate.ToShortDateString());
}
if (instructorToSave.Description != null)
{
myCommand.Parameters.AddWithValue("@Description", instructorToSave.Description);
}
//notes: add return output parameter to command object
myCommand.Parameters.Add(HelperDAL.GetReturnParameterInt("ReturnValue"));
myConnection.Open();
myCommand.ExecuteNonQuery();
result = (int)myCommand.Parameters["@ReturnValue"].Value;
}
myConnection.Close();
}
return(result);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
_userAddFilter.Perform(exec, context, controller);
if (Thread.CurrentPrincipal != null && Thread.CurrentPrincipal.Identity.IsAuthenticated)
{
log.Debug("authenticated");
return(true);
}
log.Debug("not authenticated");
controller.Redirect("intro", "index");
return(false);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext ctx, Controller c)
{
if (!controllersToSkip.IsMatch(GetControllerName(c)))
{
if (ctx.CurrentUser == null || !ctx.CurrentUser.Identity.IsAuthenticated)
{
return(TryAutoLogin());
}
}
return(true);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
String className = controller.GetType().FullName.Replace('.', '/');
if (className.StartsWith("SampleSite"))
{
className = className.Substring( "SampleSite/".Length );
}
controller.PropertyBag.Add("controllerfile", className + ".cs");
return true;
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (exec == ExecuteEnum.BeforeAction)
{
context.Response.Write("(before)");
}
else if (exec == ExecuteEnum.AfterRendering)
{
context.Response.Write("(after)");
}
return(true); // Continue execution
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Castle.MonoRail.Framework.Controller controller)
{
U_UserInfo u = context.Session["logonUser"] as U_UserInfo;
if (u == null)
{
Hashtable p = new Hashtable();
p.Add("backUrl", context.Request.Uri.AbsoluteUri);
controller.Redirect("/login", p);
return(false);
}
return(true);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
String className = controller.GetType().FullName.Replace('.', '/');
if (className.StartsWith("SampleSite"))
{
className = className.Substring("SampleSite/".Length);
}
controller.PropertyBag.Add("controllerfile", className + ".cs");
return(true);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (exec == ExecuteEnum.BeforeAction)
{
context.Response.Write("(before)");
}
else if (exec == ExecuteEnum.AfterRendering)
{
context.Response.Write("(after)");
}
return true; // Continue execution
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller c)
{
foreach (string key in c.Request.Form.AllKeys)
{
foreach (string value in c.Request.Form.GetValues(key))
{
if (rxUnsafe.IsMatch(value))
{
throw new AppException("Caracteres inválidos no formulário", "Você digitou caracteres inválidos no formulário.\nOs caracteres < (menor-que), > (maior-que), \" (aspas) e & (\"e\" comercial) são inválidos.");
}
}
}
return(true);
}
public bool Perform(ExecuteEnum when, IRailsEngineContext context, Controller controller)
{
context.CurrentUser = context.Session["user"] as IPrincipal;
if (context.CurrentUser == null ||
context.CurrentUser.Identity == null ||
!context.CurrentUser.Identity.IsAuthenticated)
{
context.Session["FromUrl"] = context.Url;
context.Response.Redirect("home", "authentication");
return(false);
}
return(true);
}
public bool Perform(ExecuteEnum when, IRailsEngineContext context, Controller controller)
{
context.CurrentUser = context.Session["user"] as IPrincipal;
if (context.CurrentUser == null ||
context.CurrentUser.Identity == null ||
!context.CurrentUser.Identity.IsAuthenticated)
{
context.Session["FromUrl"] = context.Url;
context.Response.Redirect("home", "authentication");
return false;
}
return true;
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if ((appContext.CurrentProject == null)
&& !((controller is ProjectsController) && (controller.Action.Equals("new") || controller.Action.Equals("create")))) // Avoid infinite loop when redirecting
{
if (Project.Exists())
{
appContext.CurrentProject = Project.FindFirst();
}
else
{
context.Response.Redirect("projects", "new");
return false;
}
}
controller.PropertyBag["currentproject"] = appContext.CurrentProject;
return true;
}
/// <summary>
/// Executa o filtro.
/// </summary>
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (!Enabled)
{
return(true);
}
UserAgent ua = null;
var uaString = context.UnderlyingContext.Request.UserAgent;
if (uaString != null)
{
ua = (UserAgent)cache[uaString];
if (ua == null)
{
cache[uaString] = ua = new UserAgent(uaString);
}
}
if (IsValid(ua))
{
return(true);
}
if (!logged)
{
Log.Error("Tentativa de acesso através de browser não suportado: {0}", uaString);
logged = true;
}
controller.PropertyBag["invalidGecko"] = true;
if (!Redirect)
{
return(true);
}
throw new Exception("redir: " + Redirect);
//RedirectToNotice(controller);
//return false;
}
/// <summary>
/// Implementors should perform they filter logic and
/// return <c>true</c> if the action should be processed.
/// </summary>
/// <param name="exec">When this filter is being invoked</param>
/// <param name="context">Current context</param>
/// <param name="controller">The controller instance</param>
/// <returns><c>true</c> if the action
/// should be invoked, otherwise <c>false</c></returns>
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
if (exec == ExecuteEnum.AfterAction)
{
OnAfterAction(context, controller);
return true;
}
else if (exec == ExecuteEnum.AfterRendering)
{
OnAfterRendering(context, controller);
return true;
}
else if (exec == ExecuteEnum.BeforeAction)
{
return OnBeforeAction(context, controller);
}
else // if (exec == ExecuteEnum.StartRequest)
{
return OnStartRequest(context, controller);
}
}
public dynamic CreateResult(ExecuteEnum executeType, string query, CommandType command, List <KeyValuePair <string, object> > valuePairs)
{
var result_command = CreateCommand(cmdstring: query, type: command, parameters: valuePairs);
if (executeType == ExecuteEnum.Insert)
{
int insertVal = result_command.ExecuteNonQuery();
return(insertVal);
}
if (executeType == ExecuteEnum.Delete)
{
int deleteVal = result_command.ExecuteNonQuery();
return(deleteVal);
}
if (executeType == ExecuteEnum.List)
{
DataTable searchResult = new DataTable();
SqlDataAdapter adapter_search = new SqlDataAdapter(result_command);
adapter_search.Fill(searchResult);
return(searchResult);
}
if (executeType == ExecuteEnum.Detail)
{
SqlDataReader reader = result_command.ExecuteReader();
return(reader);
}
if (executeType == ExecuteEnum.ListProduct)
{
return(result_command);
}
return(null);
}
public static int Save(int instructorId, EmailAddress emailToSave)
{
int result = 0;
ExecuteEnum queryId = ExecuteEnum.INSERT_ITEM;
if (emailToSave.EmailId > 0)
{
queryId = ExecuteEnum.UPDATE_ITEM;
}
using (SqlConnection myConnection = new SqlConnection(AppConfiguration.ConnectionString))
{
using (SqlCommand myCommand = new SqlCommand("usp_ExecuteEmail", myConnection))
{
myCommand.CommandType = CommandType.StoredProcedure;
myCommand.Parameters.AddWithValue("@QueryId", queryId);
myCommand.Parameters.AddWithValue("@EmailId", emailToSave.EmailId);
myCommand.Parameters.AddWithValue("@InstructorId", instructorId);
myCommand.Parameters.AddWithValue("@EntityTypeId", emailToSave.EmailType.EntityTypeId);
if (emailToSave.EmailValue != null)
{
myCommand.Parameters.AddWithValue("@EmailAddress", emailToSave.EmailValue);
}
myCommand.Parameters.Add(HelperDAL.GetReturnParameterInt("ReturnValue"));
myConnection.Open();
myCommand.ExecuteNonQuery();
result = (int)myCommand.Parameters["@ReturnValue"].Value;
}
myConnection.Close();
}
return(result);
}
/// <summary>
/// Executes a sequence of steps to determine the browser location/culture.
/// </summary>
/// <param name="exec">When this filter is being invoked</param>
/// <param name="context">Current context</param>
/// <param name="controller">The controller instance</param>
/// <returns>
/// <c>true</c> if the action should be invoked, otherwise <c>false</c>
/// </returns>
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
try
{
String localeId = GetLocaleId(context);
if (localeId == null && setup.UseBrowser)
localeId = GetUserLanguage(context.Request);
if (localeId != null)
{
CultureInfo culture = CultureInfo.CreateSpecificCulture(localeId);
Thread.CurrentThread.CurrentCulture = culture;
Thread.CurrentThread.CurrentUICulture = culture;
}
}
catch
{
if (setup.FailOnError) throw;
}
return true;
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
return(true);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
context.CurrentUser = context.Session["user"] as IPrincipal;
Thread.CurrentPrincipal = context.CurrentUser;
return true;
}
public static int Save(Person personToSave)
{
int result = 0;
ExecuteEnum queryId = ExecuteEnum.INSERT_ITEM;
//Notes: Check for valid PersonId - if exists then UPDATE, else INSERT
// 10 = INSERT_ITEM
// 20 = UPDATE_ITEM
if (personToSave.PersonId > 0)
{
queryId = ExecuteEnum.UPDATE_ITEM;
}
using (SqlConnection myConnection = new SqlConnection(AppConfiguration.ConnectionString))
{
using (SqlCommand myCommand = new SqlCommand("usp_ExecutePerson", myConnection))
{
myCommand.CommandType = CommandType.StoredProcedure;
myCommand.Parameters.AddWithValue("@QueryId", queryId);
if (personToSave.PersonId > 0)
{
myCommand.Parameters.AddWithValue("@PersonId", personToSave.PersonId);
}
if (personToSave.FirstName != null)
{
myCommand.Parameters.AddWithValue("@FirstName", personToSave.FirstName);
}
if (personToSave.LastName != null)
{
myCommand.Parameters.AddWithValue("@LastName", personToSave.LastName);
}
if (personToSave.DisplayFirstName != null)
{
myCommand.Parameters.AddWithValue("@DisplayFirstName", personToSave.DisplayFirstName);
}
if (personToSave.Gender != null)
{
myCommand.Parameters.AddWithValue("@Gender", personToSave.Gender);
}
if (personToSave.BirthDate != DateTime.MinValue)
{
myCommand.Parameters.AddWithValue("@BirthDate", personToSave.BirthDate.ToShortDateString());
}
//notes: add return output parameter to command object
myCommand.Parameters.Add(HelperDAL.GetReturnParameterInt("ReturnValue"));
myConnection.Open();
myCommand.ExecuteNonQuery();
//notes: get return value from stored procedure andreturn Id
result = (int)myCommand.Parameters["@ReturnValue"].Value;
}
myConnection.Close();
}
return(result);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
context.CurrentUser = context.Session["user"] as IPrincipal;
Thread.CurrentPrincipal = context.CurrentUser;
return(true);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
context.Response.Write("A");
return(true);
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
context.Response.Write("A");
return true;
}
/// <summary>
/// Implementors should perform they filter logic and
/// return <c>true</c> if the action should be processed.
/// </summary>
/// <param name="exec">When this filter is being invoked</param>
/// <param name="context">Current context</param>
/// <param name="controller">The controller instance</param>
/// <returns>
/// <c>true</c> if the action
/// should be invoked, otherwise <c>false</c>
/// </returns>
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
controller.Flash.Keep();
return true;
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
controller.PropertyBag["queryString"] = new NameValueCollectionDictionaryAdapter(context.Request.QueryString);
return true;
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
controller.Response.ContentType = "text/plain; charset=utf-8";
if (JNyuluUtils.CheckSign)
{
string _clientSign = context.Request.Params["sign"];
if (!string.IsNullOrEmpty(_clientSign))
{
LogHelper.Info("HttpMethod:" + context.Request.HttpMethod);
NameValueCollection _allParams = new NameValueCollection();
if (context.Request.HttpMethod == "GET")
{
_allParams = controller.Request.QueryString;
}
else if (context.Request.HttpMethod == "POST")
{
_allParams = controller.Request.Form;
}
LogHelper.Info("url:" + context.Request.RawUrl);
string signUrl = string.Join("", _allParams.AllKeys.Where(s => JNyuluUtils.NoSignField.IndexOf("|" + s + "|") == -1).OrderBy(s => s).Select(s => s + _allParams[s]).ToArray());
string appSecret = JNyuluUtils.AppSecret;
signUrl = appSecret + signUrl;
LogHelper.Info("signUrl:" + signUrl);
string _sign = Security.MD5(signUrl);
LogHelper.Info("_sign:" + _sign);
LogHelper.Info("_clientSign:" + _clientSign);
if (_clientSign.Equals(_sign, StringComparison.InvariantCultureIgnoreCase) || _clientSign == "jnyulu")
{
return(true);
}
else
{
Result _data = new Result
{
Code = 0,
Data = "sign бщжЄДэЮѓ"
};
string _jsonString = JsonConvert.SerializeObject(_data, Formatting.Indented);
controller.RenderText(_jsonString);
return(false);
}
}
else
{
Result _data = new Result
{
Code = -1,
Data = "sign ЮЊПежЕ"
};
string _jsonString = JsonConvert.SerializeObject(_data, Formatting.Indented);
controller.RenderText(_jsonString);
return(false);
}
}
return(true);
}
private bool ProcessFilters(ExecuteEnum when)
{
foreach(FilterDescriptor desc in filters)
{
if (filtersToSkip.Contains(desc.FilterType))
{
continue;
}
if ((desc.When & when) != 0)
{
if (!ProcessFilter(when, desc))
{
return false;
}
}
}
return true;
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
controller.PropertyBag["queryString"] = new NameValueCollectionDictionaryAdapter(context.Request.QueryString);
return(true);
}
private bool ProcessFilter(ExecuteEnum when, FilterDescriptor desc)
{
if (desc.FilterInstance == null)
{
desc.FilterInstance = filterFactory.Create(desc.FilterType);
IFilterAttributeAware filterAttAware = desc.FilterInstance as IFilterAttributeAware;
if (filterAttAware != null)
{
filterAttAware.Filter = desc.Attribute;
}
}
try
{
if (logger.IsDebugEnabled)
{
logger.DebugFormat("Running filter {0}/{1}", when, desc.FilterType.FullName);
}
return desc.FilterInstance.Perform(when, context, controller);
}
catch(Exception ex)
{
if (logger.IsErrorEnabled)
{
logger.ErrorFormat("Error processing filter " + desc.FilterType.FullName, ex);
}
throw;
}
}
public bool Perform(ExecuteEnum exec, IRailsEngineContext context, Controller controller)
{
return true;
}
