public async Task AddOrUpdateAsync(Document document, CancellationToken cancellationToken = default) { ValidateElasticSearchEnabled(); var client = _clientProvider.GetClient(); var existsResponse = await client.DocumentExistsAsync(DocumentPath <EsDocument> .Id(document.Id), x => x.Index(_options.IndexName), cancellationToken); HandleError(existsResponse); var esDocument = new EsDocument { Id = document.Id, ProjectId = document.ProjectId, Name = document.Name, FileName = document.FileName, Content = document.Content, LanguageCode = ConvertLanguageCode(document.LanguageCode), Version = ConvertVersion(document.Version) }; if (!existsResponse.Exists) { HandleError(await client.IndexAsync(esDocument, x => x.Id(document.Id).Index(_options.IndexName), cancellationToken)); } else { HandleError(await client.UpdateAsync(DocumentPath <EsDocument> .Id(document.Id), x => x.Doc(esDocument).Index(_options.IndexName), cancellationToken)); } }
public async Task <TEntity> FindAsync(Guid id) { var nestId = (id as Guid?).Value; var response = await ElasticClient.GetAsync(DocumentPath <TEntity> .Id(nestId).Index(IndexName)); return(response.Source); }
public async Task <bool> UpdateData(NewYorkUpdateDtos newYorkUpdateDtos, int id) { ISearchResponse <NewYork> searchResponse = await Exists(id); if (searchResponse != null) { var newYork = searchResponse.Documents.FirstOrDefault(); var updateResponse = await _client.UpdateAsync <NewYorkUpdateDtos>( DocumentPath <NewYorkUpdateDtos> .Id(searchResponse.Hits.FirstOrDefault().Id), descriptor => descriptor .RetryOnConflict(3) .Doc(newYorkUpdateDtos) .Refresh(Refresh.True) ); if (updateResponse.IsValid) { return(true); } return(false); } return(false); }
public async Task <bool> AddManyBulk(List <NewYorkAddDtos> newYorkList) { List <NewYorkAddDtos> tempList = new List <NewYorkAddDtos>(); foreach (var newYork in newYorkList) { ISearchResponse <NewYork> searchResponse = await Exists(newYork.id); if (searchResponse != null) { var updateResponse = await _client.UpdateAsync <NewYorkAddDtos>( DocumentPath <NewYorkAddDtos> .Id(searchResponse.Hits.FirstOrDefault().Id), descriptor => descriptor .RetryOnConflict(3) .Doc(newYork) .Refresh(Refresh.True) ); } else { tempList.Add(newYork); } } if (tempList.Count > 0) { var indexManyAsyncResponse = await _client.IndexManyAsync(tempList); return(indexManyAsyncResponse.IsValid); } else { return(true); } }
public async Task <LogModel <T> > GetByIdNest <T>(object id) where T : class, ICloneable { try { if (string.IsNullOrEmpty(collectionName)) { collectionName = typeof(T).Name.ToLower(); } var p = new DocumentPath <LogModel <T> >(new Id(id)); var response = await elasticsearchClient.SearchAsync <LogModel <T> >(s => s.Size(1) .Query(q => q.Match(m => m.Field(f => f.ObjectId) .Query(id.ToString() )) ) ); return(response.Documents.FirstOrDefault()); } catch (Exception ex) { Debug.WriteLine(ex); return(null); } }
public long GetVersion <T>(string indexName, int id) where T : class { DocumentPath <T> path = new DocumentPath <T>(id); var response = elasticClient.Get <T>(path, s => s.Index(indexName.ToLower())); return(response.Version); }
public async Task DeleteAsync <T>(string id) where T : class { await Client.DeleteAsync(DocumentPath <T> .Id(id), idx => idx.Index(PrefixIndex + "-" + typeof(T).Name.ToLower())); await Client.RefreshAsync(Indices.All); }
public static bool updateListUser(string ID, List <long> LstUserId, string Type) { if (EnableElasticServer.ToIntOrZero() == 1) { try { var result = ConnectionToES.EsClient().Get <ElasticModel>(Type + "_" + ID.ToString(), x => x.Index(ElasticIndex).Type(ElasticModel)); ElasticModel tmpModel = result.Source; if (LstUserId != null && LstUserId.Count > 0) { tmpModel.ListUser.AddRange(LstUserId); var response = ConnectionToES.EsClient().Update( DocumentPath <ElasticModel> .Id(Type + "_" + ID.ToString()), u => u.Index(ElasticIndex).Type(ElasticModel).Doc(tmpModel) ); return(true); } return(false); } catch (Exception ex) { return(false); } } return(false); }
public async Task DeleteAsync(Guid id, CancellationToken cancellationToken = default) { ValidateElasticSearchEnabled(); HandleError(await _clientProvider.GetClient() .DeleteAsync(DocumentPath <Document> .Id(id), x => x.Index(_options.IndexName), cancellationToken)); }
public bool Edit(MainRCJournalInfo mainRCJournalInfo) { DocumentPath <MainRCJournalInfo> deletePath = new DocumentPath <MainRCJournalInfo>(mainRCJournalInfo.ID); var result = _iService.EditEntityWidthScope(mainRCJournalInfo, deletePath); return(result); }
private async Task <Response> DeleteEntityFromPathAsync <TEntity>(DocumentPath <TEntity> documentPath) where TEntity : class { var result = new Response(); var indexName = ElasticSearchExtensions.GetIndexNameFrom <TEntity>(); var existsResponse = await _elasticClient.Indices.ExistsAsync(indexName) .ConfigureAwait(false); if (!existsResponse.Exists) { throw new InvalidOperationException($"Index {indexName} does not exist"); } var documentExistsResponse = await _elasticClient.DocumentExistsAsync(documentPath, d => d.Index(indexName)) .ConfigureAwait(false); if (!documentExistsResponse.Exists) { return(result); } var deleteResponse = await _elasticClient.DeleteAsync(documentPath, d => d.Index(indexName)) .ConfigureAwait(false); if (deleteResponse.IsValid) { return(result); } result.IsOk = false; result.ErrorMessage = deleteResponse.OriginalException.Message; result.Exception = deleteResponse.OriginalException; return(result); }
public async Task <DocumentResponse <TEntity> > GetEntityByIdAsync <TEntity>(Id id) where TEntity : class { var result = new DocumentResponse <TEntity>(); var indexName = ElasticSearchExtensions.GetIndexNameFrom <TEntity>(); var indexExistsResponse = await _elasticClient.Indices.ExistsAsync(indexName) .ConfigureAwait(false); if (!indexExistsResponse.Exists) { result.IsOk = false; result.ErrorMessage = $"Index {indexName} does not exist"; return(result); } var documentPath = DocumentPath <TEntity> .Id(id); var getResponse = await _elasticClient.GetAsync(documentPath, descriptor => descriptor.Index(indexName)) .ConfigureAwait(false); if (!getResponse.IsValid) { result.IsOk = false; result.ErrorMessage = getResponse.OriginalException.Message; result.Exception = getResponse.OriginalException; return(result); } result.DocumentResult = getResponse; return(result); }
public void VersionLock(string indexName) { //查询到版本号 var result = _client.Search <TestModel2>( s => s.Index(indexName) .Query(q => q.Term(tm => tm.Field(fd => fd.State).Value(1))).Size(1) .Version() //结果中包含版本号 ); foreach (var s in result.Hits) { Console.WriteLine(s.Id + " - " + s.Version); } var path = new DocumentPath <TestModel2>(1); //更新时带上版本号 如果服务端版本号与传入的版本好相同才能更新成功 var response = _client.Update(path, (p) => p .Index(indexName) .Type(typeof(TestModel2)) .Version(2)//限制es中版本号为2时才能成功 .Doc(new TestModel2() { Name = "测测测" + DateTime.Now }) ); }
//** if you have an instance of your document you can use it as well generate document paths */ [U] public void FromObject() { var project = new Project { Name = "hello-world" }; /** here we create a new document path based on a Project */ IDocumentPath path = new DocumentPath<Project>(project); Expect("project").WhenSerializing(path.Index); Expect("project").WhenSerializing(path.Type); Expect("hello-world").WhenSerializing(path.Id); /** You can still override the inferred index and type name*/ path = new DocumentPath<Project>(project).Type("project1"); Expect("project1").WhenSerializing(path.Type); path = new DocumentPath<Project>(project).Index("project1"); Expect("project1").WhenSerializing(path.Index); /** there is also a static way to describe such paths */ path = DocumentPath<Project>.Id(project); Expect("project").WhenSerializing(path.Index); Expect("project").WhenSerializing(path.Type); Expect("hello-world").WhenSerializing(path.Id); DocumentPath<Project> p = project; }
[U] public void Null() { var value = new DocumentPath <Project>(2); (value == null).Should().BeFalse(); (null == value).Should().BeFalse(); }
public virtual async Task AddOrUpdateAsync <T, TKey>(string indexName, T model) where T : ElasticEntity <TKey> { var exis = ElasticSearchClient.DocumentExists(DocumentPath <T> .Id(new Id(model)), dd => dd.Index(indexName)); if (exis.Exists) { var result = await ElasticSearchClient.UpdateAsync(DocumentPath <T> .Id(new Id(model)), ss => ss.Index(indexName).Doc(model).RetryOnConflict(3)); if (result.ServerError == null) { return; } throw new ElasticSearchException($"Update Document failed at index{indexName} :" + result.ServerError.Error.Reason); } else { var result = await ElasticSearchClient.IndexAsync(model, ss => ss.Index(indexName)); if (result.ServerError == null) { return; } throw new ElasticSearchException($"Insert Document failed at index {indexName} :" + result.ServerError.Error.Reason); } }
public bool Delete(int id) { DocumentPath <MainRCJournalInfo> deletePath = new DocumentPath <MainRCJournalInfo>(id); bool result = _iService.DeleteRowById(deletePath); return(result); }
public ActionResult Edit(MainRCJournalInfo mainRCJournalInfo) { DocumentPath <MainRCJournalInfo> deletePath = new DocumentPath <MainRCJournalInfo>(mainRCJournalInfo.ID); var result = _iService.EditEntityWidthScope(mainRCJournalInfo, deletePath); return(Json(new { result = result })); }
public static void HowToScrollIndex(IElasticClient client) { var res = client.Search <ProductListEsIndexModelExample>(s => s .From(0) .Size(1) .MatchAll() .Scroll(new Time(TimeSpan.FromSeconds(4))) ); res.ThrowIfException(); if (!ValidateHelper.IsPlumpString(res.ScrollId)) { throw new Exception("未能拿到游标地址"); } while (true) { res = client.Scroll <ProductListEsIndexModelExample>("4s", res.ScrollId); if (!res.Documents.Any()) { break; } foreach (var doc in res.Documents) { //do something client.Delete(new DeleteRequest("index", "typename", "ukey")); client.Delete(DocumentPath <ProductListEsIndexModelExample> .Id("ukey").Index("index")); } } }
public MsBuildItem(DocumentPath documentPath, string fullPath, string itemType, MsBuildProject project) { this.documentPath = documentPath; this.fullPath = fullPath; this.itemType = itemType; this.project = project; }
/// <summary> /// 保存 /// </summary> /// <typeparam name="T">实体类型</typeparam> /// <param name="indexName">索引名</param> /// <param name="entity">实体</param> /// <returns></returns> public virtual async Task SaveAsync <T>(string indexName, T entity) where T : class { var client = await GetClientAsync(); var exists = await client.DocumentExistsAsync(DocumentPath <T> .Id(new Id(entity)), dd => dd.Index(indexName)); if (exists.Exists) { var result = await client.UpdateAsync(DocumentPath <T> .Id(new Id(entity)), ss => ss.Index(indexName).Doc(entity).RetryOnConflict(3)); if (result.ServerError == null) { return; } throw new ElasticSearchException($"更新文档在索引 {indexName} 失败:{result.ServerError.Error.Reason}"); } else { var result = await client.IndexAsync <T>(entity, ss => ss.Index(indexName)); if (result.ServerError == null) { return; } throw new ElasticSearchException($"插入文档在索引 {indexName} 失败:{result.ServerError.Error.Reason}"); } }
public virtual Task UpsertDocument <TDocument>(IUpsertDocumentContext <TDocument> context) where TDocument : class { var documentType = typeof(TDocument); var client = this._clientFactory.GetClient(); var documentPath = new DocumentPath <TDocument>(context.Id) .Type(documentType); var index = this.GetIndex(context.IndexContext); var updateDescriptor = new UpdateDescriptor <TDocument, dynamic>(documentPath) .Index(index); if (context.Script != null) { updateDescriptor.Script(d => d.Inline(context.Script) .Params(context.ScriptParams.ToDictionary(k => k.Key, v => v.Value))); } else { updateDescriptor.Upsert(context.Document) .Doc(context.PartialUpdate ?? context.Document); } var updateDocResponse = client.Update <TDocument, dynamic>(updateDescriptor); this._responseHandler.ValdateAndHandleException(updateDocResponse, true); return(Task.CompletedTask); }
public SourceResponse <TDocument> Source <TDocument>(DocumentPath <TDocument> id, Action <SourceRequestDescriptor <TDocument> > configureRequest = null) { var descriptor = new SourceRequestDescriptor <TDocument>(document: id.Document, index: id?.Self?.Index ?? typeof(TDocument), id: id?.Self?.Id ?? Id.From(id.Document)); configureRequest?.Invoke(descriptor); return(DoRequest <SourceRequestDescriptor <TDocument>, SourceResponse <TDocument> >(descriptor)); }
public void RemoveCodeFile(DocumentPath documentPath) { MsBuildProject container = null; MsBuildItem itemToRemove = null; foreach (var proj in this.Solution.Projects) { if (proj.Value.Name == documentPath.ProjectName) { foreach (var item in proj.Value.Items) { if (item.DocumentPath.Equals(documentPath) && this.msBuildStoreAdapters.Any(a => a.ItemSupported(item))) { container = proj.Value; itemToRemove = item; break; } } } } if (itemToRemove != null) { container.RemoveItem(itemToRemove); } }
///// <summary> ///// 更新部分字段 ///// </summary> ///// <returns></returns> //public bool UpdatePart(UpdateRequest<T, object> request) //{ // var response = client.Update(request); // return response.IsValid; //} ///// <summary> ///// 更新部分字段 ///// </summary> ///// <returns></returns> //public bool UpdatePartAsync(UpdateRequest<T, object> request) //{ // var response = client.UpdateAsync(request); // return response.Result.IsValid; //} /// <summary> /// 更新全部字段 /// </summary> /// <returns></returns> public bool Update(T t) { DocumentPath <T> updatePath = new DocumentPath <T>(t.Id); var response = client.Update(updatePath, (p) => p.Doc(t)); return(response.IsValid); }
public override string GetPath(TransformationData data) { if (isInternalOutput) { if (IsBookmark) { return("index.html#" + BookmarkName); } else { return("index.html#" + DocumentPathId(DocumentPath.ToLower())); } } var path = Path.Combine( FileHelper.GetRelativePath( Path.GetDirectoryName(data.Document.LocalPath), Path.GetDirectoryName(DocumentPath)), "index.html"); if (IsBookmark) { var bookmark = data.ProcessedDocumentCache.Get(DocumentPath).GetBookmark(BookmarkName); if (bookmark == null) { throw new EMPathVerificationException(Language.Message("BookmarkNotFound", BookmarkName)); } path += "#" + bookmark.UniqueKey; } return(Normalizer.NormalizePath(path)); }
public TestModel2 Get(string indexName, int id) { DocumentPath <TestModel2> path = new DocumentPath <TestModel2>(id); var response = _client.Get <TestModel2>(path, s => s.Index(indexName)); return(response.Source); }
public ActionResult Delete(int id) { DocumentPath <MainRCJournalInfo> deletePath = new DocumentPath <MainRCJournalInfo>(id); bool result = _iService.DeleteRowById(deletePath); return(Json(new { result = result })); }
public long GetVersion(string indexName, int id) { DocumentPath <TestModel2> path = new DocumentPath <TestModel2>(id); var response = _client.Get <TestModel2>(path, s => s.Index(indexName)); return(response.Version); }
//** if you have an instance of your document you can use it as well generate document paths */ [U] public void FromObject() { var project = new Project { Name = "hello-world" }; /** here we create a new document path based on a Project */ IDocumentPath path = new DocumentPath <Project>(project); Expect("project").WhenSerializing(path.Index); Expect("project").WhenSerializing(path.Type); Expect("hello-world").WhenSerializing(path.Id); /** You can still override the inferred index and type name*/ path = new DocumentPath <Project>(project).Type("project1"); Expect("project1").WhenSerializing(path.Type); path = new DocumentPath <Project>(project).Index("project1"); Expect("project1").WhenSerializing(path.Index); /** there is also a static way to describe such paths */ path = DocumentPath <Project> .Id(project); Expect("project").WhenSerializing(path.Index); Expect("project").WhenSerializing(path.Type); Expect("hello-world").WhenSerializing(path.Id); DocumentPath <Project> p = project; }
public Task <Response> DeleteEntityAsync <TEntity>(Id id) where TEntity : class { var documentPath = DocumentPath <TEntity> .Id(id); return(DeleteEntityFromPathAsync(documentPath)); }
/** # DocumentPaths * Many API's in elasticsearch describe a path to a document. In NEST besides generating a constructor that takes * and Index, Type and Id seperately we also generate a constructor taking a DocumentPath that allows you to describe the path * to your document more succintly */ /** Manually newing */ [U] public void FromId() { /** here we create a new document path based on Project with the id 1 */ IDocumentPath path = new DocumentPath<Project>(1); Expect("project").WhenSerializing(path.Index); Expect("project").WhenSerializing(path.Type); Expect(1).WhenSerializing(path.Id); /** You can still override the inferred index and type name*/ path = new DocumentPath<Project>(1).Type("project1"); Expect("project1").WhenSerializing(path.Type); path = new DocumentPath<Project>(1).Index("project1"); Expect("project1").WhenSerializing(path.Index); /** there is also a static way to describe such paths */ path = DocumentPath<Project>.Id(1); Expect("project").WhenSerializing(path.Index); Expect("project").WhenSerializing(path.Type); Expect(1).WhenSerializing(path.Id); }
public static string GetDocumentPath(DocumentPath.Module documentPath, string courseId, string scenarioId, AppEnum.ApplicationRole role, string userId, string customValue) { List<string> nodeList = new List<string>(); string currentUserRole = AppCommon.GetRoleDescription(role); if (documentPath == DocumentPath.Module.Masters) { nodeList.Add(GetMasterDocumentPath()); } else if (documentPath == DocumentPath.Module.Attachments) { nodeList.Add(GetAttachmentDocumentPath()); } else { nodeList.Add(GetBaseDocumentPath(courseId, currentUserRole)); } bool isAdminUser = IsAdmin(currentUserRole); if (isAdminUser) { } else { nodeList.Add(userId); nodeList.Add(AssignmentNode); nodeList.Add(scenarioId); } switch (documentPath) { case DocumentPath.Module.PatientVisitAppointment: case DocumentPath.Module.BlockAppointment: case DocumentPath.Module.OtherAppointment: case DocumentPath.Module.RecurrenceGroup: { if (isAdminUser) { } else { nodeList.Add(AppointmentNode); if (documentPath == DocumentPath.Module.RecurrenceGroup) { nodeList.Add("Recurrence"); nodeList.Add("{0}"); } else { nodeList.Add("Type"); switch (documentPath) { case DocumentPath.Module.PatientVisitAppointment: { nodeList.Add("PatientVisit"); break; } case DocumentPath.Module.OtherAppointment: { nodeList.Add("Other"); break; } case DocumentPath.Module.BlockAppointment: { nodeList.Add("Block"); break; } } nodeList.Add(customValue); nodeList.Add("{0}"); switch (customValue) { case AppConstants.CalendarMonthFilters: break; default: nodeList.Add("{1}"); nodeList.Add("{2}"); nodeList.Add("{3}"); AppEnum.ProviderType providerType = (!AppCommon.CheckIfStringIsEmptyOrNull(customValue) ? (AppEnum.ProviderType)Enum.Parse(typeof(AppEnum.ProviderType), customValue) : AppEnum.ProviderType.SingleProvider); if (providerType == AppEnum.ProviderType.SingleProvider) { nodeList.Add("{4}"); } break; } } } break; } case DocumentPath.Module.LCMFolders: { nodeList.Add("{0}");//Based on foldertype substitute with either QuestionBank,AssignmentRepository etc., nodeList.Add("SubFolders{1}"); break; } case DocumentPath.Module.Assignments: { if (isAdminUser) { switch (customValue) { case AppConstants.Create: { nodeList.Add(AdminAssignmentRepository + "{0}"); nodeList.Add(AssignmentNode); nodeList.Add("{1}"); break; } default: { nodeList.Add(AdminAssignmentRepository); break; } } } break; } case DocumentPath.Module.Patients: { switch (customValue) { case AppConstants.Read: { nodeList.Add(isAdminUser ? AdminPatientRepository : PatientsNode); break; } case AppConstants.Create: { if (isAdminUser) { nodeList.Add(AdminPatientRepository); } nodeList.Add(PatientsNode); nodeList.Add("{0}"); break; } default: { break; } } break; } case DocumentPath.Module.QuestionBank: { if (isAdminUser) { switch (customValue) { case AppConstants.Create: { nodeList.Add(AdminQuestionBank + "{0}"); nodeList.Add(QuestionItems); nodeList.Add("{1}"); break; } default: { nodeList.Add(AdminQuestionBank); break; } } } break; } case DocumentPath.Module.Attachments: { switch (customValue) { case AppConstants.TransientAttachment: { nodeList.Add(AppConstants.TransientAttachment); break; } default: { nodeList.Add(AppConstants.PersistentAttachment); break; } } nodeList.Add("{0}"); break; } case DocumentPath.Module.SkillSets: { if (isAdminUser) { switch (customValue) { case AppConstants.Create: nodeList.Add(AdminSkillsetRepository + "{0}");// {0} will be replaced with FOLDER text nodeList.Add(Skillsets); nodeList.Add("{1}"); // {1} will be replaces with NEW GUID value for each skillset break; default: nodeList.Add(AdminSkillsetRepository); break; } } break; } case DocumentPath.Module.ReferralForm: case DocumentPath.Module.PriorAuthorizationForm: case DocumentPath.Module.PatientRecordsAccessForms: case DocumentPath.Module.MedicalRecordsReleaseDocument: case DocumentPath.Module.BillOfRights: case DocumentPath.Module.NoticeOfPrivacyPractice: { if (isAdminUser) { } else { nodeList.Add(PatientNode); nodeList.Add("{0}");//Patient Guid Value switch (documentPath) { case DocumentPath.Module.ReferralForm: { nodeList.Add("ReferralForms"); break; } case DocumentPath.Module.PriorAuthorizationForm: { nodeList.Add("PriorAuthorizationRequestForms"); break; } case DocumentPath.Module.PatientRecordsAccessForms: { nodeList.Add("PatientRecordsAccessForms"); break; } case DocumentPath.Module.MedicalRecordsReleaseDocument: { nodeList.Add("MedicalRecordsReleaseDocument"); break; } case DocumentPath.Module.BillOfRights: { nodeList.Add("BillOfRights"); break; } case DocumentPath.Module.NoticeOfPrivacyPractice: { nodeList.Add("NoticeOfPrivacyPractice"); break; } default: { break; } } if (documentPath != DocumentPath.Module.BillOfRights) { nodeList.Add("{1}");//Form Guid } } break; } case DocumentPath.Module.Masters: { switch (customValue) { case AppConstants.BillofRights: { nodeList.Add("Forms"); nodeList.Add(AppConstants.BillofRights); break; } case AppConstants.NoticePrivacyPractice: { nodeList.Add("Forms"); nodeList.Add(AppConstants.NoticePrivacyPractice); break; } case AppConstants.ApplicationModule: { nodeList.Add(AppConstants.ApplicationModule); break; } case AppConstants.Competencies: { nodeList.Add(AppConstants.Competencies + "{0}{1}"); break; } case AppConstants.CompetencySource: { nodeList.Add(AppConstants.CompetencySource); nodeList.Add("{0}"); break; } case AppConstants.QuestionType: { nodeList.Add(AppConstants.QuestionType); break; } default: { break; } } break; } default: { break; } } return string.Join("/", nodeList); }
public static string GetDocumentPath(DocumentPath.Module documentPath, DropBoxLink dropBox, string customValue) { return GetDocumentPath(documentPath, dropBox.Cid, dropBox.Sid, AppCommon.GetCurrentUserRole(dropBox.UserRole), dropBox.Uid, customValue); }