eTRM uses javascript that opens and focuses a separate window to display reports. Your browser does not appear to support javascript. This should not prevent you from using eTRM but it does mean the window focus feature will not work. Please check the contents of other windows on your desktop if you click on a link that does not appear to do anything.

APPS.OKC_RULE_DEF_PUB dependencies on OKC_API

Line 5: l_init_msg_list VARCHAR2(1) := OKC_API.G_FALSE;

1: Package Body OKC_RULE_DEF_PUB AS
2: /* $Header: OKCPRGDB.pls 120.0 2005/05/25 19:14:08 appldev noship $ */
3: l_debug VARCHAR2(1) := NVL(FND_PROFILE.VALUE('AFLOG_ENABLED'),'N');
4:
5: l_init_msg_list VARCHAR2(1) := OKC_API.G_FALSE;
6:
7: FUNCTION migrate_rdsv(p_rdsv_rec1 IN rdsv_rec_type,
8: p_rdsv_rec2 IN rdsv_rec_type)
9: RETURN rdsv_rec_type IS

Line 62: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

58: x_msg_count OUT NOCOPY NUMBER,
59: x_msg_data OUT NOCOPY VARCHAR2,
60: p_rgrv_rec IN rgrv_rec_type,
61: x_rgrv_rec OUT NOCOPY rgrv_rec_type) IS
62: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
63: l_api_name CONSTANT VARCHAR2(30) := 'create_rg_def_rule';
64: l_rgrv_rec rgrv_rec_type := p_rgrv_rec;
65: BEGIN
66: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

Line 66: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

62: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
63: l_api_name CONSTANT VARCHAR2(30) := 'create_rg_def_rule';
64: l_rgrv_rec rgrv_rec_type := p_rgrv_rec;
65: BEGIN
66: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
67: p_init_msg_list,
68: '_PUB',
69: x_return_status);
70: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 70: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

66: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
67: p_init_msg_list,
68: '_PUB',
69: x_return_status);
70: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
71: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
72: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
73: raise OKC_API.G_EXCEPTION_ERROR;
74: END IF;

Line 71: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

67: p_init_msg_list,
68: '_PUB',
69: x_return_status);
70: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
71: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
72: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
73: raise OKC_API.G_EXCEPTION_ERROR;
74: END IF;
75: -- Call user hook for BEFORE

Line 72: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

68: '_PUB',
69: x_return_status);
70: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
71: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
72: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
73: raise OKC_API.G_EXCEPTION_ERROR;
74: END IF;
75: -- Call user hook for BEFORE
76: g_rgrv_rec := l_rgrv_rec;

Line 73: raise OKC_API.G_EXCEPTION_ERROR;

69: x_return_status);
70: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
71: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
72: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
73: raise OKC_API.G_EXCEPTION_ERROR;
74: END IF;
75: -- Call user hook for BEFORE
76: g_rgrv_rec := l_rgrv_rec;
77: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 78: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

74: END IF;
75: -- Call user hook for BEFORE
76: g_rgrv_rec := l_rgrv_rec;
77: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
78: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
79: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
80: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
81: raise OKC_API.G_EXCEPTION_ERROR;
82: END IF;

Line 79: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

75: -- Call user hook for BEFORE
76: g_rgrv_rec := l_rgrv_rec;
77: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
78: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
79: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
80: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
81: raise OKC_API.G_EXCEPTION_ERROR;
82: END IF;
83: l_rgrv_rec := migrate_rgrv(l_rgrv_rec, g_rgrv_rec);

Line 80: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

76: g_rgrv_rec := l_rgrv_rec;
77: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
78: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
79: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
80: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
81: raise OKC_API.G_EXCEPTION_ERROR;
82: END IF;
83: l_rgrv_rec := migrate_rgrv(l_rgrv_rec, g_rgrv_rec);
84:

Line 81: raise OKC_API.G_EXCEPTION_ERROR;

77: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
78: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
79: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
80: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
81: raise OKC_API.G_EXCEPTION_ERROR;
82: END IF;
83: l_rgrv_rec := migrate_rgrv(l_rgrv_rec, g_rgrv_rec);
84:
85: OKC_RULE_DEF_PVT.create_rg_def_rule(

Line 94: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

90: x_msg_data => x_msg_data,
91: p_rgrv_rec => l_rgrv_rec,
92: x_rgrv_rec => x_rgrv_rec);
93:
94: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
95: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
96: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
97: raise OKC_API.G_EXCEPTION_ERROR;
98: END IF;

Line 95: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

91: p_rgrv_rec => l_rgrv_rec,
92: x_rgrv_rec => x_rgrv_rec);
93:
94: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
95: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
96: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
97: raise OKC_API.G_EXCEPTION_ERROR;
98: END IF;
99:

Line 96: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

92: x_rgrv_rec => x_rgrv_rec);
93:
94: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
95: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
96: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
97: raise OKC_API.G_EXCEPTION_ERROR;
98: END IF;
99:
100: -- Call user hook for AFTER

Line 97: raise OKC_API.G_EXCEPTION_ERROR;

93:
94: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
95: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
96: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
97: raise OKC_API.G_EXCEPTION_ERROR;
98: END IF;
99:
100: -- Call user hook for AFTER
101: g_rgrv_rec := x_rgrv_rec;

Line 103: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

99:
100: -- Call user hook for AFTER
101: g_rgrv_rec := x_rgrv_rec;
102: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
103: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
104: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
105: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
106: raise OKC_API.G_EXCEPTION_ERROR;
107: END IF;

Line 104: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

100: -- Call user hook for AFTER
101: g_rgrv_rec := x_rgrv_rec;
102: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
103: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
104: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
105: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
106: raise OKC_API.G_EXCEPTION_ERROR;
107: END IF;
108: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 105: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

101: g_rgrv_rec := x_rgrv_rec;
102: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
103: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
104: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
105: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
106: raise OKC_API.G_EXCEPTION_ERROR;
107: END IF;
108: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
109: EXCEPTION

Line 106: raise OKC_API.G_EXCEPTION_ERROR;

102: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
103: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
104: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
105: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
106: raise OKC_API.G_EXCEPTION_ERROR;
107: END IF;
108: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
109: EXCEPTION
110: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 108: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

104: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
105: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
106: raise OKC_API.G_EXCEPTION_ERROR;
107: END IF;
108: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
109: EXCEPTION
110: WHEN OKC_API.G_EXCEPTION_ERROR THEN
111: x_return_status := OKC_API.HANDLE_EXCEPTIONS
112: (l_api_name,

Line 110: WHEN OKC_API.G_EXCEPTION_ERROR THEN

106: raise OKC_API.G_EXCEPTION_ERROR;
107: END IF;
108: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
109: EXCEPTION
110: WHEN OKC_API.G_EXCEPTION_ERROR THEN
111: x_return_status := OKC_API.HANDLE_EXCEPTIONS
112: (l_api_name,
113: G_PKG_NAME,
114: 'OKC_API.G_RET_STS_ERROR',

Line 111: x_return_status := OKC_API.HANDLE_EXCEPTIONS

107: END IF;
108: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
109: EXCEPTION
110: WHEN OKC_API.G_EXCEPTION_ERROR THEN
111: x_return_status := OKC_API.HANDLE_EXCEPTIONS
112: (l_api_name,
113: G_PKG_NAME,
114: 'OKC_API.G_RET_STS_ERROR',
115: x_msg_count,

Line 114: 'OKC_API.G_RET_STS_ERROR',

110: WHEN OKC_API.G_EXCEPTION_ERROR THEN
111: x_return_status := OKC_API.HANDLE_EXCEPTIONS
112: (l_api_name,
113: G_PKG_NAME,
114: 'OKC_API.G_RET_STS_ERROR',
115: x_msg_count,
116: x_msg_data,
117: '_PUB');
118: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 118: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

114: 'OKC_API.G_RET_STS_ERROR',
115: x_msg_count,
116: x_msg_data,
117: '_PUB');
118: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
119: x_return_status := OKC_API.HANDLE_EXCEPTIONS
120: (l_api_name,
121: G_PKG_NAME,
122: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 119: x_return_status := OKC_API.HANDLE_EXCEPTIONS

115: x_msg_count,
116: x_msg_data,
117: '_PUB');
118: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
119: x_return_status := OKC_API.HANDLE_EXCEPTIONS
120: (l_api_name,
121: G_PKG_NAME,
122: 'OKC_API.G_RET_STS_UNEXP_ERROR',
123: x_msg_count,

Line 122: 'OKC_API.G_RET_STS_UNEXP_ERROR',

118: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
119: x_return_status := OKC_API.HANDLE_EXCEPTIONS
120: (l_api_name,
121: G_PKG_NAME,
122: 'OKC_API.G_RET_STS_UNEXP_ERROR',
123: x_msg_count,
124: x_msg_data,
125: '_PUB');
126: WHEN OTHERS THEN

Line 127: x_return_status := OKC_API.HANDLE_EXCEPTIONS

123: x_msg_count,
124: x_msg_data,
125: '_PUB');
126: WHEN OTHERS THEN
127: x_return_status := OKC_API.HANDLE_EXCEPTIONS
128: (l_api_name,
129: G_PKG_NAME,
130: 'OTHERS',
131: x_msg_count,

Line 150: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

146: p_rgrv_tbl IN rgrv_tbl_type,
147: x_rgrv_tbl OUT NOCOPY rgrv_tbl_type) IS
148:
149: i NUMBER := 0;
150: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
151: BEGIN
152: x_return_status := OKC_API.G_RET_STS_SUCCESS;
153: IF p_rgrv_tbl.COUNT > 0 THEN
154: i := p_rgrv_tbl.FIRST;

Line 152: x_return_status := OKC_API.G_RET_STS_SUCCESS;

148:
149: i NUMBER := 0;
150: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
151: BEGIN
152: x_return_status := OKC_API.G_RET_STS_SUCCESS;
153: IF p_rgrv_tbl.COUNT > 0 THEN
154: i := p_rgrv_tbl.FIRST;
155: LOOP
156: create_rg_def_rule(

Line 164: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

160: x_msg_count => x_msg_count,
161: x_msg_data => x_msg_data,
162: p_rgrv_rec => p_rgrv_tbl(i),
163: x_rgrv_rec => x_rgrv_tbl(i));
164: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
165: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
166: x_return_status := l_return_status;
167: raise G_EXCEPTION_HALT_VALIDATION;
168: ELSE

Line 165: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

161: x_msg_data => x_msg_data,
162: p_rgrv_rec => p_rgrv_tbl(i),
163: x_rgrv_rec => x_rgrv_tbl(i));
164: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
165: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
166: x_return_status := l_return_status;
167: raise G_EXCEPTION_HALT_VALIDATION;
168: ELSE
169: x_return_status := l_return_status;

Line 180: OKC_API.set_message(p_app_name => g_app_name,

176: EXCEPTION
177: WHEN G_EXCEPTION_HALT_VALIDATION THEN
178: NULL;
179: WHEN OTHERS THEN
180: OKC_API.set_message(p_app_name => g_app_name,
181: p_msg_name => g_unexpected_error,
182: p_token1 => g_sqlcode_token,
183: p_token1_value => sqlcode,
184: p_token2 => g_sqlerrm_token,

Line 186: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

182: p_token1 => g_sqlcode_token,
183: p_token1_value => sqlcode,
184: p_token2 => g_sqlerrm_token,
185: p_token2_value => sqlerrm);
186: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
187: END create_rg_def_rule;
188:
189:
190: --------------------------------------

Line 201: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

197: x_msg_count OUT NOCOPY NUMBER,
198: x_msg_data OUT NOCOPY VARCHAR2,
199: p_rgrv_rec IN rgrv_rec_type,
200: x_rgrv_rec OUT NOCOPY rgrv_rec_type) IS
201: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
202: l_api_name CONSTANT VARCHAR2(30) := 'update_rg_def_rule';
203: l_rgrv_rec rgrv_rec_type := p_rgrv_rec;
204: BEGIN
205: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

Line 205: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

201: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
202: l_api_name CONSTANT VARCHAR2(30) := 'update_rg_def_rule';
203: l_rgrv_rec rgrv_rec_type := p_rgrv_rec;
204: BEGIN
205: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
206: p_init_msg_list,
207: '_PUB',
208: x_return_status);
209: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 209: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

