/// <summary>
/// WapperServiceResponse
/// </summary>
/// <param name="request"></param>
/// <param name="response"></param>
protected virtual void WapperServiceResponse(HttpRequestMessage request, HttpResponseMessage response)
{
if (!response.IsSuccessStatusCode)
{
return;
}
object data;
//无返回值
if (!response.TryGetContentValue(out data) || data == null)
{
response.StatusCode = HttpStatusCode.OK;
response.Content = new ObjectContent <ServerResponse>(
ResponseProvider.Success(), new JsonMediaTypeFormatter());
return;
}
//错误情况
if (data is ServerResponse)
{
return;
}
//构建返回值
response.Content = new ObjectContent <ServerResponse>(
ResponseProvider.Success(data), new JsonMediaTypeFormatter()
);
}
public void GET_ValidAllDepartments()
{
CreateTestTable();
CreateTestTable(Name: "Table2", DepartmentID: 2);
ResponseProvider Response = ExecuteSimpleRequest("/DataTable", HttpMethod.GET);
//Verify results
Assert.IsTrue(Response.StatusCode == HttpStatusCode.OK);
JArray Data = JArray.Parse(Encoding.UTF8.GetString(Response.Data));
JArray Expected = new JArray()
{
new JObject()
{
{ "Name", "Table1" },
{ "ReqValidation", true },
{ "Department", 1 }
},
new JObject()
{
{ "Name", "Table2" },
{ "ReqValidation", true },
{ "Department", 2 }
}
};
Assert.IsTrue(JToken.DeepEquals(Data, JArray.Parse(Expected.ToString())));
}
public void GET_AllNotes()
{
// Create test departments
new Note(Connection, "SomeTitle1", "SomeText1");
new Note(Connection, "SomeTitle2", "SomeText2");
// Create mock request
ResponseProvider response = ExecuteSimpleRequest("/note?title=", HttpMethod.GET);
// Verify results
Assert.IsTrue(response.StatusCode == HttpStatusCode.OK);
JArray data = JArray.Parse(Encoding.UTF8.GetString(response.Data));
JArray expected = new JArray()
{
infoTemplate, infoTemplate
};
expected[0]["ID"] = 1;
expected[0]["Title"] = "SomeTitle1";
expected[0]["Text"] = "SomeText1";
expected[1]["ID"] = 2;
expected[1]["Title"] = "SomeTitle2";
expected[1]["Text"] = "SomeText2";
Assert.IsTrue(JToken.DeepEquals(data, JArray.Parse(expected.ToString())));
}
public void PATCH_ValidArguments()
{
CreateTestTable(ReqValidation: false);
ResponseProvider Response = ExecuteSimpleRequest("/DataTable?table=Table1", HttpMethod.PATCH, new JObject()
{
{ "Add", new JObject()
{
{ "Column1", "Blob" },
{ "Validated", "Integer" }
} },
{ "Delete", new JArray()
{
"IntegerColumn"
} },
{ "Rename", new JObject()
{
{ "StringColumn", "Column2" }
} }
});
//Verify results
Assert.IsTrue(Response.StatusCode == HttpStatusCode.OK);
GenericDataTable Table = GenericDataTable.GetTableByName(Connection, "Table1");
Dictionary <string, DataType> Columns = Table.GetColumns();
Assert.IsTrue(Columns.Count == 4);
Assert.IsTrue(Columns["Column1"] == DataType.Blob);
Assert.IsTrue(Columns["Column2"] == DataType.String);
Assert.IsTrue(Table.ReqValidation);
}
public void DELETE_MissingParams()
{
ResponseProvider Response = ExecuteSimpleRequest("/DataTable", HttpMethod.DELETE, null);
Assert.IsTrue(Response.StatusCode == HttpStatusCode.BadRequest);
Assert.IsTrue(Encoding.UTF8.GetString(Response.Data) == "Missing params");
}
public static void Main()
{
var responseProvider = new ResponseProvider();
var requestBuilder = new StringBuilder();
string inputLine;
while ((inputLine = Console.ReadLine()) != null)
{
// Smells
if (string.IsNullOrWhiteSpace(inputLine))
{
HttpResponse response = responseProvider.GetResponse(requestBuilder.ToString());
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.WriteLine(response);
Console.ResetColor();
requestBuilder.Clear();
continue;
}
requestBuilder.AppendLine(inputLine);
}
}
public void DELETE_NoSuchTable()
{
ResponseProvider Response = ExecuteSimpleRequest("/DataTable?table=Table1", HttpMethod.DELETE, null);
Assert.IsTrue(Response.StatusCode == HttpStatusCode.NotFound);
Assert.IsTrue(Encoding.UTF8.GetString(Response.Data) == "No such table");
}
public void DELETE_InvalidArguments(JObject JSON, string URL, HttpStatusCode StatusCode, string ResponseMessage = null)
{
GenericDataTable TestTable = CreateTestTable();
TestTable.Insert(new List <Dictionary <string, dynamic> > {
{ new Dictionary <string, dynamic>()
{
{ "StringColumn", "Text1" },
{ "IntegerColumn", 1 }
} },
{ new Dictionary <string, dynamic>()
{
{ "StringColumn", "Text2" },
{ "IntegerColumn", 2 }
} },
{ new Dictionary <string, dynamic>()
{
{ "StringColumn", "Text3" },
{ "IntegerColumn", 3 }
} }
});
ResponseProvider Response = ExecuteSimpleRequest(URL, HttpMethod.DELETE, JSON);
Assert.IsTrue(Response.StatusCode == StatusCode);
if (ResponseMessage != null)
{
Assert.IsTrue(Encoding.UTF8.GetString(Response.Data) == ResponseMessage);
}
}
public void GET_InvalidArguments()
{
ResponseProvider response = ExecuteSimpleRequest("/company?name=SomeDepartment", HttpMethod.GET);
// Verify results
Assert.IsTrue(response.StatusCode == HttpStatusCode.NotFound);
}
public override void OnAuthorization(AuthorizationContext filterContext)
{
//no1: 判断是否登录
var user = filterContext.HttpContext.Session?["User"] as UserDto;
var controller = filterContext.ActionDescriptor.ControllerDescriptor.ControllerName;
var action = filterContext.ActionDescriptor.ActionName;
var method = filterContext.HttpContext.Request.HttpMethod;
var url = filterContext.HttpContext.Request.RawUrl;
var categoryKey = filterContext.HttpContext.Request.QueryString["CategoryKey"];
if (user != null)
{
var token = CacheHelper.GetCache(user.LoginName);
var info = AuthConfigXmlHelper.GetAuthConfigByXml(Api.PhysicsUrl + "/Config/AuthConfig.xml"
, url, controller, action, method, categoryKey);
_roles = BusinessHelper.BreakUpOptions(info.Roles, ',');
if (!AuthManager.TryAuthorize(filterContext, token.ToString(), _roles))
{
var respMessage = ResponseProvider.Error("你没有被授权访问此资源。", 401);
//异常处理模块接入
}
}
base.OnAuthorization(filterContext);
}
public async Task <ResponseModel <FileContentResultModel> > Handle(GetByFileNameQuery request, CancellationToken cancellationToken)
{
var fileExtension = Path.GetExtension(request.FileName);
var categoryPath = Path.Combine(_contentRootPath, "Archive", request.CategoryName);
var fileAbsolutePath = Path.Combine(categoryPath, request.FileName);
var fileContentResult = new FileContentResultModel();
if (fileExtension != FileConstants.AesExtension && fileExtension != FileConstants.RijndaelExtension)
{
if (!Directory.Exists(categoryPath))
{
return(ResponseProvider.NotFound <FileContentResultModel>(nameof(request.CategoryName)));
}
if (!File.Exists(fileAbsolutePath))
{
return(ResponseProvider.NotFound <FileContentResultModel>(nameof(request.FileName)));
}
fileContentResult.StreamData = await FileHelpers.ReadFileToMemoryStream(fileAbsolutePath);
fileContentResult.FileName = request.FileName;
}
using (FileStream fs = File.Open(fileAbsolutePath, FileMode.Open))
{
byte[] data = new BinaryReader(fs).ReadBytes((int)fs.Length);
fileContentResult.StreamData = await DecryptFile(data, fileExtension);
fileContentResult.FileName = Path.GetFileNameWithoutExtension(request.FileName);
return(ResponseProvider.Ok(fileContentResult));
}
}
public void GetResponse_ShouldCatchParserExceptionAndCallFactoryMethodWithCorrectParams()
{
const string errorMessage = "Error!";
var responseFactory = new Mock <IHttpResponseFactory>();
responseFactory.Setup(
f =>
f.GetHttpResponse("1.1", HttpStatusCode.BadRequest, errorMessage,
"text/plain; charset=utf-8"));
var headHandler = new Mock <IHandler>();
var requestParser = new Mock <IRequestParser>();
requestParser.Setup(p => p.Parse(It.IsAny <string>()))
.Throws(new ParserException(errorMessage));
var responseProvider = new ResponseProvider(requestParser.Object, responseFactory.Object, headHandler.Object);
responseProvider.GetResponse("message");
responseFactory.Verify(
f =>
f.GetHttpResponse("1.1", HttpStatusCode.BadRequest, errorMessage,
"text/plain; charset=utf-8"), Times.Once());
}
public void EDIT_ValidArguments()
{
new Company(Connection, "SomeCompany", "SomeStreet", 1, "1234AB", "SomeCity", "SomeCountry", "SomePhoneNumber", "SomeEmail");
ResponseProvider response = ExecuteSimpleRequest("/company?name=SomeCompany", HttpMethod.PATCH, new JObject()
{
{ "Name", "SomeCoolCompany" },
{ "Street", "SomeCoolStreet" },
{ "HouseNumber", 2 },
{ "PostCode", "EFGH34" },
{ "City", "SomeCoolCity" },
{ "Country", "SomeCoolCountry" },
{ "PhoneNumber", "SomeCoolPhoneNumber" },
{ "Email", "SomeCoolEmail" },
});
Assert.IsTrue(response.StatusCode == HttpStatusCode.OK);
Company company = Company.GetCompanyByName(Connection, "SomeCoolCompany");
Assert.IsNotNull(company);
Assert.IsTrue(company.Name == "SomeCoolCompany");
Assert.IsTrue(company.Street == "SomeCoolStreet");
Assert.IsTrue(company.HouseNumber == 2);
Assert.IsTrue(company.PostCode == "EFGH34");
Assert.IsTrue(company.City == "SomeCoolCity");
Assert.IsTrue(company.Country == "SomeCoolCountry");
Assert.IsTrue(company.PhoneNumber == "SomeCoolPhoneNumber");
Assert.IsTrue(company.Email == "SomeCoolEmail");
}
public static void Main()
{
IHandlerFactory handlerFactory = new HandlerFactory();
IResponseProvider responseProvider = new ResponseProvider(handlerFactory);
var webSever = new WebServerConsole(responseProvider);
webSever.Start();
}
public void PATCH_ValidArguments()
{
CreateTestTable();
ResponseProvider Response = ExecuteSimpleRequest("/data?table=Table1", HttpMethod.PATCH, new JObject()
{
{ "1", new JObject()
{
{ "StringColumn", "Hello World!" },
{ "IntegerColumn", 12345 }
} }
});
Assert.IsTrue(Response.StatusCode == HttpStatusCode.OK);
GenericDataTable Table = GenericDataTable.GetTableByName(Connection, "Table1");
JArray Expected = new JArray()
{
1, "Hello World!", 12345, 0
};
JArray Actual = (JArray)Table.GetRows()["Rows"][0];
Assert.IsTrue(JArray.DeepEquals(Expected, JArray.Parse(Actual.ToString())));
Expected = new JArray()
{
2, "Text2", 2, 0
};
Actual = (JArray)Table.GetRows()["Rows"][1];
Assert.IsTrue(JArray.DeepEquals(Expected, JArray.Parse(Actual.ToString())));
}
public override void Execute()
{
try
{
string requestBody = GetRequestBody();
statusCode = HttpStatusCode.OK;
if (requestBody.Contains("GetUpdatedFormDigestInformation"))
{
responseString = DigestResponse;
responseContentType = "text/xml";
}
else
{
responseString = ResponseProvider.GetResponse(RequestUrl, RequestMethod.ToString(), requestBody);
//remove duplicated escape characters (possible due to anonymous guid serializtion)
responseString = responseString.Replace("\\\\/", "\\/");
//however add \ for Guids and Dates the expectedformat is Id: "\/Guid(...)\/"
responseString = responseString.Replace("\"/Guid(", "\"\\/Guid(");
responseString = responseString.Replace("\"/Date(", "\"\\/Date(");
responseString = responseString.Replace(")/\"", ")\\/\"");
responseContentType = "application/json";
}
}
catch (Exception ex)
{
statusCode = HttpStatusCode.InternalServerError;
responseString = ex.Message;
}
ResponseStream = new MemoryStream(Encoding.UTF8.GetBytes(responseString));
}
public void GET_BulkValidArguments()
{
//Create test user
new User("*****@*****.**", "TestPassword1", Connection);
new User("*****@*****.**", "TestPassword2", Connection);
ResponseProvider Response = ExecuteSimpleRequest("/account?email=Administrator,[email protected]", HttpMethod.GET);
//Verify results
Assert.IsTrue(Response.StatusCode == HttpStatusCode.OK);
JArray Data = JArray.Parse(Encoding.UTF8.GetString(Response.Data));
JArray Expected = new JArray()
{
InfoTemplate, InfoTemplate
};
Expected[1]["ID"] = 2;
Expected[1]["Email"] = "*****@*****.**";
Expected[1]["Permissions"] = new JObject()
{
{ "Administrators", "User" },
{ "All Users", "User" }
};
Assert.IsTrue(JToken.DeepEquals(Data, JArray.Parse(Expected.ToString())));
}
public void GET_InvalidArguments()
{
ResponseProvider Response = ExecuteSimpleRequest("/data?table=SomeTable", HttpMethod.GET);
Assert.IsTrue(Response.StatusCode == HttpStatusCode.NotFound);
Assert.IsTrue(Encoding.UTF8.GetString(Response.Data) == "No such table");
}
public void GET_GetInvalidFile()
{
ResponseProvider Response = ExecuteSimpleRequest("/backup?name=SomeFile", HttpMethod.GET);
//Verify results
Assert.IsTrue(Response.StatusCode == HttpStatusCode.NotFound);
}
public void CREATE_ValidArguments()
{
ResponseProvider Response = ExecuteSimpleRequest("/DataTable", HttpMethod.POST, new JObject()
{
{ "Name", "Table1" },
{ "Columns", new JObject()
{
{ "StringColumn", "String" },
{ "IntegerColumn", "Integer" }
} },
{ "Department", "Administrators" },
{ "RequireValidation", true }
});
//Verify results
Assert.IsTrue(Response.StatusCode == HttpStatusCode.Created);
GenericDataTable Table = GenericDataTable.GetTableByName(Connection, "Table1");
Assert.IsNotNull(Table);
Dictionary <string, DataType> Columns = Table.GetColumns();
Assert.IsTrue(Columns.Count == 4);
Assert.IsTrue(Columns.ContainsKey("rowid") && Columns["rowid"] == DataType.Integer);
Assert.IsTrue(Columns.ContainsKey("StringColumn") && Columns["StringColumn"] == DataType.String);
Assert.IsTrue(Columns.ContainsKey("IntegerColumn") && Columns["IntegerColumn"] == DataType.Integer);
Assert.IsTrue(Columns.ContainsKey("Validated") && Columns["Validated"] == DataType.Integer);
}
public void GET_InvalidDepartment()
{
ResponseProvider Response = ExecuteSimpleRequest("/DataTable?department=SomeDepartment", HttpMethod.GET);
Assert.IsTrue(Response.StatusCode == HttpStatusCode.NotFound);
Assert.IsTrue(Encoding.UTF8.GetString(Response.Data) == "No such department");
}
public void GET_InvalidArguments()
{
ResponseProvider response = ExecuteSimpleRequest("/note?title=SomeTitle", HttpMethod.GET);
// Verify results
Assert.IsTrue(response.StatusCode == HttpStatusCode.NotFound);
}
public void GET_AllDepartments()
{
// Create test departments
new Department(Connection, "SomeDepartment1", "A department to test the application (1)");
new Department(Connection, "SomeDepartment2", "A department to test the application (2)");
// Create mock request
ResponseProvider response = ExecuteSimpleRequest("/department?name=", HttpMethod.GET);
// Verify results
Assert.IsTrue(response.StatusCode == HttpStatusCode.OK);
JArray data = JArray.Parse(Encoding.UTF8.GetString(response.Data));
JArray expected = new JArray()
{
infoTemplate1, infoTemplate2, infoTemplate3, infoTemplate3
};
expected[2]["ID"] = 3;
expected[2]["Name"] = "SomeDepartment1";
expected[2]["Description"] = "A department to test the application (1)";
expected[3]["ID"] = 4;
expected[3]["Name"] = "SomeDepartment2";
expected[3]["Description"] = "A department to test the application (2)";
Assert.IsTrue(JToken.DeepEquals(data, JArray.Parse(expected.ToString())));
}
public void GET_MixedArguments()
{
ResponseProvider response = ExecuteSimpleRequest("/department?name=Administrators,SomeDepartment", HttpMethod.GET);
// Verify results
Assert.IsTrue(response.StatusCode == HttpStatusCode.OK);
}
public void DELETE_ValidArguments()
{
CreateTestTable();
ResponseProvider Response = ExecuteSimpleRequest("/DataTable?table=Table1", HttpMethod.DELETE, null);
Assert.IsTrue(Response.StatusCode == HttpStatusCode.OK);
Assert.IsNull(GenericDataTable.GetTableByName(Connection, "Table1"));
}
public Context(
IResolver resolver,
ResponseProvider provider) : base(resolver)
{
responseSubscription = provider.WhenResponseReady()
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(ObserveResponse);
}
public static void Main()
{
IHandlerFactory handlerFactory = new HandlerFactory();
IResponseProvider responseProvider = new ResponseProvider(handlerFactory);
var webSever = new WebServerConsole(responseProvider);
webSever.Start();
}
public void DELETE()
{
Cookie SessionCookie = CreateSession();
ResponseProvider Response = ExecuteSimpleRequest("/login", HttpMethod.DELETE, null, false, SessionCookie);
Assert.IsTrue(Response.StatusCode == HttpStatusCode.OK);
Assert.IsNull(Session.GetUserSession(Connection, SessionCookie.Value));
}
public override void OnAuthorization(HttpActionContext context)
{
if (!AuthManager.TryAuthorize(context, _roles))
{
var respMessage = ResponseProvider.Error("你没有被授权访问此资源。", 401);
context.Response = context.Request.CreateResponse(HttpStatusCode.OK, respMessage);
}
}
// TODO: Describe patterns, SOLID, bugs and bottleneck in Documentation.txt
public static void Main()
{
IResponseProvider responseProvider = new ResponseProvider();
var webSever = new WebServer(responseProvider);
webSever.Start();
}
public async Task <ResponseModel <PagedList <EncryptedFile> > > Handle(FullListQuery request, CancellationToken cancellationToken)
{
var encryptedFiles = _context.EncryptedFiles
.AsNoTracking();
var response = await PagedList <EncryptedFile> .Create(encryptedFiles, request.Page, request.PageSize);
return(ResponseProvider.Ok(response));
}
public WebServerConsole5()
{
this.responseProvider = new ResponseProvider();
}
private static void CreateResponseProvider()
{
responseProvider = new ResponseProvider();
}
