DBA Data[Home] [Help]

APPS.XDP_ADAPTER dependencies on XDP_ADAPTER

Line 1: PACKAGE BODY XDP_ADAPTER AS

1: PACKAGE BODY XDP_ADAPTER AS
2: /* $Header: XDPADBOB.pls 120.1 2005/06/08 23:39:05 appldev $ */
3:
4: e_RequiredInputDataNotPassed EXCEPTION;
5: e_DisplayNameNotUnique EXCEPTION;

Line 39: l_ApplicationMode xdp_adapter_types_b.application_mode%TYPE;

35: )
36: is
37: l_ChannelName varchar2(40);
38: l_AdapterName varchar2(40);
39: l_ApplicationMode xdp_adapter_types_b.application_mode%TYPE;
40: l_AdapterClass xdp_adapter_types_b.adapter_class%TYPE;
41: l_ConnReqFlag xdp_adapter_types_b.connection_required_flag%TYPE;
42: l_InboundReqFlag xdp_adapter_types_b.inbound_required_flag%TYPE;
43: l_LogFileName xdp_adapter_reg.log_file_name%TYPE;

Line 40: l_AdapterClass xdp_adapter_types_b.adapter_class%TYPE;

36: is
37: l_ChannelName varchar2(40);
38: l_AdapterName varchar2(40);
39: l_ApplicationMode xdp_adapter_types_b.application_mode%TYPE;
40: l_AdapterClass xdp_adapter_types_b.adapter_class%TYPE;
41: l_ConnReqFlag xdp_adapter_types_b.connection_required_flag%TYPE;
42: l_InboundReqFlag xdp_adapter_types_b.inbound_required_flag%TYPE;
43: l_LogFileName xdp_adapter_reg.log_file_name%TYPE;
44: l_FeID number := -1;

Line 41: l_ConnReqFlag xdp_adapter_types_b.connection_required_flag%TYPE;

37: l_ChannelName varchar2(40);
38: l_AdapterName varchar2(40);
39: l_ApplicationMode xdp_adapter_types_b.application_mode%TYPE;
40: l_AdapterClass xdp_adapter_types_b.adapter_class%TYPE;
41: l_ConnReqFlag xdp_adapter_types_b.connection_required_flag%TYPE;
42: l_InboundReqFlag xdp_adapter_types_b.inbound_required_flag%TYPE;
43: l_LogFileName xdp_adapter_reg.log_file_name%TYPE;
44: l_FeID number := -1;
45:

Line 42: l_InboundReqFlag xdp_adapter_types_b.inbound_required_flag%TYPE;

38: l_AdapterName varchar2(40);
39: l_ApplicationMode xdp_adapter_types_b.application_mode%TYPE;
40: l_AdapterClass xdp_adapter_types_b.adapter_class%TYPE;
41: l_ConnReqFlag xdp_adapter_types_b.connection_required_flag%TYPE;
42: l_InboundReqFlag xdp_adapter_types_b.inbound_required_flag%TYPE;
43: l_LogFileName xdp_adapter_reg.log_file_name%TYPE;
44: l_FeID number := -1;
45:
46: l_GenCountActive NUMBER := 0;

Line 43: l_LogFileName xdp_adapter_reg.log_file_name%TYPE;

39: l_ApplicationMode xdp_adapter_types_b.application_mode%TYPE;
40: l_AdapterClass xdp_adapter_types_b.adapter_class%TYPE;
41: l_ConnReqFlag xdp_adapter_types_b.connection_required_flag%TYPE;
42: l_InboundReqFlag xdp_adapter_types_b.inbound_required_flag%TYPE;
43: l_LogFileName xdp_adapter_reg.log_file_name%TYPE;
44: l_FeID number := -1;
45:
46: l_GenCountActive NUMBER := 0;
47: l_GenCountFuture NUMBER := 0;

Line 58: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.CREATE_ADAPTER',

54: l_count number := 0;
55:
56: begin
57: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
58: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.CREATE_ADAPTER',
59: 'BEGIN:p_AdapterDispName: '||p_AdapterDispName);
60: end if;
61: p_retcode := 0;
62: p_errbuf := '';

Line 82: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

78: p_AdapterType is null or
79: p_AdapterDispName is null or
80: p_ConcQID is null then
81: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then
82: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
83: 'Required parameters are not passed');
84: end if;
85: raise e_RequiredInputDataNotPassed;
86: end if;

Line 91: select count(*) into l_count from xdp_adapter_reg

87:
88: --
89: -- Validate unique display name
90: --
91: select count(*) into l_count from xdp_adapter_reg
92: where adapter_display_name = p_AdapterDispName;
93: if l_count > 0 then
94: raise e_DisplayNameNotUnique;
95: end if;

Line 97: l_FeID := XDP_ADAPTER_CORE_DB.Get_Fe_Id_For_Name (p_FeName);

93: if l_count > 0 then
94: raise e_DisplayNameNotUnique;
95: end if;
96:
97: l_FeID := XDP_ADAPTER_CORE_DB.Get_Fe_Id_For_Name (p_FeName);
98:
99: select application_mode, adapter_class, connection_required_flag, inbound_required_flag
100: into l_ApplicationMode, l_AdapterClass, l_ConnReqFlag, l_InboundReqFlag
101: from xdp_adapter_types_b

Line 101: from xdp_adapter_types_b

97: l_FeID := XDP_ADAPTER_CORE_DB.Get_Fe_Id_For_Name (p_FeName);
98:
99: select application_mode, adapter_class, connection_required_flag, inbound_required_flag
100: into l_ApplicationMode, l_AdapterClass, l_ConnReqFlag, l_InboundReqFlag
101: from xdp_adapter_types_b
102: where adapter_type = p_AdapterType;
103:
104: --
105: -- Validate parameters for non-implemented adapters

Line 147: XDP_ADAPTER_CORE_DB.Are_Adapter_Generics_Available (

143: --
144: -- Validate software versions available
145: --
146:
147: XDP_ADAPTER_CORE_DB.Are_Adapter_Generics_Available (
148: p_fe_id => l_FeID,
149: p_AdapterType => p_AdapterType,
150: p_GenCountActive => l_GenCountActive,
151: p_GenCountFuture => l_GenCountFuture);

Line 162: FND_LOG.STRING (FND_LOG.LEVEL_EXCEPTION, 'XDP_ADAPTER.CREATE_ADAPTER',

158: l_StartStatus := pv_statusStopped;
159: else
160: l_StartStatus := pv_statusNotAvailable;
161: if( FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
162: FND_LOG.STRING (FND_LOG.LEVEL_EXCEPTION, 'XDP_ADAPTER.CREATE_ADAPTER',
163: 'Adapter is not available');
164: end if;
165: end if;
166: end if;

Line 168: XDP_ADAPTER_CORE_DB.CreateNewAdapterChannel(p_FeName, l_ChannelName);

164: end if;
165: end if;
166: end if;
167:
168: XDP_ADAPTER_CORE_DB.CreateNewAdapterChannel(p_FeName, l_ChannelName);
169: if( FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
170: FND_LOG.STRING (FND_LOG.LEVEL_EXCEPTION, 'XDP_ADAPTER.CREATE_ADAPTER',
171: 'Channel name is: '||l_ChannelName);
172: end if;

Line 170: FND_LOG.STRING (FND_LOG.LEVEL_EXCEPTION, 'XDP_ADAPTER.CREATE_ADAPTER',

166: end if;
167:
168: XDP_ADAPTER_CORE_DB.CreateNewAdapterChannel(p_FeName, l_ChannelName);
169: if( FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
170: FND_LOG.STRING (FND_LOG.LEVEL_EXCEPTION, 'XDP_ADAPTER.CREATE_ADAPTER',
171: 'Channel name is: '||l_ChannelName);
172: end if;
173:
174: -- Fill in the Consumer Name

Line 184: XDP_ADAPTER_CORE_DB.LoadNewAdapter( l_ChannelName,

180:
181: -- Append .log to the log file name if not present already
182: l_LogFileName := Add_Log_File_Extension(p_LogFileName);
183:
184: XDP_ADAPTER_CORE_DB.LoadNewAdapter( l_ChannelName,
185: l_FeID,
186: p_AdapterType,
187: l_AdapterName,
188: p_AdapterDispName,

Line 209: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

205: FND_MESSAGE.CLEAR;
206: fnd_message.set_name('FND','UNIQUE-DUPLICATE NAME');
207: p_errbuf := FND_MESSAGE.GET;
208: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then
209: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
210: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
211: end if;
212: when e_NoGenericExists then
213: p_retCode := pv_retAdapterNoGenExists;

Line 215: fnd_message.set_name('XDP','XDP_ADAPTER_NO_SW_GEN_EXISTS');

211: end if;
212: when e_NoGenericExists then
213: p_retCode := pv_retAdapterNoGenExists;
214: FND_MESSAGE.CLEAR;
215: fnd_message.set_name('XDP','XDP_ADAPTER_NO_SW_GEN_EXISTS');
216: p_errbuf := FND_MESSAGE.GET;
217: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then
218: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
219: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);

Line 218: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

214: FND_MESSAGE.CLEAR;
215: fnd_message.set_name('XDP','XDP_ADAPTER_NO_SW_GEN_EXISTS');
216: p_errbuf := FND_MESSAGE.GET;
217: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then
218: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
219: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
220: end if;
221: when e_AdapterConfigNA then
222: p_retCode := pv_retAdapterConfigNA;

Line 224: fnd_message.set_name('XDP','XDP_ADAPTER_NOT_CONFIGURABLE');

220: end if;
221: when e_AdapterConfigNA then
222: p_retCode := pv_retAdapterConfigNA;
223: FND_MESSAGE.CLEAR;
224: fnd_message.set_name('XDP','XDP_ADAPTER_NOT_CONFIGURABLE');
225: fnd_message.set_token('OPERATION', 'Create');
226: p_errbuf := FND_MESSAGE.GET;
227: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then
228: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

Line 228: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

224: fnd_message.set_name('XDP','XDP_ADAPTER_NOT_CONFIGURABLE');
225: fnd_message.set_token('OPERATION', 'Create');
226: p_errbuf := FND_MESSAGE.GET;
227: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then
228: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
229: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
230: end if;
231: --when e_AsyncParamWrong then
232: -- p_retCode := pv_retAdapterAsyncParamWrong;

Line 234: -- fnd_message.set_name('XDP','XDP_ADAPTER_ASYNC_PARAM_WRONG');

230: end if;
231: --when e_AsyncParamWrong then
232: -- p_retCode := pv_retAdapterAsyncParamWrong;
233: -- FND_MESSAGE.CLEAR;
234: -- fnd_message.set_name('XDP','XDP_ADAPTER_ASYNC_PARAM_WRONG');
235: -- p_errbuf := FND_MESSAGE.GET;
236: -- FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
237: -- 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
238: when e_InboundParamWrong then

Line 236: -- FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

232: -- p_retCode := pv_retAdapterAsyncParamWrong;
233: -- FND_MESSAGE.CLEAR;
234: -- fnd_message.set_name('XDP','XDP_ADAPTER_ASYNC_PARAM_WRONG');
235: -- p_errbuf := FND_MESSAGE.GET;
236: -- FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
237: -- 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
238: when e_InboundParamWrong then
239: p_retCode := pv_retAdapterInboundParamWrong;
240: FND_MESSAGE.CLEAR;

Line 241: fnd_message.set_name('XDP','XDP_ADAPTER_INBND_PARAM_WRONG');

237: -- 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
238: when e_InboundParamWrong then
239: p_retCode := pv_retAdapterInboundParamWrong;
240: FND_MESSAGE.CLEAR;
241: fnd_message.set_name('XDP','XDP_ADAPTER_INBND_PARAM_WRONG');
242: p_errbuf := FND_MESSAGE.GET;
243: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then
244: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
245: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);

Line 244: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

240: FND_MESSAGE.CLEAR;
241: fnd_message.set_name('XDP','XDP_ADAPTER_INBND_PARAM_WRONG');
242: p_errbuf := FND_MESSAGE.GET;
243: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then
244: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
245: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
246: end if;
247: when e_ImplParamWrong then
248: p_retCode := pv_retAdapterImplParamWrong;

Line 250: fnd_message.set_name('XDP','XDP_ADAPTER_IMPL_PARAM_WRONG');

246: end if;
247: when e_ImplParamWrong then
248: p_retCode := pv_retAdapterImplParamWrong;
249: FND_MESSAGE.CLEAR;
250: fnd_message.set_name('XDP','XDP_ADAPTER_IMPL_PARAM_WRONG');
251: p_errbuf := FND_MESSAGE.GET;
252: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then
253: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
254: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);

Line 253: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

249: FND_MESSAGE.CLEAR;
250: fnd_message.set_name('XDP','XDP_ADAPTER_IMPL_PARAM_WRONG');
251: p_errbuf := FND_MESSAGE.GET;
252: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then
253: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
254: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
255: end if;
256: when e_ConnParamWrong then
257: p_retCode := pv_retAdapterConnParamWrong;

Line 259: fnd_message.set_name('XDP','XDP_ADAPTER_CONN_PARAM_WRONG');

255: end if;
256: when e_ConnParamWrong then
257: p_retCode := pv_retAdapterConnParamWrong;
258: FND_MESSAGE.CLEAR;
259: fnd_message.set_name('XDP','XDP_ADAPTER_CONN_PARAM_WRONG');
260: p_errbuf := FND_MESSAGE.GET;
261: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then
262: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
263: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);

Line 262: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

258: FND_MESSAGE.CLEAR;
259: fnd_message.set_name('XDP','XDP_ADAPTER_CONN_PARAM_WRONG');
260: p_errbuf := FND_MESSAGE.GET;
261: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then
262: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
263: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
264: end if;
265: when others then
266: if SQLCODE <> 0 then

Line 274: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

270: p_retCode := pv_retAdapterOtherError;
271: p_errbuf := 'Other non-SQL error';
272: END IF;
273: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then
274: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
275: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
276: end if;
277: end Create_Adapter;
278:

Line 300: l_ApplicationMode xdp_adapter_types_b.application_mode%TYPE;

296: )
297: is
298: l_AdapterLocked varchar2(1) := 'N';
299: l_CurrentStatus varchar2(30);
300: l_ApplicationMode xdp_adapter_types_b.application_mode%TYPE;
301: l_AdapterClass xdp_adapter_types_b.adapter_class%TYPE;
302: l_ConnReqFlag xdp_adapter_types_b.connection_required_flag%TYPE;
303: l_InboundReqFlag xdp_adapter_types_b.inbound_required_flag%TYPE;
304: lv_mode VARCHAR2(8); -- maintenance mode profile

Line 301: l_AdapterClass xdp_adapter_types_b.adapter_class%TYPE;

297: is
298: l_AdapterLocked varchar2(1) := 'N';
299: l_CurrentStatus varchar2(30);
300: l_ApplicationMode xdp_adapter_types_b.application_mode%TYPE;
301: l_AdapterClass xdp_adapter_types_b.adapter_class%TYPE;
302: l_ConnReqFlag xdp_adapter_types_b.connection_required_flag%TYPE;
303: l_InboundReqFlag xdp_adapter_types_b.inbound_required_flag%TYPE;
304: lv_mode VARCHAR2(8); -- maintenance mode profile
305:

Line 302: l_ConnReqFlag xdp_adapter_types_b.connection_required_flag%TYPE;

298: l_AdapterLocked varchar2(1) := 'N';
299: l_CurrentStatus varchar2(30);
300: l_ApplicationMode xdp_adapter_types_b.application_mode%TYPE;
301: l_AdapterClass xdp_adapter_types_b.adapter_class%TYPE;
302: l_ConnReqFlag xdp_adapter_types_b.connection_required_flag%TYPE;
303: l_InboundReqFlag xdp_adapter_types_b.inbound_required_flag%TYPE;
304: lv_mode VARCHAR2(8); -- maintenance mode profile
305:
306: l_LogFileName xdp_adapter_reg.log_file_name%TYPE;

Line 303: l_InboundReqFlag xdp_adapter_types_b.inbound_required_flag%TYPE;

299: l_CurrentStatus varchar2(30);
300: l_ApplicationMode xdp_adapter_types_b.application_mode%TYPE;
301: l_AdapterClass xdp_adapter_types_b.adapter_class%TYPE;
302: l_ConnReqFlag xdp_adapter_types_b.connection_required_flag%TYPE;
303: l_InboundReqFlag xdp_adapter_types_b.inbound_required_flag%TYPE;
304: lv_mode VARCHAR2(8); -- maintenance mode profile
305:
306: l_LogFileName xdp_adapter_reg.log_file_name%TYPE;
307:

Line 306: l_LogFileName xdp_adapter_reg.log_file_name%TYPE;

302: l_ConnReqFlag xdp_adapter_types_b.connection_required_flag%TYPE;
303: l_InboundReqFlag xdp_adapter_types_b.inbound_required_flag%TYPE;
304: lv_mode VARCHAR2(8); -- maintenance mode profile
305:
306: l_LogFileName xdp_adapter_reg.log_file_name%TYPE;
307:
308: e_AdapterConfigNA EXCEPTION;
309:
310: l_count number := 0;

Line 314: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.UPDATE_ADAPTER',

310: l_count number := 0;
311:
312: BEGIN
313: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
314: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.UPDATE_ADAPTER',
315: 'BEGIN:p_ChannelName: '||p_ChannelName);
316: end if;
317: p_retcode := 0;
318: p_errbuf := '';

Line 331: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADAPTER',

327: -- **********
328:
329: if p_ChannelName is null then
330: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
331: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADAPTER',
332: 'Required parameters are not passed');
333: end if;
334: raise e_RequiredInputDataNotPassed;
335: end if;

Line 337: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName,

333: end if;
334: raise e_RequiredInputDataNotPassed;
335: end if;
336:
337: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName,
338: XDP_ADAPTER.pv_opUpdate,
339: l_CurrentStatus) then
340: raise e_InvalidAdapterState;
341: end if;