205: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
206: p_init_msg_list,
207: '_PUB',
208: x_return_status);
209: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
210: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
211: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
212: raise OKC_API.G_EXCEPTION_ERROR;
213: END IF;

Line 210: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

206: p_init_msg_list,
207: '_PUB',
208: x_return_status);
209: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
210: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
211: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
212: raise OKC_API.G_EXCEPTION_ERROR;
213: END IF;
214: -- Call user hook for BEFORE

Line 211: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

207: '_PUB',
208: x_return_status);
209: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
210: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
211: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
212: raise OKC_API.G_EXCEPTION_ERROR;
213: END IF;
214: -- Call user hook for BEFORE
215: g_rgrv_rec := l_rgrv_rec;

Line 212: raise OKC_API.G_EXCEPTION_ERROR;

208: x_return_status);
209: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
210: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
211: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
212: raise OKC_API.G_EXCEPTION_ERROR;
213: END IF;
214: -- Call user hook for BEFORE
215: g_rgrv_rec := l_rgrv_rec;
216: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 217: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

213: END IF;
214: -- Call user hook for BEFORE
215: g_rgrv_rec := l_rgrv_rec;
216: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
217: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
218: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
219: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
220: raise OKC_API.G_EXCEPTION_ERROR;
221: END IF;

Line 218: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

214: -- Call user hook for BEFORE
215: g_rgrv_rec := l_rgrv_rec;
216: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
217: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
218: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
219: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
220: raise OKC_API.G_EXCEPTION_ERROR;
221: END IF;
222: l_rgrv_rec := migrate_rgrv(l_rgrv_rec, g_rgrv_rec);

Line 219: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

215: g_rgrv_rec := l_rgrv_rec;
216: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
217: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
218: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
219: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
220: raise OKC_API.G_EXCEPTION_ERROR;
221: END IF;
222: l_rgrv_rec := migrate_rgrv(l_rgrv_rec, g_rgrv_rec);
223:

Line 220: raise OKC_API.G_EXCEPTION_ERROR;

216: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
217: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
218: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
219: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
220: raise OKC_API.G_EXCEPTION_ERROR;
221: END IF;
222: l_rgrv_rec := migrate_rgrv(l_rgrv_rec, g_rgrv_rec);
223:
224: OKC_RULE_DEF_PVT.update_rg_def_rule(

Line 233: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

229: x_msg_data => x_msg_data,
230: p_rgrv_rec => l_rgrv_rec,
231: x_rgrv_rec => x_rgrv_rec);
232:
233: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
234: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
235: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
236: raise OKC_API.G_EXCEPTION_ERROR;
237: END IF;

Line 234: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

230: p_rgrv_rec => l_rgrv_rec,
231: x_rgrv_rec => x_rgrv_rec);
232:
233: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
234: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
235: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
236: raise OKC_API.G_EXCEPTION_ERROR;
237: END IF;
238:

Line 235: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

231: x_rgrv_rec => x_rgrv_rec);
232:
233: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
234: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
235: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
236: raise OKC_API.G_EXCEPTION_ERROR;
237: END IF;
238:
239: -- Call user hook for AFTER

Line 236: raise OKC_API.G_EXCEPTION_ERROR;

232:
233: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
234: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
235: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
236: raise OKC_API.G_EXCEPTION_ERROR;
237: END IF;
238:
239: -- Call user hook for AFTER
240: g_rgrv_rec := x_rgrv_rec;

Line 242: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

238:
239: -- Call user hook for AFTER
240: g_rgrv_rec := x_rgrv_rec;
241: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
242: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
243: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
244: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
245: raise OKC_API.G_EXCEPTION_ERROR;
246: END IF;

Line 243: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

239: -- Call user hook for AFTER
240: g_rgrv_rec := x_rgrv_rec;
241: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
242: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
243: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
244: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
245: raise OKC_API.G_EXCEPTION_ERROR;
246: END IF;
247: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 244: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

240: g_rgrv_rec := x_rgrv_rec;
241: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
242: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
243: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
244: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
245: raise OKC_API.G_EXCEPTION_ERROR;
246: END IF;
247: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
248: EXCEPTION

Line 245: raise OKC_API.G_EXCEPTION_ERROR;

241: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
242: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
243: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
244: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
245: raise OKC_API.G_EXCEPTION_ERROR;
246: END IF;
247: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
248: EXCEPTION
249: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 247: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

243: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
244: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
245: raise OKC_API.G_EXCEPTION_ERROR;
246: END IF;
247: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
248: EXCEPTION
249: WHEN OKC_API.G_EXCEPTION_ERROR THEN
250: x_return_status := OKC_API.HANDLE_EXCEPTIONS
251: (l_api_name,

Line 249: WHEN OKC_API.G_EXCEPTION_ERROR THEN

245: raise OKC_API.G_EXCEPTION_ERROR;
246: END IF;
247: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
248: EXCEPTION
249: WHEN OKC_API.G_EXCEPTION_ERROR THEN
250: x_return_status := OKC_API.HANDLE_EXCEPTIONS
251: (l_api_name,
252: G_PKG_NAME,
253: 'OKC_API.G_RET_STS_ERROR',

Line 250: x_return_status := OKC_API.HANDLE_EXCEPTIONS

246: END IF;
247: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
248: EXCEPTION
249: WHEN OKC_API.G_EXCEPTION_ERROR THEN
250: x_return_status := OKC_API.HANDLE_EXCEPTIONS
251: (l_api_name,
252: G_PKG_NAME,
253: 'OKC_API.G_RET_STS_ERROR',
254: x_msg_count,

Line 253: 'OKC_API.G_RET_STS_ERROR',

249: WHEN OKC_API.G_EXCEPTION_ERROR THEN
250: x_return_status := OKC_API.HANDLE_EXCEPTIONS
251: (l_api_name,
252: G_PKG_NAME,
253: 'OKC_API.G_RET_STS_ERROR',
254: x_msg_count,
255: x_msg_data,
256: '_PUB');
257: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 257: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

253: 'OKC_API.G_RET_STS_ERROR',
254: x_msg_count,
255: x_msg_data,
256: '_PUB');
257: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
258: x_return_status := OKC_API.HANDLE_EXCEPTIONS
259: (l_api_name,
260: G_PKG_NAME,
261: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 258: x_return_status := OKC_API.HANDLE_EXCEPTIONS

254: x_msg_count,
255: x_msg_data,
256: '_PUB');
257: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
258: x_return_status := OKC_API.HANDLE_EXCEPTIONS
259: (l_api_name,
260: G_PKG_NAME,
261: 'OKC_API.G_RET_STS_UNEXP_ERROR',
262: x_msg_count,

Line 261: 'OKC_API.G_RET_STS_UNEXP_ERROR',

257: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
258: x_return_status := OKC_API.HANDLE_EXCEPTIONS
259: (l_api_name,
260: G_PKG_NAME,
261: 'OKC_API.G_RET_STS_UNEXP_ERROR',
262: x_msg_count,
263: x_msg_data,
264: '_PUB');
265: WHEN OTHERS THEN

Line 266: x_return_status := OKC_API.HANDLE_EXCEPTIONS

262: x_msg_count,
263: x_msg_data,
264: '_PUB');
265: WHEN OTHERS THEN
266: x_return_status := OKC_API.HANDLE_EXCEPTIONS
267: (l_api_name,
268: G_PKG_NAME,
269: 'OTHERS',
270: x_msg_count,

Line 289: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

285: p_rgrv_tbl IN rgrv_tbl_type,
286: x_rgrv_tbl OUT NOCOPY rgrv_tbl_type) IS
287:
288: i NUMBER := 0;
289: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
290: BEGIN
291: x_return_status := OKC_API.G_RET_STS_SUCCESS;
292: IF p_rgrv_tbl.COUNT > 0 THEN
293: i := p_rgrv_tbl.FIRST;

Line 291: x_return_status := OKC_API.G_RET_STS_SUCCESS;

287:
288: i NUMBER := 0;
289: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
290: BEGIN
291: x_return_status := OKC_API.G_RET_STS_SUCCESS;
292: IF p_rgrv_tbl.COUNT > 0 THEN
293: i := p_rgrv_tbl.FIRST;
294: LOOP
295: update_rg_def_rule(

Line 303: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

299: x_msg_count => x_msg_count,
300: x_msg_data => x_msg_data,
301: p_rgrv_rec => p_rgrv_tbl(i),
302: x_rgrv_rec => x_rgrv_tbl(i));
303: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
304: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
305: x_return_status := l_return_status;
306: raise G_EXCEPTION_HALT_VALIDATION;
307: ELSE

Line 304: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

300: x_msg_data => x_msg_data,
301: p_rgrv_rec => p_rgrv_tbl(i),
302: x_rgrv_rec => x_rgrv_tbl(i));
303: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
304: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
305: x_return_status := l_return_status;
306: raise G_EXCEPTION_HALT_VALIDATION;
307: ELSE
308: x_return_status := l_return_status;

Line 319: OKC_API.set_message(p_app_name => g_app_name,

315: EXCEPTION
316: WHEN G_EXCEPTION_HALT_VALIDATION THEN
317: NULL;
318: WHEN OTHERS THEN
319: OKC_API.set_message(p_app_name => g_app_name,
320: p_msg_name => g_unexpected_error,
321: p_token1 => g_sqlcode_token,
322: p_token1_value => sqlcode,
323: p_token2 => g_sqlerrm_token,

Line 325: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

321: p_token1 => g_sqlcode_token,
322: p_token1_value => sqlcode,
323: p_token2 => g_sqlerrm_token,
324: p_token2_value => sqlerrm);
325: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
326: END update_rg_def_rule;
327:
328: --------------------------------------
329: --PROCEDURE delete_rg_def_rule

Line 338: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

334: x_return_status OUT NOCOPY VARCHAR2,
335: x_msg_count OUT NOCOPY NUMBER,
336: x_msg_data OUT NOCOPY VARCHAR2,
337: p_rgrv_rec IN rgrv_rec_type) IS
338: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
339: l_api_name CONSTANT VARCHAR2(30) := 'delete_rg_def_rule';
340: l_rgrv_rec rgrv_rec_type := p_rgrv_rec;
341: BEGIN
342: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

Line 342: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

338: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
339: l_api_name CONSTANT VARCHAR2(30) := 'delete_rg_def_rule';
340: l_rgrv_rec rgrv_rec_type := p_rgrv_rec;
341: BEGIN
342: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
343: p_init_msg_list,
344: '_PUB',
345: x_return_status);
346: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 346: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

