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;
}