Line 338: XDP_ADAPTER.pv_opUpdate,

334: raise e_RequiredInputDataNotPassed;
335: end if;
336:
337: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName,
338: XDP_ADAPTER.pv_opUpdate,
339: l_CurrentStatus) then
340: raise e_InvalidAdapterState;
341: end if;
342:

Line 344: l_AdapterLocked := XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify(p_ChannelName);

340: raise e_InvalidAdapterState;
341: end if;
342:
343: --TODO do we really need to take lock, state is already one of the STOPPED
344: l_AdapterLocked := XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify(p_ChannelName);
345: if l_AdapterLocked = 'N' then
346: raise e_UnabletoLockAdapter;
347: end if;
348:

Line 352: select count(*) into l_count from xdp_adapter_reg

348:
349: --
350: -- Validate unique display name
351: --
352: select count(*) into l_count from xdp_adapter_reg
353: where adapter_display_name = p_AdapterDispName and
354: channel_name <> p_ChannelName;
355: if l_count > 0 then
356: raise e_DisplayNameNotUnique;

Line 361: from xdp_adapter_types_b xat, xdp_adapter_reg xar

357: end if;
358:
359: select xat.application_mode, xat.adapter_class, xat.connection_required_flag, xat.inbound_required_flag
360: into l_ApplicationMode, l_AdapterClass, l_ConnReqFlag, l_InboundReqFlag
361: from xdp_adapter_types_b xat, xdp_adapter_reg xar
362: where xat.adapter_type = xar.adapter_type
363: and xar.channel_name = p_ChannelName;
364:
365: --

Line 409: XDP_ADAPTER_CORE_DB.UpdateAdapter(

405: -- Append .log to the log file name if not present already
406: l_LogFileName := Add_Log_File_Extension(p_LogFileName);
407:
408:
409: XDP_ADAPTER_CORE_DB.UpdateAdapter(
410: p_ChannelName => p_ChannelName,
411: p_AdapterName => p_AdapterName,
412: p_AdapterDispName => p_AdapterDispName,
413: p_SvcInstId => p_ConcQID,

Line 425: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

421: p_CmdLineOpts => p_CmdLineOpts,
422: p_CmdLineArgs => p_CmdLineArgs
423: );
424:
425: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
426: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
427: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.UPDATE_ADAPTER',
428: 'Could not release the lock, Channel name: '||p_ChannelName);
429: end if;

Line 427: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.UPDATE_ADAPTER',

423: );
424:
425: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
426: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
427: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.UPDATE_ADAPTER',
428: 'Could not release the lock, Channel name: '||p_ChannelName);
429: end if;
430: end if;
431:

Line 435: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

431:
432: exception
433: when e_DisplayNameNotUnique then
434: if l_AdapterLocked = 'Y' then
435: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
436: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
437: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.UPDATE_ADAPTER',
438: 'Could not release the lock, Channel name: '||p_ChannelName);
439: end if;

Line 437: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.UPDATE_ADAPTER',

433: when e_DisplayNameNotUnique then
434: if l_AdapterLocked = 'Y' then
435: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
436: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
437: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.UPDATE_ADAPTER',
438: 'Could not release the lock, Channel name: '||p_ChannelName);
439: end if;
440: end if;
441: end if;

Line 447: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADAPTER',

443: FND_MESSAGE.CLEAR;
444: fnd_message.set_name('FND','UNIQUE-DUPLICATE NAME');
445: p_errbuf := FND_MESSAGE.GET;
446: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
447: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADAPTER',
448: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
449: end if;
450: when e_InvalidAdapterState then
451: p_retCode := pv_retAdapterInvalidState;

Line 456: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADAPTER',

452: FND_MESSAGE.CLEAR;
453: fnd_message.set_name('XDP','XDP_INVALID_ADAPTER_STATE');
454: p_errbuf := FND_MESSAGE.GET;
455: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
456: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADAPTER',
457: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
458: end if;
459: when e_UnabletoLockAdapter then
460: p_retCode := pv_retAdapterCannotLock;

Line 462: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE');

458: end if;
459: when e_UnabletoLockAdapter then
460: p_retCode := pv_retAdapterCannotLock;
461: FND_MESSAGE.CLEAR;
462: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE');
463: p_errbuf := FND_MESSAGE.GET;
464: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
465: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADAPTER',
466: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);

Line 465: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADAPTER',

461: FND_MESSAGE.CLEAR;
462: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE');
463: p_errbuf := FND_MESSAGE.GET;
464: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
465: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADAPTER',
466: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
467: end if;
468: when e_AdapterConfigNA then
469: p_retCode := pv_retAdapterConfigNA;

Line 471: fnd_message.set_name('XDP','XDP_ADAPTER_NOT_CONFIGURABLE');

467: end if;
468: when e_AdapterConfigNA then
469: p_retCode := pv_retAdapterConfigNA;
470: FND_MESSAGE.CLEAR;
471: fnd_message.set_name('XDP','XDP_ADAPTER_NOT_CONFIGURABLE');
472: fnd_message.set_token('OPERATION', 'Update');
473: p_errbuf := FND_MESSAGE.GET;
474: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
475: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

Line 475: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

471: fnd_message.set_name('XDP','XDP_ADAPTER_NOT_CONFIGURABLE');
472: fnd_message.set_token('OPERATION', 'Update');
473: p_errbuf := FND_MESSAGE.GET;
474: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
475: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
476: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
477: end if;
478: when e_ImplParamWrong then
479: p_retCode := pv_retAdapterImplParamWrong;

Line 481: fnd_message.set_name('XDP','XDP_ADAPTER_IMPL_PARAM_WRONG');

477: end if;
478: when e_ImplParamWrong then
479: p_retCode := pv_retAdapterImplParamWrong;
480: FND_MESSAGE.CLEAR;
481: fnd_message.set_name('XDP','XDP_ADAPTER_IMPL_PARAM_WRONG');
482: p_errbuf := FND_MESSAGE.GET;
483: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
484: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
485: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);

Line 484: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

480: FND_MESSAGE.CLEAR;
481: fnd_message.set_name('XDP','XDP_ADAPTER_IMPL_PARAM_WRONG');
482: p_errbuf := FND_MESSAGE.GET;
483: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
484: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
485: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
486: end if;
487: when e_InboundParamWrong then
488: p_retCode := pv_retAdapterInboundParamWrong;

Line 490: fnd_message.set_name('XDP','XDP_ADAPTER_INBND_PARAM_WRONG');

486: end if;
487: when e_InboundParamWrong then
488: p_retCode := pv_retAdapterInboundParamWrong;
489: FND_MESSAGE.CLEAR;
490: fnd_message.set_name('XDP','XDP_ADAPTER_INBND_PARAM_WRONG');
491: p_errbuf := FND_MESSAGE.GET;
492: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
493: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
494: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);

Line 493: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

489: FND_MESSAGE.CLEAR;
490: fnd_message.set_name('XDP','XDP_ADAPTER_INBND_PARAM_WRONG');
491: p_errbuf := FND_MESSAGE.GET;
492: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
493: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
494: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
495: end if;
496: when e_ConnParamWrong then
497: p_retCode := pv_retAdapterConnParamWrong;

Line 499: fnd_message.set_name('XDP','XDP_ADAPTER_CONN_PARAM_WRONG');

495: end if;
496: when e_ConnParamWrong then
497: p_retCode := pv_retAdapterConnParamWrong;
498: FND_MESSAGE.CLEAR;
499: fnd_message.set_name('XDP','XDP_ADAPTER_CONN_PARAM_WRONG');
500: p_errbuf := FND_MESSAGE.GET;
501: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
502: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
503: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);

Line 502: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

498: FND_MESSAGE.CLEAR;
499: fnd_message.set_name('XDP','XDP_ADAPTER_CONN_PARAM_WRONG');
500: p_errbuf := FND_MESSAGE.GET;
501: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
502: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
503: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
504: end if;
505: when others then
506: if l_AdapterLocked = 'Y' then

Line 507: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

503: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
504: end if;
505: when others then
506: if l_AdapterLocked = 'Y' then
507: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
508: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
509: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.UPDATE_ADAPTER',
510: 'Could not release the lock, Channel name: '||p_ChannelName);
511: end if;

Line 509: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.UPDATE_ADAPTER',

505: when others then
506: if l_AdapterLocked = 'Y' then
507: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
508: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
509: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.UPDATE_ADAPTER',
510: 'Could not release the lock, Channel name: '||p_ChannelName);
511: end if;
512: end if;
513: end if;

Line 522: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADAPTER',

518: p_retCode := pv_retAdapterOtherError;
519: p_errbuf := 'Other non-SQL error';
520: END IF;
521: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
522: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADAPTER',
523: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
524: end if;
525: END Update_Adapter;
526:

Line 542: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.DELETE_ADAPTER',

538: e_AdapterConfigNA EXCEPTION;
539:
540: begin
541: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
542: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.DELETE_ADAPTER',
543: 'BEGIN:p_ChannelName: '||p_ChannelName);
544: end if;
545: p_retcode := 0;
546: p_errbuf := '';

Line 559: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ADAPTER',

555: -- **********
556:
557: if p_ChannelName is null then
558: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
559: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ADAPTER',
560: 'Required parameters are not passed');
561: end if;
562: raise e_RequiredInputDataNotPassed;
563: end if;

Line 565: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName,

561: end if;
562: raise e_RequiredInputDataNotPassed;
563: end if;
564:
565: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName,
566: XDP_ADAPTER.pv_opDelete,
567: l_CurrentStatus) then
568: raise e_InvalidAdapterState;
569: end if;

Line 566: XDP_ADAPTER.pv_opDelete,

562: raise e_RequiredInputDataNotPassed;
563: end if;
564:
565: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName,
566: XDP_ADAPTER.pv_opDelete,
567: l_CurrentStatus) then
568: raise e_InvalidAdapterState;
569: end if;
570:

Line 572: l_AdapterLocked := XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify(p_ChannelName);

568: raise e_InvalidAdapterState;
569: end if;
570:
571: --TODO do we really need to take lock, state is already one of the STOPPED
572: l_AdapterLocked := XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify(p_ChannelName);
573: if l_AdapterLocked = 'N' then
574: raise e_UnabletoLockAdapter;
575: end if;
576:

Line 577: XDP_ADAPTER_CORE_DB.Delete_Adapter (p_channel_name => p_ChannelName);

573: if l_AdapterLocked = 'N' then
574: raise e_UnabletoLockAdapter;
575: end if;
576:
577: XDP_ADAPTER_CORE_DB.Delete_Adapter (p_channel_name => p_ChannelName);
578:
579: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
580: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
581: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.DELETE_ADAPTER',

Line 579: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then

575: end if;
576:
577: XDP_ADAPTER_CORE_DB.Delete_Adapter (p_channel_name => p_ChannelName);
578:
579: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
580: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
581: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.DELETE_ADAPTER',
582: 'Could not release the lock, Channel name: '||p_ChannelName);
583: end if;

Line 581: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.DELETE_ADAPTER',

577: XDP_ADAPTER_CORE_DB.Delete_Adapter (p_channel_name => p_ChannelName);
578:
579: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
580: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
581: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.DELETE_ADAPTER',
582: 'Could not release the lock, Channel name: '||p_ChannelName);
583: end if;
584: end if;
585:

Line 593: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ADAPTER',

589: FND_MESSAGE.CLEAR;
590: fnd_message.set_name('XDP','XDP_INVALID_ADAPTER_STATE');
591: p_errbuf := FND_MESSAGE.GET;
592: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
593: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ADAPTER',
594: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
595: end if;
596: when e_UnabletoLockAdapter then
597: p_retCode := pv_retAdapterCannotLock;

Line 599: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE');

595: end if;
596: when e_UnabletoLockAdapter then
597: p_retCode := pv_retAdapterCannotLock;
598: FND_MESSAGE.CLEAR;
599: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE');
600: p_errbuf := FND_MESSAGE.GET;
601: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
602: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ADAPTER',
603: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);

Line 602: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ADAPTER',

598: FND_MESSAGE.CLEAR;
599: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE');
600: p_errbuf := FND_MESSAGE.GET;
601: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
602: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ADAPTER',
603: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
604: end if;
605: when e_AdapterConfigNA then
606: p_retCode := pv_retAdapterConfigNA;

Line 608: fnd_message.set_name('XDP','XDP_ADAPTER_NOT_CONFIGURABLE');

604: end if;
605: when e_AdapterConfigNA then
606: p_retCode := pv_retAdapterConfigNA;
607: FND_MESSAGE.CLEAR;
608: fnd_message.set_name('XDP','XDP_ADAPTER_NOT_CONFIGURABLE');
609: fnd_message.set_token('OPERATION', 'Delete');
610: p_errbuf := FND_MESSAGE.GET;
611: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
612: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

Line 612: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',

608: fnd_message.set_name('XDP','XDP_ADAPTER_NOT_CONFIGURABLE');
609: fnd_message.set_token('OPERATION', 'Delete');
610: p_errbuf := FND_MESSAGE.GET;
611: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
612: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADAPTER',
613: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
614: end if;
615: when others then
616: if l_AdapterLocked = 'Y' then

Line 617: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

613: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
614: end if;
615: when others then
616: if l_AdapterLocked = 'Y' then
617: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
618: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
619: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.DELETE_ADAPTER',
620: 'Could not release the lock, Channel name: '||p_ChannelName);
621: end if;

Line 619: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.DELETE_ADAPTER',

615: when others then
616: if l_AdapterLocked = 'Y' then
617: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
618: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
619: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.DELETE_ADAPTER',
620: 'Could not release the lock, Channel name: '||p_ChannelName);
621: end if;
622: end if;
623: end if;

Line 632: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ADAPTER',

