/// <summary>
/// 通过Post调用
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="apiName"></param>
/// <param name="form"></param>
/// <returns></returns>
public ApiResult <TResult> Post <TResult>(string apiName, string form)
where TResult : IApiResultData
{
LogRecorder.BeginStepMonitor("内部API调用" + ToUrl(apiName));
var ctx = string.IsNullOrEmpty(Bearer) ? null : $"Bearer {Bearer}";
LogRecorder.MonitorTrace(ctx);
LogRecorder.MonitorTrace("Arguments:" + form);
var req = (HttpWebRequest)WebRequest.Create(ToUrl(apiName));
req.Method = "POST";
req.ContentType = "application/x-www-form-urlencoded";
req.Headers.Add(HttpRequestHeader.Authorization, ctx);
try
{
using (var rs = req.GetRequestStream())
{
var formData = Encoding.UTF8.GetBytes(form);
rs.Write(formData, 0, formData.Length);
}
}
catch (Exception e)
{
LogRecorder.Exception(e);
LogRecorder.EndStepMonitor();
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError));
}
return(GetResult <TResult>(req));
}
public async Task <string> Create()
{
ApiResult result;
try
{
using StreamReader reader = new StreamReader(Request.Body, Encoding.UTF8);
var body = await reader.ReadToEndAsync();
var api = JsonConvert.DeserializeObject <Api>(body, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
if (api != null)
{
api.Id = Guid.NewGuid();
await _context.Apis.AddAsync(api);
await _context.SaveChangesAsync();
result = ApiResult.SucceedResult <Api>(api);
}
else
{
result = ApiResult.ErrorResult("Api creation error 1", "api is not serialized");
}
}
catch (Exception e)
{
result = ApiResult.ErrorResult("Api creation error 2", $"{e.Message} - {e.InnerException} - {e.StackTrace}");
}
return(JsonConvert.SerializeObject(result));
}
public async Task <string> GetApis(int page = 1, int size = 10, string filter = null)
{
ApiResult result;
try
{
var paginationData = await GetApisForPagination(page, size, filter);
var methods = await GetMethods(paginationData.Item1);
var listOfDto = new List <ApiDto>();
foreach (var api in paginationData.Item1)
{
var dto = _mapper.Map <ApiDto>(api);
if (methods.TryGetValue(dto.Id, out var concreteMethods))
{
dto.Methods = concreteMethods;
}
listOfDto.Add(dto);
}
var paginationDto = new SimplePaginationDto <ApiDto>(listOfDto, page, size, paginationData.Item2, filter);
result = ApiResult.SucceedResult <SimplePaginationDto <ApiDto> >(paginationDto);
}
catch (Exception e)
{
result = ApiResult.ErrorResult("Api fetching error 1", $"{e.Message} - {e.InnerException} - {e.StackTrace}");
}
return(JsonConvert.SerializeObject(result));
}
public override void OnException(ExceptionContext context)
{
context.ExceptionHandled = true;
context.Result = new ObjectResult(ApiResult.ErrorResult(context.Exception.Message))
{
StatusCode = context.Exception is ApiServiceException || context.Exception is InvalidOperationException ? 400 : 500
};
}
public ApiResult GetErrorResultFromModelState(ModelStateDictionary modelState)
{
IEnumerable <ApiError> errors = modelState.Values
.SelectMany(s => s.Errors)
.Select(e => new ApiError {
Message = e.ErrorMessage
});
return(ApiResult.ErrorResult(errors));
}
public virtual ApiResult GetErrorResultFromModelState(ModelStateDictionary modelState)
{
modelState.CheckArgumentNull(nameof(modelState));
IEnumerable <ApiError> errors = modelState.Values
.SelectMany(s => s.Errors)
.Select(e => new ApiError {
Message = e.ErrorMessage
});
return(ApiResult.ErrorResult(errors));
}
public async Task <string> Add10Apis()
{
ApiResult result;
var apis = new List <Api>();
try
{
foreach (var index in Enumerable.Range(1, 11))
{
var api = new Api();
var random = new Random();
var temp = random.Next(0, 999);
api.Id = Guid.NewGuid();
var isOdd = temp % 2 == 0;
var partOfName = isOdd ? "Odd api, by crazy maniacs." : "Vovel api, beauty is here!";
api.Name = $"{index} Api. {partOfName}";
if (isOdd)
{
api.IsFree = true;
}
else
{
api.IsFree = false;
api.AccessCost = random.Next(1, 10000);
if (temp % 8 == 0)
{
api.MonthlyCost = random.Next(1, 10000);
}
}
api.License = $"APACHIK {index}.0";
api.AdditionalAccessRules = "do nothing";
api.Description = StringHelper.RandomString(random.Next(25, 1589));
await _context.Apis.AddAsync(api);
await _context.SaveChangesAsync();
apis.Add(api);
}
result = ApiResult.SucceedResult <List <Api> >(apis);
}
catch (Exception e)
{
result = ApiResult.ErrorResult("Api creation error 2", $"{e.Message} - {e.InnerException} - {e.StackTrace}");
}
return(JsonConvert.SerializeObject(result));
}
/// <summary>
/// 通过Post调用
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="apiName"></param>
/// <param name="form"></param>
/// <returns></returns>
public ApiResult <TResult> Post <TResult>(string apiName, string form)
where TResult : IApiResultData
{
var req = CreateRequest(apiName, "POST", form);
LogRecorder.MonitorTrace("Form:" + form);
try
{
}
catch (Exception e)
{
LogRecorder.Exception(e);
LogRecorder.EndStepMonitor();
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError));
}
return(GetResult <TResult>(req));
}
public override void OnActionExecuting(ActionExecutingContext context)
{
base.OnActionExecuting(context);
Type entityType = EntityType ?? GetEntityTypeFromContext(context);
string idStr = (string)context.RouteData.Values["id"];
if (entityType != null && !string.IsNullOrEmpty(idStr))
{
Guid id = new Guid(idStr);
Type repositoryType = typeof(IRepository <>).MakeGenericType(entityType);
object repository =
context.HttpContext.RequestServices.GetService(repositoryType);
IQueryable <IIdentifiable> entities = GetEntitiesFromRepository(repositoryType, repository);
if (!entities.Any(entity => entity.Id == id))
{
context.Result = new NotFoundObjectResult(ApiResult.ErrorResult(new ApiError {
Message = "Not found"
}));
}
}
}
public async Task <string> Delete(Guid id)
{
ApiResult result;
try
{
var api = await _context.Apis.FindAsync(id);
_context.Remove(api);
await _context.SaveChangesAsync();
var keyValue = new Dictionary <string, Guid> {
{ "deletedId", id }
};
result = ApiResult.SucceedResult <Dictionary <string, Guid> >(keyValue);
}
catch (Exception e)
{
result = ApiResult.ErrorResult("Api deleting error", $"{e.Message} - {e.InnerException} - {e.StackTrace}");
}
return(JsonConvert.SerializeObject(result));
}
public override void OnActionExecuting(ActionExecutingContext context)
{
base.OnActionExecuting(context);
Type entityType = EntityType ?? GetEntityTypeFromContext(context);
string idStr = (string)context.RouteData.Values["id"];
if (entityType != null && !string.IsNullOrEmpty(idStr))
{
Guid id = new Guid(idStr);
Type repositoryType = typeof(IRepository <>).MakeGenericType(entityType);
PropertyInfo entitiesProperty = repositoryType.GetProperty("Entities");
object repository =
context.HttpContext.RequestServices.GetService(repositoryType);
IQueryable <BaseEntity> entities = (IQueryable <BaseEntity>)entitiesProperty.GetValue(repository);
if (!entities.Any(entity => entity.Id == id))
{
context.Result = new JsonResult(ApiResult.ErrorResult(new ApiError {
Message = "Not found"
}));
context.HttpContext.Response.StatusCode = 404;
}
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMediatR(Assembly.GetExecutingAssembly(), typeof(IIndexingQueue).Assembly);
services.AddSignalR();
services.AddCoreServices();
services.AddEsDocumentStorage();
services.AddAuthentication(
opt =>
{
opt.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
opt.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(opt =>
{
opt.RequireHttpsMetadata = false;
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidIssuer = JwtAuthOptions.Issuer,
ValidateAudience = true,
ValidAudience = JwtAuthOptions.Audience,
ValidateLifetime = true,
IssuerSigningKey = JwtAuthOptions.SigningKey,
ValidateIssuerSigningKey = true
};
opt.Events = new JwtBearerEvents
{
OnMessageReceived = context =>
{
var accessToken = context.Request.Query["access_token"];
var path = context.HttpContext.Request.Path;
if (!string.IsNullOrEmpty(accessToken) && path.StartsWithSegments("/signalr"))
{
context.Token = accessToken;
}
return(Task.CompletedTask);
}
};
});
services
.AddMvc(opt =>
{
opt.EnableEndpointRouting = false;
opt.Filters.Add(new ApiExceptionFilterAttribute());
opt.ModelBinderProviders.Insert(0, new ObjectsModelBinderProvider());
})
.SetCompatibilityVersion(CompatibilityVersion.Version_3_0)
.ConfigureApiBehaviorOptions(opt =>
{
opt.InvalidModelStateResponseFactory = context => new BadRequestObjectResult(
ApiResult.ErrorResult(context.ModelState.Where(x => x.Value.Errors.Any()).Select(x => x.Value.Errors.First().ErrorMessage).ToArray()));
});
services.AddHostedService <TempContentBackgroundService>();
services.AddScoped <ITempContentStorage, TempContentStorage>();
services.AddScoped <IUserService, UserService>();
services.AddSingleton <DocumentIdentityModelBinder>();
services.AddSingleton <FolderIdentityModelBinder>();
services.AddSingleton <IContentTypeProvider, FileExtensionContentTypeProvider>();
services.Configure <CoreOptions>(Configuration);
services.Configure <IndexingQueueOptions>(Configuration.GetSection("indexingQueue"));
services.Configure <ContentStorageOptions>(Configuration.GetSection("contentStorage"));
services.Configure <TempContentStorageOptions>(Configuration.GetSection("tempContentStorage"));
services.Configure <DocumentStorageOptions>(Configuration.GetSection("documentStorage"));
}
public ApiResult GetErrorResultFromException(Exception exception)
{
return(ApiResult.ErrorResult(new[] { GetApiErrorFromException(exception) }));
}
/// <summary>
/// 取返回值
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="req"></param>
/// <returns></returns>
public ApiResult <TResult> GetResult <TResult>(HttpWebRequest req)
where TResult : IApiResultData
{
string jsonResult;
try
{
using (var response = req.GetResponse())
{
var receivedStream = response.GetResponseStream();
if (receivedStream != null)
{
var streamReader = new StreamReader(receivedStream);
jsonResult = streamReader.ReadToEnd();
receivedStream.Dispose();
}
else
{
LogRecorder.EndStepMonitor();
return(ApiResult <TResult> .ErrorResult(ErrorCode.UnknowError, "服务器无返回值"));
}
response.Close();
}
}
catch (WebException e)
{
if (e.Status != WebExceptionStatus.ProtocolError)
{
LogRecorder.EndStepMonitor();
switch (e.Status)
{
case WebExceptionStatus.CacheEntryNotFound:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "找不到指定的缓存项"));
case WebExceptionStatus.ConnectFailure:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "在传输级别无法联系远程服务点"));
case WebExceptionStatus.ConnectionClosed:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "过早关闭连接"));
case WebExceptionStatus.KeepAliveFailure:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "指定保持活动状态的标头的请求的连接意外关闭"));
case WebExceptionStatus.MessageLengthLimitExceeded:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError,
"已收到一条消息的发送请求时超出指定的限制或从服务器接收响应"));
case WebExceptionStatus.NameResolutionFailure:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "名称解析程序服务或无法解析主机名"));
case WebExceptionStatus.Pending:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "内部异步请求处于挂起状态"));
case WebExceptionStatus.PipelineFailure:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "该请求是管线请求和连接被关闭之前收到响应"));
case WebExceptionStatus.ProxyNameResolutionFailure:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "名称解析程序服务无法解析代理服务器主机名"));
case WebExceptionStatus.ReceiveFailure:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "从远程服务器未收到完整的响应"));
case WebExceptionStatus.RequestCanceled:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "请求已取消"));
case WebExceptionStatus.RequestProhibitedByCachePolicy:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "缓存策略不允许该请求"));
case WebExceptionStatus.RequestProhibitedByProxy:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "由该代理不允许此请求"));
case WebExceptionStatus.SecureChannelFailure:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "使用 SSL 建立连接时出错"));
case WebExceptionStatus.SendFailure:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "无法与远程服务器发送一个完整的请求"));
case WebExceptionStatus.ServerProtocolViolation:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "服务器响应不是有效的 HTTP 响应"));
case WebExceptionStatus.Timeout:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "请求的超时期限内未不收到任何响应"));
case WebExceptionStatus.TrustFailure:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "无法验证服务器证书"));
default:
//case WebExceptionStatus.UnknownError:
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError, "发生未知类型的异常"));
}
}
using (var response = e.Response)
{
var receivedStream = response.GetResponseStream();
if (receivedStream != null)
{
var streamReader = new StreamReader(receivedStream);
jsonResult = streamReader.ReadToEnd();
receivedStream.Dispose();
}
else
{
LogRecorder.EndStepMonitor();
return(ApiResult <TResult> .ErrorResult(ErrorCode.UnknowError, "服务器无返回值"));
}
response.Close();
}
}
catch (Exception e)
{
LogRecorder.Exception(e);
LogRecorder.EndStepMonitor();
return(ApiResult <TResult> .ErrorResult(ErrorCode.NetworkError));
}
LogRecorder.MonitorTrace(jsonResult);
try
{
if (string.IsNullOrWhiteSpace(jsonResult))
{
return(ApiResult <TResult> .ErrorResult(ErrorCode.UnknowError));
}
return(JsonConvert.DeserializeObject <ApiResult <TResult> >(jsonResult));
}
catch (Exception e)
{
LogRecorder.Exception(e);
return(ApiResult <TResult> .ErrorResult(ErrorCode.UnknowError));
}
finally
{
LogRecorder.EndStepMonitor();
}
}
public virtual ApiResult GetErrorResultFromException(Exception exception)
{
exception.CheckArgumentNull(nameof(exception));
return(ApiResult.ErrorResult(GetApiErrorFromException(exception)));
}