342: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
343: p_init_msg_list,
344: '_PUB',
345: x_return_status);
346: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
347: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
348: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
349: raise OKC_API.G_EXCEPTION_ERROR;
350: END IF;

Line 347: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

343: p_init_msg_list,
344: '_PUB',
345: x_return_status);
346: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
347: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
348: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
349: raise OKC_API.G_EXCEPTION_ERROR;
350: END IF;
351: -- Call user hook for BEFORE

Line 348: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

344: '_PUB',
345: x_return_status);
346: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
347: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
348: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
349: raise OKC_API.G_EXCEPTION_ERROR;
350: END IF;
351: -- Call user hook for BEFORE
352: g_rgrv_rec := l_rgrv_rec;

Line 349: raise OKC_API.G_EXCEPTION_ERROR;

345: x_return_status);
346: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
347: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
348: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
349: raise OKC_API.G_EXCEPTION_ERROR;
350: END IF;
351: -- Call user hook for BEFORE
352: g_rgrv_rec := l_rgrv_rec;
353: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 354: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

350: END IF;
351: -- Call user hook for BEFORE
352: g_rgrv_rec := l_rgrv_rec;
353: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
354: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
355: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
356: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
357: raise OKC_API.G_EXCEPTION_ERROR;
358: END IF;

Line 355: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

351: -- Call user hook for BEFORE
352: g_rgrv_rec := l_rgrv_rec;
353: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
354: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
355: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
356: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
357: raise OKC_API.G_EXCEPTION_ERROR;
358: END IF;
359:

Line 356: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

352: g_rgrv_rec := l_rgrv_rec;
353: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
354: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
355: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
356: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
357: raise OKC_API.G_EXCEPTION_ERROR;
358: END IF;
359:
360: OKC_RULE_DEF_PVT.delete_rg_def_rule(

Line 357: raise OKC_API.G_EXCEPTION_ERROR;

353: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
354: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
355: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
356: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
357: raise OKC_API.G_EXCEPTION_ERROR;
358: END IF;
359:
360: OKC_RULE_DEF_PVT.delete_rg_def_rule(
361: p_api_version => p_api_version,

Line 368: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

364: x_msg_count => x_msg_count,
365: x_msg_data => x_msg_data,
366: p_rgrv_rec => p_rgrv_rec);
367:
368: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
369: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
370: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
371: raise OKC_API.G_EXCEPTION_ERROR;
372: END IF;

Line 369: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

365: x_msg_data => x_msg_data,
366: p_rgrv_rec => p_rgrv_rec);
367:
368: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
369: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
370: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
371: raise OKC_API.G_EXCEPTION_ERROR;
372: END IF;
373:

Line 370: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

366: p_rgrv_rec => p_rgrv_rec);
367:
368: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
369: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
370: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
371: raise OKC_API.G_EXCEPTION_ERROR;
372: END IF;
373:
374: -- Call user hook for AFTER

Line 371: raise OKC_API.G_EXCEPTION_ERROR;

367:
368: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
369: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
370: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
371: raise OKC_API.G_EXCEPTION_ERROR;
372: END IF;
373:
374: -- Call user hook for AFTER
375: g_rgrv_rec := l_rgrv_rec;

Line 377: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

373:
374: -- Call user hook for AFTER
375: g_rgrv_rec := l_rgrv_rec;
376: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
377: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
378: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
379: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
380: raise OKC_API.G_EXCEPTION_ERROR;
381: END IF;

Line 378: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

374: -- Call user hook for AFTER
375: g_rgrv_rec := l_rgrv_rec;
376: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
377: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
378: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
379: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
380: raise OKC_API.G_EXCEPTION_ERROR;
381: END IF;
382: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 379: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

375: g_rgrv_rec := l_rgrv_rec;
376: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
377: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
378: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
379: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
380: raise OKC_API.G_EXCEPTION_ERROR;
381: END IF;
382: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
383: EXCEPTION

Line 380: raise OKC_API.G_EXCEPTION_ERROR;

376: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
377: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
378: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
379: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
380: raise OKC_API.G_EXCEPTION_ERROR;
381: END IF;
382: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
383: EXCEPTION
384: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 382: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

378: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
379: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
380: raise OKC_API.G_EXCEPTION_ERROR;
381: END IF;
382: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
383: EXCEPTION
384: WHEN OKC_API.G_EXCEPTION_ERROR THEN
385: x_return_status := OKC_API.HANDLE_EXCEPTIONS
386: (l_api_name,

Line 384: WHEN OKC_API.G_EXCEPTION_ERROR THEN

380: raise OKC_API.G_EXCEPTION_ERROR;
381: END IF;
382: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
383: EXCEPTION
384: WHEN OKC_API.G_EXCEPTION_ERROR THEN
385: x_return_status := OKC_API.HANDLE_EXCEPTIONS
386: (l_api_name,
387: G_PKG_NAME,
388: 'OKC_API.G_RET_STS_ERROR',

Line 385: x_return_status := OKC_API.HANDLE_EXCEPTIONS

381: END IF;
382: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
383: EXCEPTION
384: WHEN OKC_API.G_EXCEPTION_ERROR THEN
385: x_return_status := OKC_API.HANDLE_EXCEPTIONS
386: (l_api_name,
387: G_PKG_NAME,
388: 'OKC_API.G_RET_STS_ERROR',
389: x_msg_count,

Line 388: 'OKC_API.G_RET_STS_ERROR',

384: WHEN OKC_API.G_EXCEPTION_ERROR THEN
385: x_return_status := OKC_API.HANDLE_EXCEPTIONS
386: (l_api_name,
387: G_PKG_NAME,
388: 'OKC_API.G_RET_STS_ERROR',
389: x_msg_count,
390: x_msg_data,
391: '_PUB');
392: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 392: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

388: 'OKC_API.G_RET_STS_ERROR',
389: x_msg_count,
390: x_msg_data,
391: '_PUB');
392: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
393: x_return_status := OKC_API.HANDLE_EXCEPTIONS
394: (l_api_name,
395: G_PKG_NAME,
396: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 393: x_return_status := OKC_API.HANDLE_EXCEPTIONS

389: x_msg_count,
390: x_msg_data,
391: '_PUB');
392: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
393: x_return_status := OKC_API.HANDLE_EXCEPTIONS
394: (l_api_name,
395: G_PKG_NAME,
396: 'OKC_API.G_RET_STS_UNEXP_ERROR',
397: x_msg_count,

Line 396: 'OKC_API.G_RET_STS_UNEXP_ERROR',

392: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
393: x_return_status := OKC_API.HANDLE_EXCEPTIONS
394: (l_api_name,
395: G_PKG_NAME,
396: 'OKC_API.G_RET_STS_UNEXP_ERROR',
397: x_msg_count,
398: x_msg_data,
399: '_PUB');
400: WHEN OTHERS THEN

Line 401: x_return_status := OKC_API.HANDLE_EXCEPTIONS

397: x_msg_count,
398: x_msg_data,
399: '_PUB');
400: WHEN OTHERS THEN
401: x_return_status := OKC_API.HANDLE_EXCEPTIONS
402: (l_api_name,
403: G_PKG_NAME,
404: 'OTHERS',
405: x_msg_count,

Line 423: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

419: x_msg_data OUT NOCOPY VARCHAR2,
420: p_rgrv_tbl IN rgrv_tbl_type) IS
421:
422: i NUMBER := 0;
423: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
424: BEGIN
425: x_return_status := OKC_API.G_RET_STS_SUCCESS;
426: IF p_rgrv_tbl.COUNT > 0 THEN
427: i := p_rgrv_tbl.FIRST;

Line 425: x_return_status := OKC_API.G_RET_STS_SUCCESS;

421:
422: i NUMBER := 0;
423: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
424: BEGIN
425: x_return_status := OKC_API.G_RET_STS_SUCCESS;
426: IF p_rgrv_tbl.COUNT > 0 THEN
427: i := p_rgrv_tbl.FIRST;
428: LOOP
429: delete_rg_def_rule(

Line 436: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

432: x_return_status => l_return_status,
433: x_msg_count => x_msg_count,
434: x_msg_data => x_msg_data,
435: p_rgrv_rec => p_rgrv_tbl(i));
436: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
437: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
438: x_return_status := l_return_status;
439: raise G_EXCEPTION_HALT_VALIDATION;
440: ELSE

Line 437: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

433: x_msg_count => x_msg_count,
434: x_msg_data => x_msg_data,
435: p_rgrv_rec => p_rgrv_tbl(i));
436: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
437: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
438: x_return_status := l_return_status;
439: raise G_EXCEPTION_HALT_VALIDATION;
440: ELSE
441: x_return_status := l_return_status;

Line 452: OKC_API.set_message(p_app_name => g_app_name,

448: EXCEPTION
449: WHEN G_EXCEPTION_HALT_VALIDATION THEN
450: NULL;
451: WHEN OTHERS THEN
452: OKC_API.set_message(p_app_name => g_app_name,
453: p_msg_name => g_unexpected_error,
454: p_token1 => g_sqlcode_token,
455: p_token1_value => sqlcode,
456: p_token2 => g_sqlerrm_token,

Line 458: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

454: p_token1 => g_sqlcode_token,
455: p_token1_value => sqlcode,
456: p_token2 => g_sqlerrm_token,
457: p_token2_value => sqlerrm);
458: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
459: END delete_rg_def_rule;
460:
461: --------------------------------------
462: --PROCEDURE validate_rg_def_rule

Line 471: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

467: x_return_status OUT NOCOPY VARCHAR2,
468: x_msg_count OUT NOCOPY NUMBER,
469: x_msg_data OUT NOCOPY VARCHAR2,
470: p_rgrv_rec IN rgrv_rec_type) IS
471: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
472: l_api_name CONSTANT VARCHAR2(30) := 'validate_rg_def_rule';
473: l_rgrv_rec rgrv_rec_type := p_rgrv_rec;
474: BEGIN
475: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

Line 475: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

471: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
472: l_api_name CONSTANT VARCHAR2(30) := 'validate_rg_def_rule';
473: l_rgrv_rec rgrv_rec_type := p_rgrv_rec;
474: BEGIN
475: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
476: p_init_msg_list,
477: '_PUB',
478: x_return_status);
479: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 479: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