628: p_retCode := pv_retAdapterOtherError;
629: p_errbuf := 'Other non-SQL error';
630: END IF;
631: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 27 Apr 05
632: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ADAPTER',
633: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
634: end if;
635: end Delete_Adapter;
636:

Line 646: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.DELETE_ALL_FOR_FE',

642: l_Flag boolean := FALSE;
643: e_FEAdapterRunning EXCEPTION;
644: begin
645: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
646: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.DELETE_ALL_FOR_FE',
647: 'BEGIN:p_FeName: '||p_FeName);
648: end if;
649: p_retcode := 0;
650: p_errbuf := '';

Line 652: l_FeID := XDP_ADAPTER_CORE_DB.Get_Fe_Id_For_Name (p_FeName);

648: end if;
649: p_retcode := 0;
650: p_errbuf := '';
651:
652: l_FeID := XDP_ADAPTER_CORE_DB.Get_Fe_Id_For_Name (p_FeName);
653:
654: l_Flag := XDP_ADAPTER_CORE_DB.Is_FE_Adapter_Running (p_fe_id => l_FeID);
655: if (l_Flag) then
656: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05

Line 654: l_Flag := XDP_ADAPTER_CORE_DB.Is_FE_Adapter_Running (p_fe_id => l_FeID);

650: p_errbuf := '';
651:
652: l_FeID := XDP_ADAPTER_CORE_DB.Get_Fe_Id_For_Name (p_FeName);
653:
654: l_Flag := XDP_ADAPTER_CORE_DB.Is_FE_Adapter_Running (p_fe_id => l_FeID);
655: if (l_Flag) then
656: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
657: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ALL_FOR_FE',
658: 'Some adapters are running for the FE: '||p_FeName);

Line 657: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ALL_FOR_FE',

653:
654: l_Flag := XDP_ADAPTER_CORE_DB.Is_FE_Adapter_Running (p_fe_id => l_FeID);
655: if (l_Flag) then
656: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
657: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ALL_FOR_FE',
658: 'Some adapters are running for the FE: '||p_FeName);
659: end if;
660: raise e_FEAdapterRunning;
661: END IF;

Line 663: XDP_ADAPTER_CORE_DB.Delete_Adapters_For_FE (p_fe_id => l_FeID);

659: end if;
660: raise e_FEAdapterRunning;
661: END IF;
662:
663: XDP_ADAPTER_CORE_DB.Delete_Adapters_For_FE (p_fe_id => l_FeID);
664:
665: exception
666:
667: when e_FEAdapterRunning then

Line 673: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ALL_FOR_FE',

669: FND_MESSAGE.CLEAR;
670: fnd_message.set_name('XDP','XDP_FE_RUNNING');
671: p_errbuf := FND_MESSAGE.GET;
672: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
673: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ALL_FOR_FE',
674: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
675: end if;
676:
677: when others then

Line 686: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ALL_FOR_FE',

682: p_retCode := pv_retAdapterOtherError;
683: p_errbuf := 'Other non-SQL error';
684: END IF;
685: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
686: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ALL_FOR_FE',
687: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
688: end if;
689: end Delete_All_For_FE;
690:

Line 703: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.GENERIC_OPERATION',

699: l_ProcessID number;
700: l_CmdString varchar2(2000);
701: begin
702: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
703: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.GENERIC_OPERATION',
704: 'BEGIN:p_ChannelName: '||p_ChannelName);
705: end if;
706: p_retcode := 0;
707: p_errbuf := '';

Line 710: p_Operation => XDP_ADAPTER.pv_opGeneric,

706: p_retcode := 0;
707: p_errbuf := '';
708:
709: validate_operation(p_ChannelName => p_ChannelName,
710: p_Operation => XDP_ADAPTER.pv_opGeneric,
711: p_CPID => l_CPID,
712: p_ProcessID => l_ProcessID,
713: p_retcode => p_retcode,
714: p_errbuf => p_errbuf);

Line 720: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then

716: if p_retcode <> 0 then
717: return;
718: END IF;
719:
720: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
721:
722: l_CmdString := p_ChannelName || pv_SMParamDelimiter ||
723: p_OperationName || pv_SMParamDelimiter ||
724: p_OperationParam || pv_SMParamDelimiter;

Line 740: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.GENERIC_OPERATION',

736: p_retCode := pv_retAdapterOtherError;
737: p_errbuf := 'Other non-SQL error';
738: END IF;
739: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
740: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.GENERIC_OPERATION',
741: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
742: end if;
743: END Generic_Operation;
744:

Line 762: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.CREATE_ADMIN_REQUEST',

758: e_InvalidRequestDate EXCEPTION;
759:
760: begin
761: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
762: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.CREATE_ADMIN_REQUEST',
763: 'BEGIN:p_ChannelName: '||p_ChannelName);
764: end if;
765: p_retcode := 0;
766: p_errbuf := '';

Line 771: 'XDP_ADAPTER.CREATE_ADMIN_REQUEST',

767:
768: if p_ChannelName is null then
769: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
770: FND_LOG.STRING (FND_LOG.LEVEL_ERROR,
771: 'XDP_ADAPTER.CREATE_ADMIN_REQUEST',
772: 'Required parameters are not passed');
773: end if;
774: raise e_RequiredInputDataNotPassed;
775: end if;

Line 780: 'XDP_ADAPTER.CREATE_ADMIN_REQUEST',

776:
777: if p_RequestDate < sysdate then
778: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
779: FND_LOG.STRING (FND_LOG.LEVEL_ERROR,
780: 'XDP_ADAPTER.CREATE_ADMIN_REQUEST',
781: 'Request date is less than the sysdate');
782: end if;
783: raise e_InvalidRequestDate;
784: end if;

Line 786: XDP_ADAPTER_CORE_DB.SubmitAdapterAdminReq(

782: end if;
783: raise e_InvalidRequestDate;
784: end if;
785:
786: XDP_ADAPTER_CORE_DB.SubmitAdapterAdminReq(
787: p_ChannelName => p_ChannelName,
788: p_RequestType => p_RequestType,
789: p_RequestDate => p_RequestDate,
790: p_RequestedBy => p_RequestedBy,

Line 802: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADMIN_REQUEST',

798: FND_MESSAGE.CLEAR;
799: fnd_message.set_name('XDP','XDP_SCHED_REQ_FUTURE');
800: p_errbuf := FND_MESSAGE.GET;
801: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
802: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADMIN_REQUEST',
803: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
804: end if;
805: when others then
806: if SQLCODE <> 0 then

Line 814: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADMIN_REQUEST',

810: p_retCode := pv_retAdapterOtherError;
811: p_errbuf := 'Other non-SQL error';
812: END IF;
813: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
814: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CREATE_ADMIN_REQUEST',
815: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
816: end if;
817: end Create_Admin_Request;
818:

Line 832: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.UPDATE_ADMIN_REQUEST',

828: e_InvalidRequestDate EXCEPTION;
829:
830: begin
831: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
832: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.UPDATE_ADMIN_REQUEST',
833: 'BEGIN:p_RequestID: '||p_RequestID);
834: end if;
835: p_retcode := 0;
836: p_errbuf := '';

Line 841: 'XDP_ADAPTER.UPDATE_ADMIN_REQUEST',

837:
838: if p_RequestID is null then
839: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
840: FND_LOG.STRING (FND_LOG.LEVEL_ERROR,
841: 'XDP_ADAPTER.UPDATE_ADMIN_REQUEST',
842: 'Required parameters are not passed');
843: end if;
844: raise e_RequiredInputDataNotPassed;
845: end if;

Line 850: 'XDP_ADAPTER.CREATE_ADMIN_REQUEST',

846:
847: if p_RequestDate < sysdate then
848: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
849: FND_LOG.STRING (FND_LOG.LEVEL_ERROR,
850: 'XDP_ADAPTER.CREATE_ADMIN_REQUEST',
851: 'Request date is less than the sysdate');
852: end if;
853: raise e_InvalidRequestDate;
854: end if;

Line 856: XDP_ADAPTER_CORE_DB.UpdateAdapterAdminReq(

852: end if;
853: raise e_InvalidRequestDate;
854: end if;
855:
856: XDP_ADAPTER_CORE_DB.UpdateAdapterAdminReq(
857: p_RequestID => Update_Admin_Request.p_RequestID,
858: p_RequestDate => Update_Admin_Request.p_RequestDate,
859: p_RequestedBy => Update_Admin_Request.p_RequestedBy,
860: p_Freq => Update_Admin_Request.p_Freq);

Line 869: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADMIN_REQUEST',

865: FND_MESSAGE.CLEAR;
866: fnd_message.set_name('XDP','XDP_SCHED_REQ_FUTURE');
867: p_errbuf := FND_MESSAGE.GET;
868: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
869: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADMIN_REQUEST',
870: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
871: end if;
872:
873: when others then

Line 882: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADMIN_REQUEST',

878: p_retCode := pv_retAdapterOtherError;
879: p_errbuf := 'Other non-SQL error';
880: END IF;
881: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
882: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.UPDATE_ADMIN_REQUEST',
883: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
884: end if;
885: end Update_Admin_Request;
886:

Line 897: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.DELETE_ADMIN_REQUEST',

893: l_dummydate date;
894: l_jobID number;
895: begin
896: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
897: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.DELETE_ADMIN_REQUEST',
898: 'BEGIN:p_RequestID: '||p_RequestID);
899: end if;
900: p_retcode := 0;
901: p_errbuf := '';

Line 906: 'XDP_ADAPTER.DELETE_ADMIN_REQUEST',

902:
903: if p_RequestID is null then
904: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
905: FND_LOG.STRING (FND_LOG.LEVEL_ERROR,
906: 'XDP_ADAPTER.DELETE_ADMIN_REQUEST',
907: 'Required parameters are not passed');
908: end if;
909: raise e_RequiredInputDataNotPassed;
910: end if;

Line 912: XDP_ADAPTER_CORE_DB.RemoveAdapterAdminReq(

908: end if;
909: raise e_RequiredInputDataNotPassed;
910: end if;
911:
912: XDP_ADAPTER_CORE_DB.RemoveAdapterAdminReq(
913: p_RequestID => Delete_Admin_Request.p_RequestID);
914:
915: exception
916: when others then

Line 925: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ADMIN_REQUEST',

921: p_retCode := pv_retAdapterOtherError;
922: p_errbuf := 'Other non-SQL error';
923: END IF;
924: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
925: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DELETE_ADMIN_REQUEST',
926: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
927: end if;
928: end Delete_Admin_Request;
929:

Line 961: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.START_ADAPTER',

957:
958: e_MaxAdaptersReached EXCEPTION;
959: begin
960: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
961: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.START_ADAPTER',
962: 'BEGIN:p_ChannelName: '||p_ChannelName);
963: end if;
964: p_retcode := 0;
965: p_errbuf := '';

Line 969: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.START_ADAPTER',

965: p_errbuf := '';
966:
967: if p_ChannelName is null then
968: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
969: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.START_ADAPTER',
970: 'Required parameters are not passed');
971: end if;
972: raise e_RequiredInputDataNotPassed;
973: end if;

Line 975: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName,

971: end if;
972: raise e_RequiredInputDataNotPassed;
973: end if;
974:
975: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName,
976: XDP_ADAPTER.pv_opStartup,
977: l_CurrentStatus) then
978: raise e_InvalidAdapterState;
979: end if;

Line 976: XDP_ADAPTER.pv_opStartup,

972: raise e_RequiredInputDataNotPassed;
973: end if;
974:
975: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName,
976: XDP_ADAPTER.pv_opStartup,
977: l_CurrentStatus) then
978: raise e_InvalidAdapterState;
979: end if;
980:

Line 982: l_AdapterLocked := XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify(p_ChannelName);

978: raise e_InvalidAdapterState;
979: end if;
980:
981: --TODO do we really need to take lock, state is already one of the STOPPED
982: l_AdapterLocked := XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify(p_ChannelName);
983: if l_AdapterLocked = 'N' then
984: raise e_UnabletoLockAdapter;
985: end if;
986:

Line 987: XDP_ADAPTER_CORE_DB.FetchAdapterStartupInfo(

983: if l_AdapterLocked = 'N' then
984: raise e_UnabletoLockAdapter;
985: end if;
986:
987: XDP_ADAPTER_CORE_DB.FetchAdapterStartupInfo(
988: p_ChannelName,
989: l_CmdOptions,
990: l_CmdArgs,
991: l_ControlChannelName,

Line 1001: l_FeID := XDP_ADAPTER_CORE_DB.Get_Fe_Id_For_Name (l_FeName);

997: l_ConcQID,
998: l_InboundChannelName,
999: l_LogFileName);
1000:
1001: l_FeID := XDP_ADAPTER_CORE_DB.Get_Fe_Id_For_Name (l_FeName);
1002:
1003: l_Flag := XDP_ADAPTER_CORE_DB.Is_Max_Connection_Reached (l_FeID);
1004: if (l_Flag = FALSE) then
1005: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then

Line 1003: l_Flag := XDP_ADAPTER_CORE_DB.Is_Max_Connection_Reached (l_FeID);

999: l_LogFileName);
1000:
1001: l_FeID := XDP_ADAPTER_CORE_DB.Get_Fe_Id_For_Name (l_FeName);
1002:
1003: l_Flag := XDP_ADAPTER_CORE_DB.Is_Max_Connection_Reached (l_FeID);
1004: if (l_Flag = FALSE) then
1005: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1006: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1007: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.START_ADAPTER',

Line 1005: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then

1001: l_FeID := XDP_ADAPTER_CORE_DB.Get_Fe_Id_For_Name (l_FeName);
1002:
1003: l_Flag := XDP_ADAPTER_CORE_DB.Is_Max_Connection_Reached (l_FeID);
1004: if (l_Flag = FALSE) then
1005: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1006: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1007: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.START_ADAPTER',
1008: 'Could not release the lock, Channel name: '||p_ChannelName);
1009: end if;

Line 1007: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.START_ADAPTER',

1003: l_Flag := XDP_ADAPTER_CORE_DB.Is_Max_Connection_Reached (l_FeID);
1004: if (l_Flag = FALSE) then
1005: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1006: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1007: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.START_ADAPTER',
1008: 'Could not release the lock, Channel name: '||p_ChannelName);
1009: end if;
1010: end if;
1011:

Line 1036: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then

1032: l_CmdArgs || pv_SMParamDelimiter;
1033:
1034: XDP_CONTROLLER_CORE.VerifyControllerStatus(l_ConcQID, l_CPID, l_ControllerFlag);
1035: if l_ControllerFlag = 'N' then
1036: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1037: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1038: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.START_ADAPTER',
1039: 'Could not release the lock, Channel name: '||p_ChannelName);
1040: end if;

Line 1038: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.START_ADAPTER',

1034: XDP_CONTROLLER_CORE.VerifyControllerStatus(l_ConcQID, l_CPID, l_ControllerFlag);
1035: if l_ControllerFlag = 'N' then
1036: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1037: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1038: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.START_ADAPTER',
1039: 'Could not release the lock, Channel name: '||p_ChannelName);
1040: end if;
1041: end if;
1042:

Line 1046: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then

1042:
1043: raise e_ControllerNotRunning;
1044: end if;
1045:
1046: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1047:
1048: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1049: p_ChannelName => p_ChannelName,
1050: p_Status => pv_statusStarting);

Line 1048: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1044: end if;
1045:
1046: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1047:
1048: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1049: p_ChannelName => p_ChannelName,
1050: p_Status => pv_statusStarting);
1051:
1052: XDP_ADAPTER_CORE_PIPE.CleanupPipe(p_ChannelName => p_ChannelName);

Line 1052: XDP_ADAPTER_CORE_PIPE.CleanupPipe(p_ChannelName => p_ChannelName);

1048: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1049: p_ChannelName => p_ChannelName,
1050: p_Status => pv_statusStarting);
1051:
1052: XDP_ADAPTER_CORE_PIPE.CleanupPipe(p_ChannelName => p_ChannelName);
1053: XDP_CONTROLLER_CORE.LaunchAdapter(l_CPID, l_SMParamString);
1054:
1055: --dbms_output.put_line(substr(l_SMParamString, 1,255));
1056: else

