/// <summary>
/// 修改模板（先删除新增）
/// </summary>
/// <param name="templateName">模板名称名称</param>
/// <returns></returns>
public async Task <HttpResponseResultModel <bool> > PutTemplateAsync <T>(string templateName) where T : class, new()
{
HttpResponseResultModel <bool> httpResponseResultModel = new HttpResponseResultModel <bool>();
Init <T>();
client = new ElasticSearchConfiguration(PocoAlias).GetClient();
var indexTemplateResponse = await client.Indices.TemplateExistsAsync(templateName);
if (indexTemplateResponse.Exists)
{
httpResponseResultModel = await DeleteTemplateAsync(templateName);
if (httpResponseResultModel.IsSuccess)
{
var indexSettings = new ESIndexSettingsModel();
httpResponseResultModel = await CreateTemplateAsync <T>(indexSettings);
}
}
else
{
httpResponseResultModel.IsSuccess = false;
httpResponseResultModel.ErrorMessage = "模板不存在";
}
return(httpResponseResultModel);
}
/// <summary>
/// 创建模板
/// </summary>
/// <typeparam name="T">索引实体</typeparam>
/// <param name="indexSettings"></param>
/// <returns></returns>
public async Task <HttpResponseResultModel <bool> > CreateTemplateAsync <T>(ESIndexSettingsModel indexSettings = null) where T : class, new()
{
HttpResponseResultModel <bool> httpResponseResultModel = new HttpResponseResultModel <bool>();
Init <T>();
if (indexSettings == null)
{
indexSettings = new ESIndexSettingsModel();
}
#region 创建模板
var index_patterns = PocoData.DefaultIndexName.ToLower();
int numberOfReplicas = indexSettings.NumberOfReplicas;
int numberOfShards = indexSettings.NumberOfShards;
TimeSpan refreshInterval = new TimeSpan(0, 0, 0, indexSettings.RefreshInterval);
string templateName = PocoTemplate;
//设置模板
//.Setting("index.lifecycle.name", "my_policy")
// await _client.IndexLifecycleManagement.PutLifecycleAsync("w", t => t.Policy(p => p.Phases(p1 => p1.Warm(w => w.MinimumAge("60d")))));
var templateResponse = await client.Indices.PutTemplateAsync(templateName, template => template.Create(true).Map(m => m.AutoMap <T>()).IncludeTypeName(false)
.Settings(setting => setting.NumberOfReplicas(numberOfReplicas).NumberOfShards(numberOfShards).RefreshInterval(refreshInterval))
.Aliases(a => a.Alias(PocoAlias))
.IndexPatterns(index_patterns + "_*")
.IncludeTypeName(false)
);
bool isTemplateExist = templateResponse.Acknowledged;
httpResponseResultModel.IsSuccess = isTemplateExist;
if (!isTemplateExist)
{
httpResponseResultModel.ErrorMessage = "创建模板失败";
}
return(httpResponseResultModel);
#endregion
}
/// <summary>
/// 控制器中的操作执行之前调用此方法
/// </summary>
/// <param name="actionContext"></param>
public override void OnActionExecuting(ActionExecutingContext actionContext)
{
var modelState = actionContext.ModelState;
if (!modelState.IsValid)
{
string error = string.Empty;
foreach (var key in modelState.Keys)
{
var state = modelState[key];
if (state.Errors.Any())
{
var errorInfo = state.Errors.First();
string ex = (errorInfo.Exception == null ? "" : errorInfo.Exception.ToString());
error = string.IsNullOrEmpty(errorInfo.ErrorMessage) ? ex : errorInfo.ErrorMessage;
break;
}
}
HttpResponseResultModel <string> response = new HttpResponseResultModel <string>()
{
IsSuccess = false, ErrorMessage = error, HttpStatusCode = HttpStatusCode.BadRequest
};
actionContext.Result = new JsonResult(response);
}
}
/// <summary>
/// 控制器中的操作异常调用此方法
/// </summary>
/// <param name="actionExecutedContext"></param>
/// <returns></returns>
public override Task OnExceptionAsync(ExceptionContext actionExecutedContext)
{
if (actionExecutedContext.Exception != null)
{
WriteErrorAsync(actionExecutedContext);
}
if (actionExecutedContext.Exception is NotImplementedException)
{
actionExecutedContext.HttpContext.Response.StatusCode = (int)HttpStatusCode.NotImplemented;
}
else if (actionExecutedContext.Exception is TimeoutException)
{
actionExecutedContext.HttpContext.Response.StatusCode = (int)HttpStatusCode.RequestTimeout;
}
else
{
HttpResponseResultModel <string> result = new HttpResponseResultModel <string>();
result.HttpStatusCode = HttpStatusCode.InternalServerError;
result.IsSuccess = false;
result.ErrorMessage = "出现异常,请稍后重试";
result.ExceptionMessage = actionExecutedContext.Exception.ToString();
actionExecutedContext.HttpContext.Response.StatusCode = (int)result.HttpStatusCode;
actionExecutedContext.Result = new ObjectResult(result);
}
return(base.OnExceptionAsync(actionExecutedContext));
}
/// <summary>
/// 删除索引文件((默认创建ElasticsearchIndex特性上对应的索引)
/// </summary>
/// <param name="indexName">索引名</param>
/// <returns></returns>
public async Task <HttpResponseResultModel <bool> > DeleteIndexFileAsync(string indexName = "")
{
HttpResponseResultModel <bool> httpResponseResultModel = new HttpResponseResultModel <bool>();
var isSuccess = await indexFileRepository.DeleteIndexFileAsync(indexName).ConfigureAwait(false);
httpResponseResultModel.BackResult = isSuccess;
httpResponseResultModel.IsSuccess = isSuccess;
return(httpResponseResultModel);
}
/// <summary>
/// 创建索引文件((默认创建ElasticsearchIndex特性上对应的索引)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="indexName"></param>
/// <param name="indexSettings"></param>
/// <returns></returns>
public async Task <HttpResponseResultModel <bool> > CreateIndexFileAsync <T>(string indexName = "", ESIndexSettingsModel indexSettings = null) where T : class, new()
{
HttpResponseResultModel <bool> httpResponseResultModel = new HttpResponseResultModel <bool>();
Init <T>();
if (string.IsNullOrEmpty(indexName))
{
indexName = PocoIndexName;
}
if (indexSettings == null)
{
indexSettings = new ESIndexSettingsModel();
}
IIndexState indexState = new IndexState()
{
Settings = new IndexSettings()
{
NumberOfShards = indexSettings.NumberOfShards, //分片数,
NumberOfReplicas = indexSettings.NumberOfReplicas, //副本数
}
};
bool isIndexExists = client.Indices.Exists(indexName.ToLower()).Exists;
if (!isIndexExists)
{
var isExistTemplateResponse = await client.Indices.TemplateExistsAsync(PocoTemplate);
if (isExistTemplateResponse.Exists)
{
//创建并Mapping
var result = await client.Indices.CreateAsync(indexName.ToLower(), p => p.InitializeUsing(indexState)
.Map(mp => mp.AutoMap())
.IncludeTypeName(false)
.Aliases(a => a.Alias(PocoAlias))
).ConfigureAwait(false);
//a => a.Add(add => add.Index(indexName.ToLower()).Alias(PocoAlias).IndexRouting(indexName.ToLower()))
var aliasResult = await client.Indices.PutAliasAsync(indexName.ToLower(), PocoAlias, t => t.IndexRouting(indexName.ToLower()));
bool isSuccess = result.Acknowledged && aliasResult.IsValid;
httpResponseResultModel.IsSuccess = isSuccess;
return(httpResponseResultModel);
}
httpResponseResultModel.ErrorMessage = "没有模板请先创建模板";
return(httpResponseResultModel);
}
else
{
httpResponseResultModel.ErrorMessage = "索引已存在";
return(httpResponseResultModel);
}
}
/// <summary>
/// 新增单条索引记录
/// </summary>
/// <param name="entity"></param>
/// <param name="routing"></param>
/// <returns></returns>
public async Task <HttpResponseResultModel <bool> > IndexAsync <T>(InsertUpdateModel <T> insertUpdateModel) where T : class, new()
{
HttpResponseResultModel <bool> httpResponseResultModel = new HttpResponseResultModel <bool>();
string indexName = insertUpdateModel.IndexName?.ToLower();
if (string.IsNullOrEmpty(indexName))
{
indexName = PocoIndexName;
}
IndexRequest <T> indexRequest = new IndexRequest <T>(insertUpdateModel.Entity, indexName);
if (!string.IsNullOrEmpty(insertUpdateModel.Routing))
{
indexRequest.Routing = insertUpdateModel.Routing;
}
var result = await client.IndexAsync(indexRequest).ConfigureAwait(false);
GetDebugInfo(result);
httpResponseResultModel.IsSuccess = result.IsValid;
return(httpResponseResultModel);
}
/// <summary>
/// 批量索引
/// </summary>
/// <param name="entities">实体集合</param>
/// <param name="routing">路由键</param>
/// <returns></returns>
public async Task <HttpResponseResultModel <bool> > IndexBatchAsync <T>(InsertUpdateModel <IList <T> > insertUpdateModel) where T : class, new()
{
HttpResponseResultModel <bool> httpResponseResultModel = new HttpResponseResultModel <bool>();
string indexName = insertUpdateModel.IndexName?.ToLower();
if (string.IsNullOrEmpty(indexName))
{
indexName = PocoIndexName;
}
BulkDescriptor bulkDescriptor = new BulkDescriptor();
bulkDescriptor.IndexMany(insertUpdateModel.Entity);
bulkDescriptor.Index(indexName);
if (!string.IsNullOrEmpty(insertUpdateModel.Routing))
{
bulkDescriptor.Routing(new Routing(insertUpdateModel.Routing));
}
var result = await client.BulkAsync(bulkDescriptor).ConfigureAwait(false);
GetDebugInfo(result);
//if (result.Errors || !result.ItemsWithErrors.IsNullOrEmpty())
//{
// Task.Run(() =>
// {
// var json = JsonHelper.SerializeObject(insertUpdateModel.Entity);
// WriteLog.WriteLogsAsync(json, "batchError");
// });
//}
var isSuccess = result.ItemsWithErrors.IsListNullOrEmpty();
string errorMessage = "";
if (!isSuccess)
{
var errorIdList = result.ItemsWithErrors.Select(t => t.Id);
errorMessage = string.Join(",", errorIdList);
}
httpResponseResultModel.IsSuccess = isSuccess;
httpResponseResultModel.ErrorMessage = errorMessage;
return(httpResponseResultModel);
}
/// <summary>
/// 删除单条索引
/// </summary>
/// <param name="id">主键id</param>
/// <param name="routing">路由键</param>
/// <returns></returns>
public async Task <HttpResponseResultModel <bool> > DeleteAsync <TPrimaryKeyType>(DeleteSingleModel <TPrimaryKeyType> deleteSingleModel)
{
HttpResponseResultModel <bool> httpResponseResultModel = new HttpResponseResultModel <bool>();
string indexName = deleteSingleModel.IndexName?.ToLower();
if (string.IsNullOrEmpty(indexName))
{
indexName = PocoIndexName;
}
DeleteRequest deleteRequest = new DeleteRequest(indexName, deleteSingleModel.Id.ToString());
if (!string.IsNullOrEmpty(deleteSingleModel.Routing))
{
deleteRequest.Routing = deleteSingleModel.Routing;
}
var result = await client.DeleteAsync(deleteRequest).ConfigureAwait(false);
GetDebugInfo(result);
httpResponseResultModel.IsSuccess = (result.Result == Result.Deleted);
return(httpResponseResultModel);
}
/// <summary>
/// 根据id更新部分实体字段
/// </summary>
/// <typeparam name="TPartialDocument">包含实体T中部分字段的是model</typeparam>
/// <param name="id">主键</param>
/// <param name="partEntity">部分实体model</param>
/// <param name="routing">路由键</param>
/// <returns></returns>
public async Task <HttpResponseResultModel <bool> > UpdatePartialDocumentAsync <TPartialDocument, TPrimaryKeyType>(TPrimaryKeyType id, InsertUpdateModel <TPartialDocument> insertUpdateModel) where TPartialDocument : class, new()
{
HttpResponseResultModel <bool> httpResponseResultModel = new HttpResponseResultModel <bool>();
string indexName = insertUpdateModel.IndexName?.ToLower();
if (string.IsNullOrEmpty(indexName))
{
indexName = PocoIndexName;
}
UpdateDescriptor <TEntity, TPartialDocument> updRequest = new UpdateDescriptor <TEntity, TPartialDocument>(indexName, id.ToString());
updRequest.Doc(insertUpdateModel.Entity);
updRequest.Index(indexName);
if (!string.IsNullOrEmpty(insertUpdateModel.Routing))
{
updRequest.Routing(insertUpdateModel.Routing);
}
var response = await client.UpdateAsync <TEntity, TPartialDocument>(updRequest).ConfigureAwait(false);
GetDebugInfo(response);
httpResponseResultModel.IsSuccess = (response.Result == Result.Updated);
return(httpResponseResultModel);
}
/// <summary>
/// 删除模板
/// </summary>
/// <param name="templateName">模板名称名称</param>
/// <returns></returns>
public async Task <HttpResponseResultModel <bool> > DeleteTemplateAsync(string templateName)
{
HttpResponseResultModel <bool> httpResponseResultModel = new HttpResponseResultModel <bool>();
var indexTemplateResponse = await client.Indices.TemplateExistsAsync(templateName);
if (indexTemplateResponse.Exists)
{
//删除模板
var templateResponse = await client.Indices.DeleteTemplateAsync(templateName);
var isTemplateExist = templateResponse.Acknowledged;
httpResponseResultModel.IsSuccess = isTemplateExist;
if (!isTemplateExist)
{
httpResponseResultModel.ErrorMessage = "删除模板失败";
}
}
else
{
httpResponseResultModel.IsSuccess = true;
httpResponseResultModel.ErrorMessage = "模板不存在";
}
return(httpResponseResultModel);
}
/// <summary>
/// 批量删除索引
/// </summary>
/// <typeparam name="TPrimaryKeyType"></typeparam>
/// <param name="ids"></param>
/// <param name="routing"></param>
/// <returns></returns>
public async Task <HttpResponseResultModel <bool> > DeleteBatchAsync <TPrimaryKeyType>(DeleteBatchModel <TPrimaryKeyType> deleteBatchModel)
{
HttpResponseResultModel <bool> httpResponseResultModel = new HttpResponseResultModel <bool>();
string indexName = deleteBatchModel.IndexName?.ToLower();
if (string.IsNullOrEmpty(indexName))
{
indexName = PocoIndexName;
}
BulkDescriptor bulkDescriptor = new BulkDescriptor();
foreach (var id in deleteBatchModel.IdList)
{
bulkDescriptor.AddOperation(new BulkDeleteOperation <TEntity>(id.ToString()));
}
bulkDescriptor.Index(indexName);
if (!string.IsNullOrEmpty(deleteBatchModel.Routing))
{
bulkDescriptor.Routing(new Routing(deleteBatchModel.Routing));
}
var result = await client.BulkAsync(bulkDescriptor).ConfigureAwait(false);
GetDebugInfo(result);
var isSuccess = result.ItemsWithErrors.IsListNullOrEmpty();
httpResponseResultModel.IsSuccess = isSuccess;
string errorMessage = "";
if (!isSuccess)
{
var errorIdList = result.ItemsWithErrors.Select(t => t.Id);
errorMessage = string.Join(",", errorIdList);
}
httpResponseResultModel.ErrorMessage = errorMessage;
return(httpResponseResultModel);
}
