open-index/open-npm huggingface dataset:
npm package: @inclouded/fhir-person
Description: ``` npm install --save @inclouded/fhir-person ```
Latest version: 2.0.0

# FHIR Person Firestore SDK

```
npm install --save @inclouded/fhir-person
```

## Introduction

In the repository the Firebase Cloud Firestore SDK can be found that was made for the FHIR Person resource in an installable Angular folder form. The SDK can be installed for every Angular 2+ project. The SDK accomplishes the necessary CRUD operations.

## Usage

1. For using the SDK an Angular 2+ project is needed, in which we can establish a connection to a Firestore database instance. (configured in environments.ts)

2. The SDK can be used in a Service in the following way:

```typescript
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { PersonApi } from '@inclouded/fhir-person';
import { AngularFirestore } from '@angular/fire/firestore';
import { IPerson } from '@ahryman40k/ts-fhir-types/lib/R4';

@Injectable()
export class PersonService {

  PersonApi: PersonApi;
  constructor(private afs: AngularFirestore) {
    this.PersonApi = new PersonApi(this.afs);
  }

  addPerson(person: IPerson) {
    return this.PersonApi.add(person);
  }

  getAllPersons(): Observable<IPerson[]> {
    return this.PersonApi.getAll();
  }

  deletePerson(personId: string) {
    return this.PersonApi.delete(personId);
  }

  updatePerson(person: IPerson) {
    return this.PersonApi.update(person);
  }

  getPersonById(id: string) {
      return this.PersonApi.getById(id);
  }

  getPersonsbyAddress(addressPostalCode?: string, addressCountry?: string, addressCity?: string,
    addressLine?: string): Observable<IPerson[]> {
    return this.PersonApi.getPersonsbyAddress(addressPostalCode, addressCountry, addressCity, addressLine);
  }

  getPersonsbyName(name: string): Observable<IPerson[]> {
    return this.PersonApi.getPersonsbyName(name);
  }

  getPersonsbyIdentifier(identifier: string): Observable<IPerson[]> {
    return this.PersonApi.getPersonsbyIdentifier(identifier);
  }

  getPersonsbyGender(gender: string): Observable<IPerson[]> {
    return this.PersonApi.getPersonsbyGender(gender);
  }

  getPersonsbyBirthDate(birthDate: Date): Observable<IPerson[]> {
    return this.PersonApi.getPersonsbyBirthDate(birthDate);
  }

  getPersonsbyManagingOrganization(managingOrganization: string): Observable<IPerson[]> {
    return this.PersonApi.getPersonsbyManagingOranization(managingOrganization);
  }

  getPersonsbyTelecom(telecom: string): Observable<IPerson[]> {
    return this.PersonApi.getPersonsbyTelecom(telecom);
  }

  getPersonsbyLink(link: string): Observable<IPerson[]> {
    return this.PersonApi.getPersonsbyLink(link);
  }
}

```

## Usage with MongoDB