Line 1057: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1053: XDP_CONTROLLER_CORE.LaunchAdapter(l_CPID, l_SMParamString);
1054:
1055: --dbms_output.put_line(substr(l_SMParamString, 1,255));
1056: else
1057: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1058: p_ChannelName => p_ChannelName,
1059: p_Status => pv_statusRunning);
1060:
1061: XDPCORE_FA.HandOverChannel (ChannelName => p_ChannelName,

Line 1069: if (XDP_ADAPTER.pv_callerContext = XDP_ADAPTER.pv_CallerContextUser) then

1065: ErrCode => p_retcode,
1066: ErrStr => p_errbuf);
1067: end if;
1068:
1069: if (XDP_ADAPTER.pv_callerContext = XDP_ADAPTER.pv_CallerContextUser) then
1070:
1071: -- Reset start error count to 0 for Automatic adapters
1072:
1073: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Automatic(p_ChannelName)) then

Line 1073: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Automatic(p_ChannelName)) then

1069: if (XDP_ADAPTER.pv_callerContext = XDP_ADAPTER.pv_CallerContextUser) then
1070:
1071: -- Reset start error count to 0 for Automatic adapters
1072:
1073: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Automatic(p_ChannelName)) then
1074:
1075: XDP_ERRORS_PKG.UPDATE_ERROR_COUNT (
1076: p_object_type => XDP_ADAPTER.pv_errorObjectTypeAdapter,
1077: p_object_key => p_ChannelName);

Line 1076: p_object_type => XDP_ADAPTER.pv_errorObjectTypeAdapter,

1072:
1073: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Automatic(p_ChannelName)) then
1074:
1075: XDP_ERRORS_PKG.UPDATE_ERROR_COUNT (
1076: p_object_type => XDP_ADAPTER.pv_errorObjectTypeAdapter,
1077: p_object_key => p_ChannelName);
1078: END IF;
1079: END IF;
1080:

Line 1081: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then

1077: p_object_key => p_ChannelName);
1078: END IF;
1079: END IF;
1080:
1081: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1082: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1083: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.START_ADAPTER',
1084: 'Could not release the lock, Channel name: '||p_ChannelName);
1085: end if;

Line 1083: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.START_ADAPTER',

1079: END IF;
1080:
1081: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1082: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1083: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.START_ADAPTER',
1084: 'Could not release the lock, Channel name: '||p_ChannelName);
1085: end if;
1086: end if;
1087:

Line 1095: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.START_ADAPTER',

1091: FND_MESSAGE.CLEAR;
1092: fnd_message.set_name('XDP','XDP_MAX_NUM_CONN');
1093: p_errbuf := FND_MESSAGE.GET;
1094: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1095: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.START_ADAPTER',
1096: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1097: end if;
1098: when e_InvalidAdapterState then
1099: p_retCode := pv_retAdapterInvalidState;

Line 1104: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.START_ADAPTER',

1100: FND_MESSAGE.CLEAR;
1101: fnd_message.set_name('XDP','XDP_INVALID_ADAPTER_STATE');
1102: p_errbuf := FND_MESSAGE.GET;
1103: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1104: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.START_ADAPTER',
1105: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1106: end if;
1107: when e_UnabletoLockAdapter then
1108: p_retCode := pv_retAdapterCannotLock;

Line 1110: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE');

1106: end if;
1107: when e_UnabletoLockAdapter then
1108: p_retCode := pv_retAdapterCannotLock;
1109: FND_MESSAGE.CLEAR;
1110: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE');
1111: p_errbuf := FND_MESSAGE.GET;
1112: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1113: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.START_ADAPTER',
1114: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);

Line 1113: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.START_ADAPTER',

1109: FND_MESSAGE.CLEAR;
1110: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE');
1111: p_errbuf := FND_MESSAGE.GET;
1112: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1113: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.START_ADAPTER',
1114: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1115: end if;
1116: when e_ControllerNotRunning then
1117: p_retCode := pv_retAdapterCtrlNotRunning;

Line 1122: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.START_ADAPTER',

1118: FND_MESSAGE.CLEAR;
1119: fnd_message.set_name('XDP','XDP_CONTROLLER_NOT_RUNNING');
1120: p_errbuf := FND_MESSAGE.GET;
1121: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1122: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.START_ADAPTER',
1123: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1124: end if;
1125: when others then
1126: if l_AdapterLocked = 'Y' then

Line 1127: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

1123: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1124: end if;
1125: when others then
1126: if l_AdapterLocked = 'Y' then
1127: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1128: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1129: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.START_ADAPTER',
1130: 'Could not release the lock, Channel name: '||p_ChannelName);
1131: end if;

Line 1129: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.START_ADAPTER',

1125: when others then
1126: if l_AdapterLocked = 'Y' then
1127: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1128: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1129: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.START_ADAPTER',
1130: 'Could not release the lock, Channel name: '||p_ChannelName);
1131: end if;
1132: end if;
1133: end if;

Line 1142: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.START_ADAPTER',

1138: p_retCode := pv_retAdapterOtherError;
1139: p_errbuf := 'Other non-SQL error';
1140: END IF;
1141: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1142: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.START_ADAPTER',
1143: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1144: end if;
1145: End Start_Adapter;
1146:

Line 1159: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.STOP_ADAPTER',

1155: l_ProcessID number;
1156: l_CmdString varchar2(2000);
1157: begin
1158: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1159: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.STOP_ADAPTER',
1160: 'BEGIN:p_ChannelName: '||p_ChannelName);
1161: end if;
1162: p_retcode := 0;
1163: p_errbuf := '';

Line 1166: p_Operation => XDP_ADAPTER.pv_opStop,

1162: p_retcode := 0;
1163: p_errbuf := '';
1164:
1165: validate_operation(p_ChannelName => p_ChannelName,
1166: p_Operation => XDP_ADAPTER.pv_opStop,
1167: p_CPID => l_CPID,
1168: p_ProcessID => l_ProcessID,
1169: p_retcode => p_retcode,
1170: p_errbuf => p_errbuf);

Line 1172: if p_retcode = XDP_ADAPTER.pv_retAdapterCannotLock then

1168: p_ProcessID => l_ProcessID,
1169: p_retcode => p_retcode,
1170: p_errbuf => p_errbuf);
1171:
1172: if p_retcode = XDP_ADAPTER.pv_retAdapterCannotLock then
1173:
1174: -- Stop operation is different, if we cannot lock
1175: -- we submit adapter admin request
1176:

Line 1179: l_JobID := XDP_ADAPTER_CORE_DB.DoesSystemReqAlreadyExist(

1175: -- we submit adapter admin request
1176:
1177: -- Submit a adapter admin request
1178: -- Commit should be done by the Caller
1179: l_JobID := XDP_ADAPTER_CORE_DB.DoesSystemReqAlreadyExist(
1180: p_ChannelName => p_ChannelName,
1181: p_RequestType => XDP_ADAPTER.pv_opStop,
1182: p_RequestDate => sysdate);
1183: if (l_JobID = 0) then

Line 1181: p_RequestType => XDP_ADAPTER.pv_opStop,

1177: -- Submit a adapter admin request
1178: -- Commit should be done by the Caller
1179: l_JobID := XDP_ADAPTER_CORE_DB.DoesSystemReqAlreadyExist(
1180: p_ChannelName => p_ChannelName,
1181: p_RequestType => XDP_ADAPTER.pv_opStop,
1182: p_RequestDate => sysdate);
1183: if (l_JobID = 0) then
1184: XDP_ADAPTER_CORE_DB.SubmitAdapterAdminReq (
1185: p_ChannelName => p_ChannelName,

Line 1184: XDP_ADAPTER_CORE_DB.SubmitAdapterAdminReq (

1180: p_ChannelName => p_ChannelName,
1181: p_RequestType => XDP_ADAPTER.pv_opStop,
1182: p_RequestDate => sysdate);
1183: if (l_JobID = 0) then
1184: XDP_ADAPTER_CORE_DB.SubmitAdapterAdminReq (
1185: p_ChannelName => p_ChannelName,
1186: p_RequestType => XDP_ADAPTER.pv_opStop,
1187: p_RequestedBy => XDP_ADAPTER.pv_adminReqBySystem,
1188: p_RequestID => l_RequestID,

Line 1186: p_RequestType => XDP_ADAPTER.pv_opStop,

1182: p_RequestDate => sysdate);
1183: if (l_JobID = 0) then
1184: XDP_ADAPTER_CORE_DB.SubmitAdapterAdminReq (
1185: p_ChannelName => p_ChannelName,
1186: p_RequestType => XDP_ADAPTER.pv_opStop,
1187: p_RequestedBy => XDP_ADAPTER.pv_adminReqBySystem,
1188: p_RequestID => l_RequestID,
1189: p_JobID => l_JobID);
1190: end if;

Line 1187: p_RequestedBy => XDP_ADAPTER.pv_adminReqBySystem,

1183: if (l_JobID = 0) then
1184: XDP_ADAPTER_CORE_DB.SubmitAdapterAdminReq (
1185: p_ChannelName => p_ChannelName,
1186: p_RequestType => XDP_ADAPTER.pv_opStop,
1187: p_RequestedBy => XDP_ADAPTER.pv_adminReqBySystem,
1188: p_RequestID => l_RequestID,
1189: p_JobID => l_JobID);
1190: end if;
1191: raise e_UnabletoLockAdapter;

Line 1197: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then

1193: elsif p_retcode <> 0 then
1194: return;
1195: end if;
1196:
1197: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1198:
1199: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1200: p_ChannelName => p_ChannelName,
1201: p_Status => pv_statusStopping);

Line 1199: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1195: end if;
1196:
1197: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1198:
1199: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1200: p_ChannelName => p_ChannelName,
1201: p_Status => pv_statusStopping);
1202:
1203: l_CmdString := p_ChannelName || pv_SMParamDelimiter;

Line 1205: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Automatic(p_ChannelName)) then

1201: p_Status => pv_statusStopping);
1202:
1203: l_CmdString := p_ChannelName || pv_SMParamDelimiter;
1204:
1205: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Automatic(p_ChannelName)) then
1206: if (XDP_ADAPTER.pv_callerContext = XDP_ADAPTER.pv_CallerContextUser) then
1207: l_CmdString := l_CmdString ||
1208: XDP_ADAPTER.pv_CallerContextUser ||
1209: pv_SMParamDelimiter;

Line 1206: if (XDP_ADAPTER.pv_callerContext = XDP_ADAPTER.pv_CallerContextUser) then

1202:
1203: l_CmdString := p_ChannelName || pv_SMParamDelimiter;
1204:
1205: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Automatic(p_ChannelName)) then
1206: if (XDP_ADAPTER.pv_callerContext = XDP_ADAPTER.pv_CallerContextUser) then
1207: l_CmdString := l_CmdString ||
1208: XDP_ADAPTER.pv_CallerContextUser ||
1209: pv_SMParamDelimiter;
1210: else

Line 1208: XDP_ADAPTER.pv_CallerContextUser ||

1204:
1205: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Automatic(p_ChannelName)) then
1206: if (XDP_ADAPTER.pv_callerContext = XDP_ADAPTER.pv_CallerContextUser) then
1207: l_CmdString := l_CmdString ||
1208: XDP_ADAPTER.pv_CallerContextUser ||
1209: pv_SMParamDelimiter;
1210: else
1211: l_CmdString := l_CmdString ||
1212: XDP_ADAPTER.pv_CallerContextAdmin ||

Line 1212: XDP_ADAPTER.pv_CallerContextAdmin ||

1208: XDP_ADAPTER.pv_CallerContextUser ||
1209: pv_SMParamDelimiter;
1210: else
1211: l_CmdString := l_CmdString ||
1212: XDP_ADAPTER.pv_CallerContextAdmin ||
1213: pv_SMParamDelimiter;
1214: END IF;
1215: END IF;
1216:

Line 1220: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1216:
1217: XDP_CONTROLLER_CORE.StopAdapter(l_CPID, l_CmdString);
1218:
1219: else
1220: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1221: p_ChannelName => p_ChannelName,
1222: p_Status => pv_statusStopped);
1223:
1224: -- Deactivate the automatic adapter in case user stops it.

Line 1225: if (XDP_ADAPTER.pv_callerContext = XDP_ADAPTER.pv_CallerContextUser) then

1221: p_ChannelName => p_ChannelName,
1222: p_Status => pv_statusStopped);
1223:
1224: -- Deactivate the automatic adapter in case user stops it.
1225: if (XDP_ADAPTER.pv_callerContext = XDP_ADAPTER.pv_CallerContextUser) then
1226:
1227: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Automatic(p_ChannelName)) then
1228:
1229: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

Line 1227: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Automatic(p_ChannelName)) then

1223:
1224: -- Deactivate the automatic adapter in case user stops it.
1225: if (XDP_ADAPTER.pv_callerContext = XDP_ADAPTER.pv_CallerContextUser) then
1226:
1227: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Automatic(p_ChannelName)) then
1228:
1229: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1230: p_ChannelName => p_ChannelName,
1231: p_Status => pv_statusDeactivated);

Line 1229: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1225: if (XDP_ADAPTER.pv_callerContext = XDP_ADAPTER.pv_CallerContextUser) then
1226:
1227: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Automatic(p_ChannelName)) then
1228:
1229: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1230: p_ChannelName => p_ChannelName,
1231: p_Status => pv_statusDeactivated);
1232: END IF;
1233: END IF;

Line 1237: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then

1233: END IF;
1234:
1235: end if;
1236:
1237: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1238: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1239: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.STOP_ADAPTER',
1240: 'Could not release the lock, Channel name: '||p_ChannelName);
1241: end if;

Line 1239: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.STOP_ADAPTER',

1235: end if;
1236:
1237: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1238: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1239: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.STOP_ADAPTER',
1240: 'Could not release the lock, Channel name: '||p_ChannelName);
1241: end if;
1242: end if;
1243:

Line 1249: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE_REQ_SUB');

1245:
1246: when e_UnabletoLockAdapter then
1247: p_retCode := pv_retAdapterCannotLockReqSub;
1248: FND_MESSAGE.CLEAR;
1249: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE_REQ_SUB');
1250: fnd_message.set_token('JOB_ID', l_JobID);
1251: p_errbuf := FND_MESSAGE.GET;
1252: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1253: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.STOP_ADAPTER',

Line 1253: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.STOP_ADAPTER',

1249: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE_REQ_SUB');
1250: fnd_message.set_token('JOB_ID', l_JobID);
1251: p_errbuf := FND_MESSAGE.GET;
1252: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1253: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.STOP_ADAPTER',
1254: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1255: end if;
1256: when others then
1257: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

Line 1257: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

1253: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.STOP_ADAPTER',
1254: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1255: end if;
1256: when others then
1257: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1258: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1259: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.STOP_ADAPTER',
1260: 'Could not release the lock, Channel name: '||p_ChannelName);
1261: end if;

Line 1259: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.STOP_ADAPTER',

1255: end if;
1256: when others then
1257: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1258: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1259: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.STOP_ADAPTER',
1260: 'Could not release the lock, Channel name: '||p_ChannelName);
1261: end if;
1262: end if;
1263: if SQLCODE <> 0 then

Line 1271: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.STOP_ADAPTER',

1267: p_retCode := pv_retAdapterOtherError;
1268: p_errbuf := 'Other non-SQL error';
1269: END IF;
1270: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1271: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.STOP_ADAPTER',
1272: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1273: end if;
1274: end Stop_Adapter;
1275:

Line 1286: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.SUSPEND_ADAPTER',

1282: l_ProcessID number;
1283: l_CmdString varchar2(2000);
1284: begin
1285: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1286: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.SUSPEND_ADAPTER',
1287: 'BEGIN:p_ChannelName: '||p_ChannelName);
1288: end if;
1289: p_retcode := 0;
1290: p_errbuf := '';

