Skip to content

Commit 91e2ad2

Browse files
miquelgallmiquelgall
authored
Merge pull request #9 from oracle-samples/callprocedure-method-included
First working version of call procedure result method
2 parents 27d9e61 + 24a3141 commit 91e2ad2

File tree

1 file changed

+190
-179
lines changed

1 file changed

+190
-179
lines changed

‎src/main.ts‎

Lines changed: 190 additions & 179 deletions
Original file line numberDiff line numberDiff line change
@@ -6,197 +6,208 @@
66
import { OFS } from "@ofs-users/proxy";
77

88
export class OFSMessage {
9-
apiVersion: number = -1;
10-
method: string = "no method";
11-
securedData?: any;
12-
sendInitData?: boolean;
13-
14-
static parse(str: string) {
15-
try {
16-
return Object.assign(new OFSMessage(), JSON.parse(str)) as OFSMessage;
17-
} catch (error) {
18-
return new OFSMessage()
19-
}
20-
}
9+
apiVersion: number = -1;
10+
method: string = "no method";
11+
securedData?: any;
12+
sendInitData?: boolean;
13+
14+
static parse(str: string) {
15+
try {
16+
return Object.assign(new OFSMessage(), JSON.parse(str)) as OFSMessage;
17+
} catch (error) {
18+
return new OFSMessage();
19+
}
20+
}
2121
}
2222

2323
export enum Method {
24-
Close = "close",
25-
Open = "open",
26-
Update = "update",
27-
UpdateResult = "updateResult",
28-
Init = "init",
29-
Ready = "ready",
30-
InitEnd = "initEnd",
24+
Close = "close",
25+
Open = "open",
26+
Update = "update",
27+
UpdateResult = "updateResult",
28+
Init = "init",
29+
Ready = "ready",
30+
InitEnd = "initEnd",
31+
CallProcedureResult = "callProcedureResult",
32+
CallProcedure = "callProcedure",
3133
}
3234

3335
export class OFSOpenMessage extends OFSMessage {
34-
entity: string | undefined;
36+
entity: string | undefined;
37+
}
38+
39+
export class OFSCallProcedureResultMessage extends OFSMessage {
40+
resultData: any | undefined;
3541
}
3642

3743
export class OFSCloseMessage extends OFSMessage {
38-
method: string = "close";
39-
activity?: any;
44+
method: string = "close";
45+
activity?: any;
4046
}
4147

