/// <summary>批量插入</summary>
        public async Task <string[]> InsertManyAsync(IndexDataSaveRequest <TDocument> request)
        {
            Validate(request.Values);
            await this.Accessor.InsertManyAsync(request.Values);

            return(request.Values.Select(e => e.PageId).ToArray());
        }
Example #2
0
        /// <summary>批量插入</summary>
        public async Task <AppDataSaveResult[]> InsertManyAsync(IndexDataSaveRequest <TDataSave> request)
        {
            var pairs = new List <PKSKeyValuePair <TDocument, AppDataSaveResult> >();

            foreach (var value in request.Values)
            {
                var pair = await Validate(value, false);

                pairs.Add(pair);
            }
            var options = new InsertManyOptions();
            await Accessor.InsertManyAsync(pairs.Select(e => e.Key));

            return(pairs.Select(e => e.Value).ToArray());
        }
        /// <summary>批量保存</summary>
        public async Task <string[]> SaveManyAsync(IndexDataSaveRequest <TDocument> request)
        {
            var updateOptions = new UpdateOptions {
                IsUpsert = true
            };

            Validate(request.Values);
            foreach (var doc in request.Values)
            {
                var filter = Builders <TDocument> .Filter.Eq(e => e.Id, doc.Id);

                await Accessor.ReplaceOneAsync(filter, doc, updateOptions);
            }
            return(request.Values.Select(e => e.PageId).ToArray());
        }
Example #4
0
        /// <summary>批量保存</summary>
        public async Task <AppDataSaveResult[]> SaveManyAsync(IndexDataSaveRequest <TDataSave> request)
        {
            var pairs = new List <PKSKeyValuePair <TDocument, AppDataSaveResult> >();

            foreach (var value in request.Values)
            {
                var pair = await Validate(value, true);

                pairs.Add(pair);
            }
            var updateOptions = new UpdateOptions {
                IsUpsert = true
            };

            foreach (var pair in pairs)
            {
                var doc    = pair.Key;
                var filter = Builders <TDocument> .Filter.Eq(e => e.Id, doc.Id);

                await Accessor.ReplaceOneAsync(filter, doc, updateOptions);
            }
            return(pairs.Select(e => e.Value).ToArray());
        }
 /// <summary>批量保存</summary>
 public async Task <string[]> SaveManyAsyncInternal(HttpClientWrapper client, IndexDataSaveRequest <TDocument> request)
 {
     return(await client.PostObjectAsync <string[]>(GetActionUrl(nameof(SaveMany)), request).ConfigureAwait(false));
 }
        /// <summary>批量保存</summary>
        public async Task <string[]> SaveManyAsync(IndexDataSaveRequest <TDocument> request)
        {
            var client = InitHttpClient();

            return(await SaveManyAsyncInternal(client, request).ConfigureAwait(false));
        }
        /// <summary>批量保存</summary>
        public string[] SaveMany(IndexDataSaveRequest <TDocument> request)
        {
            var client = InitHttpClient();

            return(Task.Run(() => SaveManyAsyncInternal(client, request)).Result);
        }
Example #8
0
 /// <summary>批量保存</summary>
 public AppDataSaveResult[] SaveMany(IndexDataSaveRequest <TDataSave> request)
 {
     return(Task.Run(() => SaveManyAsync(request)).Result);
 }
 /// <summary>批量保存</summary>
 public string[] SaveMany(IndexDataSaveRequest <TDocument> request)
 {
     return(Task.Run(() => SaveManyAsync(request)).Result);
 }
 /// <summary>批量保存</summary>
 private async Task <AppDataSaveResult[]> SaveManyAsyncInternal(HttpClientWrapper client, IndexDataSaveRequest <TDataSave> request)
 {
     return(await client.PostObjectAsync <AppDataSaveResult[]>(GetActionUrl(nameof(SaveMany)), request).ConfigureAwait(false));
 }
        /// <summary>批量插入</summary>
        public async Task <AppDataSaveResult[]> InsertManyAsync(IndexDataSaveRequest <TDataSave> request)
        {
            var client = InitHttpClient();

            return(await InsertManyAsyncInternal(client, request).ConfigureAwait(false));
        }
        /// <summary>批量插入</summary>
        public AppDataSaveResult[] InsertMany(IndexDataSaveRequest <TDataSave> request)
        {
            var client = InitHttpClient();

            return(Task.Run(() => InsertManyAsyncInternal(client, request)).Result);
        }
 public async Task <AppDataSaveResult[]> SaveMany(IndexDataSaveRequest <TDataSave> request)
 {
     request.Values.ForEach(Validate);
     return(await ServiceImpl.SaveManyAsync(request));
 }
 public async Task <string[]> SaveMany(IndexDataSaveRequest <TDocument> request)
 {
     return(await ServiceImpl.SaveManyAsync(request));
 }