Line 1293: p_Operation => XDP_ADAPTER.pv_opSuspend,

1289: p_retcode := 0;
1290: p_errbuf := '';
1291:
1292: validate_operation(p_ChannelName => p_ChannelName,
1293: p_Operation => XDP_ADAPTER.pv_opSuspend,
1294: p_CPID => l_CPID,
1295: p_ProcessID => l_ProcessID,
1296: p_retcode => p_retcode,
1297: p_errbuf => p_errbuf);

Line 1303: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then

1299: if p_retcode <> 0 then
1300: return;
1301: END IF;
1302:
1303: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1304:
1305: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1306: p_ChannelName => p_ChannelName,
1307: p_Status => pv_statusSuspending);

Line 1305: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1301: END IF;
1302:
1303: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1304:
1305: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1306: p_ChannelName => p_ChannelName,
1307: p_Status => pv_statusSuspending);
1308:
1309: l_CmdString := p_ChannelName || pv_SMParamDelimiter;

Line 1314: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1310:
1311: XDP_CONTROLLER_CORE.SuspendAdapter(l_CPID, l_CmdString);
1312:
1313: else
1314: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1315: p_ChannelName => p_ChannelName,
1316: p_Status => pv_statusSuspended);
1317: end if;
1318:

Line 1319: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then

1315: p_ChannelName => p_ChannelName,
1316: p_Status => pv_statusSuspended);
1317: end if;
1318:
1319: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1320: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1321: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.SUSPEND_ADAPTER',
1322: 'Could not release the lock, Channel name: '||p_ChannelName);
1323: end if;

Line 1321: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.SUSPEND_ADAPTER',

1317: end if;
1318:
1319: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1320: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1321: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.SUSPEND_ADAPTER',
1322: 'Could not release the lock, Channel name: '||p_ChannelName);
1323: end if;
1324: end if;
1325:

Line 1329: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

1325:
1326: exception
1327:
1328: when others then
1329: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1330: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1331: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.SUSPEND_ADAPTER',
1332: 'Could not release the lock, Channel name: '||p_ChannelName);
1333: end if;

Line 1331: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.SUSPEND_ADAPTER',

1327:
1328: when others then
1329: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1330: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1331: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.SUSPEND_ADAPTER',
1332: 'Could not release the lock, Channel name: '||p_ChannelName);
1333: end if;
1334: end if;
1335: if SQLCODE <> 0 then

Line 1343: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.SUSPEND_ADAPTER',

1339: p_retCode := pv_retAdapterOtherError;
1340: p_errbuf := 'Other non-SQL error';
1341: END IF;
1342: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1343: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.SUSPEND_ADAPTER',
1344: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1345: end if;
1346: end Suspend_Adapter;
1347:

Line 1358: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.RESUME_ADAPTER',

1354: l_ProcessID number;
1355: l_CmdString varchar2(2000);
1356: begin
1357: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1358: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.RESUME_ADAPTER',
1359: 'BEGIN:p_ChannelName: '||p_ChannelName);
1360: end if;
1361: p_retcode := 0;
1362: p_errbuf := '';

Line 1365: p_Operation => XDP_ADAPTER.pv_opResume,

1361: p_retcode := 0;
1362: p_errbuf := '';
1363:
1364: validate_operation(p_ChannelName => p_ChannelName,
1365: p_Operation => XDP_ADAPTER.pv_opResume,
1366: p_CPID => l_CPID,
1367: p_ProcessID => l_ProcessID,
1368: p_retcode => p_retcode,
1369: p_errbuf => p_errbuf);

Line 1375: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then

1371: if p_retcode <> 0 then
1372: return;
1373: END IF;
1374:
1375: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1376:
1377: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1378: p_ChannelName => p_ChannelName,
1379: p_Status => pv_statusResuming);

Line 1377: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1373: END IF;
1374:
1375: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1376:
1377: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1378: p_ChannelName => p_ChannelName,
1379: p_Status => pv_statusResuming);
1380:
1381: l_CmdString := p_ChannelName || pv_SMParamDelimiter;

Line 1388: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1384:
1385: --HandOverChannel needs to be done by Controller
1386:
1387: else
1388: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1389: p_ChannelName => p_ChannelName,
1390: p_Status => pv_statusRunning);
1391:
1392: XDPCORE_FA.HandOverChannel (ChannelName => p_ChannelName,

Line 1400: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then

1396: ErrCode => p_retcode,
1397: ErrStr => p_errbuf);
1398: end if;
1399:
1400: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1401: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1402: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.RESUME_ADAPTER',
1403: 'Could not release the lock, Channel name: '||p_ChannelName);
1404: end if;

Line 1402: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.RESUME_ADAPTER',

1398: end if;
1399:
1400: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1401: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1402: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.RESUME_ADAPTER',
1403: 'Could not release the lock, Channel name: '||p_ChannelName);
1404: end if;
1405: end if;
1406:

Line 1410: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

1406:
1407: exception
1408:
1409: when others then
1410: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1411: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1412: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.RESUME_ADAPTER',
1413: 'Could not release the lock, Channel name: '||p_ChannelName);
1414: end if;

Line 1412: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.RESUME_ADAPTER',

1408:
1409: when others then
1410: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1411: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1412: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.RESUME_ADAPTER',
1413: 'Could not release the lock, Channel name: '||p_ChannelName);
1414: end if;
1415: end if;
1416: if SQLCODE <> 0 then

Line 1424: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.RESUME_ADAPTER',

1420: p_retCode := pv_retAdapterOtherError;
1421: p_errbuf := 'Other non-SQL error';
1422: END IF;
1423: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1424: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.RESUME_ADAPTER',
1425: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1426: end if;
1427: end Resume_Adapter;
1428:

Line 1440: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.CONNECT_ADAPTER',

1436: l_CmdString varchar2(2000);
1437:
1438: begin
1439: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1440: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.CONNECT_ADAPTER',
1441: 'BEGIN:p_ChannelName: '||p_ChannelName);
1442: end if;
1443: p_retcode := 0;
1444: p_errbuf := '';

Line 1447: p_Operation => XDP_ADAPTER.pv_opConnect,

1443: p_retcode := 0;
1444: p_errbuf := '';
1445:
1446: validate_operation(p_ChannelName => p_ChannelName,
1447: p_Operation => XDP_ADAPTER.pv_opConnect,
1448: p_CPID => l_CPID,
1449: p_ProcessID => l_ProcessID,
1450: p_retcode => p_retcode,
1451: p_errbuf => p_errbuf);

Line 1457: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then

1453: if p_retcode <> 0 then
1454: return;
1455: END IF;
1456:
1457: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1458:
1459: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1460: p_ChannelName => p_ChannelName,
1461: p_Status => pv_statusConnecting);

Line 1459: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1455: END IF;
1456:
1457: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1458:
1459: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1460: p_ChannelName => p_ChannelName,
1461: p_Status => pv_statusConnecting);
1462:
1463: l_CmdString := p_ChannelName || pv_SMParamDelimiter;

Line 1470: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1466:
1467: --HandOverChannel needs to be done by Controller
1468:
1469: else
1470: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1471: p_ChannelName => p_ChannelName,
1472: p_Status => pv_statusRunning);
1473:
1474: XDPCORE_FA.HandOverChannel (ChannelName => p_ChannelName,

Line 1482: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then

1478: ErrCode => p_retcode,
1479: ErrStr => p_errbuf);
1480: end if;
1481:
1482: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1483: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1484: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.CONNECT_ADAPTER',
1485: 'Could not release the lock, Channel name: '||p_ChannelName);
1486: end if;

Line 1484: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.CONNECT_ADAPTER',

1480: end if;
1481:
1482: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1483: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1484: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.CONNECT_ADAPTER',
1485: 'Could not release the lock, Channel name: '||p_ChannelName);
1486: end if;
1487: end if;
1488:

Line 1492: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

1488:
1489: exception
1490:
1491: when others then
1492: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1493: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1494: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.CONNECT_ADAPTER',
1495: 'Could not release the lock, Channel name: '||p_ChannelName);
1496: end if;

Line 1494: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.CONNECT_ADAPTER',

1490:
1491: when others then
1492: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1493: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1494: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.CONNECT_ADAPTER',
1495: 'Could not release the lock, Channel name: '||p_ChannelName);
1496: end if;
1497: end if;
1498: if SQLCODE <> 0 then

Line 1506: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CONNECT_ADAPTER',

1502: p_retCode := pv_retAdapterOtherError;
1503: p_errbuf := 'Other non-SQL error';
1504: END IF;
1505: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1506: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.CONNECT_ADAPTER',
1507: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1508: end if;
1509: end Connect_Adapter;
1510:

Line 1521: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.DISCONNECT_ADAPTER',

1517: l_ProcessID number;
1518: l_CmdString varchar2(2000);
1519: begin
1520: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1521: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.DISCONNECT_ADAPTER',
1522: 'BEGIN:p_ChannelName: '||p_ChannelName);
1523: end if;
1524: p_retcode := 0;
1525: p_errbuf := '';

Line 1528: p_Operation => XDP_ADAPTER.pv_opDisconnect,

1524: p_retcode := 0;
1525: p_errbuf := '';
1526:
1527: validate_operation(p_ChannelName => p_ChannelName,
1528: p_Operation => XDP_ADAPTER.pv_opDisconnect,
1529: p_CPID => l_CPID,
1530: p_ProcessID => l_ProcessID,
1531: p_retcode => p_retcode,
1532: p_errbuf => p_errbuf);

Line 1538: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then

1534: if p_retcode <> 0 then
1535: return;
1536: END IF;
1537:
1538: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1539:
1540: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1541: p_ChannelName => p_ChannelName,
1542: p_Status => pv_statusDisconnecting);

Line 1540: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1536: END IF;
1537:
1538: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1539:
1540: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1541: p_ChannelName => p_ChannelName,
1542: p_Status => pv_statusDisconnecting);
1543:
1544: l_CmdString := p_ChannelName || pv_SMParamDelimiter;

Line 1549: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1545:
1546: XDP_CONTROLLER_CORE.DisconnectAdapter(l_CPID, l_CmdString);
1547:
1548: else
1549: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1550: p_ChannelName => p_ChannelName,
1551: p_Status => pv_statusDisconnected);
1552: end if;
1553:

Line 1554: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then

1550: p_ChannelName => p_ChannelName,
1551: p_Status => pv_statusDisconnected);
1552: end if;
1553:
1554: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1555: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1556: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.DISCONNECT_ADAPTER',
1557: 'Could not release the lock, Channel name: '||p_ChannelName);
1558: end if;

Line 1556: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.DISCONNECT_ADAPTER',

1552: end if;
1553:
1554: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1555: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1556: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.DISCONNECT_ADAPTER',
1557: 'Could not release the lock, Channel name: '||p_ChannelName);
1558: end if;
1559: end if;
1560:

Line 1564: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

1560:
1561: exception
1562:
1563: when others then
1564: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1565: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1566: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.DISCONNECT_ADAPTER',
1567: 'Could not release the lock, Channel name: '||p_ChannelName);
1568: end if;

Line 1566: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.DISCONNECT_ADAPTER',

1562:
1563: when others then
1564: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1565: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1566: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.DISCONNECT_ADAPTER',
1567: 'Could not release the lock, Channel name: '||p_ChannelName);
1568: end if;
1569: end if;
1570: if SQLCODE <> 0 then

Line 1578: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DISCONNECT_ADAPTER',

1574: p_retCode := pv_retAdapterOtherError;
1575: p_errbuf := 'Other non-SQL error';
1576: END IF;
1577: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1578: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.DISCONNECT_ADAPTER',
1579: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1580: end if;
1581: end Disconnect_Adapter;
1582:

Line 1594: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.TERMINATE_ADAPTER',

1590: l_CmdString varchar2(2000);
1591: l_ProcessID number;
1592: begin
1593: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1594: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.TERMINATE_ADAPTER',
1595: 'BEGIN:p_ChannelName: '||p_ChannelName);
1596: end if;
1597: p_retcode := 0;
1598: p_errbuf := '';

Line 1601: p_Operation => XDP_ADAPTER.pv_opTerminate,

1597: p_retcode := 0;
1598: p_errbuf := '';
1599:
1600: validate_operation(p_ChannelName => p_ChannelName,
1601: p_Operation => XDP_ADAPTER.pv_opTerminate,
1602: p_CPID => l_CPID,
1603: p_ProcessID => l_ProcessID,
1604: p_retcode => p_retcode,
1605: p_errbuf => p_errbuf);

Line 1611: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then

1607: if p_retcode <> 0 then
1608: return;
1609: END IF;
1610:
1611: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1612:
1613: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1614: p_ChannelName => p_ChannelName,
1615: p_Status => pv_statusTerminating);

Line 1613: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1609: END IF;
1610:
1611: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1612:
1613: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1614: p_ChannelName => p_ChannelName,
1615: p_Status => pv_statusTerminating);
1616:
1617: l_CmdString := p_ChannelName || pv_SMParamDelimiter ||

Line 1622: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1618: l_ProcessID || pv_SMParamDelimiter;
1619:
1620: XDP_CONTROLLER_CORE.TerminateAdapter(l_CPID, l_CmdString);
1621: else
1622: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1623: p_ChannelName => p_ChannelName,
1624: p_Status => pv_statusTerminated,
1625: p_ErrorMsg => 'XDP_ADAPTER_TERMINATED');
1626: end if;

Line 1625: p_ErrorMsg => 'XDP_ADAPTER_TERMINATED');

1621: else
1622: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1623: p_ChannelName => p_ChannelName,
1624: p_Status => pv_statusTerminated,
1625: p_ErrorMsg => 'XDP_ADAPTER_TERMINATED');
1626: end if;
1627:
1628: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1629: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05

Line 1628: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then

1624: p_Status => pv_statusTerminated,
1625: p_ErrorMsg => 'XDP_ADAPTER_TERMINATED');
1626: end if;
1627:
1628: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1629: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1630: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.TERMINATE_ADAPTER',
1631: 'Could not release the lock, Channel name: '||p_ChannelName);
1632: end if;

Line 1630: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.TERMINATE_ADAPTER',

1626: end if;
1627:
1628: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
1629: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1630: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.TERMINATE_ADAPTER',
1631: 'Could not release the lock, Channel name: '||p_ChannelName);
1632: end if;
1633: end if;
1634:

Line 1638: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

1634:
1635: exception
1636:
1637: when others then
1638: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1639: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1640: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.TERMINATE_ADAPTER',
1641: 'Could not release the lock, Channel name: '||p_ChannelName);
1642: end if;

Line 1640: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.TERMINATE_ADAPTER',

1636:
1637: when others then
1638: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
1639: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1640: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.TERMINATE_ADAPTER',
1641: 'Could not release the lock, Channel name: '||p_ChannelName);
1642: end if;
1643: end if;
1644: if SQLCODE <> 0 then

Line 1652: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.TERMINATE_ADAPTER',

1648: p_retCode := pv_retAdapterOtherError;
1649: p_errbuf := 'Other non-SQL error';
1650: END IF;
1651: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1652: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.TERMINATE_ADAPTER',
1653: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1654: end if;
1655: end Terminate_Adapter;
1656:

Line 1679: XDP_ADAPTER_CORE_DB.LoadNewAdapterType(p_AdapterType,

1675: is
1676:
1677: begin
1678:
1679: XDP_ADAPTER_CORE_DB.LoadNewAdapterType(p_AdapterType,
1680: p_AdapterClass,
1681: p_ApplicationMode,
1682: p_InboundReqFlag,
1683: p_SyncBufSize,

Line 1703: xdp_adapter_reg

1699:
1700: CURSOR c1 IS
1701: SELECT 'x' FROM
1702: xdp_fes,
1703: xdp_adapter_reg
1704: WHERE xdp_fes.fe_id = p_fe_id
1705: AND xdp_fes.fe_id = xdp_adapter_reg.fe_id;
1706:
1707: BEGIN

Line 1705: AND xdp_fes.fe_id = xdp_adapter_reg.fe_id;

1701: SELECT 'x' FROM
1702: xdp_fes,
1703: xdp_adapter_reg
1704: WHERE xdp_fes.fe_id = p_fe_id
1705: AND xdp_fes.fe_id = xdp_adapter_reg.fe_id;
1706:
1707: BEGIN
1708: lv_result:=FALSE;
1709:

Line 1729: l_log_file_name xdp_adapter_reg_v.log_file_name%TYPE;

1725: p_gwyuid in VARCHAR2,
1726: p_two_task in VARCHAR2) return VARCHAR2
1727:
1728: AS
1729: l_log_file_name xdp_adapter_reg_v.log_file_name%TYPE;
1730: l_target_node xdp_adapter_reg_v.target_node%TYPE;
1731: l_file_id fnd_file_temp.file_id%TYPE;
1732: l_url VARCHAR2(2000);
1733:

Line 1730: l_target_node xdp_adapter_reg_v.target_node%TYPE;

1726: p_two_task in VARCHAR2) return VARCHAR2
1727:
1728: AS
1729: l_log_file_name xdp_adapter_reg_v.log_file_name%TYPE;
1730: l_target_node xdp_adapter_reg_v.target_node%TYPE;
1731: l_file_id fnd_file_temp.file_id%TYPE;
1732: l_url VARCHAR2(2000);
1733:
1734: BEGIN

Line 1738: FROM xdp_adapter_reg_v

1734: BEGIN
1735:
1736: SELECT log_file_name, target_node
1737: INTO l_log_file_name, l_target_node
1738: FROM xdp_adapter_reg_v
1739: WHERE channel_name = p_channel_name;
1740:
1741: -- Comment back in the below two lines when FND provides the API
1742: l_file_id := Fnd_Webfile.create_id(l_log_file_name, l_target_node);

Line 1783: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.VERIFY_ADAPTER',

1779: l_CurrentStatus varchar2(30);
1780:
1781: begin
1782: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1783: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.VERIFY_ADAPTER',
1784: 'BEGIN:p_ChannelName: '||p_ChannelName);
1785: end if;
1786: p_retcode := 0;
1787: p_errbuf := '';

Line 1791: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ADAPTER',

1787: p_errbuf := '';
1788:
1789: if p_ChannelName is null then
1790: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1791: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ADAPTER',
1792: 'Required parameters are not passed');
1793: end if;
1794: raise e_RequiredInputDataNotPassed;
1795: end if;

Line 1797: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName,

1793: end if;
1794: raise e_RequiredInputDataNotPassed;
1795: end if;
1796:
1797: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName,
1798: XDP_ADAPTER.pv_opVerify,
1799: l_CurrentStatus) then
1800: raise e_InvalidAdapterState;
1801: end if;

Line 1798: XDP_ADAPTER.pv_opVerify,

1794: raise e_RequiredInputDataNotPassed;
1795: end if;
1796:
1797: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName,
1798: XDP_ADAPTER.pv_opVerify,
1799: l_CurrentStatus) then
1800: raise e_InvalidAdapterState;
1801: end if;
1802:

Line 1804: --l_AdapterLocked := XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify(p_ChannelName);

1800: raise e_InvalidAdapterState;
1801: end if;
1802:
1803: --Hold session lock only for state change operations - bug3300862
1804: --l_AdapterLocked := XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify(p_ChannelName);
1805: --if l_AdapterLocked = 'N' then
1806: -- raise e_UnabletoLockAdapter;
1807: --end if;
1808:

Line 1809: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then

1805: --if l_AdapterLocked = 'N' then
1806: -- raise e_UnabletoLockAdapter;
1807: --end if;
1808:
1809: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1810:
1811: l_AdapterLocked1 := XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify('SESSION_'||p_ChannelName);
1812:
1813: if l_AdapterLocked1 = 'Y' then

Line 1811: l_AdapterLocked1 := XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify('SESSION_'||p_ChannelName);

1807: --end if;
1808:
1809: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
1810:
1811: l_AdapterLocked1 := XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify('SESSION_'||p_ChannelName);
1812:
1813: if l_AdapterLocked1 = 'Y' then
1814:
1815: -- Adapter NOT running, release the SESSION lock

Line 1820: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock('SESSION_'||p_ChannelName) = 'N' then

1816:
1817: --dbms_output.put_line('Got SESSION lock for: ' || p_ChannelName);
1818: --dbms_output.put_line('Adapter NOT RUNNING');
1819:
1820: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock('SESSION_'||p_ChannelName) = 'N' then
1821: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1822: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VERIFY_ADAPTER',
1823: 'Could not release SESSION lock, Channel name: '||p_ChannelName);
1824: end if;

Line 1822: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VERIFY_ADAPTER',

1818: --dbms_output.put_line('Adapter NOT RUNNING');
1819:
1820: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock('SESSION_'||p_ChannelName) = 'N' then
1821: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1822: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VERIFY_ADAPTER',
1823: 'Could not release SESSION lock, Channel name: '||p_ChannelName);
1824: end if;
1825: end if;
1826:

Line 1827: XDP_ADAPTER_CORE_DB.FetchAdapterInfo(

1823: 'Could not release SESSION lock, Channel name: '||p_ChannelName);
1824: end if;
1825: end if;
1826:
1827: XDP_ADAPTER_CORE_DB.FetchAdapterInfo(
1828: p_ChannelName => p_ChannelName,
1829: p_FEID => l_FeID,
1830: p_ProcessID => l_ProcessID,
1831: p_ConcQID => l_ConcQID);

Line 1833: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(

1829: p_FEID => l_FeID,
1830: p_ProcessID => l_ProcessID,
1831: p_ConcQID => l_ConcQID);
1832:
1833: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1834: p_ChannelName,
1835: pv_statusStoppedError,
1836: 'XDP_ADAPTER_ABNORMAL_EXIT',
1837: 'PROCESS_ID='||l_ProcessID||'#XDP#');

Line 1836: 'XDP_ADAPTER_ABNORMAL_EXIT',

1832:
1833: XDP_ADAPTER_CORE_DB.Update_Adapter_Status(
1834: p_ChannelName,
1835: pv_statusStoppedError,
1836: 'XDP_ADAPTER_ABNORMAL_EXIT',
1837: 'PROCESS_ID='||l_ProcessID||'#XDP#');
1838:
1839: raise e_OperationFailure;
1840: else

Line 1845: XDP_ADAPTER_CORE_DB.UpdateAdapter (

1841: --dbms_output.put_line('Did not get SESSION lock for: ' || p_ChannelName);
1842: --dbms_output.put_line('Adapter RUNNING');
1843:
1844: -- Could not get lock, Adapter running, update last_verified_date
1845: XDP_ADAPTER_CORE_DB.UpdateAdapter (
1846: p_ChannelName => p_ChannelName,
1847: p_LastVerified => sysdate);
1848: end if;
1849: else

Line 1851: XDP_ADAPTER_CORE_DB.UpdateAdapter (

1847: p_LastVerified => sysdate);
1848: end if;
1849: else
1850: -- Adapter not implemented, so Adapter is 'running', update last_verified_date
1851: XDP_ADAPTER_CORE_DB.UpdateAdapter (
1852: p_ChannelName => p_ChannelName,
1853: p_LastVerified => sysdate);
1854: end if;
1855:

Line 1864: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ADAPTER',

1860: FND_MESSAGE.CLEAR;
1861: fnd_message.set_name('XDP','XDP_INVALID_ADAPTER_STATE');
1862: p_errbuf := FND_MESSAGE.GET;
1863: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1864: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ADAPTER',
1865: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1866: end if;
1867:
1868: when e_OperationFailure then

Line 1871: fnd_message.set_name('XDP','XDP_ADAPTER_ABNORMAL_EXIT');

1867:
1868: when e_OperationFailure then
1869: p_retCode := pv_retAdapterAbnormalExit;
1870: FND_MESSAGE.CLEAR;
1871: fnd_message.set_name('XDP','XDP_ADAPTER_ABNORMAL_EXIT');
1872: fnd_message.set_token('PROCESS_ID' , l_ProcessID);
1873: p_errbuf := FND_MESSAGE.GET;
1874: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1875: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ADAPTER',

Line 1875: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ADAPTER',

1871: fnd_message.set_name('XDP','XDP_ADAPTER_ABNORMAL_EXIT');
1872: fnd_message.set_token('PROCESS_ID' , l_ProcessID);
1873: p_errbuf := FND_MESSAGE.GET;
1874: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1875: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ADAPTER',
1876: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1877: end if;
1878: when others then
1879: if l_AdapterLocked1 = 'Y' then

Line 1880: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock('SESSION_'||p_ChannelName) = 'N' then

1876: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1877: end if;
1878: when others then
1879: if l_AdapterLocked1 = 'Y' then
1880: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock('SESSION_'||p_ChannelName) = 'N' then
1881: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1882: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VERIFY_ADAPTER',
1883: 'Could not release SESSION lock, Channel name: '||p_ChannelName);
1884: end if;

Line 1882: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VERIFY_ADAPTER',

1878: when others then
1879: if l_AdapterLocked1 = 'Y' then
1880: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock('SESSION_'||p_ChannelName) = 'N' then
1881: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1882: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VERIFY_ADAPTER',
1883: 'Could not release SESSION lock, Channel name: '||p_ChannelName);
1884: end if;
1885: end if;
1886: end if;

Line 1896: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ADAPTER',

1892: p_retCode := pv_retAdapterOtherError;
1893: p_errbuf := 'Other non-SQL error';
1894: END IF;
1895: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1896: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ADAPTER',
1897: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
1898: end if;
1899: end Verify_Adapter;
1900:

Line 1909: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.VERIFY_RUNNING_ADAPTERS', 'BEGIN:');

1905: is
1906:
1907: BEGIN
1908: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1909: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.VERIFY_RUNNING_ADAPTERS', 'BEGIN:');
1910: end if;
1911:
1912: x_adapter_info := 'NONE';
1913: p_retcode := 0;

Line 1915: for v_AdapterPID in XDP_ADAPTER_CORE_DB.G_Get_Running_Adapters

1911:
1912: x_adapter_info := 'NONE';
1913: p_retcode := 0;
1914:
1915: for v_AdapterPID in XDP_ADAPTER_CORE_DB.G_Get_Running_Adapters
1916: (p_controller_instance_id) loop
1917:
1918: if (v_AdapterPID.is_implemented = 'Y') then
1919:

Line 1921: (v_AdapterPID.adapter_status <> XDP_ADAPTER.pv_statusStarting))

1917:
1918: if (v_AdapterPID.is_implemented = 'Y') then
1919:
1920: if (((v_AdapterPID.process_id > 0) AND
1921: (v_AdapterPID.adapter_status <> XDP_ADAPTER.pv_statusStarting))
1922: OR
1923: ((v_AdapterPID.adapter_status = XDP_ADAPTER.pv_statusStarting) AND
1924: ((v_AdapterPID.STATUS_ACTIVE_TIME + (5/(60*24))) < SYSDATE))) then
1925: -- To take care of STARTING adapters, check after 5 minutes

Line 1923: ((v_AdapterPID.adapter_status = XDP_ADAPTER.pv_statusStarting) AND

1919:
1920: if (((v_AdapterPID.process_id > 0) AND
1921: (v_AdapterPID.adapter_status <> XDP_ADAPTER.pv_statusStarting))
1922: OR
1923: ((v_AdapterPID.adapter_status = XDP_ADAPTER.pv_statusStarting) AND
1924: ((v_AdapterPID.STATUS_ACTIVE_TIME + (5/(60*24))) < SYSDATE))) then
1925: -- To take care of STARTING adapters, check after 5 minutes
1926: -- if they are still in STARTING state
1927:

Line 1928: XDP_ADAPTER.Verify_Adapter (

1924: ((v_AdapterPID.STATUS_ACTIVE_TIME + (5/(60*24))) < SYSDATE))) then
1925: -- To take care of STARTING adapters, check after 5 minutes
1926: -- if they are still in STARTING state
1927:
1928: XDP_ADAPTER.Verify_Adapter (
1929: p_ChannelName => v_AdapterPID.channel_name,
1930: p_retcode => p_retcode,
1931: p_errbuf => p_errbuf);
1932:

Line 1934: (p_retcode <> XDP_ADAPTER.pv_retAdapterAbnormalExit) and

1930: p_retcode => p_retcode,
1931: p_errbuf => p_errbuf);
1932:
1933: if ((p_retcode <> 0) and
1934: (p_retcode <> XDP_ADAPTER.pv_retAdapterAbnormalExit) and
1935: (p_retcode <> XDP_ADAPTER.pv_retAdapterInvalidState)) then
1936: -- pv_retAdapterInvalidState means Adapter is
1937: -- already Stopped (with error), terminated or
1938: -- Not available

Line 1935: (p_retcode <> XDP_ADAPTER.pv_retAdapterInvalidState)) then

1931: p_errbuf => p_errbuf);
1932:
1933: if ((p_retcode <> 0) and
1934: (p_retcode <> XDP_ADAPTER.pv_retAdapterAbnormalExit) and
1935: (p_retcode <> XDP_ADAPTER.pv_retAdapterInvalidState)) then
1936: -- pv_retAdapterInvalidState means Adapter is
1937: -- already Stopped (with error), terminated or
1938: -- Not available
1939: -- OK case for this

Line 1945: 'XDP_ADAPTER.VERIFY_RUNNING_ADAPTERS',