4248
export abstract class OFSPlugin {
43-
private _proxy!: OFS;
44-
private _tag: string;
45-
46-
constructor(tag: string) {
47-
console.log(`${tag}: Created`);
48-
49-
this._tag = tag;
50-
51-
this._setup();
52-
}
53-
54-
get proxy(): OFS {
55-
return this._proxy;
56-
}
57-
58-
get tag(): string {
59-
return this._tag;
60-
}
61-
62-
/**
63-
* Processes received messages
64-
* @param message Message received
65-
* @returns
66-
*/
67-
private _getWebMessage(message: MessageEvent): boolean {
68-
console.log(`${this._tag}: Message received:`, message.data);
69-
console.log(`${this._tag}: Coming from ${message.origin}`);
70-
// Validate that it is a valid OFS message
71-
var parsed_message = OFSMessage.parse(message.data);
72-
this._storeCredentials(parsed_message);
73-
switch (parsed_message.method) {
74-
case "init":
75-
this._init(parsed_message);
76-
break;
77-
case "open":
78-
this.open(parsed_message as OFSOpenMessage);
79-
break;
80-
case "updateResult":
81-
this.updateResult(parsed_message);
82-
break;
83-
case "wakeUp":
84-
this.wakeup(parsed_message);
85-
break;
86-
case "error":
87-
this.error(parsed_message);
88-
break;
89-
case "no method":
90-
console.warn(`${this._tag}: Message discarded`)
91-
break;
92-
93-
default:
94-
throw new Error(`Unknown method ${parsed_message.method}`);
95-
break;
96-
}
97-
return true;
98-
}
99-
100-
private async _init(message: OFSMessage) {
101-
this.init(message);
102-
var messageData: OFSMessage = {
103-
apiVersion: 1,
104-
method: "initEnd",
105-
};
106-
this._sendWebMessage(messageData);
107-
}
108-
109-
private _storeCredentials(message: OFSMessage) {
110-
if (message.securedData) {
111-
console.log(`${this._tag}: Processing`, message.securedData);
112-
// STEP 1: are we going to create a proxy?
113-
if (
114-
message.securedData.ofsInstance &&
115-
message.securedData.ofsClientId &&
116-
message.securedData.ofsClientSecret
117-
) {
118-
this._proxy = new OFS({
119-
instance: message.securedData.ofsInstance,
120-
clientId: message.securedData.ofsClientId,
121-
clientSecret: message.securedData.ofsClientSecret,
122-
});
123-
}
124-
}
125-
}
126-
127-
private static _getOriginURL(url: string) {
128-
if (url != "") {
129-
if (url.indexOf("://") > -1) {
130-
return "https://" + url.split("/")[2];
131-
} else {
132-
return "https://" + url.split("/")[0];
133-
}
134-
}
135-
return "";
136-
}
137-
private _sendWebMessage(data: OFSMessage) {
138-
console.log(
139-
`${this._tag}: Sending message` +
140-
JSON.stringify(data, undefined, 4)
49+
private _proxy!: OFS;
50+
private _tag: string;
51+
52+
constructor(tag: string) {
53+
console.log(`${tag}: Created`);
54+
55+
this._tag = tag;
56+
57+
this._setup();
58+
}
59+
60+
get proxy(): OFS {
61+
return this._proxy;
62+
}
63+
64+
get tag(): string {
65+
return this._tag;
66+
}
67+
68+
/**
69+
* Processes received messages
70+
* @param message Message received
71+
* @returns
72+
*/
73+
private _getWebMessage(message: MessageEvent): boolean {
74+
console.log(`${this._tag}: Message received:`, message.data);
75+
console.log(`${this._tag}: Coming from ${message.origin}`);
76+
// Validate that it is a valid OFS message
77+
var parsed_message = OFSMessage.parse(message.data);
78+
this._storeCredentials(parsed_message);
79+
switch (parsed_message.method) {
80+
case "init":
81+
this._init(parsed_message);
82+
break;
83+
case "open":
84+
this.open(parsed_message as OFSOpenMessage);
85+
break;
86+
case "updateResult":
87+
this.updateResult(parsed_message);
88+
break;
89+
case "callProcedureResult":
90+
this.callProcedureResult(
91+
parsed_message as OFSCallProcedureResultMessage
14192
);
142-
var originUrl =
143-
document.referrer ||
144-
(document.location.ancestorOrigins &&
145-
document.location.ancestorOrigins[0]) ||
146-
"";
147-
148-
if (originUrl) {
149-
parent.postMessage(data, OFSPlugin._getOriginURL(originUrl));
150-
}
151-
}
152-
153-
public sendMessage(method: Method, data?: any): void {
154-
this._sendWebMessage({
155-
apiVersion: 1,
156-
method: method,
157-
...data,
93+
break;
94+
case "wakeUp":
95+
this.wakeup(parsed_message);
96+
break;
97+
case "error":
98+
this.error(parsed_message);
99+
break;
100+
case "no method":
101+
console.warn(`${this._tag}: Message discarded`);
102+
break;
103+
104+
default:
105+
throw new Error(`Unknown method ${parsed_message.method}`);
106+
break;
107+
}
108+
return true;
109+
}
110+
111+
private async _init(message: OFSMessage) {
112+
this.init(message);
113+
var messageData: OFSMessage = {
114+
apiVersion: 1,
115+
method: "initEnd",
116+
};
117+
this._sendWebMessage(messageData);
118+
}
119+
120+
private _storeCredentials(message: OFSMessage) {
121+
if (message.securedData) {
122+
console.log(`${this._tag}: Processing`, message.securedData);
123+
// STEP 1: are we going to create a proxy?
124+
if (
125+
message.securedData.ofsInstance &&
126+
message.securedData.ofsClientId &&
127+
message.securedData.ofsClientSecret
128+
) {
129+
this._proxy = new OFS({
130+
instance: message.securedData.ofsInstance,
131+
clientId: message.securedData.ofsClientId,
132+
clientSecret: message.securedData.ofsClientSecret,
158133
});
159-
}
160-
161-
private _setup() {
162-
console.log("OFS plugin ready");
163-
window.addEventListener(
164-
"message",
165-
this._getWebMessage.bind(this),
166-
false
167-
);
168-
var messageData: OFSMessage = {
169-
apiVersion: 1,
170-
method: "ready",
171-
sendInitData: true,
172-
};
173-
this._sendWebMessage(messageData);
174-
}
175-
176-
// There should be always an 'open' method
177-
abstract open(data: OFSOpenMessage): void;
178-
179-
// These methods can be overwritten
180-
init(message: OFSMessage) {
181-
// Nothing to be done if not needed
182-
console.warn(`${this._tag}: Empty init method`);
183-
}
184-
185-
public close(data?: any): void {
186-
this.sendMessage(Method.Close, data);
187-
}
188-
189-
public update(data?: any): void {
190-
this.sendMessage(Method.Update, data);
191-
}
192-
193-
error(parsed_message: OFSMessage) {
194-
throw new Error("ERROR Method not implemented.");
195-
}
196-
wakeup(parsed_message: OFSMessage) {
197-
throw new Error("WAKEUP Method not implemented.");
198-
}
199-
updateResult(parsed_message: OFSMessage) {
200-
throw new Error("UPDATERESULT Method not implemented.");
201-
}
134+
}
135+
}
136+
}
137+
138+
private static _getOriginURL(url: string) {
139+
if (url != "") {
140+
if (url.indexOf("://") > -1) {
141+
return "https://" + url.split("/")[2];
142+
} else {
143+
return "https://" + url.split("/")[0];
144+
}
145+
}
146+
return "";
147+
}
148+
private _sendWebMessage(data: OFSMessage) {
149+
console.log(
150+
`${this._tag}: Sending message` + JSON.stringify(data, undefined, 4)
151+
);
152+
var originUrl =
153+
document.referrer ||
154+
(document.location.ancestorOrigins &&
155+
document.location.ancestorOrigins[0]) ||
156+
"";
157+
158+
if (originUrl) {
159+
parent.postMessage(data, OFSPlugin._getOriginURL(originUrl));
160+
}
161+
}
162+
163+
public sendMessage(method: Method, data?: any): void {
164+
this._sendWebMessage({
165+
apiVersion: 1,
166+
method: method,
167+
...data,
168+
});
169+
}
170+
171+
private _setup() {
172+
console.log("OFS plugin ready");
173+
window.addEventListener("message", this._getWebMessage.bind(this), false);
174+
var messageData: OFSMessage = {
175+
apiVersion: 1,
176+
method: "ready",
177+
sendInitData: true,
178+
};
179+
this._sendWebMessage(messageData);
180+
}
181+
182+
// There should be always an 'open' method
183+
abstract open(data: OFSOpenMessage): void;
184+
185+
// These methods can be overwritten
186+
init(message: OFSMessage) {
187+
// Nothing to be done if not needed
188+
console.warn(`${this._tag}: Empty init method`);
189+
}
190+
191+
public close(data?: any): void {
192+
this.sendMessage(Method.Close, data);
193+
}
194+
public callProcedure(data?: any): void {
195+
this.sendMessage(Method.CallProcedure, data);
196+
}
197+
public update(data?: any): void {
198+
this.sendMessage(Method.Update, data);
199+
}
200+
201+
error(parsed_message: OFSMessage) {
202+
throw new Error("ERROR Method not implemented.");
203+
}
204+
wakeup(parsed_message: OFSMessage) {
205+
throw new Error("WAKEUP Method not implemented.");
206+
}
207+
updateResult(parsed_message: OFSMessage) {
208+
throw new Error("UPDATERESULT Method not implemented.");
209+
}
210+
callProcedureResult(parsed_message: OFSMessage) {
211+
throw new Error("CALLPROCEDURERESULT Method not implemented.");
212+
}
202213
}

0 commit comments

Comments
 (0)