475: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
476: p_init_msg_list,
477: '_PUB',
478: x_return_status);
479: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
480: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
481: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
482: raise OKC_API.G_EXCEPTION_ERROR;
483: END IF;

Line 480: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

476: p_init_msg_list,
477: '_PUB',
478: x_return_status);
479: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
480: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
481: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
482: raise OKC_API.G_EXCEPTION_ERROR;
483: END IF;
484: -- Call user hook for BEFORE

Line 481: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

477: '_PUB',
478: x_return_status);
479: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
480: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
481: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
482: raise OKC_API.G_EXCEPTION_ERROR;
483: END IF;
484: -- Call user hook for BEFORE
485: g_rgrv_rec := l_rgrv_rec;

Line 482: raise OKC_API.G_EXCEPTION_ERROR;

478: x_return_status);
479: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
480: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
481: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
482: raise OKC_API.G_EXCEPTION_ERROR;
483: END IF;
484: -- Call user hook for BEFORE
485: g_rgrv_rec := l_rgrv_rec;
486: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 487: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

483: END IF;
484: -- Call user hook for BEFORE
485: g_rgrv_rec := l_rgrv_rec;
486: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
487: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
488: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
489: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
490: raise OKC_API.G_EXCEPTION_ERROR;
491: END IF;

Line 488: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

484: -- Call user hook for BEFORE
485: g_rgrv_rec := l_rgrv_rec;
486: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
487: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
488: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
489: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
490: raise OKC_API.G_EXCEPTION_ERROR;
491: END IF;
492:

Line 489: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

485: g_rgrv_rec := l_rgrv_rec;
486: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
487: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
488: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
489: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
490: raise OKC_API.G_EXCEPTION_ERROR;
491: END IF;
492:
493: OKC_RULE_DEF_PVT.validate_rg_def_rule(

Line 490: raise OKC_API.G_EXCEPTION_ERROR;

486: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
487: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
488: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
489: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
490: raise OKC_API.G_EXCEPTION_ERROR;
491: END IF;
492:
493: OKC_RULE_DEF_PVT.validate_rg_def_rule(
494: p_api_version => p_api_version,

Line 501: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

497: x_msg_count => x_msg_count,
498: x_msg_data => x_msg_data,
499: p_rgrv_rec => p_rgrv_rec);
500:
501: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
502: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
503: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
504: raise OKC_API.G_EXCEPTION_ERROR;
505: END IF;

Line 502: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

498: x_msg_data => x_msg_data,
499: p_rgrv_rec => p_rgrv_rec);
500:
501: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
502: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
503: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
504: raise OKC_API.G_EXCEPTION_ERROR;
505: END IF;
506:

Line 503: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

499: p_rgrv_rec => p_rgrv_rec);
500:
501: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
502: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
503: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
504: raise OKC_API.G_EXCEPTION_ERROR;
505: END IF;
506:
507: -- Call user hook for AFTER

Line 504: raise OKC_API.G_EXCEPTION_ERROR;

500:
501: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
502: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
503: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
504: raise OKC_API.G_EXCEPTION_ERROR;
505: END IF;
506:
507: -- Call user hook for AFTER
508: g_rgrv_rec := l_rgrv_rec;

Line 510: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

506:
507: -- Call user hook for AFTER
508: g_rgrv_rec := l_rgrv_rec;
509: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
510: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
511: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
512: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
513: raise OKC_API.G_EXCEPTION_ERROR;
514: END IF;

Line 511: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

507: -- Call user hook for AFTER
508: g_rgrv_rec := l_rgrv_rec;
509: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
510: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
511: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
512: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
513: raise OKC_API.G_EXCEPTION_ERROR;
514: END IF;
515: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 512: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

508: g_rgrv_rec := l_rgrv_rec;
509: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
510: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
511: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
512: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
513: raise OKC_API.G_EXCEPTION_ERROR;
514: END IF;
515: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
516: EXCEPTION

Line 513: raise OKC_API.G_EXCEPTION_ERROR;

509: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
510: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
511: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
512: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
513: raise OKC_API.G_EXCEPTION_ERROR;
514: END IF;
515: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
516: EXCEPTION
517: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 515: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

511: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
512: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
513: raise OKC_API.G_EXCEPTION_ERROR;
514: END IF;
515: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
516: EXCEPTION
517: WHEN OKC_API.G_EXCEPTION_ERROR THEN
518: x_return_status := OKC_API.HANDLE_EXCEPTIONS
519: (l_api_name,

Line 517: WHEN OKC_API.G_EXCEPTION_ERROR THEN

513: raise OKC_API.G_EXCEPTION_ERROR;
514: END IF;
515: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
516: EXCEPTION
517: WHEN OKC_API.G_EXCEPTION_ERROR THEN
518: x_return_status := OKC_API.HANDLE_EXCEPTIONS
519: (l_api_name,
520: G_PKG_NAME,
521: 'OKC_API.G_RET_STS_ERROR',

Line 518: x_return_status := OKC_API.HANDLE_EXCEPTIONS

514: END IF;
515: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
516: EXCEPTION
517: WHEN OKC_API.G_EXCEPTION_ERROR THEN
518: x_return_status := OKC_API.HANDLE_EXCEPTIONS
519: (l_api_name,
520: G_PKG_NAME,
521: 'OKC_API.G_RET_STS_ERROR',
522: x_msg_count,

Line 521: 'OKC_API.G_RET_STS_ERROR',

517: WHEN OKC_API.G_EXCEPTION_ERROR THEN
518: x_return_status := OKC_API.HANDLE_EXCEPTIONS
519: (l_api_name,
520: G_PKG_NAME,
521: 'OKC_API.G_RET_STS_ERROR',
522: x_msg_count,
523: x_msg_data,
524: '_PUB');
525: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 525: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

521: 'OKC_API.G_RET_STS_ERROR',
522: x_msg_count,
523: x_msg_data,
524: '_PUB');
525: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
526: x_return_status := OKC_API.HANDLE_EXCEPTIONS
527: (l_api_name,
528: G_PKG_NAME,
529: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 526: x_return_status := OKC_API.HANDLE_EXCEPTIONS

522: x_msg_count,
523: x_msg_data,
524: '_PUB');
525: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
526: x_return_status := OKC_API.HANDLE_EXCEPTIONS
527: (l_api_name,
528: G_PKG_NAME,
529: 'OKC_API.G_RET_STS_UNEXP_ERROR',
530: x_msg_count,

Line 529: 'OKC_API.G_RET_STS_UNEXP_ERROR',

525: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
526: x_return_status := OKC_API.HANDLE_EXCEPTIONS
527: (l_api_name,
528: G_PKG_NAME,
529: 'OKC_API.G_RET_STS_UNEXP_ERROR',
530: x_msg_count,
531: x_msg_data,
532: '_PUB');
533: WHEN OTHERS THEN

Line 534: x_return_status := OKC_API.HANDLE_EXCEPTIONS

530: x_msg_count,
531: x_msg_data,
532: '_PUB');
533: WHEN OTHERS THEN
534: x_return_status := OKC_API.HANDLE_EXCEPTIONS
535: (l_api_name,
536: G_PKG_NAME,
537: 'OTHERS',
538: x_msg_count,

Line 555: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

551: x_msg_data OUT NOCOPY VARCHAR2,
552: p_rgrv_tbl IN rgrv_tbl_type) IS
553:
554: i NUMBER := 0;
555: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
556: BEGIN
557: x_return_status := OKC_API.G_RET_STS_SUCCESS;
558: IF p_rgrv_tbl.COUNT > 0 THEN
559: i := p_rgrv_tbl.FIRST;

Line 557: x_return_status := OKC_API.G_RET_STS_SUCCESS;

553:
554: i NUMBER := 0;
555: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
556: BEGIN
557: x_return_status := OKC_API.G_RET_STS_SUCCESS;
558: IF p_rgrv_tbl.COUNT > 0 THEN
559: i := p_rgrv_tbl.FIRST;
560: LOOP
561: validate_rg_def_rule(

Line 568: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

564: x_return_status => l_return_status,
565: x_msg_count => x_msg_count,
566: x_msg_data => x_msg_data,
567: p_rgrv_rec => p_rgrv_tbl(i));
568: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
569: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
570: x_return_status := l_return_status;
571: raise G_EXCEPTION_HALT_VALIDATION;
572: ELSE

Line 569: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

565: x_msg_count => x_msg_count,
566: x_msg_data => x_msg_data,
567: p_rgrv_rec => p_rgrv_tbl(i));
568: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
569: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
570: x_return_status := l_return_status;
571: raise G_EXCEPTION_HALT_VALIDATION;
572: ELSE
573: x_return_status := l_return_status;

Line 584: OKC_API.set_message(p_app_name => g_app_name,

580: EXCEPTION
581: WHEN G_EXCEPTION_HALT_VALIDATION THEN
582: NULL;
583: WHEN OTHERS THEN
584: OKC_API.set_message(p_app_name => g_app_name,
585: p_msg_name => g_unexpected_error,
586: p_token1 => g_sqlcode_token,
587: p_token1_value => sqlcode,
588: p_token2 => g_sqlerrm_token,

Line 590: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

586: p_token1 => g_sqlcode_token,
587: p_token1_value => sqlcode,
588: p_token2 => g_sqlerrm_token,
589: p_token2_value => sqlerrm);
590: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
591: END validate_rg_def_rule;
592:
593: --------------------------------------
594: --PROCEDURE lock_rg_def_rule

Line 603: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

599: x_return_status OUT NOCOPY VARCHAR2,
600: x_msg_count OUT NOCOPY NUMBER,
601: x_msg_data OUT NOCOPY VARCHAR2,
602: p_rgrv_rec IN rgrv_rec_type) IS
603: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
604: BEGIN
605: OKC_RULE_DEF_PVT.lock_rg_def_rule(
606: p_api_version => p_api_version,
607: p_init_msg_list => p_init_msg_list,

Line 626: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

622: x_msg_data OUT NOCOPY VARCHAR2,
623: p_rgrv_tbl IN rgrv_tbl_type) IS
624:
625: i NUMBER := 0;
626: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
627: BEGIN
628: x_return_status := OKC_API.G_RET_STS_SUCCESS;
629: IF p_rgrv_tbl.COUNT > 0 THEN
630: i := p_rgrv_tbl.FIRST;

Line 628: x_return_status := OKC_API.G_RET_STS_SUCCESS;

624:
625: i NUMBER := 0;
626: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
627: BEGIN
628: x_return_status := OKC_API.G_RET_STS_SUCCESS;
629: IF p_rgrv_tbl.COUNT > 0 THEN
630: i := p_rgrv_tbl.FIRST;
631: LOOP
632: lock_rg_def_rule(

Line 639: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

635: x_return_status => l_return_status,
636: x_msg_count => x_msg_count,
637: x_msg_data => x_msg_data,
638: p_rgrv_rec => p_rgrv_tbl(i));
639: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
640: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
641: x_return_status := l_return_status;
642: raise G_EXCEPTION_HALT_VALIDATION;
643: ELSE

Line 640: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

636: x_msg_count => x_msg_count,
637: x_msg_data => x_msg_data,
638: p_rgrv_rec => p_rgrv_tbl(i));
639: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
640: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
641: x_return_status := l_return_status;
642: raise G_EXCEPTION_HALT_VALIDATION;
643: ELSE
644: x_return_status := l_return_status;

