Esempio n. 1
0
        public async Task <SyncResponse> DoSyncAsync(SyncAzureQuery query, IBinder binder, CancellationToken token)
        {
            var(update, delete, version) =
                await _bus.QueryAsync <(IEnumerable <UniversitySearchDto> update, IEnumerable <string> delete, long version)>(query, token);



            var syncService = await binder.BindAsync <
                IAsyncCollector <AzureSearchSyncOutput> >(
                new AzureSearchSyncAttribute(UniversitySearchWrite.IndexName), token);

            var needContinue = false;

            foreach (var s in update)
            {
                needContinue = true;
                await syncService.AddAsync(new AzureSearchSyncOutput()
                {
                    Item = new Search.Entities.University
                    {
                        Name        = s.Name,
                        Id          = s.UniversityId,
                        Country     = s.Country.ToUpperInvariant(),
                        Extra       = s.Extra,
                        DisplayName = s.Name,
                        Prefix      = new[] { s.Name, s.Extra }.Where(x => x != null).ToArray(),
                        Image       = s.Image,
                        UsersCount  = s.UsersCount,
                        InsertDate  = DateTime.UtcNow
                    },
                    Insert = true
                }, token);
            }

            foreach (var questionDelete in delete)
            {
                needContinue = true;
                await syncService.AddAsync(new AzureSearchSyncOutput()
                {
                    Item = new Search.Entities.University
                    {
                        Id = questionDelete
                    },
                    Insert = false
                }, token);
            }

            await syncService.FlushAsync(token);

            return(new SyncResponse(version, needContinue));
        }
Esempio n. 2
0
        public static async Task <SyncAzureQuery> GetSyncProgress(
            [ActivityTrigger] string blobName, IBinder binder, CancellationToken token)
        {
            var dynamicBlobAttribute =
                new BlobAttribute($"spitball/AzureSearch/{blobName}-version.txt");

            var blob = await binder.BindAsync <CloudBlockBlob>(dynamicBlobAttribute, token);

            if (!await blob.ExistsAsync())
            {
                return(SyncAzureQuery.Empty());
            }
            var text = await blob.DownloadTextAsync();

            return(SyncAzureQuery.ConvertFromString(text));
        }
Esempio n. 3
0
        //public Task CreateIndexAsync(CancellationToken token)
        //{
        //    return _questionServiceWrite.CreateOrUpdateAsync(token);
        //}

        public async Task <SyncResponse> DoSyncAsync(SyncAzureQuery query, IBinder binder, CancellationToken token)
        {
            var(update, delete, version) =
                await _bus.QueryAsync <(IEnumerable <DocumentSearchDto> update, IEnumerable <string> delete, long version)>(query, token);

            var syncService = await binder.BindAsync <
                IAsyncCollector <AzureSearchSyncOutput> >(
                new AzureSearchSyncAttribute(DocumentSearchWrite.IndexName), token);

            var needContinue = false;

            foreach (var document in update)
            {
                needContinue = true;
                await syncService.AddAsync(new AzureSearchSyncOutput
                {
                    Item   = Search.Entities.Document.FromDto(document),
                    Insert = true
                }, token);
            }

            foreach (var document in delete)
            {
                needContinue = true;
                await syncService.AddAsync(new AzureSearchSyncOutput
                {
                    Item = new Search.Entities.Document()
                    {
                        Id = document
                    },
                    Insert = false
                }, token);
            }

            await syncService.FlushAsync(token);

            return(new SyncResponse(version, needContinue));
        }
        public async Task <(IEnumerable <T> update, IEnumerable <string> delete, long version)> GetAsync(SyncAzureQuery query, CancellationToken token)
        {
            var sql = query.Version == 0 ? FirstQuery : VersionSql;

            var sqlQuery = _session.CreateSQLQuery(sql);

            sqlQuery.SetInt32("PageSize", PageSize);
            sqlQuery.SetInt32("PageNumber", query.Page);
            if (sqlQuery.NamedParameters.Any(a => string.Equals(a, "Version", StringComparison.OrdinalIgnoreCase)))
            {
                sqlQuery.SetInt64("Version", query.Version);
            }
            sqlQuery.SetResultTransformer(new AzureSyncBaseDtoTransformer <AzureSyncBaseDto <T>, T>());


            var result = await sqlQuery.ListAsync <AzureSyncBaseDto <T> >(token);

            if (result.Count == 0)
            {
                return(Enumerable.Empty <T>(), Enumerable.Empty <string>(), 0);
            }

            var lookupTable = SeparateUpdateFromDelete(result);

            var max = result.Max(m => m.SYS_CHANGE_VERSION.GetValueOrDefault());

            return(lookupTable[false].Select(s => s.Data), lookupTable[true].Select(s => s.Id), max);
        }