### File

`src/core/services/common/search.service.ts`

### Description

Search service provider

### Index

###### Properties

- Private Readonly ES_IP
- Private Readonly ES_PORT

###### Methods

- Async findByContext
- Async findByID

### Constructor

`constructor(httpService: HttpService)`
Defined in src/core/services/common/search.service.ts:11

Constructs the service with injection of HTTPService instance

Parameters :

Name | Type | Optional
httpService | `HttpService` | No

### Methods

Async findByContext
`findByContext(es_query: EsQueryDto)`
Defined in src/core/services/common/search.service.ts:71

Finds relevant documents by context using the given query string

Parameters :

Name | Type | Optional
es_query | `EsQueryDto` | No

Returns : `Promise<EsResponseDto>`

Elasticsearch hits or an error object

Async findByID
`findByID(uuid: string)`
Defined in src/core/services/common/search.service.ts:34

Finds a paper by its own ID

Parameters :

Name | Type | Optional
uuid | `string` | No

Returns : `Promise<EsResponseDto>`

Elasticsearch hits or an error object

### Properties

Private Readonly ES_IP
Default value : `process.env.ES_CONTAINER_NAME`
Defined in src/core/services/common/search.service.ts:27
Elasticsearch IP address

Private Readonly ES_PORT
Default value : `process.env.ES_PORT`
Defined in src/core/services/common/search.service.ts:22
Elastichsearch server port-number

    import { HttpService } from "@nestjs/axios";
    import { BadRequestException, GatewayTimeoutException, HttpException, Injectable, NotFoundException } from "@nestjs/common";
    import { map, take } from "rxjs";
    import { EsResponseDto} from "../../domain/dtos";
    import { EsQueryDto } from "../../domain/dtos/elastic/es-query.dto";

    /**
     * Search service provider
     */
    @Injectable()
    export class SearchService {
        /**
         * Constructs the service with injection of
         * HTTPService instance
         * @param httpService
         */
        constructor(private readonly httpService: HttpService) {}

        /**
         * Elastichsearch server port-number
         */
        private readonly ES_PORT = process.env.ES_PORT;

        /**
         * Elasticsearch IP address
         */
        private readonly ES_IP = process.env.ES_CONTAINER_NAME;

        /**
         * Finds a paper by its own ID
         * @param uuid
         * @returns Elasticsearch hits or an error object
         */
        async findByID(uuid: string): Promise<EsResponseDto> { // Should I change 'object' to specific DTO?
            let ESQ: EsQueryDto = new EsQueryDto;

            // ESQ.size = 1;
            ESQ.query = {
                query_string: {
                    query: ('id:' + uuid),
                }
            }

            return new Promise((resolve, reject) => {
                try {
                    (this.httpService.get<EsResponseDto>(`http://${this.ES_IP}:${this.ES_PORT}/_search`, {
                        data: ESQ,
                        headers: {'Content-Type': 'application/json'},
                    }))
                    ?.pipe(take(1), map(axiosRes => axiosRes.data))
                    .subscribe((res: EsResponseDto) => {
                        if (!res.hits.hits.length) {
                            reject(new NotFoundException);
                        }
                        if (res.timed_out) {
                            reject(new GatewayTimeoutException('Elasticsearch Timed Out'));
                        }
                        resolve(res);
                    });
                } catch (error) {
                    reject(error);
                }
            });
        }

        /**
         * Finds relevant documents by context using the given query string
         * @param query, <EsQueryDto>
         * @returns Elasticsearch hits or an error object
         */
        async findByContext(es_query: EsQueryDto): Promise<EsResponseDto> {
            return new Promise((resolve, reject) => {
                try {
                    if (!es_query.query.query_string.query) {
                        throw new BadRequestException;
                    }

                    (this.httpService.get<EsResponseDto>(`http://${this.ES_IP}:${this.ES_PORT}/_search`, {
                        data: es_query,
                        headers: {'Content-Type': 'application/json'},
                    }))
                    ?.pipe(take(1), map(axiosRes => axiosRes.data))
                    .subscribe((res: EsResponseDto) => {
                        if (res.timed_out) {
                            reject(new GatewayTimeoutException('Elasticsearch Timed Out'));
                        }
                        resolve(res);
                    });
                } catch (error) {
                    reject(error);
                }
            });
        }
    }

# results matching ""

# No results matching ""