Line 655: OKC_API.set_message(p_app_name => g_app_name,

651: EXCEPTION
652: WHEN G_EXCEPTION_HALT_VALIDATION THEN
653: NULL;
654: WHEN OTHERS THEN
655: OKC_API.set_message(p_app_name => g_app_name,
656: p_msg_name => g_unexpected_error,
657: p_token1 => g_sqlcode_token,
658: p_token1_value => sqlcode,
659: p_token2 => g_sqlerrm_token,

Line 661: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

657: p_token1 => g_sqlcode_token,
658: p_token1_value => sqlcode,
659: p_token2 => g_sqlerrm_token,
660: p_token2_value => sqlerrm);
661: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
662: END lock_rg_def_rule;
663:
664: --------------------------------------
665: --PROCEDURE create_rd_source

Line 675: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

671: x_msg_count OUT NOCOPY NUMBER,
672: x_msg_data OUT NOCOPY VARCHAR2,
673: p_rdsv_rec IN rdsv_rec_type,
674: x_rdsv_rec OUT NOCOPY rdsv_rec_type) IS
675: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
676: l_api_name CONSTANT VARCHAR2(30) := 'create_rd_source';
677: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
678: BEGIN
679: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

Line 679: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

675: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
676: l_api_name CONSTANT VARCHAR2(30) := 'create_rd_source';
677: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
678: BEGIN
679: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
680: p_init_msg_list,
681: '_PUB',
682: x_return_status);
683: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 683: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

679: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
680: p_init_msg_list,
681: '_PUB',
682: x_return_status);
683: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
684: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
685: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
686: raise OKC_API.G_EXCEPTION_ERROR;
687: END IF;

Line 684: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

680: p_init_msg_list,
681: '_PUB',
682: x_return_status);
683: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
684: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
685: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
686: raise OKC_API.G_EXCEPTION_ERROR;
687: END IF;
688: -- Call user hook for BEFORE

Line 685: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

681: '_PUB',
682: x_return_status);
683: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
684: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
685: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
686: raise OKC_API.G_EXCEPTION_ERROR;
687: END IF;
688: -- Call user hook for BEFORE
689: g_rdsv_rec := l_rdsv_rec;

Line 686: raise OKC_API.G_EXCEPTION_ERROR;

682: x_return_status);
683: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
684: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
685: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
686: raise OKC_API.G_EXCEPTION_ERROR;
687: END IF;
688: -- Call user hook for BEFORE
689: g_rdsv_rec := l_rdsv_rec;
690: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 691: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

687: END IF;
688: -- Call user hook for BEFORE
689: g_rdsv_rec := l_rdsv_rec;
690: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
691: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
692: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
693: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
694: raise OKC_API.G_EXCEPTION_ERROR;
695: END IF;

Line 692: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

688: -- Call user hook for BEFORE
689: g_rdsv_rec := l_rdsv_rec;
690: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
691: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
692: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
693: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
694: raise OKC_API.G_EXCEPTION_ERROR;
695: END IF;
696: l_rdsv_rec := migrate_rdsv(l_rdsv_rec, g_rdsv_rec);

Line 693: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

689: g_rdsv_rec := l_rdsv_rec;
690: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
691: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
692: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
693: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
694: raise OKC_API.G_EXCEPTION_ERROR;
695: END IF;
696: l_rdsv_rec := migrate_rdsv(l_rdsv_rec, g_rdsv_rec);
697:

Line 694: raise OKC_API.G_EXCEPTION_ERROR;

690: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
691: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
692: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
693: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
694: raise OKC_API.G_EXCEPTION_ERROR;
695: END IF;
696: l_rdsv_rec := migrate_rdsv(l_rdsv_rec, g_rdsv_rec);
697:
698: OKC_RULE_DEF_PVT.create_rd_source(

Line 707: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

703: x_msg_data => x_msg_data,
704: p_rdsv_rec => l_rdsv_rec,
705: x_rdsv_rec => x_rdsv_rec);
706:
707: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
708: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
709: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
710: raise OKC_API.G_EXCEPTION_ERROR;
711: END IF;

Line 708: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

704: p_rdsv_rec => l_rdsv_rec,
705: x_rdsv_rec => x_rdsv_rec);
706:
707: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
708: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
709: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
710: raise OKC_API.G_EXCEPTION_ERROR;
711: END IF;
712:

Line 709: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

705: x_rdsv_rec => x_rdsv_rec);
706:
707: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
708: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
709: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
710: raise OKC_API.G_EXCEPTION_ERROR;
711: END IF;
712:
713: -- Call user hook for AFTER

Line 710: raise OKC_API.G_EXCEPTION_ERROR;

706:
707: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
708: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
709: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
710: raise OKC_API.G_EXCEPTION_ERROR;
711: END IF;
712:
713: -- Call user hook for AFTER
714: g_rdsv_rec := x_rdsv_rec;

Line 716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

712:
713: -- Call user hook for AFTER
714: g_rdsv_rec := x_rdsv_rec;
715: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: raise OKC_API.G_EXCEPTION_ERROR;
720: END IF;

Line 717: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

713: -- Call user hook for AFTER
714: g_rdsv_rec := x_rdsv_rec;
715: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: raise OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

714: g_rdsv_rec := x_rdsv_rec;
715: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: raise OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
722: EXCEPTION

Line 719: raise OKC_API.G_EXCEPTION_ERROR;

715: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
716: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
717: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: raise OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
722: EXCEPTION
723: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 721: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

717: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
718: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
719: raise OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
722: EXCEPTION
723: WHEN OKC_API.G_EXCEPTION_ERROR THEN
724: x_return_status := OKC_API.HANDLE_EXCEPTIONS
725: (l_api_name,

Line 723: WHEN OKC_API.G_EXCEPTION_ERROR THEN

719: raise OKC_API.G_EXCEPTION_ERROR;
720: END IF;
721: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
722: EXCEPTION
723: WHEN OKC_API.G_EXCEPTION_ERROR THEN
724: x_return_status := OKC_API.HANDLE_EXCEPTIONS
725: (l_api_name,
726: G_PKG_NAME,
727: 'OKC_API.G_RET_STS_ERROR',

Line 724: x_return_status := OKC_API.HANDLE_EXCEPTIONS

720: END IF;
721: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
722: EXCEPTION
723: WHEN OKC_API.G_EXCEPTION_ERROR THEN
724: x_return_status := OKC_API.HANDLE_EXCEPTIONS
725: (l_api_name,
726: G_PKG_NAME,
727: 'OKC_API.G_RET_STS_ERROR',
728: x_msg_count,

Line 727: 'OKC_API.G_RET_STS_ERROR',

723: WHEN OKC_API.G_EXCEPTION_ERROR THEN
724: x_return_status := OKC_API.HANDLE_EXCEPTIONS
725: (l_api_name,
726: G_PKG_NAME,
727: 'OKC_API.G_RET_STS_ERROR',
728: x_msg_count,
729: x_msg_data,
730: '_PUB');
731: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 731: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

727: 'OKC_API.G_RET_STS_ERROR',
728: x_msg_count,
729: x_msg_data,
730: '_PUB');
731: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
732: x_return_status := OKC_API.HANDLE_EXCEPTIONS
733: (l_api_name,
734: G_PKG_NAME,
735: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 732: x_return_status := OKC_API.HANDLE_EXCEPTIONS

728: x_msg_count,
729: x_msg_data,
730: '_PUB');
731: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
732: x_return_status := OKC_API.HANDLE_EXCEPTIONS
733: (l_api_name,
734: G_PKG_NAME,
735: 'OKC_API.G_RET_STS_UNEXP_ERROR',
736: x_msg_count,

Line 735: 'OKC_API.G_RET_STS_UNEXP_ERROR',

731: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
732: x_return_status := OKC_API.HANDLE_EXCEPTIONS
733: (l_api_name,
734: G_PKG_NAME,
735: 'OKC_API.G_RET_STS_UNEXP_ERROR',
736: x_msg_count,
737: x_msg_data,
738: '_PUB');
739: WHEN OTHERS THEN

Line 740: x_return_status := OKC_API.HANDLE_EXCEPTIONS

736: x_msg_count,
737: x_msg_data,
738: '_PUB');
739: WHEN OTHERS THEN
740: x_return_status := OKC_API.HANDLE_EXCEPTIONS
741: (l_api_name,
742: G_PKG_NAME,
743: 'OTHERS',
744: x_msg_count,

Line 762: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

758: p_rdsv_tbl IN rdsv_tbl_type,
759: x_rdsv_tbl OUT NOCOPY rdsv_tbl_type) IS
760:
761: i NUMBER := 0;
762: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
763: BEGIN
764: x_return_status := OKC_API.G_RET_STS_SUCCESS;
765: IF p_rdsv_tbl.COUNT > 0 THEN
766: i := p_rdsv_tbl.FIRST;

Line 764: x_return_status := OKC_API.G_RET_STS_SUCCESS;

760:
761: i NUMBER := 0;
762: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
763: BEGIN
764: x_return_status := OKC_API.G_RET_STS_SUCCESS;
765: IF p_rdsv_tbl.COUNT > 0 THEN
766: i := p_rdsv_tbl.FIRST;
767: LOOP
768: create_rd_source(

Line 776: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

772: x_msg_count => x_msg_count,
773: x_msg_data => x_msg_data,
774: p_rdsv_rec => p_rdsv_tbl(i),
775: x_rdsv_rec => x_rdsv_tbl(i));
776: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
777: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
778: x_return_status := l_return_status;
779: raise G_EXCEPTION_HALT_VALIDATION;
780: ELSE

Line 777: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

773: x_msg_data => x_msg_data,
774: p_rdsv_rec => p_rdsv_tbl(i),
775: x_rdsv_rec => x_rdsv_tbl(i));
776: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
777: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
778: x_return_status := l_return_status;
779: raise G_EXCEPTION_HALT_VALIDATION;
780: ELSE
781: x_return_status := l_return_status;

Line 792: OKC_API.set_message(p_app_name => g_app_name,

788: EXCEPTION
789: WHEN G_EXCEPTION_HALT_VALIDATION THEN
790: NULL;
791: WHEN OTHERS THEN
792: OKC_API.set_message(p_app_name => g_app_name,
793: p_msg_name => g_unexpected_error,
794: p_token1 => g_sqlcode_token,
795: p_token1_value => sqlcode,
796: p_token2 => g_sqlerrm_token,

Line 798: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

794: p_token1 => g_sqlcode_token,
795: p_token1_value => sqlcode,
796: p_token2 => g_sqlerrm_token,
797: p_token2_value => sqlerrm);
798: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
799: END create_rd_source;
800:
801: --------------------------------------
802: --PROCEDURE update_rd_source

Line 812: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

808: x_msg_count OUT NOCOPY NUMBER,
809: x_msg_data OUT NOCOPY VARCHAR2,
810: p_rdsv_rec IN rdsv_rec_type,
811: x_rdsv_rec OUT NOCOPY rdsv_rec_type) IS
812: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
813: l_api_name CONSTANT VARCHAR2(30) := 'update_rd_source';
814: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
815: BEGIN
816: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

Line 816: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

812: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
813: l_api_name CONSTANT VARCHAR2(30) := 'update_rd_source';
814: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
815: BEGIN
816: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
817: p_init_msg_list,
818: '_PUB',
819: x_return_status);
820: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 820: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