See in the description of FhirApi:
[a link](https://www.npmjs.com/package/@inclouded/fhirapi)

> The Person class must be equal with the form.value, this way there's no need for building the object locally. For the usage of the more complex objects there are more available interfaces, the properties of Person that possess more complex objects build upon these. 

Developer: Zoltán R. Jánki (jankiz@inf.u-szeged.hu), Gábor Simon (simonovszkij@gmail.com)
npm package: @inclouded/fhir-practitionerrole
Description: ``` npm install --save @inclouded/fhir-practitionerrole ```
Latest version: 3.0.3

# FHIR PractitionerRole Firestore SDK

```
npm install --save @inclouded/fhir-practitionerrole
```

## Introduction

In the repository the Firebase Cloud Firestore SDK can be found that was made for the FHIR PractitionerRole resource in an installable Angular folder form. The SDK can be installed for every Angular 2+ project. The SDK accomplishes the necessary CRUD operations.

## Usage

1. For using the SDK an Angular 2+ project is needed, in which we can establish a connection to a Firestore database instance. (configured in environments.ts)

2. The SDK can be used in a Service in the following way:

```typescript
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { PractitionerRoleApi } from '@inclouded/fhir-practitionerrole';
import { AngularFirestore } from '@angular/fire/firestore';
import { IPractitionerRole } from '@ahryman40k/ts-fhir-types/lib/R4';

@Injectable()
export class PractitionerRoleService {

  PractitionerRoleApi: PractitionerRoleApi;
  constructor(private afs: AngularFirestore) {
    this.PractitionerRoleApi = new PractitionerRoleApi(this.afs);
  }

  addPractitionerRole(practitionerRole: IPractitionerRole) {
    return this.PractitionerRoleApi.add(practitionerRole);
  }

  getAllPractitionerRoles(): Observable<IPractitionerRole[]> {
    return this.PractitionerRoleApi.getAll();
  }

  deletePractitionerRole(practitionerRoleId: string) {
    return this.PractitionerRoleApi.delete(practitionerRoleId);
  }

  updatePractitionerRole(practitionerRole: IPractitionerRole) {
    return this.PractitionerRoleApi.update(practitionerRole);
  }

  getPractitionerRoleByPractitioner(practitioner: string): Observable<IPractitionerRole[]> {
    return this.PractitionerRoleApi.getPractitionerRoleByPractitioner(practitioner);
  }

  getPractitionerRoleById(id: string) {
      return this.PractitionerRoleApi.getById(id);
  }

  getPractitionerRoleByActive(active: boolean): Observable<IPractitionerRole[]> {
    return this.PractitionerRoleApi.getPractitionerRoleByActive(active);
  }

  getPractitionerRoleByCode(code: string): Observable<IPractitionerRole[]> {
    return this.PractitionerRoleApi.getPractitionerRoleByCode(code);
  }
}

```

## Usage with MongoDB

See in the description of FhirApi:
[a link](https://www.npmjs.com/package/@inclouded/fhirapi)

> The PractitionerRole class must be equal with the form.value, this way there's no need for building the object locally. For the usage of the more complex objects there are more available interfaces, the properties of PractitionerRole that possess more complex objects build upon these. 

Developer: Zoltán R. Jánki (jankiz@inf.u-szeged.hu), Gábor Simon (simonovszkij@gmail.com)
npm package: @inclouded/fhir-provenance
Description: ``` npm install --save @inclouded/fhir-provenance ```
Latest version: 3.0.0

# FHIR Provenance Firestore SDK

```
npm install --save @inclouded/fhir-provenance
```

## Introduction

In the repository the Firebase Cloud Firestore SDK can be found that was made for the FHIR Provenance resource in an installable Angular folder form. The SDK can be installed for every Angular 2+ project. The SDK accomplishes the necessary CRUD operations.

## Usage

1. For using the SDK an Angular 2+ project is needed, in which we can establish a connection to a Firestore database instance. (configured in environments.ts)

2. The SDK can be used in a Service in the following way:

```typescript
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { ProvenanceApi } from '@inclouded/fhir-provenance';
import { AngularFirestore } from '@angular/fire/firestore';
import { IProvenance } from '@ahryman40k/ts-fhir-types/lib/R4';

@Injectable()
export class ProvenanceService {

    ProvenanceApi: ProvenanceApi;
    constructor(private afs: AngularFirestore) {
        this.ProvenanceApi = new ProvenanceApi(this.afs);
    }

    getProvenances(): Observable<IProvenance[]> {
        return this.ProvenanceApi.getAll();
    }

    addProvenance(careteam: IProvenance) {
        return this.ProvenanceApi.add(careteam);
    }


    deleteProvenance(careteamId: string) {
        return this.ProvenanceApi.delete(careteamId);
    }


    updateProvenance(careteam: IProvenance) {
        return this.ProvenanceApi.update(careteam);
    }


    getProvenancesbyTarget(target: string): Observable<IProvenance[]> {
        return this.ProvenanceApi.getProvenancesbyTarget(target);
    }

    getProvenanceById(id: string): Observable<IProvenance[]> {
        return this.ProvenanceApi.getById(id);
    }

    getProvenancesbyRecorded(recorded: Date): Observable<IProvenance[]> {
        return this.ProvenanceApi.getProvenancesbyRecorded(recorded);
    }

    getProvenancesbyAgent(agent: string): Observable<IProvenance[]> {
        return this.ProvenanceApi.getProvenancesbyAgent(agent);
    }

    getProvenancesbyEntity(entity: string): Observable<IProvenance[]> {
        return this.ProvenanceApi.getProvenancesbyEntity(entity);
    }
}

```

## Usage with MongoDB

See in the description of FhirApi:
[a link](https://www.npmjs.com/package/@inclouded/fhirapi)

> The Provenance class must be equal with the form.value, this way there's no need for building the object locally. For the usage of the more complex objects there are more available interfaces, the properties of Provenance that possess more complex objects build upon these. 

Developer: Zoltán R. Jánki (jankiz@inf.u-szeged.hu), Gábor Simon (simonovszkij@gmail.com)
npm package: @inclouded/fhir-questionnaire
Description: ``` npm install --save @inclouded/fhir-questionnaire ```
Latest version: 2.0.0

# FHIR Questionnaire Firestore SDK

```
npm install --save @inclouded/fhir-questionnaire
```

## Introduction

In the repository the Firebase Cloud Firestore SDK can be found that was made for the FHIR Questionnaire resource in an installable Angular folder form. The SDK can be installed for every Angular 2+ project. The SDK accomplishes the necessary CRUD operations.

## Usage

1. For using the SDK an Angular 2+ project is needed, in which we can establish a connection to a Firestore database instance. (configured in environments.ts)

2. The SDK can be used in a Service in the following way:

```typescript
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { QuestionnaireApi } from '@inclouded/fhir-questionnaire';
import { AngularFirestore } from '@angular/fire/firestore';
import { IQuestionnaire } from '@ahryman40k/ts-fhir-types/lib/R4';

@Injectable()
export class QuestionnaireService {

  QuestionnaireApi: QuestionnaireApi;
  constructor(private afs: AngularFirestore) {
    this.QuestionnaireApi = new QuestionnaireApi(this.afs);
  }

  addQuestionnaire(questionnaire: IQuestionnaire) {
    return this.QuestionnaireApi.add(questionnaire);
  }

  getAllQuestionnaires(): Observable<IQuestionnaire[]> {
    return this.QuestionnaireApi.getAll();
  }

  deleteQuestionnaire(questionnairebyId: string) {
    return this.QuestionnaireApi.delete(questionnairebyId);
  }

  updateQuestionnaire(questionnaire: IQuestionnaire) {
    return this.QuestionnaireApi.update(questionnaire);
  }

  getQuestionnaireById(id: string) {
      return this.QuestionnaireApi.getById(id);
  }

  getQuestionnairesbyStatus(status: string): Observable<IQuestionnaire[]> {
    return this.QuestionnaireApi.getQuestionnairesbyStatus(status);
  }

  getQuestionnairesByCode(code: string): Observable<IQuestionnaire[]> {
    return this.QuestionnaireApi.getQuestionnairesByCode(code);
  }
}

```

## Usage with MongoDB

See in the description of FhirApi:
[a link](https://www.npmjs.com/package/@inclouded/fhirapi)

> The Questionnaire class must be equal with the form.value, this way there's no need for building the object locally. For the usage of the more complex objects there are more available interfaces, the Questionnaire of Provenance that possess more complex objects build upon these. 

Developer: Zoltán R. Jánki (jankiz@inf.u-szeged.hu), Gábor Simon (simonovszkij@gmail.com)
npm package: @inclouded/fhir-specimen
Description: ``` npm install --save @inclouded/fhir-specimen ```
Latest version: 2.0.0

# FHIR Specimen Firestore SDK

```
npm install --save @inclouded/fhir-specimen
```

## Introduction

In the repository the Firebase Cloud Firestore SDK can be found that was made for the FHIR Specimen resource in an installable Angular folder form. The SDK can be installed for every Angular 2+ project. The SDK accomplishes the necessary CRUD operations.

## Usage

1. For using the SDK an Angular 2+ project is needed, in which we can establish a connection to a Firestore database instance. (configured in environments.ts)

2. The SDK can be used in a Service in the following way:

```javascript
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { SpecimenApi } from '@inclouded/fhir-specimen';
import { ISpecimen } from '@ahryman40k/ts-fhir-types/lib/R4';
import { AngularFirestore } from '@angular/fire/firestore';

@Injectable()
export class SpecimenService {

  SpecimenApi: SpecimenApi;
  constructor(private afs: AngularFirestore) {
    this.SpecimenApi = new SpecimenApi(this.afs);
  }

  addSpecimen(specimen: ISpecimen) {
    return this.SpecimenApi.add(specimen);
  }

  getAllSpecimens(): Observable<ISpecimen[]> {
    return this.SpecimenApi.getAll();
  }

  getSpecimensByMetaAndStatus(meta?: string, status?: string): Observable<ISpecimen[]> {
    return this.SpecimenApi.getSpecimensByMetaAndStatus(meta, status);
  }

  deleteSpecimen(specimenId: string){
    return this.SpecimenApi.delete(specimenId);
  }

  updateSpecimen(specimen: ISpecimen) {
    return this.SpecimenApi.update(specimen);
  }

}

```

## Usage with MongoDB

See in the description of FhirApi:
[a link](https://www.npmjs.com/package/@inclouded/fhirapi)

> The Specimen class must be equal with the form.value, this way there's no need for building the object locally. For the usage of the more complex objects there are more available interfaces, the Specimen of Provenance that possess more complex objects build upon these. 

Developer: Zoltán R. Jánki (jankiz@inf.u-szeged.hu), Gábor Simon (simonovszkij@gmail.com)
npm package: @inclouded/fhir-storage
Description: ## Introduction
Latest version: 3.0.0

# Fhir-storage SDK

## Introduction

In the repository the Firebase Cloud Firestore SDK can be found that was made for the FHIR Storage resource in an installable Angular folder form. The SDK can be installed for every Angular 2+ project. The SDK accomplishes the necessary CRUD operations.

## Usage

1. For using the SDK an Angular 2+ project is needed, in which with the help of the angularfire2 modul we have a connection with a Firestore database. (configured in environments.ts)

2. Related interfaces (fhir-storage.ts):

```typescript
export interface File {
  path: string;
  data: ArrayBuffer;
}
```

Developer: Gábor Simon (simonovszkij@gmail.com)
npm package: @inclouded/lavinia-sdk
Description: ## Bevezető
Latest version: 1.0.0

# Lavinia Api SDK

## Bevezető

A repository-ban az LaviniaApi SDK található egy telepíthető Angular könyvtár formájában. Az SDK telepíthető minden Angular 2+ projekthez. Az SDK megvalósítja a szükséges CRUD műveleteket.

## Használata

1. Az SDK használatához szükséges egy Angular 2+ projekt.

2. A hozzá kapcsolódó interface-ek (User.ts, Device.ts, LaviniaDAO.ts):

```typescript
export class User {
    _id: string;
    className: string;
    email: string;
    fullname: string;
    active: boolean;
    comment: string;
    password: string;
    type: string;
}

export class Device {
    _id: string;
    className: string;
    name: string;
    description: string;
    owner: string;
    hwId: string;
    acls: string;
}

export interface LaviniaDAO {
    httpClient: HttpClient;
    url: string;
}

export enum ClassName {
    user = 'model.User',
    device = 'model.Device',
}

export enum UserType {
    admin = 'admin',
    user = 'user'
}
```

3. Egy Service-ben felhasználható az SDK, az alábbi módon:

```javascript
import { Injectable } from '@angular/core';
import { LaviniaApi, documentType, LaviniaDAO } from '@inclouded/lavinia-sdk';
import { HttpClient } from '@angular/common/http';

@Injectable()
export class LaviniaApiService {

  LaviniaApi: LaviniaApi;
  LaviniaDAO: LaviniaDAO = {
   httpClient: this.http,
   url: 'https://url.hu'
  };
  collectionName = 'collectionName';
  documentType = documentType;

  constructor(private http: HttpClient) {
    this.LaviniaApi = new LaviniaApi(this.LaviniaDAO, this.collectionName, this.documentType);
  }

  add(data: any) {
    return this.LaviniaApi.add(data);
  }

  delete(id: string) {
    return this.LaviniaApi.delete(id);
  }

  update(data: any, id: string) {
    return this.LaviniaApi.delete(data, id);
  }
}

```

Felelős fejlesztő: Simon Gábor (simonovszkij@gmail.com)