public void Parse(string value, IParameterCollection target) { int index = 0; var lastCh = char.MinValue; var name = ""; int oldPos = 0; while (index < value.Length) { var ch = value[index]; switch (ch) { case '=': if (lastCh != '\\') { name = value.Substring(oldPos, index - oldPos).Trim(' '); oldPos = index + 1; } break; case ',': if (lastCh != '\\') { target.Add(name, value.Substring(oldPos, index - oldPos).Trim(' ', '"')); oldPos = index + 1; } break; } lastCh = value[index]; ++index; } }
object NewToken(RestVerbs verbs, IParameterCollection parameters) { var user = verbs["username"]; var pass = verbs["password"]; RestObject obj = null; if (Verify != null) obj = Verify(user, pass); if (obj == null) obj = new RestObject("401") { Error = "Invalid username/password combination provided. Please re-submit your query with a correct pair." }; if (obj.Error != null) return obj; string hash; var rand = new Random(); var randbytes = new byte[32]; do { rand.NextBytes(randbytes); hash = randbytes.Aggregate("", (s, b) => s + b.ToString("X2")); } while (Tokens.ContainsKey(hash)); Tokens.Add(hash, user); obj["token"] = hash; return obj; }
public DataConverter(IParameterCollection queryString, IParameterCollection form) { _queryString = queryString; _form = form; _formArray = new ArrayParameterCollection(form); _queryStringArray = new ArrayParameterCollection(_queryString); }
/// <summary> /// Parse a query string /// </summary> /// <param name="reader">string to parse</param> /// <param name="parameters">Parameter collection to fill</param> /// <returns>A collection</returns> /// <exception cref="ArgumentNullException"><c>reader</c> is <c>null</c>.</exception> public void Parse(TextReader reader, IParameterCollection parameters) { if (reader == null) throw new ArgumentNullException("reader"); var canRun = true; while (canRun) { var result = reader.ReadToEnd("&="); var name = Uri.UnescapeDataString(result.Value); switch (result.Delimiter) { case '&': parameters.Add(name, string.Empty); break; case '=': result = reader.ReadToEnd("&"); parameters.Add(name, Uri.UnescapeDataString(result.Value)); break; case char.MinValue: // EOF = no delimiter && no value if (!string.IsNullOrEmpty(name)) parameters.Add(name, string.Empty); break; } canRun = result.Delimiter != char.MinValue; } }
/// <summary> /// Assign properties in the specified object. /// </summary> /// <param name="instance">Object to fill.</param> /// <param name="parameters">Contains all parameters that should be assigned to the properties.</param> /// <exception cref="PropertyException">Properties was not found or value could not be converted.</exception> /// <exception cref="ArgumentNullException">Any parameter is <c>null</c>.</exception> public static void Assign(object instance, IParameterCollection parameters) { if (instance == null) throw new ArgumentNullException("instance"); if (parameters == null) throw new ArgumentNullException("parameters"); var errors = new Dictionary<string, Exception>(); ICachedType type = PropertyProvider.Get(instance.GetType()); foreach (IParameter parameter in parameters) { try { object value = parameter.Value; if (_handler != null && !_handler(instance, parameter.Name, ref value)) continue; type.SetConvertedValue(instance, parameter.Name, value); } catch (Exception err) { errors[parameter.Name] = err; } } if (errors.Count != 0) throw new PropertyException(errors); }
/// <summary> /// Initializes a new instance of the <see cref="HttpRequest" /> class. /// </summary> public HttpRequest() { _cookies = new HttpCookieCollection<IHttpCookie>(); _files = new HttpFileCollection(); _queryString = new ParameterCollection(); _form = new ParameterCollection(); }
public RestRequestArgs(RestVerbs verbs, IParameterCollection param, IRequest request, SecureRest.TokenData tokenData, IHttpContext context) { Verbs = verbs; Parameters = param; Request = request; TokenData = tokenData; Context = context; }
/// <summary> /// Initializes a new instance of the <see cref="ArrayParameterCollection"/> class. /// </summary> /// <param name="collection">Parse parameters from the this collection.</param> public ArrayParameterCollection(IParameterCollection collection) : base("root", string.Empty) { foreach (var item in collection) { foreach (var value in item) Add(item.Name, value); } }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="link">The link this command is associated with.</param> protected Command(IDataLink link) { if (link == null) throw new ArgumentNullException("link", "Link cannot be null."); if (link.IsDisposed) throw new ObjectDisposedException(link.ToString()); _Link = link; _Parameters = _Link.Engine.CreateParameterCollection(); if (_Parameters == null) throw new CannotCreateException( "Cannot create a new collection of parameters for this instance."); }
// TODO: Break in to Supporting Objects, User, Object, and Field Level Security Processing public void ProcessBefore(IParameterCollection inputs, IList<CustomAttributeNamedArgument> customAttributeNamedArguments) { if (_validationContext.EnableValidation) { var parameters = customAttributeNamedArguments.FirstOrDefault(x => x.MemberName == "Parameters").TypedValue.Value as string; if (parameters == null) { parameters = string.Empty; } var parameterList = parameters.Split(new[] {","}, StringSplitOptions.RemoveEmptyEntries); var validationMessages = new List<string>(); var isValid = true; if (parameterList.Length == 0 && inputs.Count > 0) { var flaggedInput = inputs[0]; if (flaggedInput != null) { var response = Validate(flaggedInput); isValid = response.IsValid; validationMessages.AddRange(response.ValidationErrors); } } else { foreach (var parameter in parameterList) { if (!String.IsNullOrWhiteSpace(parameter) && inputs.ContainsParameter(parameter)) { var flaggedInput = inputs[parameter]; if (flaggedInput != null) { var response = Validate(flaggedInput); isValid = isValid && response.IsValid; validationMessages.AddRange(response.ValidationErrors); } } else { throw new ConfigurationErrorsException(string.Format("Incorrect Parameter Specified {0}, Parameter Does Not Exist!", parameter)); } } } if (!isValid) { var validationMessageStringBuilder = new StringBuilder(); foreach (var validationMessage in validationMessages) { validationMessageStringBuilder.Append(validationMessage); validationMessageStringBuilder.Append(" "); } throw new ValidationException(validationMessageStringBuilder.ToString()); } } }
/*----------------------------------------------------------------------------------------*/ /// <summary> /// Creates a new root context. /// </summary> /// <param name="service">The type that was requested.</param> /// <param name="scope">The scope in which the activation is occurring.</param> /// <param name="parameters">A collection of transient parameters to apply to the context.</param> /// <returns>The root context.</returns> public IContext Create(Type service, IScope scope, IParameterCollection parameters) { Ensure.ArgumentNotNull(service, "service"); Ensure.ArgumentNotNull(scope, "scope"); Ensure.ArgumentNotNull(parameters, "parameters"); IContext context = CreateRootContext(service, scope); context.Parameters = parameters; return context; }
public void ProcessBefore(IParameterCollection inputs, IEnumerable<CustomAttributeData> customAttributeDatas) { InitializeDictionary(); foreach (var customAttributeData in customAttributeDatas) { if (_strategyHash.ContainsKey(customAttributeData.AttributeType)) { _strategyHash[customAttributeData.AttributeType].ProcessBefore(inputs, customAttributeData.NamedArguments); } } }
object DestroyToken(RestVerbs verbs, IParameterCollection parameters) { var token = verbs["token"]; try { Tokens.Remove(token); } catch (Exception) { return new Dictionary<string, string> { { "status", "400" }, { "error", "The specified token queued for destruction failed to be deleted." } }; } return new Dictionary<string, string> { { "status", "200" }, { "response", "Requested token was successfully destroyed." } }; }
protected override object ExecuteCommand(RestCommand cmd, RestVerbs verbs, IParameterCollection parms) { if (cmd.RequiresToken) { var strtoken = parms["token"]; if (strtoken == null) return new Dictionary<string, string> { { "status", "401" }, { "error", "Not authorized. The specified API endpoint requires a token." } }; object token; if (!Tokens.TryGetValue(strtoken, out token)) return new Dictionary<string, string> { { "status", "403" }, { "error", "Not authorized. The specified API endpoint requires a token, but the provided token was not valid." } }; } return base.ExecuteCommand(cmd, verbs, parms); }
public string GetUserNameFromInputs(IParameterCollection inputs) { foreach (var requestInput in inputs) { Request = requestInput as RequestBase; if (Request != null) { UserName = Request.UserName; break; } } return UserName; }
private object GetInventory(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData) { List<TSPlayer> players = TShock.Utils.FindPlayer(verbs["user"]); if (players.Count > 1) { return new RestObject("400") {Response = "Found more than one match."}; } else if (players.Count < 1) { return new RestObject("400") {Response = "Found no matches."}; } string inventory = players[0].PlayerData.inventory.ToString(); return new RestObject{{"inventory", inventory}}; }
public string Post(IParameterCollection form) { if (form["page"] == "settings.htm") { if (!Persistance.API.ContainsKey(form["var"])) { Persistance.API.Add(form["var"], form["value"]); } else { Persistance.API[form["var"]] = form["value"]; } return "Return to <a href='settings.htm'>settings.htm</a>"; } return ""; }
/// <summary> /// Invoked when disposing or finalizing this instance. /// </summary> /// <param name="disposing">True if the object is being disposed, false otherwise.</param> protected virtual void OnDispose(bool disposing) { if (disposing) { try { if (_Parameters != null && !_Parameters.IsDisposed) _Parameters.Dispose(); } catch { } } _Parameters = null; _Link = null; _IsDisposed = true; }
private object ServerStatus(RestVerbs verbs, IParameterCollection parameters) { if (TPulse.Config.EnableTokenEndpointAuthentication) { return(RestError("Server settings require a token for this API call")); } var activeplayers = Main.player.Where(p => null != p && p.active).ToList(); return(new RestObject() { { "name", TPulse.Config.ServerName }, { "port", Convert.ToString(Netplay.serverPort) }, { "playercount", Convert.ToString(activeplayers.Count()) }, { "players", string.Join(", ", activeplayers.Select(p => p.name)) }, }); }
public string OpenHtml(string json_params) { IParameterCollection Params = Util.DeserializeParams(json_params); if (Params.Contains("html")) { string Id = PutString(Params["html"].Value.ToString()); var result = new { action = "window.open('Query/GetHtml?Id=" + Id + "','user html', 'width=400,height=400,status=1,menubar=1');" }; return(JsonConvert.SerializeObject(result)); } if (Params.Contains("URL")) { var result = new { action = "window.open('" + Params["URL"].Value.ToString() + "');" }; return(JsonConvert.SerializeObject(result)); } return(null); }
/// <summary> /// Parsers an unary operation. /// </summary> protected virtual string OnParseUnary(DynamicNode.Unary obj, IParameterCollection pc, bool nulls) { switch (obj.Operation) { // This are artifacts generated by the parser... case ExpressionType.IsTrue: case ExpressionType.IsFalse: return(this.Parse(obj.Target, pc, nulls)); case ExpressionType.Not: return("(NOT {0})".FormatWith(Parse(obj.Target, pc, nulls))); case ExpressionType.Negate: return("-{0}".FormatWith(this.Parse(obj.Target, pc, nulls))); } throw new ArgumentException("Not supported unary operation '{0}'".FormatWith(obj)); }
private object PlayerKill(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData) { var ret = PlayerFind(parameters); if (ret is RestObject) { return(ret); } TSPlayer player = (TSPlayer)ret; player.DamagePlayer(999999); var from = string.IsNullOrWhiteSpace(parameters["from"]) ? "Server Admin" : parameters["from"]; player.SendMessage(string.Format("{0} just killed you!", from)); return(RestResponse("Player " + player.Name + " was killed")); }
private object PlayerListV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData) { var playerList = new ArrayList(); foreach (TSPlayer tsPlayer in TShock.Players.Where(p => null != p)) { var p = PlayerFilter(tsPlayer, parameters); if (null != p) { playerList.Add(p); } } return(new RestObject() { { "players", playerList } }); }
private ActionResult GetViewByName(string view_name, IParameterCollection Params, bool doDeleteView = true) { foreach (IParameter Param in Params) { if (Param.Name != "cshtml") { ViewData[Param.Name] = Param.Value; } } ActionResult V = View("~/Views/Temp/" + view_name); if (doDeleteView) { Response.Headers.Add("view_name", view_name); } return(V); }
private object PlayerSetMute(IParameterCollection parameters, bool mute) { var ret = PlayerFind(parameters); if (ret is RestObject) { return(ret); } TSPlayer player = (TSPlayer)ret; player.mute = mute; var verb = mute ? "muted" : "unmuted"; player.SendMessage("You have been remotely " + verb); return(RestResponse("Player " + player.Name + " was " + verb)); }
//http://127.0.0.1:8080/HelloWorld/name/{username}?type=status object UserTest(RestVerbs verbs, IParameterCollection parameters) { var ret = new Dictionary <string, string>(); var type = parameters["type"]; if (type == null) { ret.Add("Error", "Invalid Type"); return(ret); } if (type == "status") { ret.Add("Users", "Info here"); return(ret); } return(null); }
private object BanInfoV2(RestVerbs verbs, IParameterCollection parameters) { var ret = BanFind(parameters); if (ret is RestObject) { return(ret); } Ban ban = (Ban)ret; return(new RestObject() { { "name", null == ban.Name ? "" : ban.Name }, { "ip", null == ban.IP ? "" : ban.IP }, { "reason", null == ban.Reason ? "" : ban.Reason }, }); }
object DestroyToken(RestVerbs verbs, IParameterCollection parameters) { var token = verbs["token"]; try { Tokens.Remove(token); } catch (Exception) { return(new Dictionary <string, string> { { "status", "400" }, { "error", "The specified token queued for destruction failed to be deleted." } }); } return(new Dictionary <string, string> { { "status", "200" }, { "response", "Requested token was successfully destroyed." } }); }
private object UserInfoV2(RestVerbs verbs, IParameterCollection parameters) { var user = TShock.Users.GetUserByName(parameters["user"]); if (user == null) { return(new Dictionary <string, string> { { "status", "400" }, { "error", "The specified user account does not exist." } }); } var returnBlock = new Dictionary <string, string>(); returnBlock.Add("status", "200"); returnBlock.Add("group", user.Group); returnBlock.Add("id", user.ID.ToString()); return(returnBlock); }
private object GroupFind(IParameterCollection parameters) { var name = parameters["group"]; if (string.IsNullOrWhiteSpace(name)) { return(RestMissingParam("group")); } var group = TShock.Groups.GetGroupByName(name); if (null == group) { return(RestError("Group '" + name + "' doesn't exist")); } return(group); }
private static string PrintInputParameters(IParameterCollection parameters) { if (0 == parameters.Count) { return " without parameters "; } var parameterString = new StringBuilder(); parameterString.Append("("); for (int i = 0; i < parameters.Count; i++) { ParameterInfo parameter = parameters.GetParameterInfo(i); parameterString.Append(parameter.Name + " = " + parameters[i]); } parameterString.Append(")"); return parameterString.ToString(); }
private object ServerCommand(RestVerbs verbs, IParameterCollection parameters) { if (parameters["cmd"] != null && parameters["cmd"].Trim() != "") { TSRestPlayer tr = new TSRestPlayer(); RestObject ro = new RestObject("200"); Commands.HandleCommand(tr, parameters["cmd"]); foreach (string s in tr.GetCommandOutput()) { ro.Add("response", s); } return(ro); } RestObject fail = new RestObject("400"); fail["response"] = "Missing or blank cmd parameter."; return(fail); }
private object UserList(RestVerbs verbs, IParameterCollection parameters) { var ret = new RestObject("200"); string playerlist = ""; foreach (var TSPlayer in TShock.Players) { if (playerlist == "") { playerlist += TSPlayer.UserAccountName; } else { playerlist += ", " + TSPlayer.UserAccountName; } } ret["activeuesrs"] = playerlist; return(ret); }
object BanCreate(RestVerbs verbs, IParameterCollection parameters) { var returnBlock = new Dictionary<string, string>(); var ip = parameters["ip"]; var name = parameters["name"]; var reason = parameters["reason"]; if (ip == null && name == null) { returnBlock.Add("status", "400"); returnBlock.Add("error", "Required parameters were missing from this API endpoint."); return returnBlock; } if (ip == null) { ip = ""; } if (name == null) { name = ""; } if (reason == null) { reason = ""; } try { TShock.Bans.AddBan(ip, name, reason); } catch (Exception) { returnBlock.Add("status", "400"); returnBlock.Add("error", "The specified ban was unable to be created."); return returnBlock; } returnBlock.Add("status", "200"); returnBlock.Add("response", "Ban created successfully."); return returnBlock; }
private object BanCreate(RestVerbs verbs, IParameterCollection parameters) { var returnBlock = new Dictionary <string, string>(); var ip = parameters["ip"]; var name = parameters["name"]; var reason = parameters["reason"]; if (ip == null && name == null) { returnBlock.Add("status", "400"); returnBlock.Add("error", "Required parameters were missing from this API endpoint."); return(returnBlock); } if (ip == null) { ip = ""; } if (name == null) { name = ""; } if (reason == null) { reason = ""; } try { TShock.Bans.AddBan(ip, name, reason); } catch (Exception) { returnBlock.Add("status", "400"); returnBlock.Add("error", "The specified ban was unable to be created."); return(returnBlock); } returnBlock.Add("status", "200"); returnBlock.Add("response", "Ban created successfully."); return(returnBlock); }
private object UserInfo(RestVerbs verbs, IParameterCollection parameters) { var user = TShock.Users.GetUserByName(verbs["user"]); if (user == null) { return(new Dictionary <string, string> { { "status", "400" }, { "error", "The specified user account does not exist." } }); } var returnBlock = new Dictionary <string, string>(); returnBlock.Add("status", "200"); returnBlock.Add("group", user.Group); returnBlock.Add("id", user.ID.ToString()); returnBlock.Add("deprecated", "This endpoint is deprecated. It will be fully removed from code in TShock 3.6."); return(returnBlock); }
private static string PrintInputParameters(IParameterCollection parameters) { if (0 == parameters.Count) { return(" without parameters "); } var parameterString = new StringBuilder(); parameterString.Append("("); for (int i = 0; i < parameters.Count; i++) { ParameterInfo parameter = parameters.GetParameterInfo(i); parameterString.Append(parameter.Name + " = " + parameters[i]); } parameterString.Append(")"); return(parameterString.ToString()); }
/// <summary> /// Invoked when disposing or finalizing this instance. /// </summary> /// <param name="disposing">True if the object is being disposed, false otherwise.</param> protected virtual void OnDispose(bool disposing) { if (disposing) { try { if (_Parameters != null && !_Parameters.IsDisposed) { _Parameters.Dispose(); } } catch { } } _Parameters = null; _Link = null; _IsDisposed = true; }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="link">The link this command is associated with.</param> protected Command(IDataLink link) { if (link == null) { throw new ArgumentNullException("link", "Link cannot be null."); } if (link.IsDisposed) { throw new ObjectDisposedException(link.ToString()); } _Link = link; _Parameters = _Link.Engine.CreateParameterCollection(); if (_Parameters == null) { throw new CannotCreateException( "Cannot create a new collection of parameters for this instance."); } }
private object GroupCreate(RestVerbs verbs, IParameterCollection parameters) { var name = parameters["group"]; if (string.IsNullOrWhiteSpace(name)) { return(RestMissingParam("group")); } try { TShock.Groups.AddGroup(name, parameters["parent"], parameters["permissions"], parameters["chatcolor"], true); } catch (Exception e) { return(RestError(e.Message)); } return(RestResponse("Group '" + name + "' created successfully")); }
/// <summary> /// Remove the authorization HTTP header if it's not equal to the old one. /// </summary> /// <param name="parameters">List of HTTP headers</param> /// <param name="header">The type of the HTTP header that stores the authorization information</param> /// <param name="authValue">The authorization header value</param> /// <returns>true = header removed, false = same header already exists, null = header not found</returns> public static bool?RemoveAuthorizationHeader([NotNull, ItemNotNull] IParameterCollection parameters, AuthHeader header, [NotNull] string authValue) { var authParam = parameters.Find(ParameterType.HttpHeader, header.ToAuthorizationHeaderName()).FirstOrDefault(); if (authParam == null) { return(null); } var v = (string)authParam.Value; if (v != null && v == authValue) { return(false); } parameters.Remove(authParam); return(true); }
public ParameterProxyCollection(IParameterCollection source, IType contextType, IMethod contextMethod) { if (source == null) { throw new ArgumentNullException("source"); } if (contextType == null) { throw new ArgumentNullException("contextType"); } if (contextMethod == null) { throw new ArgumentNullException("contextMethod"); } _source = source; _contextType = contextType; _contextMethod = contextMethod; }
private object NewToken(RestVerbs verbs, IParameterCollection parameters) { var user = verbs["username"]; var pass = verbs["password"]; RestObject obj = null; if (Verify != null) { obj = Verify(user, pass); } if (obj == null) { obj = new RestObject("401") { Error = "Invalid username/password combination provided. Please re-submit your query with a correct pair." } } ; if (obj.Error != null) { return(obj); } string hash; var rand = new Random(); var randbytes = new byte[32]; do { rand.NextBytes(randbytes); hash = randbytes.Aggregate("", (s, b) => s + b.ToString("X2")); } while (Tokens.ContainsKey(hash)); Tokens.Add(hash, user); obj["token"] = hash; obj["deprecated"] = "This method will be removed from TShock in 3.6."; return(obj); }
private object UserFind(IParameterCollection parameters) { string name = parameters["user"]; if (string.IsNullOrWhiteSpace(name)) { return(RestMissingParam("user")); } User user; string type = parameters["type"]; try { switch (type) { case null: case "name": type = "name"; user = TShock.Users.GetUserByName(name); break; case "id": user = TShock.Users.GetUserByID(Convert.ToInt32(name)); break; default: return(RestError("Invalid Type: '" + type + "'")); } } catch (Exception e) { return(RestError(e.Message)); } if (null == user) { return(RestError(String.Format("User {0} '{1}' doesn't exist", type, name))); } return(user); }
private object BanInfo(RestVerbs verbs, IParameterCollection parameters) { var returnBlock = new Dictionary <string, string>(); var type = parameters["type"]; if (type == null) { returnBlock.Add("Error", "Invalid Type"); return(returnBlock); } var ban = new Ban(); if (type == "ip") { ban = TShock.Bans.GetBanByIp(verbs["user"]); } else if (type == "name") { ban = TShock.Bans.GetBanByName(verbs["user"]); } else { returnBlock.Add("Error", "Invalid Type"); return(returnBlock); } if (ban == null) { return(new Dictionary <string, string> { { "status", "400" }, { "error", "The specified ban does not exist." } }); } returnBlock.Add("status", "200"); returnBlock.Add("name", ban.Name); returnBlock.Add("ip", ban.IP); returnBlock.Add("reason", ban.Reason); returnBlock.Add("deprecated", "This endpoint is deprecated. It will be fully removed from code in TShock 3.6."); return(returnBlock); }
private string FormatArguments(IParameterCollection arguments) { if (arguments == null || arguments.Count == 0) { return(string.Empty); } var sb = new StringBuilder(); for (var i = 0; i < arguments.Count; i++) { sb.AppendFormat("{0}: {1},", arguments.ParameterName(i), FormatArgument(arguments[i])); } if (sb.Length != 0) { sb.Length--; } return(sb.ToString()); }
private object BanCreate(RestVerbs verbs, IParameterCollection parameters) { var ip = parameters["ip"]; var name = parameters["name"]; if (string.IsNullOrWhiteSpace(ip) && string.IsNullOrWhiteSpace(name)) { return(RestMissingParam("ip", "name")); } try { TShock.Bans.AddBan(ip, name, parameters["reason"], true); } catch (Exception e) { return(RestError(e.Message)); } return(RestResponse("Ban created successfully")); }
private object UserDestroyV2(RestVerbs verbs, IParameterCollection parameters) { var ret = UserFind(parameters); if (ret is RestObject) { return(ret); } try { TShock.Users.RemoveUser((User)ret); } catch (Exception e) { return(RestError(e.Message)); } return(RestResponse("User deleted successfully")); }
private object DestroyToken(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData) { var token = verbs["token"]; try { Tokens.Remove(token); } catch (Exception) { return(new RestObject("400") { Error = "The specified token queued for destruction failed to be deleted." }); } return(new RestObject() { Response = "Requested token was successfully destroyed." }); }
/// <summary> /// Invoked when disposing or finalizing this instance. /// </summary> /// <param name="disposing">True if the object is being disposed, false otherwise.</param> protected virtual void OnDispose(bool disposing) { if (disposing) { try { if (_Owner != null) { var temp = _Owner; _Owner = null; if (temp != null && !temp.IsDisposed) temp.Remove(this); } } catch { } } _Owner = null; _Value = disposing ? (_Value == null ? null : _Value.ToString()) : null; _IsDisposed = true; }
public ActionResult Report(string proc_name, string parameters) { DersaSqlManager M = new DersaSqlManager(); IParameterCollection Params = Util.DeserializeParams(parameters); if (Params.Contains("proc_name") || !string.IsNullOrEmpty(proc_name)) { if (Params.Contains("proc_name")) { proc_name = Params["proc_name"].Value.ToString(); Params.Remove("proc_name"); } System.Data.DataTable T = M.ExecuteSPWithParams(proc_name, Params); return(View(T)); } else { throw new System.Exception("procedure for report is not defined!"); } }
/// <summary> /// Parse string /// </summary> /// <param name="value">contains "a=b,c=d" etc</param> /// <param name="target">Collection to fill with the values</param> public void Parse(string value, IParameterCollection target) { if (value == null) throw new ArgumentNullException("value"); if (target == null) throw new ArgumentNullException("target"); var index = 0; var lastCh = char.MinValue; var name = ""; var oldPos = 0; while (index < value.Length) { var ch = value[index]; switch (ch) { case '=': if (lastCh != '\\') { name = value.Substring(oldPos, index - oldPos).Trim(' '); oldPos = index + 1; } break; case ',': if (lastCh != '\\') { target.Add(name, value.Substring(oldPos, index - oldPos).Trim(' ', '"')); name = ""; oldPos = index + 1; } break; } lastCh = value[index]; ++index; } if (name != "") { target.Add(name, value.Substring(oldPos).Trim(' ', '"')); } }
public void TryPopulateModel(object model, IParameterCollection parameterCollection) { if (parameterCollection == null) throw new ArgumentNullException("parameterCollection"); var errors = new Dictionary<string, Exception>(); ICachedType type = PropertyProvider.Get(model.GetType()); foreach (IParameter parameter in parameterCollection) { try { object value = parameter.Value; type.SetConvertedValue(model, parameter.Name, value); } catch (Exception err) { errors[parameter.Name] = err; } } if (errors.Count != 0) throw new PropertyException(errors); }
private object WorldSave(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData) { SaveManager.Instance.SaveWorld(); return RestResponse("World saved"); }
private object WorldRead(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData) { return new RestObject() { {"name", Main.worldName}, {"size", Main.maxTilesX + "*" + Main.maxTilesY}, {"time", Main.time}, {"daytime", Main.dayTime}, {"bloodmoon", Main.bloodMoon}, {"invasionsize", Main.invasionSize} }; }
private object WorldMeteor(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData) { if (null == WorldGen.genRand) WorldGen.genRand = new Random(); WorldGen.dropMeteor(); return RestResponse("Meteor has been spawned"); }
private object WorldChangeSaveSettings(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData) { bool autoSave; if (!bool.TryParse(verbs["bool"], out autoSave)) return RestInvalidParam("state"); TShock.Config.AutoSave = autoSave; return RestResponse("AutoSave has been set to " + autoSave); }
private object WorldButcher(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData) { bool killFriendly; if (!bool.TryParse(parameters["killfriendly"], out killFriendly)) return RestInvalidParam("killfriendly"); if (killFriendly) killFriendly = !killFriendly; int killcount = 0; for (int i = 0; i < Main.npc.Length; i++) { if (Main.npc[i].active && Main.npc[i].type != 0 && !Main.npc[i].townNPC && (!Main.npc[i].friendly || killFriendly)) { TSPlayer.Server.StrikeNPC(i, 99999, 90f, 1); killcount++; } } return RestResponse(killcount + " NPCs have been killed"); }
private object WorldBloodmoon(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData) { bool bloodmoon; if (!bool.TryParse(verbs["bool"], out bloodmoon)) return RestInvalidParam("bloodmoon"); Main.bloodMoon = bloodmoon; return RestResponse("Blood Moon has been set to " + bloodmoon); }
private object UserUpdateV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData) { var ret = UserFind(parameters); if (ret is RestObject) return ret; var password = parameters["password"]; var group = parameters["group"]; if (string.IsNullOrWhiteSpace(group) && string.IsNullOrWhiteSpace(password)) return RestMissingParam("group", "password"); User user = (User)ret; var response = new RestObject(); if (!string.IsNullOrWhiteSpace(password)) { try { TShock.Users.SetUserPassword(user, password); response.Add("password-response", "Password updated successfully"); } catch (Exception e) { return RestError("Failed to update user password (" + e.Message + ")"); } } if (!string.IsNullOrWhiteSpace(group)) { try { TShock.Users.SetUserGroup(user, group); response.Add("group-response", "Group updated successfully"); } catch (Exception e) { return RestError("Failed to update user group (" + e.Message + ")"); } } return response; }