816: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
817: p_init_msg_list,
818: '_PUB',
819: x_return_status);
820: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
821: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
822: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
823: raise OKC_API.G_EXCEPTION_ERROR;
824: END IF;

Line 821: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

817: p_init_msg_list,
818: '_PUB',
819: x_return_status);
820: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
821: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
822: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
823: raise OKC_API.G_EXCEPTION_ERROR;
824: END IF;
825: -- Call user hook for BEFORE

Line 822: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

818: '_PUB',
819: x_return_status);
820: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
821: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
822: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
823: raise OKC_API.G_EXCEPTION_ERROR;
824: END IF;
825: -- Call user hook for BEFORE
826: g_rdsv_rec := l_rdsv_rec;

Line 823: raise OKC_API.G_EXCEPTION_ERROR;

819: x_return_status);
820: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
821: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
822: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
823: raise OKC_API.G_EXCEPTION_ERROR;
824: END IF;
825: -- Call user hook for BEFORE
826: g_rdsv_rec := l_rdsv_rec;
827: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 828: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

824: END IF;
825: -- Call user hook for BEFORE
826: g_rdsv_rec := l_rdsv_rec;
827: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
828: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
829: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
830: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
831: raise OKC_API.G_EXCEPTION_ERROR;
832: END IF;

Line 829: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

825: -- Call user hook for BEFORE
826: g_rdsv_rec := l_rdsv_rec;
827: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
828: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
829: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
830: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
831: raise OKC_API.G_EXCEPTION_ERROR;
832: END IF;
833: l_rdsv_rec := migrate_rdsv(l_rdsv_rec, g_rdsv_rec);

Line 830: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

826: g_rdsv_rec := l_rdsv_rec;
827: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
828: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
829: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
830: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
831: raise OKC_API.G_EXCEPTION_ERROR;
832: END IF;
833: l_rdsv_rec := migrate_rdsv(l_rdsv_rec, g_rdsv_rec);
834:

Line 831: raise OKC_API.G_EXCEPTION_ERROR;

827: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
828: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
829: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
830: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
831: raise OKC_API.G_EXCEPTION_ERROR;
832: END IF;
833: l_rdsv_rec := migrate_rdsv(l_rdsv_rec, g_rdsv_rec);
834:
835: OKC_RULE_DEF_PVT.update_rd_source(

Line 844: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

840: x_msg_data => x_msg_data,
841: p_rdsv_rec => l_rdsv_rec,
842: x_rdsv_rec => x_rdsv_rec);
843:
844: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
846: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
847: raise OKC_API.G_EXCEPTION_ERROR;
848: END IF;

Line 845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

841: p_rdsv_rec => l_rdsv_rec,
842: x_rdsv_rec => x_rdsv_rec);
843:
844: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
846: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
847: raise OKC_API.G_EXCEPTION_ERROR;
848: END IF;
849:

Line 846: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

842: x_rdsv_rec => x_rdsv_rec);
843:
844: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
846: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
847: raise OKC_API.G_EXCEPTION_ERROR;
848: END IF;
849:
850: -- Call user hook for AFTER

Line 847: raise OKC_API.G_EXCEPTION_ERROR;

843:
844: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
845: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
846: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
847: raise OKC_API.G_EXCEPTION_ERROR;
848: END IF;
849:
850: -- Call user hook for AFTER
851: g_rdsv_rec := x_rdsv_rec;

Line 853: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

849:
850: -- Call user hook for AFTER
851: g_rdsv_rec := x_rdsv_rec;
852: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
853: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
856: raise OKC_API.G_EXCEPTION_ERROR;
857: END IF;

Line 854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

850: -- Call user hook for AFTER
851: g_rdsv_rec := x_rdsv_rec;
852: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
853: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
856: raise OKC_API.G_EXCEPTION_ERROR;
857: END IF;
858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

851: g_rdsv_rec := x_rdsv_rec;
852: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
853: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
856: raise OKC_API.G_EXCEPTION_ERROR;
857: END IF;
858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
859: EXCEPTION

Line 856: raise OKC_API.G_EXCEPTION_ERROR;

852: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
853: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
856: raise OKC_API.G_EXCEPTION_ERROR;
857: END IF;
858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
859: EXCEPTION
860: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

854: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
855: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
856: raise OKC_API.G_EXCEPTION_ERROR;
857: END IF;
858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
859: EXCEPTION
860: WHEN OKC_API.G_EXCEPTION_ERROR THEN
861: x_return_status := OKC_API.HANDLE_EXCEPTIONS
862: (l_api_name,

Line 860: WHEN OKC_API.G_EXCEPTION_ERROR THEN

856: raise OKC_API.G_EXCEPTION_ERROR;
857: END IF;
858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
859: EXCEPTION
860: WHEN OKC_API.G_EXCEPTION_ERROR THEN
861: x_return_status := OKC_API.HANDLE_EXCEPTIONS
862: (l_api_name,
863: G_PKG_NAME,
864: 'OKC_API.G_RET_STS_ERROR',

Line 861: x_return_status := OKC_API.HANDLE_EXCEPTIONS

857: END IF;
858: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
859: EXCEPTION
860: WHEN OKC_API.G_EXCEPTION_ERROR THEN
861: x_return_status := OKC_API.HANDLE_EXCEPTIONS
862: (l_api_name,
863: G_PKG_NAME,
864: 'OKC_API.G_RET_STS_ERROR',
865: x_msg_count,

Line 864: 'OKC_API.G_RET_STS_ERROR',

860: WHEN OKC_API.G_EXCEPTION_ERROR THEN
861: x_return_status := OKC_API.HANDLE_EXCEPTIONS
862: (l_api_name,
863: G_PKG_NAME,
864: 'OKC_API.G_RET_STS_ERROR',
865: x_msg_count,
866: x_msg_data,
867: '_PUB');
868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

864: 'OKC_API.G_RET_STS_ERROR',
865: x_msg_count,
866: x_msg_data,
867: '_PUB');
868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
869: x_return_status := OKC_API.HANDLE_EXCEPTIONS
870: (l_api_name,
871: G_PKG_NAME,
872: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 869: x_return_status := OKC_API.HANDLE_EXCEPTIONS

865: x_msg_count,
866: x_msg_data,
867: '_PUB');
868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
869: x_return_status := OKC_API.HANDLE_EXCEPTIONS
870: (l_api_name,
871: G_PKG_NAME,
872: 'OKC_API.G_RET_STS_UNEXP_ERROR',
873: x_msg_count,

Line 872: 'OKC_API.G_RET_STS_UNEXP_ERROR',

868: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
869: x_return_status := OKC_API.HANDLE_EXCEPTIONS
870: (l_api_name,
871: G_PKG_NAME,
872: 'OKC_API.G_RET_STS_UNEXP_ERROR',
873: x_msg_count,
874: x_msg_data,
875: '_PUB');
876: WHEN OTHERS THEN

Line 877: x_return_status := OKC_API.HANDLE_EXCEPTIONS

873: x_msg_count,
874: x_msg_data,
875: '_PUB');
876: WHEN OTHERS THEN
877: x_return_status := OKC_API.HANDLE_EXCEPTIONS
878: (l_api_name,
879: G_PKG_NAME,
880: 'OTHERS',
881: x_msg_count,

Line 899: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

895: p_rdsv_tbl IN rdsv_tbl_type,
896: x_rdsv_tbl OUT NOCOPY rdsv_tbl_type) IS
897:
898: i NUMBER := 0;
899: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
900: BEGIN
901: x_return_status := OKC_API.G_RET_STS_SUCCESS;
902: IF p_rdsv_tbl.COUNT > 0 THEN
903: i := p_rdsv_tbl.FIRST;

Line 901: x_return_status := OKC_API.G_RET_STS_SUCCESS;

897:
898: i NUMBER := 0;
899: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
900: BEGIN
901: x_return_status := OKC_API.G_RET_STS_SUCCESS;
902: IF p_rdsv_tbl.COUNT > 0 THEN
903: i := p_rdsv_tbl.FIRST;
904: LOOP
905: update_rd_source(

Line 913: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

909: x_msg_count => x_msg_count,
910: x_msg_data => x_msg_data,
911: p_rdsv_rec => p_rdsv_tbl(i),
912: x_rdsv_rec => x_rdsv_tbl(i));
913: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
914: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
915: x_return_status := l_return_status;
916: raise G_EXCEPTION_HALT_VALIDATION;
917: ELSE

Line 914: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

910: x_msg_data => x_msg_data,
911: p_rdsv_rec => p_rdsv_tbl(i),
912: x_rdsv_rec => x_rdsv_tbl(i));
913: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
914: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
915: x_return_status := l_return_status;
916: raise G_EXCEPTION_HALT_VALIDATION;
917: ELSE
918: x_return_status := l_return_status;

Line 929: OKC_API.set_message(p_app_name => g_app_name,

925: EXCEPTION
926: WHEN G_EXCEPTION_HALT_VALIDATION THEN
927: NULL;
928: WHEN OTHERS THEN
929: OKC_API.set_message(p_app_name => g_app_name,
930: p_msg_name => g_unexpected_error,
931: p_token1 => g_sqlcode_token,
932: p_token1_value => sqlcode,
933: p_token2 => g_sqlerrm_token,

Line 935: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

931: p_token1 => g_sqlcode_token,
932: p_token1_value => sqlcode,
933: p_token2 => g_sqlerrm_token,
934: p_token2_value => sqlerrm);
935: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
936: END update_rd_source;
937:
938: --------------------------------------
939: --PROCEDURE delete_rd_source

Line 948: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

944: x_return_status OUT NOCOPY VARCHAR2,
945: x_msg_count OUT NOCOPY NUMBER,
946: x_msg_data OUT NOCOPY VARCHAR2,
947: p_rdsv_rec IN rdsv_rec_type) IS
948: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
949: l_api_name CONSTANT VARCHAR2(30) := 'delete_rd_source';
950: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
951: BEGIN
952: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

Line 952: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

948: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
949: l_api_name CONSTANT VARCHAR2(30) := 'delete_rd_source';
950: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
951: BEGIN
952: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
953: p_init_msg_list,
954: '_PUB',
955: x_return_status);
956: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 956: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

