public void OnPost(string ImageUrl, string Description, bool SmallImage, string EmbedColor, string SiteName)
{
if (Program.Config.ApiOnly)
{
Response.Redirect("/ApiOnly");
return;
}
if (Url == null)
{
Response.Redirect("/error");
return;
}
var name = Redirects.Create(new RedirectInfo
{
Url = Url,
Title = Title,
ImageUrl = ImageUrl,
Description = Description,
SmallImage = SmallImage,
EmbedColor = EmbedColor ?? "2F3136",
SiteName = SiteName
});
Response.Redirect($"/Created?name={name}");
}
public FilterState?RedirectFilter(string name)
{
if (!FilterSet.ContainsKey(name))
{
return(null);
}
if (Redirects.Contains(name))
{
return(null); // Recursion in filters!
}
Redirects.Add(name);
var newFilterDef = FilterSet[name];
if (newFilterDef is null)
{
return(null);
}
return(new FilterState {
Type = newFilterDef.MappingType,
SourcePath = newFilterDef.DataPath,
OriginalPath = OriginalPath,
Params = newFilterDef.MappingParameters,
RepeaterData = RepeaterData,
Data = Data,
FilterSet = FilterSet,
Redirects = Redirects,
RunningTotals = RunningTotals
});
}
public LocationsDataHandler()
{
Redirects.Add("id", new LocationsDataIdHandler());
Redirects.Add("within", new LocationsDataWithinHandler());
Redirects.Add("top", new LocationsDataTopHandler());
Redirects.Add("all", new LocationsDataAllHandler());
}
public AdminTokenHandler()
{
Redirects.Add("storedproc", new AdminStoredProcHandler());
Redirects.Add("updateversion", new AdminUpdateVersionHandler());
Redirects.Add("scriptdb", new DatabaseScripter());
Redirects.Add("pathdata", new AdminPathDataHandler());
}
public DirectionsHandler()
{
Redirects.Add("status", new DirectionsStatusHandler());
Redirects.Add("fromloc", new DirectionsFromLocHandler());
Redirects.Add("fromgps", new DirectionsFromGpsHandler());
Redirects.Add("testing", new TestingDirectionsHandler());
}
public InitialPathHandler()
{
Redirects.Add("locations", new LocationsHandler());
Redirects.Add("directions", new DirectionsHandler());
Redirects.Add("tours", new ToursHandler());
Redirects.Add("admin", new AdminHandler());
Redirects.Add("services", new ServicesHandler());
Redirects.Add("clientaccesspolicy.xml", new ClientAccessPolicyHandler());
}
/// <summary>
/// Validates using task chains.
/// </summary>
private void Validate()
{
ValidatedItems = Redirects.Select(ValidateItems()).ToList();
foreach (var item in ValidatedItems)
{
File.Rows[item.Index].AddCell(item.Status.ToString());
File.Rows[item.Index].AddCell(string.Join(",", item.ValidationResults.Select(a => a.ErrorMessage)));
}
File.Save(FileName, Seperator);
}
public IEnumerable <ThreadInfo> HandlePath(ThreadManager TM, IEnumerable <string> path, Dictionary <string, string> query, object state)
{
var currentThread = TM.CurrentThread;
if (path.Any())
{
if (Redirects.ContainsKey(path.First()))
{
yield return(TM.Await(currentThread, Redirects[path.First()].HandlePath(TM, path.Skip(1), query, state)));
}
else
{
int intValue;
if (Int32.TryParse(path.First(), out intValue))
{
yield return(TM.Await(currentThread, HandleIntPath(TM, intValue, state)));
if (!(TM.GetResultNoException(currentThread) is JsonResponse))
{
yield return(TM.Await(currentThread, IntRedirect.HandlePath(TM, path.Skip(1), query, TM.GetResult(currentThread))));
}
}
else
{
double floatValue;
if (Double.TryParse(path.First(), out floatValue))
{
yield return(TM.Await(currentThread, HandleFloatPath(TM, floatValue, state)));
if (!(TM.GetResultNoException(currentThread) is JsonResponse))
{
yield return(TM.Await(currentThread, FloatRedirect.HandlePath(TM, path.Skip(1), query, TM.GetResult(currentThread))));
}
}
else
{
yield return(TM.Await(currentThread, HandleUnknownPath(TM, path.First(), state)));
if (!(TM.GetResultNoException(currentThread) is JsonResponse))
{
yield return(TM.Await(currentThread, UnknownRedirect.HandlePath(TM, path.Skip(1), query, TM.GetResult(currentThread))));
}
}
}
}
}
else
{
yield return(TM.Await(currentThread, HandleNoPath(TM, query, state)));
}
yield return(TM.Return(currentThread));
}
public void Refresh()
{
Detach();
foreach (var redirect in Redirects.ToList())
{
if (redirect.WillRemove)
{
Redirects.Remove(redirect);
}
}
Attach();
}
// private methods...
#region AddRedirectControls
private void AddRedirectControls(Redirects redirects)
{
const int INT_TopMargin = 5;
const int INT_SpaceBetweenButtons = 4;
int yPos = lblOptions.Bottom + INT_TopMargin;
int longestButtonTextWidth = 0;
foreach (CompatibilityRedirect redirect in redirects)
{
Graphics graphics = Graphics.FromHwnd(Handle);
SizeF rect = graphics.MeasureString(redirect.ButtonText, Font);
int thisWidth = (int)Math.Ceiling(rect.Width);
if (thisWidth > longestButtonTextWidth)
longestButtonTextWidth = thisWidth;
}
const int INT_ExplanationLabelMargin = 8; // Distance between disabled button and explaning label.
int xPos = 8;
int buttonWidth = longestButtonTextWidth + 16;
int longestWidth = buttonWidth;
foreach (CompatibilityRedirect redirect in redirects)
{
RedirectButton button = new RedirectButton(redirect.Command, redirect.Parameters);
pnlOptions.Controls.Add(button);
button.Text = redirect.ButtonText;
button.Enabled = redirect.IsAvailable;
button.Left = xPos;
button.Width = buttonWidth;
toolTip1.SetToolTip(button, redirect.Description);
button.Top = yPos;
button.Click += new EventHandler(redirectButton_Click);
if (!redirect.IsAvailable)
{
Label explanationLabel = new Label();
pnlOptions.Controls.Add(explanationLabel);
explanationLabel.Top = yPos;
explanationLabel.Left = button.Right + INT_ExplanationLabelMargin;
explanationLabel.AutoSize = true;
explanationLabel.Text = redirect.AvailabilityHint;
explanationLabel.ForeColor = SystemColors.GrayText;
if (longestWidth < explanationLabel.Right)
longestWidth = explanationLabel.Right;
}
yPos += button.Height + INT_SpaceBetweenButtons;
}
pnlOptions.Height = yPos;
pnlOptions.Width = longestWidth;
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddScoped <StatisticsContext>();
var redirects = new Redirects(Configuration.GetSection("Redirects")
.GetChildren()
.ToDictionary(k => k.Key, v => v.Value));
redirects.Add("", "");
services.AddSingleton(redirects);
}
public void Attach()
{
if (!Attached)
{
Attached = true;
Redirects.CollectionChanged += RedirectsCahnged;
AttachedItems = Redirects.ToArray();
foreach (var redirect in AttachedItems)
{
redirect.PropertyChanged += RedirectCahnged;
}
IsDirty = false;
}
}
public void Detach()
{
if (Attached)
{
Redirects.CollectionChanged += RedirectsCahnged;
AttachedItems = Redirects.ToArray();
foreach (var redirect in AttachedItems)
{
redirect.PropertyChanged += RedirectCahnged;
}
AttachedItems = null;
Attached = false;
}
}
/// <summary>
/// Validates using task chains.
/// </summary>
private void Validate()
{
ValidatedItems = Redirects.Select(ValidateItems()).ToList();
foreach (var item in ValidatedItems)
{
//TODO: bit odd
//File.AddValue(item.Index+1,5,item.Status.ToString());
//File.AddValue(item.Index+1, 5, string.Join(",", item.ValidationResults.Select(a => a.ErrorMessage)));
}
//using (FastExcel.FastExcel fastExcel = new FastExcel.FastExcel(inputFile))
//{
// fastExcel.Write(File);
//}
}
public async Task <IActionResult> CreateRedirect()
{
string json;
using (StreamReader reader = new StreamReader(Request.Body))
{
json = await reader.ReadToEndAsync();
}
var redirectInfo = JsonConvert.DeserializeObject <RedirectInfo>(json);
// todo: add checks for too long SiteName, Description etc
if (redirectInfo.Url == null | redirectInfo.Url == "")
{
return(BadRequest("Url must be specified"));
}
return(Content(Redirects.Create(redirectInfo)));
}
public object Create(object parent, object configContext, XmlNode section)
{
//throw new Exception("The method or operation is not implemented.");
Redirects r = new Redirects();
foreach (XmlNode node in section.SelectNodes("redirect"))
{
string pattern = node.Attributes["pattern"].Value;
if (pattern != null)
{
r.Patterns.Add(new Regex(pattern,
RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.IgnorePatternWhitespace
| RegexOptions.ExplicitCapture)
);
}
}
return r;
}
public WelcomeConfigurationBuilder RedirectTo(Type modelType, RunningObjectsAction action, Func <object> expression, Func <bool> condition = null)
{
Redirects.Add
(
() =>
{
if (condition == null || condition())
{
var urlHelper = new UrlHelper(HttpContext.Current.Request.RequestContext);
var completeUrl = urlHelper.Action(modelType, action, expression());
if (!string.IsNullOrEmpty(completeUrl))
{
return(new RedirectResult(completeUrl));
}
}
return(null);
}
);
return(this);
}
private Uri FindMatchingRedirect(Uri source)
{
var result = Redirects
.Select(x => new { key = x.Key, value = x.Value })
.FirstOrDefault(redirect =>
{
var path = HttpUtility.UrlDecode(source.AbsolutePath);
return(Match(path, redirect.key));
});
if (result != null)
{
var builder = new UriBuilder(result.value)
{
Query = source.Query
};
return(builder.Uri);
}
return(null);
}
public static void CreateSessionInstance(Path.Parser path, Schools.School school)
{
WebServer.PleaseTakes.Session.CreateNewInstance(school);
if (path.IsEmpty)
{
Redirects.ToLogin(path);
}
else
if (path.Contains("dologin"))
{
BasicResponses.Login.Action.AttemptLogin();
}
else
{
WebServer.PleaseTakes.Redirect(path.ToString());
}
// This is what is was before the minor modifications (2010-08-12)
//Redirects.ToLogin(path);
}
public static void NoSessionExists(Path.Parser path)
{
if (SchoolsInformation.MoreThanOneAvailable(path))
{
if (SchoolsInformation.NoDefaultExists(path))
{
if (SchoolsInformation.QueryStringBlank())
{
Redirects.ToSelectionScreen(path, false);
}
else
if (SchoolsInformation.QueryStringIsValid())
{
CreateSessionInstance(path, WebServer.PleaseTakes.Application.CurrentInstance.Schools[WebServer.Request["schoolID"]]);
}
else
{
Redirects.ToSelectionScreen(path, true);
}
}
}
}
private void actReSharperChangeSignature_Execute(ExecuteEventArgs ea)
{
bool allowPersistResponse = false;
string title = "Change Signature";
string message = "CodeRush includes several useful refactorings dedicated to changing signatures. Select from one of the signature-changing refactorings below.";
Redirects redirects = new Redirects();
redirects.AddRefactoring("Add Parameter", "Place caret inside the parameter list before invoking.");
redirects.AddRefactoring("Create Overload", "Place caret on the member declaration before invoking.");
redirects.AddRefactoring("Decompose Parameter", "Place caret on the parameter to decompose before invoking.");
redirects.AddRefactoring("Introduce Parameter Object", "Select the parameters to consolidate before invoking.");
redirects.AddRefactoring("Make Extension", "Place caret on a method signature with parameters to extend before invoking.");
redirects.AddRefactoring("Make Member non-Static", "Place caret on a static member signature before invoking.");
redirects.AddRefactoring("Make Member Static", "Place caret on an instance member signature that can be made static before invoking.");
redirects.AddRefactoring("Promote to Parameter", "Place caret on a local or field variable that can be promoted to a parameter before invoking.");
redirects.AddRefactoring("Reorder Parameters", "Place caret on a parameter that can be reordered before invoking.");
redirects.AddRefactoring("Safe Rename", "Place caret on a public member before invoking.");
FrmResharperCompatibility frmResharperCompatibility = new FrmResharperCompatibility(title, message, redirects, allowPersistResponse);
frmResharperCompatibility.ShowDialog(CodeRush.IDE);
if (frmResharperCompatibility.Result == CompatibilityResult.ExecuteCommand)
CodeRush.Command.Execute(frmResharperCompatibility.Command, frmResharperCompatibility.Parameters);
}
private void actReSharperSurroundWithTemplate_Execute(ExecuteEventArgs ea)
{
bool allowPersistResponse = false;
string title = "Surround With Template";
string message = "CodeRush includes several built-in features to wrap and modify selections. There are keyboard shortcuts for many of these (just select the code you want to modify and press the specified key), and you can also access these from the right-click context menu. Select from one of the options below.";
Redirects redirects = new Redirects();
redirects.AddSelectionEmbedding("block", "Embeds a selection inside block delimiters (e.g., {} braces in C# or C++).");
redirects.AddSelectionEmbedding("lock", "Embeds a selection inside a lock statement.");
redirects.AddSelectionEmbedding("region", "Embeds a selection inside a region.");
redirects.AddSelectionEmbedding("SyncLock", "Embeds a selection inside a SyncLock statement.");
redirects.AddSelectionEmbedding("ToString", "Converts a selection to a string, escaping characters as needed.");
redirects.AddSelectionEmbedding("try/catch", "Embeds a selection inside a try/catch block.");
redirects.AddSelectionEmbedding("try/catch/finally", "Embeds a selection inside a try/catch/finally block.");
redirects.AddSelectionEmbedding("try/finally", "Embeds a selection inside a try/finally block.");
redirects.AddSelectionEmbedding("using", "Embeds a selection inside a using statement.");
redirects.AddSelectionEmbedding("WaitCursor", "Embeds a selection inside code that displays an hourglass cursor while the code executes.");
redirects.AddOptionsPage("Embedding Options && Customization", "Editor\\Selections\\Embedding", "Click this button to view, change, and create custom embeddings.");
FrmResharperCompatibility frmResharperCompatibility = new FrmResharperCompatibility(title, message, redirects, allowPersistResponse);
frmResharperCompatibility.ShowDialog(CodeRush.IDE);
if (frmResharperCompatibility.Result == CompatibilityResult.ExecuteCommand)
CodeRush.Command.Execute(frmResharperCompatibility.Command, frmResharperCompatibility.Parameters);
}
public void TryCommandElseRedirectToCommunity(string title, string Action, string WikiPage)
{
if (ActionExists(Action))
{
CodeRush.Command.Execute(Action);
return;
}
bool allowPersistResponse = false;
string message = "This feature is not supplied by CodeRush directly. However a community plugin exists to provide an equivalent function.";
Redirects redirects = new Redirects();
redirects.AddLink(String.Format("Visit {0} page on the Community plugin site to retrieve this plugin.", WikiPage), GetWikiPage(WikiPage));
FrmResharperCompatibility frmResharperCompatibility = new FrmResharperCompatibility(title, message, redirects, allowPersistResponse);
frmResharperCompatibility.ShowDialog(CodeRush.IDE);
if (frmResharperCompatibility.Result == CompatibilityResult.ExecuteCommand && frmResharperCompatibility.Command == "ShowURL")
CodeRush.ShowURL(frmResharperCompatibility.Parameters);
}
public TestingDirectionsHandler()
{
Redirects.Add("directions", new TestingDirectionsDirectionsHandler());
Redirects.Add("tour", new TestingDirectionsTourHandler());
//Redirects.Add("schedule", new TestingDirectionsScheduleHandler());
}
private Func <RedirectItem, int, ValidatedRedirectItem> ValidateItems()
{
return((redirect, index) => RedirectItemValidationContext.Validate(index, redirect, Redirects.Where(a => !string.IsNullOrEmpty(a.LinkUrl) && !string.IsNullOrEmpty(a.Url))));
}
// constructors...
#region FrmResharperCompatibility(string message, Redirects redirects, bool allowPersistResponse)
public FrmResharperCompatibility(string title, string message, Redirects redirects, bool allowPersistResponse)
{
InitializeComponent();
ClearFields();
int optionsHeight = 0;
int optionsWidth = 0;
if (redirects != null)
{
AddRedirectControls(redirects);
chkAlwaysPerformThisAction.Visible = allowPersistResponse;
optionsHeight = pnlOptions.Height;
optionsWidth = pnlOptions.Width;
pnlOptions.Dock = DockStyle.Fill;
}
else
{
pnlOptions.Visible = false;
chkAlwaysPerformThisAction.Visible = false;
}
if (optionsWidth > ClientSize.Width)
Width += optionsWidth - ClientSize.Width;
lblTitle.Text = title;
lblCompatibilityNote.Text = message;
int desiredHeight = pnlTop.Height + optionsHeight + pnlBottom.Height;
int deltaHeight = desiredHeight - ClientSize.Height;
Height += deltaHeight;
MinimumSize = new Size(Width, Height);
}
public MessageRedirect this[Guid id] => Redirects.SingleOrDefault(r => r.MessageRedirectId == id);
public ToursHandler()
{
Redirects.Add("tags", new ToursTagsHandler());
Redirects.Add("offcampus", new ToursOffCampusHandler());
}
public static void SessionExists(Path.Parser path)
{
Redirects.Standard(path);
}
public DirectionsToHandler()
{
Redirects.Add("toloc", new DirectionsToLocHandler());
Redirects.Add("tobath", new DirectionsToBathHandler());
Redirects.Add("toprinter", new DirectionsToPrinterHandler());
}
public HomeController(Redirects redirects)
{
this.redirects = redirects;
}
public T Search <T>(string query)
{
//API example: http://en.wikipedia.org/w/api.php?action=query&list=search&srsearch=wikipedia&srprop=timestamp
Client.BaseUrl = new Uri(string.Format((UseTls ? "https://{0}.wikipedia.org/w/" : "http://{0}.wikipedia.org/w/"), "en"));
RestRequest request = new RestRequest("api.php", Method.GET);
//Required
request.AddParameter("action", "query");
request.AddParameter("format", Format.ToString().ToLower());
if (ExternParameters != null)
{
foreach (var parameter in ExternParameters)
{
if (!string.IsNullOrWhiteSpace(parameter.Item1) && parameter.Item2 != null)
{
request.AddParameter(parameter.Item1, parameter.Item2);
}
}
}
if (!string.IsNullOrWhiteSpace(query))
{
request.AddParameter("srsearch", query);
}
//Optional
if (Infos.HasElements())
{
request.AddParameter("srinfo", string.Join("|", Infos).ToLower());
}
if (Limit != 0)
{
switch (List)
{
case ListType.Geosearch:
request.AddParameter("list", List.ToString().ToLower());
request.AddParameter("gslimit", Limit);
break;
case ListType.Search:
request.AddParameter("list", List.ToString().ToLower());
request.AddParameter("srlimit", Limit);
break;
}
}
if (Offset != 0)
{
request.AddParameter("sroffset", Offset);
}
if (Namespaces.HasElements())
{
request.AddParameter("srnamespace", string.Join("|", Namespaces).ToLower());
}
if (Properties.HasElements())
{
request.AddParameter("srprop", string.Join("|", Properties).ToLower());
}
if (Redirects)
{
request.AddParameter("srredirects", Redirects.ToString().ToLower());
}
if (What != What.Title)
{
request.AddParameter("srwhat", What.ToString().ToLower());
}
if (ServedBy)
{
request.AddParameter("servedby", ServedBy.ToString().ToLower());
}
if (!string.IsNullOrEmpty(RequestId))
{
request.AddParameter("requestid", RequestId);
}
//Output
RestResponse response = (RestResponse)Client.Execute(request);
IDeserializer deserializer;
switch (Format)
{
case Format.Xml:
deserializer = new XmlAttributeDeserializer();
break;
case Format.Json:
deserializer = new JsonDeserializer();
break;
default:
deserializer = new XmlAttributeDeserializer();
break;
}
//The format that Wikipedia uses
deserializer.DateFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'";
return(deserializer.Deserialize <T>(response));
}
public MessageRedirect this[string from] => Redirects.SingleOrDefault(r => r.FromPhysicalAddress == from);
public QueryResult Search(string query)
{
//API example: http://en.wikipedia.org/w/api.php?action=query&list=search&srsearch=wikipedia&srprop=timestamp
_client.BaseUrl = string.Format(UseTLS ? "https://{0}.wikipedia.org/w/" : "http://{0}.wikipedia.org/w/", Language.GetStringValue());
RestRequest request = new RestRequest("api.php", Method.GET);
//Required
request.AddParameter("action", "query");
request.AddParameter("list", "search");
request.AddParameter("srsearch", query);
request.AddParameter("format", Format.ToString().ToLower());
//Optional
if (Infos.HasElements())
{
request.AddParameter("srinfo", string.Join("|", Infos).ToLower());
}
if (Limit != 0)
{
request.AddParameter("srlimit", Limit);
}
if (Offset != 0)
{
request.AddParameter("sroffset", Offset);
}
if (Namespaces.HasElements())
{
request.AddParameter("srnamespace", string.Join("|", Namespaces).ToLower());
}
if (Properties.HasElements())
{
request.AddParameter("srprop", string.Join("|", Properties).ToLower());
}
if (Redirects)
{
request.AddParameter("srredirects", Redirects.ToString().ToLower());
}
if (What != What.Title)
{
request.AddParameter("srwhat", What.ToString().ToLower());
}
if (ServedBy)
{
request.AddParameter("servedby", ServedBy.ToString().ToLower());
}
if (!string.IsNullOrEmpty(RequestID))
{
request.AddParameter("requestid", RequestID);
}
//Output
RestResponse response = (RestResponse)_client.Execute(request);
IDeserializer deserializer;
switch (Format)
{
case Format.XML:
deserializer = new XmlAttributeDeserializer();
break;
case Format.JSON:
deserializer = new JsonDeserializer();
break;
default:
deserializer = new XmlAttributeDeserializer();
break;
}
//The format that Wikipedia uses
deserializer.DateFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'";
deserializer.RootElement = "query";
QueryResult results = deserializer.Deserialize <QueryResult>(response);
//For convinience, we autocreate Uris that point directly to the wiki page.
if (results.Search != null)
{
foreach (Search search in results.Search)
{
search.Url = UseTLS ? new Uri("https://" + Language.GetStringValue() + ".wikipedia.org/wiki/" + search.Title) : new Uri("http://" + Language.GetStringValue() + ".wikipedia.org/wiki/" + search.Title);
}
}
return(results);
}
private static void Checks(bool inDatabase)
{
if (inDatabase)
{
Helpers.Database.ParameterBuilder paramBuilder = new Helpers.Database.ParameterBuilder();
paramBuilder.AddParameter(SqlDbType.VarChar, "@Username", Action.Username);
paramBuilder.AddParameter(SqlDbType.VarChar, "@Password", Action.Password);
using (SqlDataReader dataReader = Helpers.Database.Provider.ExecuteReader("/Sql/Specific/Login/retrieve.sql", paramBuilder.Parameters)) {
int timetableId;
if (dataReader.Read())
{
if (!int.TryParse(dataReader["TimetableId"].ToString(), out timetableId))
{
Redirects.MissingTimetableId();
}
else
if ((bool)dataReader["IsActive"])
{
// Temporary
if ((bool)dataReader["IsAdmin"])
{
UserManagement.Accounts.TeachingAccount account = new UserManagement.Accounts.TeachingAccount(
dataReader["Username"] as string,
dataReader["Password"] as string,
dataReader["Title"] as string,
dataReader["Forename"] as string,
dataReader["Surname"] as string,
dataReader["HoldingName"] as string,
(int)dataReader["StaffId"],
(int)dataReader["TimetableId"],
(bool)dataReader["IsActive"],
(bool)dataReader["IsAdmin"]);
Action.LoginUser(account);
}
// Temporary
else
{
Action.Redirects.NonAdmin();
}
}
else
{
Action.Redirects.Disabled();
}
}
else
{
Action.Redirects.Invalid();
}
}
}
else
{
UserManagement.Accounts.Account account = WebServer.PleaseTakes.Session.CurrentInstance.School.Settings.NonTeachingAccounts[Action.Username];
if (account.Password.Equals(Action.Password))
{
if (account.IsActive)
{
Action.LoginUser(account);
}
else
{
Action.Redirects.Disabled();
}
}
else
{
Action.Redirects.Invalid();
}
}
}
public AdminHandler()
{
Redirects.Add("authenticate", new AdminAuthenticateHandler());
UnknownRedirect = new AdminTokenHandler();
}
