public void ReadMultipleParameters()
{
// Basic container class with multiple fields
HttpContent content = FormContent("X=3&Y=4");
FormDataCollection fd = content.ReadAsAsync <FormDataCollection>().Result;
Assert.Equal(3, fd.ReadAs <int>("X", requiredMemberSelector: null, formatterLogger: null));
Assert.Equal("3", fd.ReadAs <string>("X", requiredMemberSelector: null, formatterLogger: null));
Assert.Equal(4, fd.ReadAs <int>("Y", requiredMemberSelector: null, formatterLogger: null));
}
public async Task <IHttpActionResult> Post(FormDataCollection collection)
{
var command = collection.ReadAs <CommandParameters>();
var client = WebApiConfig.Clients?.SingleOrDefault(c => c.TeamId == command.Team_id);
if (client == null)
{
return(this.BadRequest($"Client for {command.Team_id} not found."));
}
var channelName = command.Channel_name;
if (string.IsNullOrWhiteSpace(channelName))
{
channelName = "#general";
}
var channel = client.Channels.FirstOrDefault(c => c.name == channelName);
if (channel == null)
{
return(this.BadRequest($"Could not find channel named {channelName}"));
}
if (command.Text.Count(c => c.Equals('\n')) > 15)
{
await client.PostTextMessageToChannelAsAttachment(command.Text, channel.id);
}
else
{
await client.PostTextMessageToChannel(command.Text, channel.id);
}
return(this.Ok());
}
public async Task Read_As_NoServicesChangeInConfig()
{
// Arrange
HttpContent content = FormContent("a=30");
FormDataCollection formData = await content.ReadAsAsync <FormDataCollection>();
using (HttpConfiguration configuration = new HttpConfiguration())
{
// Act
HttpControllerSettings settings = new HttpControllerSettings(configuration);
HttpConfiguration clonedConfiguration = HttpConfiguration.ApplyControllerSettings(
settings,
configuration
);
int actual = (int)formData.ReadAs(
typeof(int),
"a",
requiredMemberSelector: null,
formatterLogger: (new Mock <IFormatterLogger>()).Object,
config: configuration
);
// Assert
Assert.Equal(30, actual);
Assert.Same(clonedConfiguration.Services, configuration.Services);
}
}
/// <summary>从内容绑定模型</summary>
protected async Task <T> BindModelFromBody <T>(string uploadPath)
{
var httpContent = this.Request.Content;
NameValueCollection formData = null;
if (httpContent.IsFormData())
{
formData = await httpContent.ReadAsFormDataAsync();
}
else if (httpContent.IsMimeMultipartContent())
{
var provider = await httpContent.ReadAsMultipartAsync(new MultipartFormDataStreamProvider(uploadPath));
foreach (var fileData in provider.FileData)
{
File.Delete(fileData.LocalFileName);
}
formData = provider.FormData;
}
if (formData != null)
{
var pairs = new List <KeyValuePair <string, string> >(formData.Count);
foreach (string key in formData.Keys)
{
var values = formData.GetValues(key);
foreach (var value in values)
{
pairs.Add(new KeyValuePair <string, string>(key, value));
}
}
var formData2 = new FormDataCollection(pairs);
return(formData2.ReadAs <T>());
}
return(default(T));
}
public async Task <Message> PostSlap(FormDataCollection collection)
{
Input.SaveFormParams(collection, nameof(SlapController));
var command = collection.ReadAs <CommandParameters>();
try
{
await command.GetUserFromText();
return(new Message()
{
Text = string.Format("Slaps {0} around a bit with a large trout", command.Text)
});
}
catch (Exception ex)
{
return(new Message()
{
IsPrivate = true, Text = $"{ex.Message} + {command.Text}"
});
}
return(new Message()
{
IsPrivate = true, Text = "Use as '/slap @username'"
});
}
private T ParseJQuery <T>(string jquery)
{
HttpContent content = FormContent(jquery);
FormDataCollection fd = content.ReadAsAsync <FormDataCollection>().Result;
T result = fd.ReadAs <T>();
return(result);
}
public void ReadClassWithFieldsFromUri()
{
var uri = new Uri("http://foo.com/?X=3&Y=4&Z=5");
FormDataCollection fd = new FormDataCollection(uri);
var result = fd.ReadAs <Point>();
Assert.Equal(3, result.X);
Assert.Equal(4, result.Y);
}
private async Task <T> ParseJQueryAsync <T>(string jquery)
{
HttpContent content = FormContent(jquery);
FormDataCollection fd = await content.ReadAsAsync <FormDataCollection>();
T result = fd.ReadAs <T>();
return(result);
}
public async Task ReadAs_NullActionContextThrows()
{
// Arrange
HttpContent content = FormContent("=30");
FormDataCollection formData = await content.ReadAsAsync <FormDataCollection>();
// Act/Assert
Assert.Throws <ArgumentNullException>(() => formData.ReadAs <int>((HttpActionContext)null));
}
public void ReadForThrowingSetterTypeRecordsCorrectModelError()
{
HttpContent content = FormContent("Throws=text");
FormDataCollection fd = content.ReadAsAsync <FormDataCollection>().Result;
Mock <IFormatterLogger> mockLogger = new Mock <IFormatterLogger>();
fd.ReadAs <ThrowingSetterType>(String.Empty, requiredMemberSelector: null, formatterLogger: mockLogger.Object);
mockLogger.Verify(mock => mock.LogError("Throws", ThrowingSetterType.Exception));
}
public async Task <Message> Post(FormDataCollection collection)
{
Input.SaveFormParams(collection, nameof(VotebanController));
var parameters = collection.ReadAs <CommandParameters>();
var voteban = await Voteban.Create(parameters);
voteban.Save();
var vote = new Vote(voteban, voteban.GetAuthor(), true);
vote.Save();
var message = FormatMessage(voteban);
return(message);
}
public async Task ReadAs_WithModelNameAndHttpActionContext()
{
// Arrange
int expected = 30;
HttpContent content = FormContent("a=30");
FormDataCollection formData = await content.ReadAsAsync <FormDataCollection>();
using (HttpConfiguration configuration = new HttpConfiguration())
{
HttpActionContext actionContext = CreateActionContext(configuration);
// Act
int actual = (int)formData.ReadAs(typeof(int), "a", actionContext);
// Assert
Assert.Equal(expected, actual);
}
}
public async Task ReadAs_WithHttpActionContext()
{
// Arrange
int expected = 30;
HttpContent content = FormContent("=30");
FormDataCollection formData = await content.ReadAsAsync <FormDataCollection>();
using (HttpConfiguration configuration = new HttpConfiguration())
{
HttpActionContext actionContext = CreateActionContext(configuration);
// Act
int actual = formData.ReadAs <int>(actionContext);
// Assert
Assert.Equal(expected, actual);
}
}
public async Task <Message> PostDice(FormDataCollection collection)
{
Input.SaveFormParams(collection, nameof(DiceController));
var command = collection.ReadAs <CommandParameters>();
try
{
var parsed = regex.Match(command.Text);
if (parsed.Success && parsed.Groups[2].Success)
{
var sum = 0;
var count = int.Parse(parsed.Groups[1].Value);
for (int i = 0; i < count; i++)
{
sum += Random.Next(0, int.Parse(parsed.Groups[2].Value)) + 1;
}
if (count == sum)
{
return new Message()
{
Text = string.Format("{0} бросает кубик и получает им по лбу в ответ!", command.User_name)
}
}
;
return(new Message()
{
Text = string.Format("{0} бросает кубик и выбрасывает {1}!", command.User_name, sum)
});
}
}
catch
{
return(new Message()
{
IsPrivate = true, Text = "Кубик укатился..."
});
}
return(new Message()
{
IsPrivate = true, Text = "Use as '/dice 1d20'"
});
}
private async Task <object> ReadFromStreamAsyncCore(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
object obj = await base.ReadFromStreamAsync(typeof(FormDataCollection), readStream, content, formatterLogger);
FormDataCollection fd = (FormDataCollection)obj;
try
{
return(fd.ReadAs(type, String.Empty, RequiredMemberSelector, formatterLogger));
}
catch (Exception e)
{
if (formatterLogger == null)
{
throw;
}
formatterLogger.LogError(String.Empty, e);
return(GetDefaultValueForType(type));
}
}
public async Task Read_As_WithHttpActionContextAndCustomModelBinder()
{
// Arrange
int expected = 15;
HttpContent content = FormContent("a=30");
FormDataCollection formData = await content.ReadAsAsync <FormDataCollection>();
using (HttpConfiguration configuration = new HttpConfiguration())
{
configuration.Services.Insert(typeof(ModelBinderProvider), 0, new CustomIntModelBinderProvider());
HttpActionContext actionContext = CreateActionContext(configuration);
// Act
int actual = (int)formData.ReadAs(typeof(int), "a", actionContext);
// Assert
Assert.Equal(expected, actual);
}
}
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (readStream == null)
{
throw new ArgumentNullException("readStream");
}
// For simple types, defer to base class
if (base.CanReadType(type))
{
return(base.ReadFromStreamAsync(type, readStream, content, formatterLogger));
}
return(base.ReadFromStreamAsync(typeof(FormDataCollection), readStream, content, formatterLogger).Then(
(obj) =>
{
FormDataCollection fd = (FormDataCollection)obj;
try
{
return fd.ReadAs(type, String.Empty, RequiredMemberSelector, formatterLogger);
}
catch (Exception e)
{
if (formatterLogger == null)
{
throw;
}
formatterLogger.LogError(String.Empty, e);
return GetDefaultValueForType(type);
}
}));
}
public void ParseVoteban()
{
var input = new[]
{
new KeyValuePair <string, string>("token", "token_123"),
new KeyValuePair <string, string>("team_id", "team_id_123"),
new KeyValuePair <string, string>("team_domain", "team_domain_123"),
new KeyValuePair <string, string>("channel_id", "channel_id_123"),
new KeyValuePair <string, string>("channel_name", "channel_name_123"),
new KeyValuePair <string, string>("user_id", "user_id_123"),
new KeyValuePair <string, string>("user_name", "user_name_123"),
new KeyValuePair <string, string>("command", "command_123"),
new KeyValuePair <string, string>("text", "text_123"),
new KeyValuePair <string, string>("response_url", "response_url_123"),
};
var commandInput = new FormDataCollection(input);
var parsed = commandInput.ReadAs <CommandParameters>();
Assert.IsNotNull(parsed);
Assert.IsFalse(string.IsNullOrWhiteSpace(parsed.Team_id));
Assert.IsFalse(string.IsNullOrWhiteSpace(parsed.Text));
}