952: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
953: p_init_msg_list,
954: '_PUB',
955: x_return_status);
956: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
957: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
958: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
959: raise OKC_API.G_EXCEPTION_ERROR;
960: END IF;

Line 957: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

953: p_init_msg_list,
954: '_PUB',
955: x_return_status);
956: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
957: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
958: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
959: raise OKC_API.G_EXCEPTION_ERROR;
960: END IF;
961: -- Call user hook for BEFORE

Line 958: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

954: '_PUB',
955: x_return_status);
956: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
957: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
958: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
959: raise OKC_API.G_EXCEPTION_ERROR;
960: END IF;
961: -- Call user hook for BEFORE
962: g_rdsv_rec := l_rdsv_rec;

Line 959: raise OKC_API.G_EXCEPTION_ERROR;

955: x_return_status);
956: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
957: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
958: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
959: raise OKC_API.G_EXCEPTION_ERROR;
960: END IF;
961: -- Call user hook for BEFORE
962: g_rdsv_rec := l_rdsv_rec;
963: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 964: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

960: END IF;
961: -- Call user hook for BEFORE
962: g_rdsv_rec := l_rdsv_rec;
963: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
964: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
965: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
966: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
967: raise OKC_API.G_EXCEPTION_ERROR;
968: END IF;

Line 965: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

961: -- Call user hook for BEFORE
962: g_rdsv_rec := l_rdsv_rec;
963: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
964: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
965: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
966: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
967: raise OKC_API.G_EXCEPTION_ERROR;
968: END IF;
969:

Line 966: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

962: g_rdsv_rec := l_rdsv_rec;
963: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
964: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
965: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
966: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
967: raise OKC_API.G_EXCEPTION_ERROR;
968: END IF;
969:
970: OKC_RULE_DEF_PVT.delete_rd_source(

Line 967: raise OKC_API.G_EXCEPTION_ERROR;

963: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
964: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
965: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
966: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
967: raise OKC_API.G_EXCEPTION_ERROR;
968: END IF;
969:
970: OKC_RULE_DEF_PVT.delete_rd_source(
971: p_api_version => p_api_version,

Line 978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

974: x_msg_count => x_msg_count,
975: x_msg_data => x_msg_data,
976: p_rdsv_rec => p_rdsv_rec);
977:
978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
981: raise OKC_API.G_EXCEPTION_ERROR;
982: END IF;

Line 979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

975: x_msg_data => x_msg_data,
976: p_rdsv_rec => p_rdsv_rec);
977:
978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
981: raise OKC_API.G_EXCEPTION_ERROR;
982: END IF;
983:

Line 980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

976: p_rdsv_rec => p_rdsv_rec);
977:
978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
981: raise OKC_API.G_EXCEPTION_ERROR;
982: END IF;
983:
984: -- Call user hook for AFTER

Line 981: raise OKC_API.G_EXCEPTION_ERROR;

977:
978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
981: raise OKC_API.G_EXCEPTION_ERROR;
982: END IF;
983:
984: -- Call user hook for AFTER
985: g_rdsv_rec := l_rdsv_rec;

Line 987: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

983:
984: -- Call user hook for AFTER
985: g_rdsv_rec := l_rdsv_rec;
986: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
987: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
988: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
989: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
990: raise OKC_API.G_EXCEPTION_ERROR;
991: END IF;

Line 988: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

984: -- Call user hook for AFTER
985: g_rdsv_rec := l_rdsv_rec;
986: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
987: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
988: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
989: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
990: raise OKC_API.G_EXCEPTION_ERROR;
991: END IF;
992: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 989: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

985: g_rdsv_rec := l_rdsv_rec;
986: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
987: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
988: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
989: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
990: raise OKC_API.G_EXCEPTION_ERROR;
991: END IF;
992: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
993: EXCEPTION

Line 990: raise OKC_API.G_EXCEPTION_ERROR;

986: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
987: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
988: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
989: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
990: raise OKC_API.G_EXCEPTION_ERROR;
991: END IF;
992: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
993: EXCEPTION
994: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 992: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

988: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
989: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
990: raise OKC_API.G_EXCEPTION_ERROR;
991: END IF;
992: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
993: EXCEPTION
994: WHEN OKC_API.G_EXCEPTION_ERROR THEN
995: x_return_status := OKC_API.HANDLE_EXCEPTIONS
996: (l_api_name,

Line 994: WHEN OKC_API.G_EXCEPTION_ERROR THEN

990: raise OKC_API.G_EXCEPTION_ERROR;
991: END IF;
992: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
993: EXCEPTION
994: WHEN OKC_API.G_EXCEPTION_ERROR THEN
995: x_return_status := OKC_API.HANDLE_EXCEPTIONS
996: (l_api_name,
997: G_PKG_NAME,
998: 'OKC_API.G_RET_STS_ERROR',

Line 995: x_return_status := OKC_API.HANDLE_EXCEPTIONS

991: END IF;
992: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
993: EXCEPTION
994: WHEN OKC_API.G_EXCEPTION_ERROR THEN
995: x_return_status := OKC_API.HANDLE_EXCEPTIONS
996: (l_api_name,
997: G_PKG_NAME,
998: 'OKC_API.G_RET_STS_ERROR',
999: x_msg_count,

Line 998: 'OKC_API.G_RET_STS_ERROR',

994: WHEN OKC_API.G_EXCEPTION_ERROR THEN
995: x_return_status := OKC_API.HANDLE_EXCEPTIONS
996: (l_api_name,
997: G_PKG_NAME,
998: 'OKC_API.G_RET_STS_ERROR',
999: x_msg_count,
1000: x_msg_data,
1001: '_PUB');
1002: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1002: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

998: 'OKC_API.G_RET_STS_ERROR',
999: x_msg_count,
1000: x_msg_data,
1001: '_PUB');
1002: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1003: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1004: (l_api_name,
1005: G_PKG_NAME,
1006: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1003: x_return_status := OKC_API.HANDLE_EXCEPTIONS

999: x_msg_count,
1000: x_msg_data,
1001: '_PUB');
1002: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1003: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1004: (l_api_name,
1005: G_PKG_NAME,
1006: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1007: x_msg_count,

Line 1006: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1002: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1003: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1004: (l_api_name,
1005: G_PKG_NAME,
1006: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1007: x_msg_count,
1008: x_msg_data,
1009: '_PUB');
1010: WHEN OTHERS THEN

Line 1011: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1007: x_msg_count,
1008: x_msg_data,
1009: '_PUB');
1010: WHEN OTHERS THEN
1011: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1012: (l_api_name,
1013: G_PKG_NAME,
1014: 'OTHERS',
1015: x_msg_count,

Line 1032: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1028: x_msg_data OUT NOCOPY VARCHAR2,
1029: p_rdsv_tbl IN rdsv_tbl_type) IS
1030:
1031: i NUMBER := 0;
1032: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1033: BEGIN
1034: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1035: IF p_rdsv_tbl.COUNT > 0 THEN
1036: i := p_rdsv_tbl.FIRST;

Line 1034: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1030:
1031: i NUMBER := 0;
1032: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1033: BEGIN
1034: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1035: IF p_rdsv_tbl.COUNT > 0 THEN
1036: i := p_rdsv_tbl.FIRST;
1037: LOOP
1038: delete_rd_source(

Line 1045: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1041: x_return_status => l_return_status,
1042: x_msg_count => x_msg_count,
1043: x_msg_data => x_msg_data,
1044: p_rdsv_rec => p_rdsv_tbl(i));
1045: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1046: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1047: x_return_status := l_return_status;
1048: raise G_EXCEPTION_HALT_VALIDATION;
1049: ELSE

Line 1046: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1042: x_msg_count => x_msg_count,
1043: x_msg_data => x_msg_data,
1044: p_rdsv_rec => p_rdsv_tbl(i));
1045: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1046: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1047: x_return_status := l_return_status;
1048: raise G_EXCEPTION_HALT_VALIDATION;
1049: ELSE
1050: x_return_status := l_return_status;

Line 1061: OKC_API.set_message(p_app_name => g_app_name,

1057: EXCEPTION
1058: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1059: NULL;
1060: WHEN OTHERS THEN
1061: OKC_API.set_message(p_app_name => g_app_name,
1062: p_msg_name => g_unexpected_error,
1063: p_token1 => g_sqlcode_token,
1064: p_token1_value => sqlcode,
1065: p_token2 => g_sqlerrm_token,

Line 1067: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1063: p_token1 => g_sqlcode_token,
1064: p_token1_value => sqlcode,
1065: p_token2 => g_sqlerrm_token,
1066: p_token2_value => sqlerrm);
1067: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1068: END delete_rd_source;
1069:
1070: --------------------------------------
1071: --PROCEDURE validate_rd_source

Line 1080: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1076: x_return_status OUT NOCOPY VARCHAR2,
1077: x_msg_count OUT NOCOPY NUMBER,
1078: x_msg_data OUT NOCOPY VARCHAR2,
1079: p_rdsv_rec IN rdsv_rec_type) IS
1080: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1081: l_api_name CONSTANT VARCHAR2(30) := 'validate_rd_source';
1082: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
1083: BEGIN
1084: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

Line 1084: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

1080: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1081: l_api_name CONSTANT VARCHAR2(30) := 'validate_rd_source';
1082: l_rdsv_rec rdsv_rec_type := p_rdsv_rec;
1083: BEGIN
1084: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1085: p_init_msg_list,
1086: '_PUB',
1087: x_return_status);
1088: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

Line 1088: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1084: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1085: p_init_msg_list,
1086: '_PUB',
1087: x_return_status);
1088: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1089: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1090: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1091: raise OKC_API.G_EXCEPTION_ERROR;
1092: END IF;

