export interface NAP {
	fromHost$: Observable<NAPMessage>;
	toHost$: Subject<NAPMessage>;
	errors$: Observable<NAPError>;
	subscribe: (subscriber: NAPHostSubscriber) => void; 
	unsubscribe: (subscriber: NAPHostSubscriber) => void; 
	send: (message: NAPMessage) => void;
}

import { createNAP, NAP} from "nap-typescript-sdk";
const nap:Nap = createNAP();

export interface NAPMessage {
  date: string;
  id: string;
  event: NAPEvent;
}
export interface NAPEvent {
  type: NAPEventType;
  context?: FHIR.Context[];
}
export interface Context {
    resource?: {
        resourceType: string;
        meta?: Meta;
        code?: {
            coding: Coding[];
        };
        name?: Name[];
        identifier?: Identifier[];
        extension?: Extension[];
    };
}
export interface Name {
    family: string;
    given: string[];
}
export interface Extension {
    url: string;
    value: string;
}
export interface Identifier {
    system: string;
    value: string;
}
export interface Coding {
    system: string;
    code: string;
}
export interface Meta {
    profile: string[];
}

import { NAPEventCatalogue } from 'nap-typescript-sdk';
const sessionCloseEvent = NAPEventCatalogue.v1.SessionClose;

export interface NAPError {
  id: number;
  message: string;
  isFatal: boolean;
}

this.napAngular.errors$.subscribe(res => {
     console.error(res);
    });

import { FHIRValueGetter, NAPMessage, NAPPatientInfo } from 'nap-typescript-sdk';
const sessionToken = FHIRValueGetter.getSessionValue(napMessage);
const patientData: NAPPatientInfo = FHIRValueGetter.getSessionValue(napMessage);

import {filterEvents, NAPEventCatalogue} from 'nap-typescript-sdk';

nap.incoming$.pipe(
        filterEvents([
          NAPEventCatalogue.v1.SessionOpen,
          NAPEventCatalogue.v1.SessionClose,
        ])
      )

import {NAPMessage, NAPEventCatalogue, FHIRValueSetter} from 'nap-typescript-sdk';
import { v4 as UUID } from 'uuid';

const napMessageSessionError: NAPMessage = {
  date: new Date().toISOString(),
  id: UUID(),
  event: {
    type: NAPEventCatalogue.v1.SessionError,
    context: [
      {
        resource: {
          resourceType: FHIRValueSetter.FHIRResourceType.Basic,
          code: {
            coding: [
              {
                code: NAPEventCatalogue.v1.SessionError,
                system: FHIRValueSetter.FHIRSystem.NAP,
              },
            ],
          },
          identifier: [
            {
              system: FHIRValueSetter.FHIRIdentifierSystem.NAPErrorMessage,
              value: 'This is my error message',
            },
            {
              system: FHIRValueSetter.FHIRIdentifierSystem.NAPErrorDescription,
              value: 'This is a longere description of the error message',
            },
          ],
        },
      },
    ],
  },
};

NapTypescriptSdk.send(napMessageSessionError)

NapAngularService {
	// attributter
	incoming$: Observable<NAPmessage>
	errors$: Observable<NAPError>
	outgoing$: Subject<NapMessage>
	sendMessage(message: NAPMessage):void
 	subscribeToMessages(callback: (message: NAPMessage) => void): void
}

import { NapAngularService } from 'nap-angular-sdk';
import { filterEvents, NAPEventCatalogue, NAPMessage } from 'nap-typescript-sdk';
import { v4 as UUID } from 'uuid';

export class MyComponent {
	
	// proxy for SAMLAssertion
	public session$: Observable<NAPMessage | undefined> = 
		this.napSDK.incoming$.pipe(
		filterEvents([NAPEventCatalogue.v1.SessionOpen, NAPEventCatalogue.v1.SessionClose])
	);
		//inject the nap-angular-sdk service
	constructor(private napSK: NapAngularService) {
		// Construct an SessionOpen NAPMessage
		const napMsg: NAPMessage = {
		date: new Date().toISOString(),
		id: UUID(),
		event: { type: NAPEventCatalogue.v1.SessionOpen },
	};

		// Ask for the SAMLassertion in host
		this.napSDK.sendMessage(napMsg);
	}
}

import { NapAngularService } from 'nap-angular-sdk';
import { filterEvents, NAPEventCatalogue, NAPMessage, FHIRValueSetter, FHIRValueGetter } from 'nap-typescript-sdk';
import { v4 as UUID } from 'uuid';

export class MyComponent {
	
	// proxy for currentPatient
	public currentPatient$: Observable<NAPPatientInfo | undefined> = this.napSDK.incoming$.pipe(
    	filterEvent(NAPEventCatalogue.v1.PatientOpen),
	    map((message) => FHIRValueGetter.getPatientInfo(message))
    );
	
	//inject the nap-angular-sdk service
	constructor(private napSK: NapAngularService) {
	  	
		// Construct an patient NAPMessage
	 	const napMsg: NAPMessage = {
			date: new Date().toISOString(),
      		id: UUID(),
      		event: { type: NAPEventCatalogue.v1.PatientOpen}
     	 };
      	
		this.napSDK.sendMessage(napMsg);

	  	// Ask for the patient context in host
	  	this.napSDK.sendMessage(napMsg);
	}

	// Something triggered a patientClose on the client site 
	public patientClose(patient: NAPPatientInfo) {
		const napMsg: NAPMessage = {
  			date: new Date().toISOstring(),
			id: UUID(),
		  	event: {
    			type: NAPEventType.PatientClose,
		    	context: [{
        			resource: {
		          	resourceType: FHIRValueSetter.FHIRResourceType.Patient,
          		  	code: { 
						coding: [{ code: NAPEventCatalogue.v1.Close, system: FHIRSystem.NAP}] 
						},
	          		identifier: [{
		        	      system: FHIRSystem.CPR,
        		    	  value: patient.ssNo,
			           	 }],
          			name: [{ family: patient.familyName, given: [patient.familyName] }],
		          	meta: {profile: ['http://hl7.dk/fhir/core/StructureDefinition/dk-core-patient']},
      			}],
  			}
		};
		
		// Send the message
		this.napSDK.sendMessage(napMsg);
	}
	
}

interface Context {
  latestIncoming: NAPMessage | null;
  latestError: NAPError | null;
  postMessage: (message: NAPMessage) => void;
  subscribe: (subscriber: NAPHostSubscriber) => void;
  unsubscribe: (subscriber: NAPHostSubscriber) => void;
}

import { NapContextProvider, NAPEventType, useNap } from 'nap-react-sdk';
import React from 'react';
import { v4 as UUID } from 'uuid';

const IncomingMessageComponent: React.FC = () => {
  const napContext = useNap()

  return <div> {JSON.stringify(napContext.latestIncoming)}</div>
}

const IncomingErrorsComponent: React.FC = () => {
  const napContext = useNap()
  return (
    <div >
      <p> Error received: {JSON.stringify(napContext.latestError)}</p>
    </div>
  )
}


const PostMessageComponent: React.FC = () => {
  const napContext = useNap()
  return (
    <button
      onClick={() => {
        napContext.postMessage({
          date: new Date().toString(),
          id: UUID(),
          event: { type: NAPEventType.SessionOpen }
        })
      }}
    >
      Send message
    </button>
  )
}

const App = () => {

  return (
    <>
      <NapContextProvider>
        <IncomingMessageComponent></IncomingMessageComponent>
		<IncomingErrorsComponent></IncomingErrorsComponent>
        <PostMessageComponent></PostMessageComponent>
      </NapContextProvider>
    </>
  )
}

export default App