1941: -- There are only 2 possibilities now, "CannotLock"
1942: -- or some "when others" error
1943: if( FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1944: FND_LOG.STRING (FND_LOG.LEVEL_EXCEPTION,
1945: 'XDP_ADAPTER.VERIFY_RUNNING_ADAPTERS',
1946: 'XDP_ADAPTER.Verify_Adapter errored ChannelName: '||
1947: v_AdapterPID.channel_name||', Errorcode: '||
1948: p_retcode||', ErrorDesc: '||
1949: p_errbuf);

Line 1946: 'XDP_ADAPTER.Verify_Adapter errored ChannelName: '||

1942: -- or some "when others" error
1943: if( FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1944: FND_LOG.STRING (FND_LOG.LEVEL_EXCEPTION,
1945: 'XDP_ADAPTER.VERIFY_RUNNING_ADAPTERS',
1946: 'XDP_ADAPTER.Verify_Adapter errored ChannelName: '||
1947: v_AdapterPID.channel_name||', Errorcode: '||
1948: p_retcode||', ErrorDesc: '||
1949: p_errbuf);
1950: end if;

Line 1952: if (p_retcode = XDP_ADAPTER.pv_retAdapterCannotLock) then

1948: p_retcode||', ErrorDesc: '||
1949: p_errbuf);
1950: end if;
1951:
1952: if (p_retcode = XDP_ADAPTER.pv_retAdapterCannotLock) then
1953:
1954: if x_adapter_info = 'NONE' then
1955: -- First time
1956: x_adapter_info := v_AdapterPID.channel_name||

Line 1957: XDP_ADAPTER.pv_SMParamDelimiter||

1953:
1954: if x_adapter_info = 'NONE' then
1955: -- First time
1956: x_adapter_info := v_AdapterPID.channel_name||
1957: XDP_ADAPTER.pv_SMParamDelimiter||
1958: v_AdapterPID.process_id||
1959: XDP_ADAPTER.pv_SMParamDelimiter;
1960: else
1961: x_adapter_info := x_adapter_info||

Line 1959: XDP_ADAPTER.pv_SMParamDelimiter;

1955: -- First time
1956: x_adapter_info := v_AdapterPID.channel_name||
1957: XDP_ADAPTER.pv_SMParamDelimiter||
1958: v_AdapterPID.process_id||
1959: XDP_ADAPTER.pv_SMParamDelimiter;
1960: else
1961: x_adapter_info := x_adapter_info||
1962: v_AdapterPID.channel_name||
1963: XDP_ADAPTER.pv_SMParamDelimiter||

Line 1963: XDP_ADAPTER.pv_SMParamDelimiter||

1959: XDP_ADAPTER.pv_SMParamDelimiter;
1960: else
1961: x_adapter_info := x_adapter_info||
1962: v_AdapterPID.channel_name||
1963: XDP_ADAPTER.pv_SMParamDelimiter||
1964: v_AdapterPID.process_id||
1965: XDP_ADAPTER.pv_SMParamDelimiter;
1966: end if;
1967: else

Line 1965: XDP_ADAPTER.pv_SMParamDelimiter;

1961: x_adapter_info := x_adapter_info||
1962: v_AdapterPID.channel_name||
1963: XDP_ADAPTER.pv_SMParamDelimiter||
1964: v_AdapterPID.process_id||
1965: XDP_ADAPTER.pv_SMParamDelimiter;
1966: end if;
1967: else
1968: -- Some "when others" error
1969: raise e_OperationFailure;

Line 1978: 'XDP_ADAPTER.VERIFY_RUNNING_ADAPTERS',

1974:
1975: else
1976: if( FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1977: FND_LOG.STRING (FND_LOG.LEVEL_EXCEPTION,
1978: 'XDP_ADAPTER.VERIFY_RUNNING_ADAPTERS',
1979: 'Adapter verification ignored ChannelName: '||
1980: v_AdapterPID.channel_name||', process id: '||
1981: v_AdapterPID.process_id||', AdapterStatus: '||
1982: v_AdapterPID.adapter_status);

Line 1991: FND_LOG.STRING (FND_LOG.LEVEL_EXCEPTION, 'XDP_ADAPTER.VERIFY_RUNNING_ADAPTERS',

1987: end loop;
1988:
1989: p_retcode := 0;
1990: if( FND_LOG.LEVEL_EXCEPTION >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1991: FND_LOG.STRING (FND_LOG.LEVEL_EXCEPTION, 'XDP_ADAPTER.VERIFY_RUNNING_ADAPTERS',
1992: 'Adapters still required to be verified: '||x_adapter_info);
1993: end if;
1994: exception
1995: when e_OperationFailure then

Line 1999: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_RUNNING_ADAPTERS',

1995: when e_OperationFailure then
1996: x_adapter_info := 'NONE';
1997: -- p_retcode and p_errbuf are already set
1998: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
1999: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_RUNNING_ADAPTERS',
2000: 'Verify_Adapter returned Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
2001: end if;
2002: when others then
2003: x_adapter_info := 'NONE';

Line 2012: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_RUNNING_ADAPTERS',

2008: p_retCode := pv_retAdapterOtherError;
2009: p_errbuf := 'Other non-SQL error';
2010: END IF;
2011: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2012: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_RUNNING_ADAPTERS',
2013: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
2014: end if;
2015: end Verify_Running_Adapters;
2016:

Line 2028: for v_GetSvcID in XDP_ADAPTER_CORE_DB.G_Get_Controller_Instances loop

2024:
2025: BEGIN
2026: p_retcode := 0;
2027:
2028: for v_GetSvcID in XDP_ADAPTER_CORE_DB.G_Get_Controller_Instances loop
2029:
2030: l_CustomParamList := 'NONE';
2031:
2032: XDP_ADAPTER.Verify_Running_Adapters (

Line 2032: XDP_ADAPTER.Verify_Running_Adapters (

2028: for v_GetSvcID in XDP_ADAPTER_CORE_DB.G_Get_Controller_Instances loop
2029:
2030: l_CustomParamList := 'NONE';
2031:
2032: XDP_ADAPTER.Verify_Running_Adapters (
2033: p_controller_instance_id => v_GetSvcID.service_instance_id,
2034: x_adapter_info => l_CustomParamList,
2035: p_retcode => p_retcode,
2036: p_errbuf => p_errbuf);

Line 2051: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ALL_ADAPTERS',

2047: exception
2048: when e_OperationFailure then
2049: -- p_retcode and p_errbuf are already set
2050: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2051: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ALL_ADAPTERS',
2052: 'Verify_Running_Adapters returned Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
2053: end if;
2054: when others then
2055: if SQLCODE <> 0 then

Line 2063: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ALL_ADAPTERS',

2059: p_retCode := pv_retAdapterOtherError;
2060: p_errbuf := 'Other non-SQL error';
2061: END IF;
2062: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2063: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ALL_ADAPTERS',
2064: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
2065: end if;
2066: END Verify_All_Adapters;
2067:

Line 2079: l_ChannelName XDP_ADAPTER_REG.CHANNEL_NAME%TYPE;

2075: TYPE t_FlexibleRef IS REF CURSOR;
2076: cv_Channelname t_FlexibleRef;
2077: sql_stmt VARCHAR2(4000);
2078:
2079: l_ChannelName XDP_ADAPTER_REG.CHANNEL_NAME%TYPE;
2080: l_ProcessID XDP_ADAPTER_REG.PROCESS_ID%TYPE;
2081: l_AdapterStatus XDP_ADAPTER_REG.ADAPTER_STATUS%TYPE;
2082: l_StatusActiveTime XDP_ADAPTER_REG.STATUS_ACTIVE_TIME%TYPE;
2083:

Line 2080: l_ProcessID XDP_ADAPTER_REG.PROCESS_ID%TYPE;

2076: cv_Channelname t_FlexibleRef;
2077: sql_stmt VARCHAR2(4000);
2078:
2079: l_ChannelName XDP_ADAPTER_REG.CHANNEL_NAME%TYPE;
2080: l_ProcessID XDP_ADAPTER_REG.PROCESS_ID%TYPE;
2081: l_AdapterStatus XDP_ADAPTER_REG.ADAPTER_STATUS%TYPE;
2082: l_StatusActiveTime XDP_ADAPTER_REG.STATUS_ACTIVE_TIME%TYPE;
2083:
2084: BEGIN

Line 2081: l_AdapterStatus XDP_ADAPTER_REG.ADAPTER_STATUS%TYPE;

2077: sql_stmt VARCHAR2(4000);
2078:
2079: l_ChannelName XDP_ADAPTER_REG.CHANNEL_NAME%TYPE;
2080: l_ProcessID XDP_ADAPTER_REG.PROCESS_ID%TYPE;
2081: l_AdapterStatus XDP_ADAPTER_REG.ADAPTER_STATUS%TYPE;
2082: l_StatusActiveTime XDP_ADAPTER_REG.STATUS_ACTIVE_TIME%TYPE;
2083:
2084: BEGIN
2085: p_retcode := 0;

Line 2082: l_StatusActiveTime XDP_ADAPTER_REG.STATUS_ACTIVE_TIME%TYPE;

2078:
2079: l_ChannelName XDP_ADAPTER_REG.CHANNEL_NAME%TYPE;
2080: l_ProcessID XDP_ADAPTER_REG.PROCESS_ID%TYPE;
2081: l_AdapterStatus XDP_ADAPTER_REG.ADAPTER_STATUS%TYPE;
2082: l_StatusActiveTime XDP_ADAPTER_REG.STATUS_ACTIVE_TIME%TYPE;
2083:
2084: BEGIN
2085: p_retcode := 0;
2086:

Line 2092: sql_stmt := 'select CHANNEL_NAME, PROCESS_ID, ADAPTER_STATUS, STATUS_ACTIVE_TIME from XDP_ADAPTER_REG_V a, XDP_ADAPTER_TYPES_B b where ADAPTER_STATUS not in ';

2088: Verify_All_Adapters ( p_retcode => p_retcode,
2089: p_errbuf => p_errbuf);
2090: else
2091:
2092: sql_stmt := 'select CHANNEL_NAME, PROCESS_ID, ADAPTER_STATUS, STATUS_ACTIVE_TIME from XDP_ADAPTER_REG_V a, XDP_ADAPTER_TYPES_B b where ADAPTER_STATUS not in ';
2093: sql_stmt := sql_stmt||'('''||XDP_ADAPTER.pv_statusStopped||''','''||XDP_ADAPTER.pv_statusStoppedError||''','''||XDP_ADAPTER.pv_statusTerminated||''','''||XDP_ADAPTER.pv_statusNotAvailable||''',''';
2094: sql_stmt := sql_stmt||XDP_ADAPTER.pv_statusDeactivated||''','''||XDP_ADAPTER.pv_statusDeactivatedSystem||''')';
2095: sql_stmt := sql_stmt||' and a.adapter_type = b.adapter_type and b.adapter_class <> ''NONE'' and UPPER('||p_FilterType||') like UPPER('''||p_FilterKey||''')';
2096:

Line 2093: sql_stmt := sql_stmt||'('''||XDP_ADAPTER.pv_statusStopped||''','''||XDP_ADAPTER.pv_statusStoppedError||''','''||XDP_ADAPTER.pv_statusTerminated||''','''||XDP_ADAPTER.pv_statusNotAvailable||''',''';

2089: p_errbuf => p_errbuf);
2090: else
2091:
2092: sql_stmt := 'select CHANNEL_NAME, PROCESS_ID, ADAPTER_STATUS, STATUS_ACTIVE_TIME from XDP_ADAPTER_REG_V a, XDP_ADAPTER_TYPES_B b where ADAPTER_STATUS not in ';
2093: sql_stmt := sql_stmt||'('''||XDP_ADAPTER.pv_statusStopped||''','''||XDP_ADAPTER.pv_statusStoppedError||''','''||XDP_ADAPTER.pv_statusTerminated||''','''||XDP_ADAPTER.pv_statusNotAvailable||''',''';
2094: sql_stmt := sql_stmt||XDP_ADAPTER.pv_statusDeactivated||''','''||XDP_ADAPTER.pv_statusDeactivatedSystem||''')';
2095: sql_stmt := sql_stmt||' and a.adapter_type = b.adapter_type and b.adapter_class <> ''NONE'' and UPPER('||p_FilterType||') like UPPER('''||p_FilterKey||''')';
2096:
2097: --XDP_UTILITIES.DISPLAY('sql_stmt:'||sql_stmt||':');

Line 2094: sql_stmt := sql_stmt||XDP_ADAPTER.pv_statusDeactivated||''','''||XDP_ADAPTER.pv_statusDeactivatedSystem||''')';

2090: else
2091:
2092: sql_stmt := 'select CHANNEL_NAME, PROCESS_ID, ADAPTER_STATUS, STATUS_ACTIVE_TIME from XDP_ADAPTER_REG_V a, XDP_ADAPTER_TYPES_B b where ADAPTER_STATUS not in ';
2093: sql_stmt := sql_stmt||'('''||XDP_ADAPTER.pv_statusStopped||''','''||XDP_ADAPTER.pv_statusStoppedError||''','''||XDP_ADAPTER.pv_statusTerminated||''','''||XDP_ADAPTER.pv_statusNotAvailable||''',''';
2094: sql_stmt := sql_stmt||XDP_ADAPTER.pv_statusDeactivated||''','''||XDP_ADAPTER.pv_statusDeactivatedSystem||''')';
2095: sql_stmt := sql_stmt||' and a.adapter_type = b.adapter_type and b.adapter_class <> ''NONE'' and UPPER('||p_FilterType||') like UPPER('''||p_FilterKey||''')';
2096:
2097: --XDP_UTILITIES.DISPLAY('sql_stmt:'||sql_stmt||':');
2098:

Line 2105: (l_AdapterStatus <> XDP_ADAPTER.pv_statusStarting))

2101: FETCH cv_ChannelName INTO l_ChannelName, l_ProcessID, l_AdapterStatus, l_StatusActiveTime;
2102: EXIT WHEN cv_ChannelName%NOTFOUND;
2103:
2104: if (((l_ProcessID > 0) AND
2105: (l_AdapterStatus <> XDP_ADAPTER.pv_statusStarting))
2106: OR
2107: ((l_AdapterStatus = XDP_ADAPTER.pv_statusStarting) AND
2108: ((l_StatusActiveTime + (5/(60*24))) < SYSDATE))) then
2109:

Line 2107: ((l_AdapterStatus = XDP_ADAPTER.pv_statusStarting) AND

2103:
2104: if (((l_ProcessID > 0) AND
2105: (l_AdapterStatus <> XDP_ADAPTER.pv_statusStarting))
2106: OR
2107: ((l_AdapterStatus = XDP_ADAPTER.pv_statusStarting) AND
2108: ((l_StatusActiveTime + (5/(60*24))) < SYSDATE))) then
2109:
2110: XDP_ADAPTER.Verify_Adapter (
2111: p_ChannelName => l_ChannelName,

Line 2110: XDP_ADAPTER.Verify_Adapter (

2106: OR
2107: ((l_AdapterStatus = XDP_ADAPTER.pv_statusStarting) AND
2108: ((l_StatusActiveTime + (5/(60*24))) < SYSDATE))) then
2109:
2110: XDP_ADAPTER.Verify_Adapter (
2111: p_ChannelName => l_ChannelName,
2112: p_retcode => p_retcode,
2113: p_errbuf => p_errbuf);
2114:

Line 2116: (p_retcode <> XDP_ADAPTER.pv_retAdapterInvalidState) and

2112: p_retcode => p_retcode,
2113: p_errbuf => p_errbuf);
2114:
2115: if ((p_retcode <> 0) and
2116: (p_retcode <> XDP_ADAPTER.pv_retAdapterInvalidState) and
2117: (p_retcode <> XDP_ADAPTER.pv_retAdapterAbnormalExit) and
2118: (p_retcode <> XDP_ADAPTER.pv_retAdapterCannotLock)) then
2119: raise e_OperationFailure;
2120: END IF;

Line 2117: (p_retcode <> XDP_ADAPTER.pv_retAdapterAbnormalExit) and

2113: p_errbuf => p_errbuf);
2114:
2115: if ((p_retcode <> 0) and
2116: (p_retcode <> XDP_ADAPTER.pv_retAdapterInvalidState) and
2117: (p_retcode <> XDP_ADAPTER.pv_retAdapterAbnormalExit) and
2118: (p_retcode <> XDP_ADAPTER.pv_retAdapterCannotLock)) then
2119: raise e_OperationFailure;
2120: END IF;
2121: END IF;

Line 2118: (p_retcode <> XDP_ADAPTER.pv_retAdapterCannotLock)) then

2114:
2115: if ((p_retcode <> 0) and
2116: (p_retcode <> XDP_ADAPTER.pv_retAdapterInvalidState) and
2117: (p_retcode <> XDP_ADAPTER.pv_retAdapterAbnormalExit) and
2118: (p_retcode <> XDP_ADAPTER.pv_retAdapterCannotLock)) then
2119: raise e_OperationFailure;
2120: END IF;
2121: END IF;
2122:

Line 2141: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ADAPTERS',

2137: CLOSE cv_ChannelName;
2138: END IF;
2139: -- p_retcode and p_errbuf are already set
2140: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2141: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ADAPTERS',
2142: 'Verify_Adapter returned Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
2143: end if;
2144: when others then
2145: if cv_ChannelName%ISOPEN then

Line 2157: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ADAPTERS',

2153: p_retCode := pv_retAdapterOtherError;
2154: p_errbuf := 'Other non-SQL error';
2155: END IF;
2156: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2157: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VERIFY_ADAPTERS',
2158: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
2159: end if;
2160: END Verify_Adapters;
2161:

Line 2174: l_AdapterLocked := XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify(p_ChannelName);

2170:
2171: l_AdapterLocked varchar2(1) := 'N';
2172:
2173: BEGIN
2174: l_AdapterLocked := XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify(p_ChannelName);
2175: if l_AdapterLocked = 'N' then
2176: return;
2177: else
2178: if (p_ResetStatusFlag) then

Line 2179: XDP_ADAPTER_CORE_DB.UpdateAdapter(

2175: if l_AdapterLocked = 'N' then
2176: return;
2177: else
2178: if (p_ResetStatusFlag) then
2179: XDP_ADAPTER_CORE_DB.UpdateAdapter(
2180: p_ChannelName => p_ChannelName,
2181: p_Status => pv_statusStopped);
2182: END IF;
2183:

Line 2187: p_object_type => XDP_ADAPTER.pv_errorObjectTypeAdapter,

2183:
2184: -- Reset start error count to 0
2185:
2186: XDP_ERRORS_PKG.UPDATE_ERROR_COUNT (
2187: p_object_type => XDP_ADAPTER.pv_errorObjectTypeAdapter,
2188: p_object_key => p_ChannelName);
2189:
2190: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
2191: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05

Line 2190: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

2186: XDP_ERRORS_PKG.UPDATE_ERROR_COUNT (
2187: p_object_type => XDP_ADAPTER.pv_errorObjectTypeAdapter,
2188: p_object_key => p_ChannelName);
2189:
2190: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
2191: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2192: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.RESET_SYSDEACTIVATED_ADAPTER',
2193: 'Could not release the lock, Channel name: '||p_ChannelName);
2194: end if;

Line 2192: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.RESET_SYSDEACTIVATED_ADAPTER',

2188: p_object_key => p_ChannelName);
2189:
2190: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
2191: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2192: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.RESET_SYSDEACTIVATED_ADAPTER',
2193: 'Could not release the lock, Channel name: '||p_ChannelName);
2194: end if;
2195: end if;
2196: end if;

Line 2203: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

2199:
2200: when others then
2201:
2202: if l_AdapterLocked = 'Y' then
2203: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
2204: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2205: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.RESET_SYSDEACTIVATED_ADAPTER',
2206: 'Could not release the lock, Channel name: '||p_ChannelName);
2207: end if;

Line 2205: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.RESET_SYSDEACTIVATED_ADAPTER',

2201:
2202: if l_AdapterLocked = 'Y' then
2203: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
2204: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2205: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.RESET_SYSDEACTIVATED_ADAPTER',
2206: 'Could not release the lock, Channel name: '||p_ChannelName);
2207: end if;
2208: end if;
2209: end if;

Line 2211: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.RESET_SYSDEACTIVATED_ADAPTER',

2207: end if;
2208: end if;
2209: end if;
2210: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2211: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.RESET_SYSDEACTIVATED_ADAPTER',
2212: 'Unhandled error, SQLCODE: '||SQLCODE);
2213: end if;
2214: END Reset_SysDeactivated_Adapter;
2215:

Line 2220: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.RESET_SYSDEACTIVATED_ADAPTERS', 'BEGIN:');

2216: PROCEDURE Reset_SysDeactivated_Adapters (p_controller_instance_id IN NUMBER)
2217: is
2218: BEGIN
2219: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2220: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.RESET_SYSDEACTIVATED_ADAPTERS', 'BEGIN:');
2221: end if;
2222:
2223: for v_SysDeactivatedAdapter in XDP_ADAPTER_CORE_DB.G_Get_SysDeactivated_Adapters
2224: (p_controller_instance_id) loop

Line 2223: for v_SysDeactivatedAdapter in XDP_ADAPTER_CORE_DB.G_Get_SysDeactivated_Adapters

2219: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2220: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.RESET_SYSDEACTIVATED_ADAPTERS', 'BEGIN:');
2221: end if;
2222:
2223: for v_SysDeactivatedAdapter in XDP_ADAPTER_CORE_DB.G_Get_SysDeactivated_Adapters
2224: (p_controller_instance_id) loop
2225:
2226: if (v_SysDeactivatedAdapter.adapter_status = XDP_ADAPTER.pv_statusDeactivatedSystem) then
2227:

Line 2226: if (v_SysDeactivatedAdapter.adapter_status = XDP_ADAPTER.pv_statusDeactivatedSystem) then

2222:
2223: for v_SysDeactivatedAdapter in XDP_ADAPTER_CORE_DB.G_Get_SysDeactivated_Adapters
2224: (p_controller_instance_id) loop
2225:
2226: if (v_SysDeactivatedAdapter.adapter_status = XDP_ADAPTER.pv_statusDeactivatedSystem) then
2227:
2228: XDP_ADAPTER.Reset_SysDeactivated_Adapter (
2229: p_ChannelName => v_SysDeactivatedAdapter.channel_name);
2230: else

Line 2228: XDP_ADAPTER.Reset_SysDeactivated_Adapter (

2224: (p_controller_instance_id) loop
2225:
2226: if (v_SysDeactivatedAdapter.adapter_status = XDP_ADAPTER.pv_statusDeactivatedSystem) then
2227:
2228: XDP_ADAPTER.Reset_SysDeactivated_Adapter (
2229: p_ChannelName => v_SysDeactivatedAdapter.channel_name);
2230: else
2231: XDP_ADAPTER.Reset_SysDeactivated_Adapter (
2232: p_ChannelName => v_SysDeactivatedAdapter.channel_name,

Line 2231: XDP_ADAPTER.Reset_SysDeactivated_Adapter (

2227:
2228: XDP_ADAPTER.Reset_SysDeactivated_Adapter (
2229: p_ChannelName => v_SysDeactivatedAdapter.channel_name);
2230: else
2231: XDP_ADAPTER.Reset_SysDeactivated_Adapter (
2232: p_ChannelName => v_SysDeactivatedAdapter.channel_name,
2233: p_ResetStatusFlag => false);
2234: END IF;
2235:

Line 2244: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.RESET_SYSDEACTIVATED_ADAPTERS',

2240: exception
2241:
2242: when others then
2243: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2244: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.RESET_SYSDEACTIVATED_ADAPTERS',
2245: 'Unhandled error, SQLCODE: '||SQLCODE);
2246: end if;
2247: end RESET_SYSDEACTIVATED_ADAPTERS;
2248:

Line 2262: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.VALIDATE_OPERATION',

2258: l_ConcQID number;
2259: l_Flag varchar2(10);
2260: begin
2261: if( FND_LOG.LEVEL_PROCEDURE >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2262: FND_LOG.STRING (FND_LOG.LEVEL_PROCEDURE, 'XDP_ADAPTER.VALIDATE_OPERATION',
2263: 'BEGIN:p_ChannelName: '||p_ChannelName);
2264: end if;
2265: p_retcode := 0;
2266: p_errbuf := '';

Line 2270: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',

2266: p_errbuf := '';
2267:
2268: if p_ChannelName is null then
2269: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2270: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',
2271: 'Required parameters are not passed');
2272: end if;
2273: raise e_RequiredInputDataNotPassed;
2274: end if;

Line 2277: if (p_Operation <> XDP_ADAPTER.pv_opTerminate) then

2273: raise e_RequiredInputDataNotPassed;
2274: end if;
2275:
2276: --Verify adapter state for operation only if operation is not Terminate
2277: if (p_Operation <> XDP_ADAPTER.pv_opTerminate) then
2278: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName, p_Operation,
2279: l_CurrentStatus) then
2280: raise e_InvalidAdapterState;
2281: end if;

Line 2278: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName, p_Operation,

2274: end if;
2275:
2276: --Verify adapter state for operation only if operation is not Terminate
2277: if (p_Operation <> XDP_ADAPTER.pv_opTerminate) then
2278: if not XDP_ADAPTER_CORE.VerifyAdapterOperation(p_ChannelName, p_Operation,
2279: l_CurrentStatus) then
2280: raise e_InvalidAdapterState;
2281: end if;
2282: END IF;

Line 2285: if (p_Operation <> XDP_ADAPTER.pv_opGeneric) then

2281: end if;
2282: END IF;
2283:
2284: --Hold session lock only for state change operations - bug3300862
2285: if (p_Operation <> XDP_ADAPTER.pv_opGeneric) then
2286: if (XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify(p_ChannelName) = 'N') then
2287: raise e_UnabletoLockAdapter;
2288: end if;
2289: END IF;

Line 2286: if (XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify(p_ChannelName) = 'N') then

2282: END IF;
2283:
2284: --Hold session lock only for state change operations - bug3300862
2285: if (p_Operation <> XDP_ADAPTER.pv_opGeneric) then
2286: if (XDP_ADAPTER_CORE_DB.ObtainAdapterLock_Verify(p_ChannelName) = 'N') then
2287: raise e_UnabletoLockAdapter;
2288: end if;
2289: END IF;
2290:

Line 2294: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then

2290:
2291: -- Though Controller is only needed for implemented adapter types but to give consistent
2292: -- response for non-implemented adapter types we should always check if Controller
2293: -- is up.
2294: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
2295:
2296: -- We need to retrieve process id, Verify_Adapter could set it to -1
2297: XDP_ADAPTER_CORE_DB.FetchAdapterInfo(
2298: p_ChannelName => p_ChannelName,

Line 2297: XDP_ADAPTER_CORE_DB.FetchAdapterInfo(

2293: -- is up.
2294: if (XDP_ADAPTER_CORE_DB.Is_Adapter_Implemented (p_ChannelName)) then
2295:
2296: -- We need to retrieve process id, Verify_Adapter could set it to -1
2297: XDP_ADAPTER_CORE_DB.FetchAdapterInfo(
2298: p_ChannelName => p_ChannelName,
2299: p_FEID => l_FeID,
2300: p_ProcessID => p_ProcessID,
2301: p_ConcQID => l_ConcQID);

Line 2304: if (p_Operation <> XDP_ADAPTER.pv_opStartup) then

2300: p_ProcessID => p_ProcessID,
2301: p_ConcQID => l_ConcQID);
2302:
2303: --Verify adapter state for operation only if operation is not Start
2304: if (p_Operation <> XDP_ADAPTER.pv_opStartup) then
2305: -- Cannot use Verify_Adapter API as call to update row has to be autonomous
2306: if not XDP_ADAPTER_CORE_DB.Verify_Adapter (p_ChannelName) then
2307: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
2308: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05

Line 2306: if not XDP_ADAPTER_CORE_DB.Verify_Adapter (p_ChannelName) then

2302:
2303: --Verify adapter state for operation only if operation is not Start
2304: if (p_Operation <> XDP_ADAPTER.pv_opStartup) then
2305: -- Cannot use Verify_Adapter API as call to update row has to be autonomous
2306: if not XDP_ADAPTER_CORE_DB.Verify_Adapter (p_ChannelName) then
2307: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
2308: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2309: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VALIDATE_OPERATION',
2310: 'Could not release the lock, Channel name: '||p_ChannelName);

Line 2307: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then

2303: --Verify adapter state for operation only if operation is not Start
2304: if (p_Operation <> XDP_ADAPTER.pv_opStartup) then
2305: -- Cannot use Verify_Adapter API as call to update row has to be autonomous
2306: if not XDP_ADAPTER_CORE_DB.Verify_Adapter (p_ChannelName) then
2307: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
2308: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2309: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VALIDATE_OPERATION',
2310: 'Could not release the lock, Channel name: '||p_ChannelName);
2311: end if;

Line 2309: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VALIDATE_OPERATION',

2305: -- Cannot use Verify_Adapter API as call to update row has to be autonomous
2306: if not XDP_ADAPTER_CORE_DB.Verify_Adapter (p_ChannelName) then
2307: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
2308: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2309: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VALIDATE_OPERATION',
2310: 'Could not release the lock, Channel name: '||p_ChannelName);
2311: end if;
2312: end if;
2313:

Line 2320: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then

2316: END IF;
2317:
2318: XDP_CONTROLLER_CORE.VerifyControllerStatus(l_ConcQID, p_CPID, l_Flag);
2319: if l_Flag = 'N' then
2320: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
2321: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2322: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VALIDATE_OPERATION',
2323: 'Could not release the lock, Channel name: '||p_ChannelName);
2324: end if;

Line 2322: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VALIDATE_OPERATION',

2318: XDP_CONTROLLER_CORE.VerifyControllerStatus(l_ConcQID, p_CPID, l_Flag);
2319: if l_Flag = 'N' then
2320: if XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N' then
2321: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2322: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VALIDATE_OPERATION',
2323: 'Could not release the lock, Channel name: '||p_ChannelName);
2324: end if;
2325: end if;
2326:

Line 2337: fnd_message.set_name('XDP','XDP_ADAPTER_ABNORMAL_EXIT');

2333: when e_OperationFailure then
2334: FND_MESSAGE.CLEAR;
2335: p_retCode := pv_retAdapterCommFailed;
2336: -- p_retCode := pv_retAdapterAbnormalExit;
2337: fnd_message.set_name('XDP','XDP_ADAPTER_ABNORMAL_EXIT');
2338: fnd_message.set_token('PROCESS_ID' , p_ProcessID);
2339:
2340: p_errbuf := FND_MESSAGE.GET;
2341: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05

Line 2342: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',

2338: fnd_message.set_token('PROCESS_ID' , p_ProcessID);
2339:
2340: p_errbuf := FND_MESSAGE.GET;
2341: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2342: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',
2343: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
2344: end if;
2345:
2346: when e_InvalidAdapterState then

Line 2352: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',

2348: FND_MESSAGE.CLEAR;
2349: fnd_message.set_name('XDP','XDP_INVALID_ADAPTER_STATE');
2350: p_errbuf := FND_MESSAGE.GET;
2351: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2352: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',
2353: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
2354: end if;
2355: when e_UnabletoLockAdapter then
2356: p_retCode := pv_retAdapterCannotLock;

Line 2358: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE');

2354: end if;
2355: when e_UnabletoLockAdapter then
2356: p_retCode := pv_retAdapterCannotLock;
2357: FND_MESSAGE.CLEAR;
2358: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE');
2359: p_errbuf := FND_MESSAGE.GET;
2360: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2361: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',
2362: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);

Line 2361: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',

2357: FND_MESSAGE.CLEAR;
2358: fnd_message.set_name('XDP','XDP_ADAPTER_UNLOCKABLE');
2359: p_errbuf := FND_MESSAGE.GET;
2360: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2361: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',
2362: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
2363: end if;
2364: when e_ControllerNotRunning then
2365: p_retCode := pv_retAdapterCtrlNotRunning;

Line 2370: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',

2366: FND_MESSAGE.CLEAR;
2367: fnd_message.set_name('XDP','XDP_CONTROLLER_NOT_RUNNING');
2368: p_errbuf := FND_MESSAGE.GET;
2369: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2370: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',
2371: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
2372: end if;
2373: when others then
2374: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

Line 2374: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then

2370: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',
2371: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
2372: end if;
2373: when others then
2374: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
2375: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2376: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VALIDATE_OPERATION',
2377: 'Could not release the lock, Channel name: '||p_ChannelName);
2378: end if;

Line 2376: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VALIDATE_OPERATION',

2372: end if;
2373: when others then
2374: if (XDP_ADAPTER_CORE_DB.ReleaseAdapterLock(p_ChannelName) = 'N') then
2375: if( FND_LOG.LEVEL_UNEXPECTED >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2376: FND_LOG.STRING (FND_LOG.LEVEL_UNEXPECTED, 'XDP_ADAPTER.VALIDATE_OPERATION',
2377: 'Could not release the lock, Channel name: '||p_ChannelName);
2378: end if;
2379: end if;
2380: if SQLCODE <> 0 then

Line 2388: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',

2384: p_retCode := pv_retAdapterOtherError;
2385: p_errbuf := 'Other non-SQL error';
2386: END IF;
2387: if( FND_LOG.LEVEL_ERROR >= FND_LOG.G_CURRENT_RUNTIME_LEVEL ) then --Fix Bug: 4256771, dputhiye, 28 Apr 05
2388: FND_LOG.STRING (FND_LOG.LEVEL_ERROR, 'XDP_ADAPTER.VALIDATE_OPERATION',
2389: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
2390: end if;
2391: end validate_operation;
2392:

Line 2393: END XDP_ADAPTER;

2389: 'Error code: '||p_retCode||' ,Error desc: '||p_errbuf);
2390: end if;
2391: end validate_operation;
2392:
2393: END XDP_ADAPTER;