Line 1089: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1085: p_init_msg_list,
1086: '_PUB',
1087: x_return_status);
1088: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1089: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1090: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1091: raise OKC_API.G_EXCEPTION_ERROR;
1092: END IF;
1093: -- Call user hook for BEFORE

Line 1090: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN

1086: '_PUB',
1087: x_return_status);
1088: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1089: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1090: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1091: raise OKC_API.G_EXCEPTION_ERROR;
1092: END IF;
1093: -- Call user hook for BEFORE
1094: g_rdsv_rec := l_rdsv_rec;

Line 1091: raise OKC_API.G_EXCEPTION_ERROR;

1087: x_return_status);
1088: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1089: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1090: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1091: raise OKC_API.G_EXCEPTION_ERROR;
1092: END IF;
1093: -- Call user hook for BEFORE
1094: g_rdsv_rec := l_rdsv_rec;
1095: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

Line 1096: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1092: END IF;
1093: -- Call user hook for BEFORE
1094: g_rdsv_rec := l_rdsv_rec;
1095: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1096: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1097: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1098: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1099: raise OKC_API.G_EXCEPTION_ERROR;
1100: END IF;

Line 1097: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1093: -- Call user hook for BEFORE
1094: g_rdsv_rec := l_rdsv_rec;
1095: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1096: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1097: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1098: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1099: raise OKC_API.G_EXCEPTION_ERROR;
1100: END IF;
1101:

Line 1098: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1094: g_rdsv_rec := l_rdsv_rec;
1095: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1096: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1097: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1098: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1099: raise OKC_API.G_EXCEPTION_ERROR;
1100: END IF;
1101:
1102: OKC_RULE_DEF_PVT.validate_rd_source(

Line 1099: raise OKC_API.G_EXCEPTION_ERROR;

1095: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1096: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1097: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1098: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1099: raise OKC_API.G_EXCEPTION_ERROR;
1100: END IF;
1101:
1102: OKC_RULE_DEF_PVT.validate_rd_source(
1103: p_api_version => p_api_version,

Line 1110: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1106: x_msg_count => x_msg_count,
1107: x_msg_data => x_msg_data,
1108: p_rdsv_rec => p_rdsv_rec);
1109:
1110: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1111: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1112: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1113: raise OKC_API.G_EXCEPTION_ERROR;
1114: END IF;

Line 1111: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1107: x_msg_data => x_msg_data,
1108: p_rdsv_rec => p_rdsv_rec);
1109:
1110: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1111: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1112: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1113: raise OKC_API.G_EXCEPTION_ERROR;
1114: END IF;
1115:

Line 1112: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1108: p_rdsv_rec => p_rdsv_rec);
1109:
1110: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1111: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1112: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1113: raise OKC_API.G_EXCEPTION_ERROR;
1114: END IF;
1115:
1116: -- Call user hook for AFTER

Line 1113: raise OKC_API.G_EXCEPTION_ERROR;

1109:
1110: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1111: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1112: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1113: raise OKC_API.G_EXCEPTION_ERROR;
1114: END IF;
1115:
1116: -- Call user hook for AFTER
1117: g_rdsv_rec := l_rdsv_rec;

Line 1119: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1115:
1116: -- Call user hook for AFTER
1117: g_rdsv_rec := l_rdsv_rec;
1118: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1119: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1120: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1121: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1122: raise OKC_API.G_EXCEPTION_ERROR;
1123: END IF;

Line 1120: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1116: -- Call user hook for AFTER
1117: g_rdsv_rec := l_rdsv_rec;
1118: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1119: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1120: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1121: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1122: raise OKC_API.G_EXCEPTION_ERROR;
1123: END IF;
1124: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 1121: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN

1117: g_rdsv_rec := l_rdsv_rec;
1118: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1119: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1120: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1121: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1122: raise OKC_API.G_EXCEPTION_ERROR;
1123: END IF;
1124: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1125: EXCEPTION

Line 1122: raise OKC_API.G_EXCEPTION_ERROR;

1118: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1119: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1120: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1121: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1122: raise OKC_API.G_EXCEPTION_ERROR;
1123: END IF;
1124: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1125: EXCEPTION
1126: WHEN OKC_API.G_EXCEPTION_ERROR THEN

Line 1124: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

1120: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1121: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1122: raise OKC_API.G_EXCEPTION_ERROR;
1123: END IF;
1124: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1125: EXCEPTION
1126: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1127: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1128: (l_api_name,

Line 1126: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1122: raise OKC_API.G_EXCEPTION_ERROR;
1123: END IF;
1124: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1125: EXCEPTION
1126: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1127: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1128: (l_api_name,
1129: G_PKG_NAME,
1130: 'OKC_API.G_RET_STS_ERROR',

Line 1127: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1123: END IF;
1124: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1125: EXCEPTION
1126: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1127: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1128: (l_api_name,
1129: G_PKG_NAME,
1130: 'OKC_API.G_RET_STS_ERROR',
1131: x_msg_count,

Line 1130: 'OKC_API.G_RET_STS_ERROR',

1126: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1127: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1128: (l_api_name,
1129: G_PKG_NAME,
1130: 'OKC_API.G_RET_STS_ERROR',
1131: x_msg_count,
1132: x_msg_data,
1133: '_PUB');
1134: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1134: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1130: 'OKC_API.G_RET_STS_ERROR',
1131: x_msg_count,
1132: x_msg_data,
1133: '_PUB');
1134: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1135: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1136: (l_api_name,
1137: G_PKG_NAME,
1138: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1135: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1131: x_msg_count,
1132: x_msg_data,
1133: '_PUB');
1134: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1135: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1136: (l_api_name,
1137: G_PKG_NAME,
1138: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1139: x_msg_count,

Line 1138: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1134: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1135: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1136: (l_api_name,
1137: G_PKG_NAME,
1138: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1139: x_msg_count,
1140: x_msg_data,
1141: '_PUB');
1142: WHEN OTHERS THEN

Line 1143: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1139: x_msg_count,
1140: x_msg_data,
1141: '_PUB');
1142: WHEN OTHERS THEN
1143: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1144: (l_api_name,
1145: G_PKG_NAME,
1146: 'OTHERS',
1147: x_msg_count,

Line 1164: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1160: x_msg_data OUT NOCOPY VARCHAR2,
1161: p_rdsv_tbl IN rdsv_tbl_type) IS
1162:
1163: i NUMBER := 0;
1164: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1165: BEGIN
1166: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1167: IF p_rdsv_tbl.COUNT > 0 THEN
1168: i := p_rdsv_tbl.FIRST;

Line 1166: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1162:
1163: i NUMBER := 0;
1164: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1165: BEGIN
1166: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1167: IF p_rdsv_tbl.COUNT > 0 THEN
1168: i := p_rdsv_tbl.FIRST;
1169: LOOP
1170: validate_rd_source(

Line 1177: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1173: x_return_status => l_return_status,
1174: x_msg_count => x_msg_count,
1175: x_msg_data => x_msg_data,
1176: p_rdsv_rec => p_rdsv_tbl(i));
1177: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1178: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1179: x_return_status := l_return_status;
1180: raise G_EXCEPTION_HALT_VALIDATION;
1181: ELSE

Line 1178: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1174: x_msg_count => x_msg_count,
1175: x_msg_data => x_msg_data,
1176: p_rdsv_rec => p_rdsv_tbl(i));
1177: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1178: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1179: x_return_status := l_return_status;
1180: raise G_EXCEPTION_HALT_VALIDATION;
1181: ELSE
1182: x_return_status := l_return_status;

Line 1193: OKC_API.set_message(p_app_name => g_app_name,

1189: EXCEPTION
1190: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1191: NULL;
1192: WHEN OTHERS THEN
1193: OKC_API.set_message(p_app_name => g_app_name,
1194: p_msg_name => g_unexpected_error,
1195: p_token1 => g_sqlcode_token,
1196: p_token1_value => sqlcode,
1197: p_token2 => g_sqlerrm_token,

Line 1199: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1195: p_token1 => g_sqlcode_token,
1196: p_token1_value => sqlcode,
1197: p_token2 => g_sqlerrm_token,
1198: p_token2_value => sqlerrm);
1199: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1200: END validate_rd_source;
1201:
1202: --------------------------------------
1203: --PROCEDURE lock_rd_source

Line 1212: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1208: x_return_status OUT NOCOPY VARCHAR2,
1209: x_msg_count OUT NOCOPY NUMBER,
1210: x_msg_data OUT NOCOPY VARCHAR2,
1211: p_rdsv_rec IN rdsv_rec_type) IS
1212: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1213: BEGIN
1214: OKC_RULE_DEF_PVT.lock_rd_source(
1215: p_api_version => p_api_version,
1216: p_init_msg_list => p_init_msg_list,

Line 1235: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;

1231: x_msg_data OUT NOCOPY VARCHAR2,
1232: p_rdsv_tbl IN rdsv_tbl_type) IS
1233:
1234: i NUMBER := 0;
1235: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1236: BEGIN
1237: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1238: IF p_rdsv_tbl.COUNT > 0 THEN
1239: i := p_rdsv_tbl.FIRST;

Line 1237: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1233:
1234: i NUMBER := 0;
1235: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1236: BEGIN
1237: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1238: IF p_rdsv_tbl.COUNT > 0 THEN
1239: i := p_rdsv_tbl.FIRST;
1240: LOOP
1241: lock_rd_source(

Line 1248: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN

1244: x_return_status => l_return_status,
1245: x_msg_count => x_msg_count,
1246: x_msg_data => x_msg_data,
1247: p_rdsv_rec => p_rdsv_tbl(i));
1248: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1249: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1250: x_return_status := l_return_status;
1251: raise G_EXCEPTION_HALT_VALIDATION;
1252: ELSE

Line 1249: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

1245: x_msg_count => x_msg_count,
1246: x_msg_data => x_msg_data,
1247: p_rdsv_rec => p_rdsv_tbl(i));
1248: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1249: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1250: x_return_status := l_return_status;
1251: raise G_EXCEPTION_HALT_VALIDATION;
1252: ELSE
1253: x_return_status := l_return_status;

Line 1264: OKC_API.set_message(p_app_name => g_app_name,

1260: EXCEPTION
1261: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1262: NULL;
1263: WHEN OTHERS THEN
1264: OKC_API.set_message(p_app_name => g_app_name,
1265: p_msg_name => g_unexpected_error,
1266: p_token1 => g_sqlcode_token,
1267: p_token1_value => sqlcode,
1268: p_token2 => g_sqlerrm_token,

Line 1270: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1266: p_token1 => g_sqlcode_token,
1267: p_token1_value => sqlcode,
1268: p_token2 => g_sqlerrm_token,
1269: p_token2_value => sqlerrm);
1270: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1271: END lock_rd_source;
1272:
1273: END okc_rule_def_pub;