Example #15
0
        /// <summary>
        /// 保存索引数据
        /// </summary>
        public bool SaveAppIndex(Dictionary <Metadata, AppDataSaveRequest> indexMetadatas)
        {
            //保存App Data
            var resourceKeys            = indexMetadatas.Where(item => item.Value != null).Select(item => item.Value.ResourceKey).ToList();
            var existsResourceKeys      = new List <string>();
            var notExistsDbResourceKeys = new List <string>();
            var appDataMatchResult      = GetExistsResourceKeys(resourceKeys.Select(item => item as object).ToArray());

            if (appDataMatchResult != null && appDataMatchResult.Total > 0)
            {
                existsResourceKeys = appDataMatchResult.Values.Select(item => item.ResourceKey).ToList();
            }
            if (existsResourceKeys.Any())
            {
                IndexDataSaveRequest <AppDataSaveRequest> appDataSaveRequests = new IndexDataSaveRequest <AppDataSaveRequest>();
                appDataSaveRequests.Values = indexMetadatas.Where(item => item.Value != null && notExistsDbResourceKeys.Contains(item.Value.ResourceKey)).Select(item => item.Value).ToList();
                var appDataSaveResult = _appDataService.SaveMany(appDataSaveRequests);
            }
            notExistsDbResourceKeys = resourceKeys.Where(item => !existsResourceKeys.Contains(item)).ToList();

            if (notExistsDbResourceKeys.Any())
            {
                IndexDataSaveRequest <AppDataSaveRequest> appDataInsertRequests =
                    new IndexDataSaveRequest <AppDataSaveRequest>();
                appDataInsertRequests.Values = indexMetadatas.Where(item => item.Value != null && notExistsDbResourceKeys.Contains(item.Value.ResourceKey)).Select(item => item.Value).ToList();
                var appDataResult = _appDataService.InsertMany(appDataInsertRequests);
                //
                for (int i = 0; i < appDataResult.Length; i++)
                {
                    var resourceKey      = notExistsDbResourceKeys[i];
                    var kvpIndexMetadata = indexMetadatas.FirstOrDefault(item => item.Value.ResourceKey == resourceKey);
                    if (!string.IsNullOrWhiteSpace(appDataResult[i].DataId))
                    {
                        kvpIndexMetadata.Key.DataId = appDataResult[i].DataId;
                    }
                    if (!string.IsNullOrWhiteSpace(appDataResult[i].Thumbnail))
                    {
                        kvpIndexMetadata.Key.Thumbnail = appDataResult[i].Thumbnail;
                    }
                    if (!string.IsNullOrWhiteSpace(appDataResult[i].Fulltext))
                    {
                        kvpIndexMetadata.Key.Fulltext = appDataResult[i].Fulltext;
                    }
                }
            }



            //保存Es Metadta
            var iiids = indexMetadatas.Select(item => item.Key.IIId).ToList();
            //var existsDbIIIds = new List<string>();
            //var notExistsDbIIIds = new List<string>();
            //var esMetadataMatchResult = GetExistsIIIds(iiids.Select(item => item as object).ToArray());
            //if (esMetadataMatchResult != null && esMetadataMatchResult.Total > 0)
            //{
            //    existsDbIIIds = esMetadataMatchResult.Metadatas.Select(item => item.IIId).ToList();
            //}
            //notExistsDbIIIds = iiids.Where(item => !existsDbIIIds.Contains(item)).ToList();
            //if (existsDbIIIds.Any())
            //{
            var saveRequest = new IndexSaveRequest();
            // var metadatas = indexMetadatas.Where(item => existsDbIIIds.Contains(item.Key.IIId)).Select(item => item.Key).ToList();
            var metadatas = indexMetadatas.Select(item => item.Key).ToList();

            saveRequest.Metadatas = new MetadataCollection(metadatas);
            saveRequest.Replace   = true;
            _indexerService.Save(saveRequest);
            // }
            //if (notExistsDbIIIds.Any())
            //{
            //    var request = new IndexInsertRequest();
            //    var metadatas = indexMetadatas.Where(item => notExistsDbIIIds.Contains(item.Key.IIId)).Select(item => item.Key).ToList();
            //    request.Metadatas = new MetadataCollection(metadatas);
            //    _indexerService.Insert(request);
            //}
            return(true);
        }