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_QA_CHECK_LIST_PUB dependencies on OKC_API

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

56: x_msg_count OUT NOCOPY NUMBER,
57: x_msg_data OUT NOCOPY VARCHAR2,
58: p_qclv_rec IN qclv_rec_type,
59: x_qclv_rec OUT NOCOPY qclv_rec_type) IS
60: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
61: l_api_name CONSTANT VARCHAR2(30) := 'create_qa_check_list';
62: l_qclv_rec qclv_rec_type := p_qclv_rec;
63: BEGIN
64: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

60: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
61: l_api_name CONSTANT VARCHAR2(30) := 'create_qa_check_list';
62: l_qclv_rec qclv_rec_type := p_qclv_rec;
63: BEGIN
64: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
65: p_init_msg_list,
66: '_PUB',
67: x_return_status);
68: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

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

Line 69: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

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

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

Line 71: raise OKC_API.G_EXCEPTION_ERROR;

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

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

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

Line 77: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

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

74: g_qclv_rec := p_qclv_rec;
75: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
76: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
77: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
78: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
79: raise OKC_API.G_EXCEPTION_ERROR;
80: END IF;
81: l_qclv_rec := migrate_qclv(l_qclv_rec, g_qclv_rec);
82:

Line 79: raise OKC_API.G_EXCEPTION_ERROR;

75: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
76: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
77: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
78: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
79: raise OKC_API.G_EXCEPTION_ERROR;
80: END IF;
81: l_qclv_rec := migrate_qclv(l_qclv_rec, g_qclv_rec);
82:
83: OKC_QA_CHECK_LIST_PVT.create_qa_check_list(

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

88: x_msg_data => x_msg_data,
89: p_qclv_rec => l_qclv_rec,
90: x_qclv_rec => x_qclv_rec);
91:
92: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
93: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
94: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
95: raise OKC_API.G_EXCEPTION_ERROR;
96: END IF;

Line 93: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

89: p_qclv_rec => l_qclv_rec,
90: x_qclv_rec => x_qclv_rec);
91:
92: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
93: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
94: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
95: raise OKC_API.G_EXCEPTION_ERROR;
96: END IF;
97:

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

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

Line 95: raise OKC_API.G_EXCEPTION_ERROR;

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

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

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

Line 102: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

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

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

Line 104: raise OKC_API.G_EXCEPTION_ERROR;

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

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

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

Line 108: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

Line 109: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 112: ,'OKC_API.G_RET_STS_ERROR'

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

Line 116: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

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

Line 117: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

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

Line 120: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

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

Line 125: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

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

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

142: x_msg_data OUT NOCOPY VARCHAR2,
143: p_qclv_tbl IN qclv_tbl_type,
144: x_qclv_tbl OUT NOCOPY qclv_tbl_type) IS
145: i NUMBER := 0;
146: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
147: BEGIN
148: x_return_status := OKC_API.G_RET_STS_SUCCESS;
149: IF p_qclv_tbl.COUNT > 0 THEN
150: i := p_qclv_tbl.FIRST;

Line 148: x_return_status := OKC_API.G_RET_STS_SUCCESS;

144: x_qclv_tbl OUT NOCOPY qclv_tbl_type) IS
145: i NUMBER := 0;
146: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
147: BEGIN
148: x_return_status := OKC_API.G_RET_STS_SUCCESS;
149: IF p_qclv_tbl.COUNT > 0 THEN
150: i := p_qclv_tbl.FIRST;
151: LOOP
152: create_qa_check_list(

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

156: x_msg_count => x_msg_count,
157: x_msg_data => x_msg_data,
158: p_qclv_rec => p_qclv_tbl(i),
159: x_qclv_rec => x_qclv_tbl(i));
160: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
161: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
162: x_return_status := l_return_status;
163: raise G_EXCEPTION_HALT_VALIDATION;
164: ELSE

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

157: x_msg_data => x_msg_data,
158: p_qclv_rec => p_qclv_tbl(i),
159: x_qclv_rec => x_qclv_tbl(i));
160: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
161: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
162: x_return_status := l_return_status;
163: raise G_EXCEPTION_HALT_VALIDATION;
164: ELSE
165: x_return_status := l_return_status;

Line 177: OKC_API.SET_MESSAGE(

173: WHEN G_EXCEPTION_HALT_VALIDATION THEN
174: NULL;
175: WHEN OTHERS THEN
176: -- store SQL error message on message stack
177: OKC_API.SET_MESSAGE(
178: p_app_name => G_APP_NAME,
179: p_msg_name => G_UNEXPECTED_ERROR,
180: p_token1 => G_SQLCODE_TOKEN,
181: p_token1_value => SQLCODE,

Line 185: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

181: p_token1_value => SQLCODE,
182: p_token2 => G_SQLERRM_TOKEN,
183: p_token2_value => SQLERRM);
184: -- notify caller of an error as UNEXPETED error
185: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
186: END create_qa_check_list;
187:
188: --------------------------------------
189: -- PROCEDURE update_qa_check_list

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

195: x_msg_count OUT NOCOPY NUMBER,
196: x_msg_data OUT NOCOPY VARCHAR2,
197: p_qclv_rec IN qclv_rec_type,
198: x_qclv_rec OUT NOCOPY qclv_rec_type) IS
199: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
200: l_api_name CONSTANT VARCHAR2(30) := 'update_qa_check_list';
201: l_qclv_rec qclv_rec_type := p_qclv_rec;
202: BEGIN
203: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

199: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
200: l_api_name CONSTANT VARCHAR2(30) := 'update_qa_check_list';
201: l_qclv_rec qclv_rec_type := p_qclv_rec;
202: BEGIN
203: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
204: p_init_msg_list,
205: '_PUB',
206: x_return_status);
207: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

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

Line 208: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

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

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

Line 210: raise OKC_API.G_EXCEPTION_ERROR;

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

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

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

Line 216: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

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

213: g_qclv_rec := p_qclv_rec;
214: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
215: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
216: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
217: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
218: raise OKC_API.G_EXCEPTION_ERROR;
219: END IF;
220: l_qclv_rec := migrate_qclv(l_qclv_rec, g_qclv_rec);
221:

Line 218: raise OKC_API.G_EXCEPTION_ERROR;

214: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
215: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
216: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
217: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
218: raise OKC_API.G_EXCEPTION_ERROR;
219: END IF;
220: l_qclv_rec := migrate_qclv(l_qclv_rec, g_qclv_rec);
221:
222: OKC_QA_CHECK_LIST_PVT.update_qa_check_list(

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

227: x_msg_data => x_msg_data,
228: p_qclv_rec => l_qclv_rec,
229: x_qclv_rec => x_qclv_rec);
230:
231: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
232: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
233: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
234: raise OKC_API.G_EXCEPTION_ERROR;
235: END IF;

Line 232: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

228: p_qclv_rec => l_qclv_rec,
229: x_qclv_rec => x_qclv_rec);
230:
231: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
232: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
233: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
234: raise OKC_API.G_EXCEPTION_ERROR;
235: END IF;
236:

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

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

Line 234: raise OKC_API.G_EXCEPTION_ERROR;

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

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

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

Line 241: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

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

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

Line 243: raise OKC_API.G_EXCEPTION_ERROR;

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

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

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

Line 247: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

Line 248: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 251: ,'OKC_API.G_RET_STS_ERROR'

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

Line 255: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

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

Line 256: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

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

Line 259: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

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

Line 264: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

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

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

281: x_msg_data OUT NOCOPY VARCHAR2,
282: p_qclv_tbl IN qclv_tbl_type,
283: x_qclv_tbl OUT NOCOPY qclv_tbl_type) IS
284: i NUMBER := 0;
285: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
286: BEGIN
287: x_return_status := OKC_API.G_RET_STS_SUCCESS;
288: IF p_qclv_tbl.COUNT > 0 THEN
289: i := p_qclv_tbl.FIRST;

Line 287: x_return_status := OKC_API.G_RET_STS_SUCCESS;

283: x_qclv_tbl OUT NOCOPY qclv_tbl_type) IS
284: i NUMBER := 0;
285: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
286: BEGIN
287: x_return_status := OKC_API.G_RET_STS_SUCCESS;
288: IF p_qclv_tbl.COUNT > 0 THEN
289: i := p_qclv_tbl.FIRST;
290: LOOP
291: update_qa_check_list(

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

295: x_msg_count => x_msg_count,
296: x_msg_data => x_msg_data,
297: p_qclv_rec => p_qclv_tbl(i),
298: x_qclv_rec => x_qclv_tbl(i));
299: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
300: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
301: x_return_status := l_return_status;
302: raise G_EXCEPTION_HALT_VALIDATION;
303: ELSE

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

296: x_msg_data => x_msg_data,
297: p_qclv_rec => p_qclv_tbl(i),
298: x_qclv_rec => x_qclv_tbl(i));
299: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
300: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
301: x_return_status := l_return_status;
302: raise G_EXCEPTION_HALT_VALIDATION;
303: ELSE
304: x_return_status := l_return_status;

Line 316: OKC_API.SET_MESSAGE(

312: WHEN G_EXCEPTION_HALT_VALIDATION THEN
313: NULL;
314: WHEN OTHERS THEN
315: -- store SQL error message on message stack
316: OKC_API.SET_MESSAGE(
317: p_app_name => G_APP_NAME,
318: p_msg_name => G_UNEXPECTED_ERROR,
319: p_token1 => G_SQLCODE_TOKEN,
320: p_token1_value => SQLCODE,

Line 324: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

320: p_token1_value => SQLCODE,
321: p_token2 => G_SQLERRM_TOKEN,
322: p_token2_value => SQLERRM);
323: -- notify caller of an error as UNEXPETED error
324: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
325: END update_qa_check_list;
326:
327: --------------------------------------
328: -- PROCEDURE delete_qa_check_list

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

333: x_return_status OUT NOCOPY VARCHAR2,
334: x_msg_count OUT NOCOPY NUMBER,
335: x_msg_data OUT NOCOPY VARCHAR2,
336: p_qclv_rec IN qclv_rec_type) IS
337: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
338: l_api_name CONSTANT VARCHAR2(30) := 'delete_qa_check_list';
339: l_qclv_rec qclv_rec_type := p_qclv_rec;
340: BEGIN
341: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

337: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
338: l_api_name CONSTANT VARCHAR2(30) := 'delete_qa_check_list';
339: l_qclv_rec qclv_rec_type := p_qclv_rec;
340: BEGIN
341: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
342: p_init_msg_list,
343: '_PUB',
344: x_return_status);
345: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

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

Line 346: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

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

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

Line 348: raise OKC_API.G_EXCEPTION_ERROR;

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

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

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

Line 354: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

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

351: g_qclv_rec := p_qclv_rec;
352: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
353: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
354: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
355: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
356: raise OKC_API.G_EXCEPTION_ERROR;
357: END IF;
358:
359: OKC_QA_CHECK_LIST_PVT.delete_qa_check_list(

Line 356: raise OKC_API.G_EXCEPTION_ERROR;

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

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

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

Line 368: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

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

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

Line 370: raise OKC_API.G_EXCEPTION_ERROR;

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

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

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

Line 377: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

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

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

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

Line 379: raise OKC_API.G_EXCEPTION_ERROR;

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

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

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

Line 383: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

Line 384: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 387: ,'OKC_API.G_RET_STS_ERROR'

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

Line 391: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

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

Line 392: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

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

Line 395: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

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

Line 400: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

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

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

416: x_msg_count OUT NOCOPY NUMBER,
417: x_msg_data OUT NOCOPY VARCHAR2,
418: p_qclv_tbl IN qclv_tbl_type) IS
419: i NUMBER := 0;
420: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
421: BEGIN
422: x_return_status := OKC_API.G_RET_STS_SUCCESS;
423: IF p_qclv_tbl.COUNT > 0 THEN
424: i := p_qclv_tbl.FIRST;

Line 422: x_return_status := OKC_API.G_RET_STS_SUCCESS;

418: p_qclv_tbl IN qclv_tbl_type) IS
419: i NUMBER := 0;
420: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
421: BEGIN
422: x_return_status := OKC_API.G_RET_STS_SUCCESS;
423: IF p_qclv_tbl.COUNT > 0 THEN
424: i := p_qclv_tbl.FIRST;
425: LOOP
426: delete_qa_check_list(

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

429: x_return_status => l_return_status,
430: x_msg_count => x_msg_count,
431: x_msg_data => x_msg_data,
432: p_qclv_rec => p_qclv_tbl(i));
433: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
434: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
435: x_return_status := l_return_status;
436: raise G_EXCEPTION_HALT_VALIDATION;
437: ELSE

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

430: x_msg_count => x_msg_count,
431: x_msg_data => x_msg_data,
432: p_qclv_rec => p_qclv_tbl(i));
433: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
434: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
435: x_return_status := l_return_status;
436: raise G_EXCEPTION_HALT_VALIDATION;
437: ELSE
438: x_return_status := l_return_status;

Line 450: OKC_API.SET_MESSAGE(

446: WHEN G_EXCEPTION_HALT_VALIDATION THEN
447: NULL;
448: WHEN OTHERS THEN
449: -- store SQL error message on message stack
450: OKC_API.SET_MESSAGE(
451: p_app_name => G_APP_NAME,
452: p_msg_name => G_UNEXPECTED_ERROR,
453: p_token1 => G_SQLCODE_TOKEN,
454: p_token1_value => SQLCODE,

Line 458: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

454: p_token1_value => SQLCODE,
455: p_token2 => G_SQLERRM_TOKEN,
456: p_token2_value => SQLERRM);
457: -- notify caller of an error as UNEXPETED error
458: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
459: END delete_qa_check_list;
460:
461: --------------------------------------
462: -- PROCEDURE lock_qa_check_list

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

488: x_msg_count OUT NOCOPY NUMBER,
489: x_msg_data OUT NOCOPY VARCHAR2,
490: p_qclv_tbl IN qclv_tbl_type) IS
491: i NUMBER := 0;
492: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
493: BEGIN
494: x_return_status := OKC_API.G_RET_STS_SUCCESS;
495: IF p_qclv_tbl.COUNT > 0 THEN
496: i := p_qclv_tbl.FIRST;

Line 494: x_return_status := OKC_API.G_RET_STS_SUCCESS;

490: p_qclv_tbl IN qclv_tbl_type) IS
491: i NUMBER := 0;
492: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
493: BEGIN
494: x_return_status := OKC_API.G_RET_STS_SUCCESS;
495: IF p_qclv_tbl.COUNT > 0 THEN
496: i := p_qclv_tbl.FIRST;
497: LOOP
498: lock_qa_check_list(

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

501: x_return_status => l_return_status,
502: x_msg_count => x_msg_count,
503: x_msg_data => x_msg_data,
504: p_qclv_rec => p_qclv_tbl(i));
505: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
506: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
507: x_return_status := l_return_status;
508: raise G_EXCEPTION_HALT_VALIDATION;
509: ELSE

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

502: x_msg_count => x_msg_count,
503: x_msg_data => x_msg_data,
504: p_qclv_rec => p_qclv_tbl(i));
505: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
506: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
507: x_return_status := l_return_status;
508: raise G_EXCEPTION_HALT_VALIDATION;
509: ELSE
510: x_return_status := l_return_status;

Line 522: OKC_API.SET_MESSAGE(

518: WHEN G_EXCEPTION_HALT_VALIDATION THEN
519: NULL;
520: WHEN OTHERS THEN
521: -- store SQL error message on message stack
522: OKC_API.SET_MESSAGE(
523: p_app_name => G_APP_NAME,
524: p_msg_name => G_UNEXPECTED_ERROR,
525: p_token1 => G_SQLCODE_TOKEN,
526: p_token1_value => SQLCODE,

Line 530: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

526: p_token1_value => SQLCODE,
527: p_token2 => G_SQLERRM_TOKEN,
528: p_token2_value => SQLERRM);
529: -- notify caller of an error as UNEXPETED error
530: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
531: END lock_qa_check_list;
532:
533: --------------------------------------
534: -- PROCEDURE validate_qa_check_list

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

539: x_return_status OUT NOCOPY VARCHAR2,
540: x_msg_count OUT NOCOPY NUMBER,
541: x_msg_data OUT NOCOPY VARCHAR2,
542: p_qclv_rec IN qclv_rec_type) IS
543: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
544: l_api_name CONSTANT VARCHAR2(30) := 'validate_qa_check_list';
545: l_qclv_rec qclv_rec_type := p_qclv_rec;
546: BEGIN
547: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

543: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
544: l_api_name CONSTANT VARCHAR2(30) := 'validate_qa_check_list';
545: l_qclv_rec qclv_rec_type := p_qclv_rec;
546: BEGIN
547: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
548: p_init_msg_list,
549: '_PUB',
550: x_return_status);
551: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

547: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
548: p_init_msg_list,
549: '_PUB',
550: x_return_status);
551: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
552: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
553: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
554: raise OKC_API.G_EXCEPTION_ERROR;
555: END IF;

Line 552: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

548: p_init_msg_list,
549: '_PUB',
550: x_return_status);
551: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
552: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
553: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
554: raise OKC_API.G_EXCEPTION_ERROR;
555: END IF;
556: -- Call user hook for BEFORE

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

549: '_PUB',
550: x_return_status);
551: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
552: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
553: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
554: raise OKC_API.G_EXCEPTION_ERROR;
555: END IF;
556: -- Call user hook for BEFORE
557: g_qclv_rec := p_qclv_rec;

Line 554: raise OKC_API.G_EXCEPTION_ERROR;

550: x_return_status);
551: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
552: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
553: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
554: raise OKC_API.G_EXCEPTION_ERROR;
555: END IF;
556: -- Call user hook for BEFORE
557: g_qclv_rec := p_qclv_rec;
558: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

555: END IF;
556: -- Call user hook for BEFORE
557: g_qclv_rec := p_qclv_rec;
558: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
559: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
560: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
561: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
562: raise OKC_API.G_EXCEPTION_ERROR;
563: END IF;

Line 560: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

556: -- Call user hook for BEFORE
557: g_qclv_rec := p_qclv_rec;
558: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
559: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
560: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
561: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
562: raise OKC_API.G_EXCEPTION_ERROR;
563: END IF;
564:

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

557: g_qclv_rec := p_qclv_rec;
558: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
559: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
560: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
561: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
562: raise OKC_API.G_EXCEPTION_ERROR;
563: END IF;
564:
565: OKC_QA_CHECK_LIST_PVT.validate_qa_check_list(

Line 562: raise OKC_API.G_EXCEPTION_ERROR;

558: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
559: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
560: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
561: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
562: raise OKC_API.G_EXCEPTION_ERROR;
563: END IF;
564:
565: OKC_QA_CHECK_LIST_PVT.validate_qa_check_list(
566: p_api_version => p_api_version,

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

569: x_msg_count => x_msg_count,
570: x_msg_data => x_msg_data,
571: p_qclv_rec => p_qclv_rec);
572:
573: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
575: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
576: raise OKC_API.G_EXCEPTION_ERROR;
577: END IF;

Line 574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

570: x_msg_data => x_msg_data,
571: p_qclv_rec => p_qclv_rec);
572:
573: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
575: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
576: raise OKC_API.G_EXCEPTION_ERROR;
577: END IF;
578:

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

571: p_qclv_rec => p_qclv_rec);
572:
573: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
575: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
576: raise OKC_API.G_EXCEPTION_ERROR;
577: END IF;
578:
579: -- Call user hook for AFTER

Line 576: raise OKC_API.G_EXCEPTION_ERROR;

572:
573: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
574: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
575: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
576: raise OKC_API.G_EXCEPTION_ERROR;
577: END IF;
578:
579: -- Call user hook for AFTER
580: g_qclv_rec := l_qclv_rec;

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

578:
579: -- Call user hook for AFTER
580: g_qclv_rec := l_qclv_rec;
581: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
582: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
583: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
584: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
585: raise OKC_API.G_EXCEPTION_ERROR;
586: END IF;

Line 583: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

579: -- Call user hook for AFTER
580: g_qclv_rec := l_qclv_rec;
581: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
582: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
583: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
584: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
585: raise OKC_API.G_EXCEPTION_ERROR;
586: END IF;
587: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

580: g_qclv_rec := l_qclv_rec;
581: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
582: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
583: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
584: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
585: raise OKC_API.G_EXCEPTION_ERROR;
586: END IF;
587: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
588: EXCEPTION

Line 585: raise OKC_API.G_EXCEPTION_ERROR;

581: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
582: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
583: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
584: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
585: raise OKC_API.G_EXCEPTION_ERROR;
586: END IF;
587: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
588: EXCEPTION
589: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

583: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
584: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
585: raise OKC_API.G_EXCEPTION_ERROR;
586: END IF;
587: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
588: EXCEPTION
589: WHEN OKC_API.G_EXCEPTION_ERROR THEN
590: x_return_status := OKC_API.HANDLE_EXCEPTIONS
591: (l_api_name

Line 589: WHEN OKC_API.G_EXCEPTION_ERROR THEN

585: raise OKC_API.G_EXCEPTION_ERROR;
586: END IF;
587: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
588: EXCEPTION
589: WHEN OKC_API.G_EXCEPTION_ERROR THEN
590: x_return_status := OKC_API.HANDLE_EXCEPTIONS
591: (l_api_name
592: ,G_PKG_NAME
593: ,'OKC_API.G_RET_STS_ERROR'

Line 590: x_return_status := OKC_API.HANDLE_EXCEPTIONS

586: END IF;
587: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
588: EXCEPTION
589: WHEN OKC_API.G_EXCEPTION_ERROR THEN
590: x_return_status := OKC_API.HANDLE_EXCEPTIONS
591: (l_api_name
592: ,G_PKG_NAME
593: ,'OKC_API.G_RET_STS_ERROR'
594: ,x_msg_count

Line 593: ,'OKC_API.G_RET_STS_ERROR'

589: WHEN OKC_API.G_EXCEPTION_ERROR THEN
590: x_return_status := OKC_API.HANDLE_EXCEPTIONS
591: (l_api_name
592: ,G_PKG_NAME
593: ,'OKC_API.G_RET_STS_ERROR'
594: ,x_msg_count
595: ,x_msg_data
596: ,'_PUB');
597: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 597: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

593: ,'OKC_API.G_RET_STS_ERROR'
594: ,x_msg_count
595: ,x_msg_data
596: ,'_PUB');
597: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
598: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
599: (l_api_name
600: ,G_PKG_NAME
601: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 598: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

594: ,x_msg_count
595: ,x_msg_data
596: ,'_PUB');
597: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
598: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
599: (l_api_name
600: ,G_PKG_NAME
601: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
602: ,x_msg_count

Line 601: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

597: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
598: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
599: (l_api_name
600: ,G_PKG_NAME
601: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
602: ,x_msg_count
603: ,x_msg_data
604: ,'_PUB');
605: WHEN OTHERS THEN

Line 606: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

602: ,x_msg_count
603: ,x_msg_data
604: ,'_PUB');
605: WHEN OTHERS THEN
606: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
607: (l_api_name
608: ,G_PKG_NAME
609: ,'OTHERS'
610: ,x_msg_count

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

622: x_msg_count OUT NOCOPY NUMBER,
623: x_msg_data OUT NOCOPY VARCHAR2,
624: p_qclv_tbl IN qclv_tbl_type) IS
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_qclv_tbl.COUNT > 0 THEN
630: i := p_qclv_tbl.FIRST;

Line 628: x_return_status := OKC_API.G_RET_STS_SUCCESS;

624: p_qclv_tbl IN qclv_tbl_type) IS
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_qclv_tbl.COUNT > 0 THEN
630: i := p_qclv_tbl.FIRST;
631: LOOP
632: validate_qa_check_list(

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_qclv_rec => p_qclv_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_qclv_rec => p_qclv_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 656: OKC_API.SET_MESSAGE(

652: WHEN G_EXCEPTION_HALT_VALIDATION THEN
653: NULL;
654: WHEN OTHERS THEN
655: -- store SQL error message on message stack
656: OKC_API.SET_MESSAGE(
657: p_app_name => G_APP_NAME,
658: p_msg_name => G_UNEXPECTED_ERROR,
659: p_token1 => G_SQLCODE_TOKEN,
660: p_token1_value => SQLCODE,

Line 664: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

660: p_token1_value => SQLCODE,
661: p_token2 => G_SQLERRM_TOKEN,
662: p_token2_value => SQLERRM);
663: -- notify caller of an error as UNEXPETED error
664: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
665: END validate_qa_check_list;
666:
667: ---------------------------------------------------------------------------
668: -- FUNCTION migrate_qlpv

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

716: x_msg_count OUT NOCOPY NUMBER,
717: x_msg_data OUT NOCOPY VARCHAR2,
718: p_qlpv_rec IN qlpv_rec_type,
719: x_qlpv_rec OUT NOCOPY qlpv_rec_type) IS
720: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
721: l_api_name CONSTANT VARCHAR2(30) := 'create_qa_process';
722: l_qlpv_rec qlpv_rec_type := p_qlpv_rec;
723: BEGIN
724: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

720: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
721: l_api_name CONSTANT VARCHAR2(30) := 'create_qa_process';
722: l_qlpv_rec qlpv_rec_type := p_qlpv_rec;
723: BEGIN
724: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
725: p_init_msg_list,
726: '_PUB',
727: x_return_status);
728: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

724: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
725: p_init_msg_list,
726: '_PUB',
727: x_return_status);
728: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
729: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
730: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
731: raise OKC_API.G_EXCEPTION_ERROR;
732: END IF;

Line 729: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

725: p_init_msg_list,
726: '_PUB',
727: x_return_status);
728: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
729: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
730: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
731: raise OKC_API.G_EXCEPTION_ERROR;
732: END IF;
733: -- Call user hook for BEFORE

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

726: '_PUB',
727: x_return_status);
728: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
729: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
730: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
731: raise OKC_API.G_EXCEPTION_ERROR;
732: END IF;
733: -- Call user hook for BEFORE
734: g_qlpv_rec := p_qlpv_rec;

Line 731: raise OKC_API.G_EXCEPTION_ERROR;

727: x_return_status);
728: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
729: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
730: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
731: raise OKC_API.G_EXCEPTION_ERROR;
732: END IF;
733: -- Call user hook for BEFORE
734: g_qlpv_rec := p_qlpv_rec;
735: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

732: END IF;
733: -- Call user hook for BEFORE
734: g_qlpv_rec := p_qlpv_rec;
735: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
736: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
737: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
738: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
739: raise OKC_API.G_EXCEPTION_ERROR;
740: END IF;

Line 737: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

733: -- Call user hook for BEFORE
734: g_qlpv_rec := p_qlpv_rec;
735: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
736: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
737: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
738: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
739: raise OKC_API.G_EXCEPTION_ERROR;
740: END IF;
741: l_qlpv_rec := migrate_qlpv(l_qlpv_rec, g_qlpv_rec);

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

734: g_qlpv_rec := p_qlpv_rec;
735: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
736: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
737: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
738: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
739: raise OKC_API.G_EXCEPTION_ERROR;
740: END IF;
741: l_qlpv_rec := migrate_qlpv(l_qlpv_rec, g_qlpv_rec);
742:

Line 739: raise OKC_API.G_EXCEPTION_ERROR;

735: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
736: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
737: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
738: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
739: raise OKC_API.G_EXCEPTION_ERROR;
740: END IF;
741: l_qlpv_rec := migrate_qlpv(l_qlpv_rec, g_qlpv_rec);
742:
743: OKC_QA_CHECK_LIST_PVT.create_qa_process(

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

748: x_msg_data => x_msg_data,
749: p_qlpv_rec => l_qlpv_rec,
750: x_qlpv_rec => x_qlpv_rec);
751:
752: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
753: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
754: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
755: raise OKC_API.G_EXCEPTION_ERROR;
756: END IF;

Line 753: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

749: p_qlpv_rec => l_qlpv_rec,
750: x_qlpv_rec => x_qlpv_rec);
751:
752: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
753: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
754: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
755: raise OKC_API.G_EXCEPTION_ERROR;
756: END IF;
757:

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

750: x_qlpv_rec => x_qlpv_rec);
751:
752: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
753: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
754: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
755: raise OKC_API.G_EXCEPTION_ERROR;
756: END IF;
757:
758: -- Call user hook for AFTER

Line 755: raise OKC_API.G_EXCEPTION_ERROR;

751:
752: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
753: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
754: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
755: raise OKC_API.G_EXCEPTION_ERROR;
756: END IF;
757:
758: -- Call user hook for AFTER
759: g_qlpv_rec := x_qlpv_rec;

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

757:
758: -- Call user hook for AFTER
759: g_qlpv_rec := x_qlpv_rec;
760: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
764: raise OKC_API.G_EXCEPTION_ERROR;
765: END IF;

Line 762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

758: -- Call user hook for AFTER
759: g_qlpv_rec := x_qlpv_rec;
760: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
764: raise OKC_API.G_EXCEPTION_ERROR;
765: END IF;
766: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

759: g_qlpv_rec := x_qlpv_rec;
760: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
764: raise OKC_API.G_EXCEPTION_ERROR;
765: END IF;
766: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
767: EXCEPTION

Line 764: raise OKC_API.G_EXCEPTION_ERROR;

760: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
761: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
764: raise OKC_API.G_EXCEPTION_ERROR;
765: END IF;
766: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
767: EXCEPTION
768: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

762: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
763: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
764: raise OKC_API.G_EXCEPTION_ERROR;
765: END IF;
766: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
767: EXCEPTION
768: WHEN OKC_API.G_EXCEPTION_ERROR THEN
769: x_return_status := OKC_API.HANDLE_EXCEPTIONS
770: (l_api_name

Line 768: WHEN OKC_API.G_EXCEPTION_ERROR THEN

764: raise OKC_API.G_EXCEPTION_ERROR;
765: END IF;
766: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
767: EXCEPTION
768: WHEN OKC_API.G_EXCEPTION_ERROR THEN
769: x_return_status := OKC_API.HANDLE_EXCEPTIONS
770: (l_api_name
771: ,G_PKG_NAME
772: ,'OKC_API.G_RET_STS_ERROR'

Line 769: x_return_status := OKC_API.HANDLE_EXCEPTIONS

765: END IF;
766: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
767: EXCEPTION
768: WHEN OKC_API.G_EXCEPTION_ERROR THEN
769: x_return_status := OKC_API.HANDLE_EXCEPTIONS
770: (l_api_name
771: ,G_PKG_NAME
772: ,'OKC_API.G_RET_STS_ERROR'
773: ,x_msg_count

Line 772: ,'OKC_API.G_RET_STS_ERROR'

768: WHEN OKC_API.G_EXCEPTION_ERROR THEN
769: x_return_status := OKC_API.HANDLE_EXCEPTIONS
770: (l_api_name
771: ,G_PKG_NAME
772: ,'OKC_API.G_RET_STS_ERROR'
773: ,x_msg_count
774: ,x_msg_data
775: ,'_PUB');
776: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 776: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

772: ,'OKC_API.G_RET_STS_ERROR'
773: ,x_msg_count
774: ,x_msg_data
775: ,'_PUB');
776: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
777: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
778: (l_api_name
779: ,G_PKG_NAME
780: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 777: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

773: ,x_msg_count
774: ,x_msg_data
775: ,'_PUB');
776: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
777: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
778: (l_api_name
779: ,G_PKG_NAME
780: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
781: ,x_msg_count

Line 780: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

776: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
777: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
778: (l_api_name
779: ,G_PKG_NAME
780: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
781: ,x_msg_count
782: ,x_msg_data
783: ,'_PUB');
784: WHEN OTHERS THEN

Line 785: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

781: ,x_msg_count
782: ,x_msg_data
783: ,'_PUB');
784: WHEN OTHERS THEN
785: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
786: (l_api_name
787: ,G_PKG_NAME
788: ,'OTHERS'
789: ,x_msg_count

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

802: x_msg_data OUT NOCOPY VARCHAR2,
803: p_qlpv_tbl IN qlpv_tbl_type,
804: x_qlpv_tbl OUT NOCOPY qlpv_tbl_type) IS
805: i NUMBER := 0;
806: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
807: BEGIN
808: x_return_status := OKC_API.G_RET_STS_SUCCESS;
809: IF p_qlpv_tbl.COUNT > 0 THEN
810: i := p_qlpv_tbl.FIRST;

Line 808: x_return_status := OKC_API.G_RET_STS_SUCCESS;

804: x_qlpv_tbl OUT NOCOPY qlpv_tbl_type) IS
805: i NUMBER := 0;
806: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
807: BEGIN
808: x_return_status := OKC_API.G_RET_STS_SUCCESS;
809: IF p_qlpv_tbl.COUNT > 0 THEN
810: i := p_qlpv_tbl.FIRST;
811: LOOP
812: create_qa_process(

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

816: x_msg_count => x_msg_count,
817: x_msg_data => x_msg_data,
818: p_qlpv_rec => p_qlpv_tbl(i),
819: x_qlpv_rec => x_qlpv_tbl(i));
820: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
821: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
822: x_return_status := l_return_status;
823: raise G_EXCEPTION_HALT_VALIDATION;
824: ELSE

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

817: x_msg_data => x_msg_data,
818: p_qlpv_rec => p_qlpv_tbl(i),
819: x_qlpv_rec => x_qlpv_tbl(i));
820: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
821: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
822: x_return_status := l_return_status;
823: raise G_EXCEPTION_HALT_VALIDATION;
824: ELSE
825: x_return_status := l_return_status;

Line 837: OKC_API.SET_MESSAGE(

833: WHEN G_EXCEPTION_HALT_VALIDATION THEN
834: NULL;
835: WHEN OTHERS THEN
836: -- store SQL error message on message stack
837: OKC_API.SET_MESSAGE(
838: p_app_name => G_APP_NAME,
839: p_msg_name => G_UNEXPECTED_ERROR,
840: p_token1 => G_SQLCODE_TOKEN,
841: p_token1_value => SQLCODE,

Line 845: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

841: p_token1_value => SQLCODE,
842: p_token2 => G_SQLERRM_TOKEN,
843: p_token2_value => SQLERRM);
844: -- notify caller of an error as UNEXPETED error
845: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
846: END create_qa_process;
847:
848: --------------------------------------
849: -- PROCEDURE update_qa_process

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

855: x_msg_count OUT NOCOPY NUMBER,
856: x_msg_data OUT NOCOPY VARCHAR2,
857: p_qlpv_rec IN qlpv_rec_type,
858: x_qlpv_rec OUT NOCOPY qlpv_rec_type) IS
859: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
860: l_api_name CONSTANT VARCHAR2(30) := 'update_qa_process';
861: l_qlpv_rec qlpv_rec_type := p_qlpv_rec;
862: BEGIN
863: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

859: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
860: l_api_name CONSTANT VARCHAR2(30) := 'update_qa_process';
861: l_qlpv_rec qlpv_rec_type := p_qlpv_rec;
862: BEGIN
863: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
864: p_init_msg_list,
865: '_PUB',
866: x_return_status);
867: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

863: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
864: p_init_msg_list,
865: '_PUB',
866: x_return_status);
867: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
868: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
869: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
870: raise OKC_API.G_EXCEPTION_ERROR;
871: END IF;

Line 868: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

864: p_init_msg_list,
865: '_PUB',
866: x_return_status);
867: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
868: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
869: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
870: raise OKC_API.G_EXCEPTION_ERROR;
871: END IF;
872: -- Call user hook for BEFORE

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

865: '_PUB',
866: x_return_status);
867: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
868: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
869: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
870: raise OKC_API.G_EXCEPTION_ERROR;
871: END IF;
872: -- Call user hook for BEFORE
873: g_qlpv_rec := p_qlpv_rec;

Line 870: raise OKC_API.G_EXCEPTION_ERROR;

866: x_return_status);
867: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
868: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
869: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
870: raise OKC_API.G_EXCEPTION_ERROR;
871: END IF;
872: -- Call user hook for BEFORE
873: g_qlpv_rec := p_qlpv_rec;
874: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

871: END IF;
872: -- Call user hook for BEFORE
873: g_qlpv_rec := p_qlpv_rec;
874: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
875: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
876: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
877: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
878: raise OKC_API.G_EXCEPTION_ERROR;
879: END IF;

Line 876: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

872: -- Call user hook for BEFORE
873: g_qlpv_rec := p_qlpv_rec;
874: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
875: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
876: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
877: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
878: raise OKC_API.G_EXCEPTION_ERROR;
879: END IF;
880: l_qlpv_rec := migrate_qlpv(l_qlpv_rec, g_qlpv_rec);

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

873: g_qlpv_rec := p_qlpv_rec;
874: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
875: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
876: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
877: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
878: raise OKC_API.G_EXCEPTION_ERROR;
879: END IF;
880: l_qlpv_rec := migrate_qlpv(l_qlpv_rec, g_qlpv_rec);
881:

Line 878: raise OKC_API.G_EXCEPTION_ERROR;

874: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
875: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
876: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
877: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
878: raise OKC_API.G_EXCEPTION_ERROR;
879: END IF;
880: l_qlpv_rec := migrate_qlpv(l_qlpv_rec, g_qlpv_rec);
881:
882: OKC_QA_CHECK_LIST_PVT.update_qa_process(

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

887: x_msg_data => x_msg_data,
888: p_qlpv_rec => l_qlpv_rec,
889: x_qlpv_rec => x_qlpv_rec);
890:
891: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
892: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
893: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
894: raise OKC_API.G_EXCEPTION_ERROR;
895: END IF;

Line 892: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

888: p_qlpv_rec => l_qlpv_rec,
889: x_qlpv_rec => x_qlpv_rec);
890:
891: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
892: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
893: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
894: raise OKC_API.G_EXCEPTION_ERROR;
895: END IF;
896:

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

889: x_qlpv_rec => x_qlpv_rec);
890:
891: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
892: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
893: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
894: raise OKC_API.G_EXCEPTION_ERROR;
895: END IF;
896:
897: -- Call user hook for AFTER

Line 894: raise OKC_API.G_EXCEPTION_ERROR;

890:
891: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
892: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
893: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
894: raise OKC_API.G_EXCEPTION_ERROR;
895: END IF;
896:
897: -- Call user hook for AFTER
898: g_qlpv_rec := x_qlpv_rec;

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

896:
897: -- Call user hook for AFTER
898: g_qlpv_rec := x_qlpv_rec;
899: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
900: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
901: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
902: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
903: raise OKC_API.G_EXCEPTION_ERROR;
904: END IF;

Line 901: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

897: -- Call user hook for AFTER
898: g_qlpv_rec := x_qlpv_rec;
899: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
900: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
901: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
902: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
903: raise OKC_API.G_EXCEPTION_ERROR;
904: END IF;
905: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

898: g_qlpv_rec := x_qlpv_rec;
899: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
900: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
901: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
902: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
903: raise OKC_API.G_EXCEPTION_ERROR;
904: END IF;
905: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
906: EXCEPTION

Line 903: raise OKC_API.G_EXCEPTION_ERROR;

899: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
900: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
901: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
902: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
903: raise OKC_API.G_EXCEPTION_ERROR;
904: END IF;
905: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
906: EXCEPTION
907: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

901: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
902: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
903: raise OKC_API.G_EXCEPTION_ERROR;
904: END IF;
905: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
906: EXCEPTION
907: WHEN OKC_API.G_EXCEPTION_ERROR THEN
908: x_return_status := OKC_API.HANDLE_EXCEPTIONS
909: (l_api_name

Line 907: WHEN OKC_API.G_EXCEPTION_ERROR THEN

903: raise OKC_API.G_EXCEPTION_ERROR;
904: END IF;
905: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
906: EXCEPTION
907: WHEN OKC_API.G_EXCEPTION_ERROR THEN
908: x_return_status := OKC_API.HANDLE_EXCEPTIONS
909: (l_api_name
910: ,G_PKG_NAME
911: ,'OKC_API.G_RET_STS_ERROR'

Line 908: x_return_status := OKC_API.HANDLE_EXCEPTIONS

904: END IF;
905: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
906: EXCEPTION
907: WHEN OKC_API.G_EXCEPTION_ERROR THEN
908: x_return_status := OKC_API.HANDLE_EXCEPTIONS
909: (l_api_name
910: ,G_PKG_NAME
911: ,'OKC_API.G_RET_STS_ERROR'
912: ,x_msg_count

Line 911: ,'OKC_API.G_RET_STS_ERROR'

907: WHEN OKC_API.G_EXCEPTION_ERROR THEN
908: x_return_status := OKC_API.HANDLE_EXCEPTIONS
909: (l_api_name
910: ,G_PKG_NAME
911: ,'OKC_API.G_RET_STS_ERROR'
912: ,x_msg_count
913: ,x_msg_data
914: ,'_PUB');
915: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 915: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

911: ,'OKC_API.G_RET_STS_ERROR'
912: ,x_msg_count
913: ,x_msg_data
914: ,'_PUB');
915: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
916: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
917: (l_api_name
918: ,G_PKG_NAME
919: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 916: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

912: ,x_msg_count
913: ,x_msg_data
914: ,'_PUB');
915: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
916: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
917: (l_api_name
918: ,G_PKG_NAME
919: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
920: ,x_msg_count

Line 919: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

915: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
916: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
917: (l_api_name
918: ,G_PKG_NAME
919: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
920: ,x_msg_count
921: ,x_msg_data
922: ,'_PUB');
923: WHEN OTHERS THEN

Line 924: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

920: ,x_msg_count
921: ,x_msg_data
922: ,'_PUB');
923: WHEN OTHERS THEN
924: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
925: (l_api_name
926: ,G_PKG_NAME
927: ,'OTHERS'
928: ,x_msg_count

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

941: x_msg_data OUT NOCOPY VARCHAR2,
942: p_qlpv_tbl IN qlpv_tbl_type,
943: x_qlpv_tbl OUT NOCOPY qlpv_tbl_type) IS
944: i NUMBER := 0;
945: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
946: BEGIN
947: x_return_status := OKC_API.G_RET_STS_SUCCESS;
948: IF p_qlpv_tbl.COUNT > 0 THEN
949: i := p_qlpv_tbl.FIRST;

Line 947: x_return_status := OKC_API.G_RET_STS_SUCCESS;

943: x_qlpv_tbl OUT NOCOPY qlpv_tbl_type) IS
944: i NUMBER := 0;
945: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
946: BEGIN
947: x_return_status := OKC_API.G_RET_STS_SUCCESS;
948: IF p_qlpv_tbl.COUNT > 0 THEN
949: i := p_qlpv_tbl.FIRST;
950: LOOP
951: update_qa_process(

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

955: x_msg_count => x_msg_count,
956: x_msg_data => x_msg_data,
957: p_qlpv_rec => p_qlpv_tbl(i),
958: x_qlpv_rec => x_qlpv_tbl(i));
959: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
960: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
961: x_return_status := l_return_status;
962: raise G_EXCEPTION_HALT_VALIDATION;
963: ELSE

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

956: x_msg_data => x_msg_data,
957: p_qlpv_rec => p_qlpv_tbl(i),
958: x_qlpv_rec => x_qlpv_tbl(i));
959: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
960: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
961: x_return_status := l_return_status;
962: raise G_EXCEPTION_HALT_VALIDATION;
963: ELSE
964: x_return_status := l_return_status;

Line 976: OKC_API.SET_MESSAGE(

972: WHEN G_EXCEPTION_HALT_VALIDATION THEN
973: NULL;
974: WHEN OTHERS THEN
975: -- store SQL error message on message stack
976: OKC_API.SET_MESSAGE(
977: p_app_name => G_APP_NAME,
978: p_msg_name => G_UNEXPECTED_ERROR,
979: p_token1 => G_SQLCODE_TOKEN,
980: p_token1_value => SQLCODE,

Line 984: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

980: p_token1_value => SQLCODE,
981: p_token2 => G_SQLERRM_TOKEN,
982: p_token2_value => SQLERRM);
983: -- notify caller of an error as UNEXPETED error
984: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
985: END update_qa_process;
986:
987: --------------------------------------
988: -- PROCEDURE delete_qa_process

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

993: x_return_status OUT NOCOPY VARCHAR2,
994: x_msg_count OUT NOCOPY NUMBER,
995: x_msg_data OUT NOCOPY VARCHAR2,
996: p_qlpv_rec IN qlpv_rec_type) IS
997: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
998: l_api_name CONSTANT VARCHAR2(30) := 'delete_qa_process';
999: l_qlpv_rec qlpv_rec_type := p_qlpv_rec;
1000: BEGIN
1001: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

997: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
998: l_api_name CONSTANT VARCHAR2(30) := 'delete_qa_process';
999: l_qlpv_rec qlpv_rec_type := p_qlpv_rec;
1000: BEGIN
1001: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1002: p_init_msg_list,
1003: '_PUB',
1004: x_return_status);
1005: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1001: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1002: p_init_msg_list,
1003: '_PUB',
1004: x_return_status);
1005: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1006: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1007: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1008: raise OKC_API.G_EXCEPTION_ERROR;
1009: END IF;

Line 1006: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1002: p_init_msg_list,
1003: '_PUB',
1004: x_return_status);
1005: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1006: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1007: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1008: raise OKC_API.G_EXCEPTION_ERROR;
1009: END IF;
1010: -- Call user hook for BEFORE

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

1003: '_PUB',
1004: x_return_status);
1005: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1006: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1007: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1008: raise OKC_API.G_EXCEPTION_ERROR;
1009: END IF;
1010: -- Call user hook for BEFORE
1011: g_qlpv_rec := p_qlpv_rec;

Line 1008: raise OKC_API.G_EXCEPTION_ERROR;

1004: x_return_status);
1005: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1006: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1007: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1008: raise OKC_API.G_EXCEPTION_ERROR;
1009: END IF;
1010: -- Call user hook for BEFORE
1011: g_qlpv_rec := p_qlpv_rec;
1012: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1009: END IF;
1010: -- Call user hook for BEFORE
1011: g_qlpv_rec := p_qlpv_rec;
1012: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1013: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1014: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1015: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1016: raise OKC_API.G_EXCEPTION_ERROR;
1017: END IF;

Line 1014: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1010: -- Call user hook for BEFORE
1011: g_qlpv_rec := p_qlpv_rec;
1012: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1013: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1014: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1015: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1016: raise OKC_API.G_EXCEPTION_ERROR;
1017: END IF;
1018:

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

1011: g_qlpv_rec := p_qlpv_rec;
1012: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1013: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1014: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1015: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1016: raise OKC_API.G_EXCEPTION_ERROR;
1017: END IF;
1018:
1019: OKC_QA_CHECK_LIST_PVT.delete_qa_process(

Line 1016: raise OKC_API.G_EXCEPTION_ERROR;

1012: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1013: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1014: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1015: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1016: raise OKC_API.G_EXCEPTION_ERROR;
1017: END IF;
1018:
1019: OKC_QA_CHECK_LIST_PVT.delete_qa_process(
1020: p_api_version => p_api_version,

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

1023: x_msg_count => x_msg_count,
1024: x_msg_data => x_msg_data,
1025: p_qlpv_rec => p_qlpv_rec);
1026:
1027: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1028: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1029: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1030: raise OKC_API.G_EXCEPTION_ERROR;
1031: END IF;

Line 1028: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1024: x_msg_data => x_msg_data,
1025: p_qlpv_rec => p_qlpv_rec);
1026:
1027: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1028: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1029: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1030: raise OKC_API.G_EXCEPTION_ERROR;
1031: END IF;
1032:

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

1025: p_qlpv_rec => p_qlpv_rec);
1026:
1027: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1028: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1029: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1030: raise OKC_API.G_EXCEPTION_ERROR;
1031: END IF;
1032:
1033: -- Call user hook for AFTER

Line 1030: raise OKC_API.G_EXCEPTION_ERROR;

1026:
1027: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1028: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1029: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1030: raise OKC_API.G_EXCEPTION_ERROR;
1031: END IF;
1032:
1033: -- Call user hook for AFTER
1034: g_qlpv_rec := l_qlpv_rec;

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

1032:
1033: -- Call user hook for AFTER
1034: g_qlpv_rec := l_qlpv_rec;
1035: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1036: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1037: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1038: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1039: raise OKC_API.G_EXCEPTION_ERROR;
1040: END IF;

Line 1037: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1033: -- Call user hook for AFTER
1034: g_qlpv_rec := l_qlpv_rec;
1035: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1036: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1037: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1038: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1039: raise OKC_API.G_EXCEPTION_ERROR;
1040: END IF;
1041: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1034: g_qlpv_rec := l_qlpv_rec;
1035: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1036: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1037: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1038: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1039: raise OKC_API.G_EXCEPTION_ERROR;
1040: END IF;
1041: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1042: EXCEPTION

Line 1039: raise OKC_API.G_EXCEPTION_ERROR;

1035: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1036: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1037: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1038: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1039: raise OKC_API.G_EXCEPTION_ERROR;
1040: END IF;
1041: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1042: EXCEPTION
1043: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1037: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1038: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1039: raise OKC_API.G_EXCEPTION_ERROR;
1040: END IF;
1041: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1042: EXCEPTION
1043: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1044: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1045: (l_api_name

Line 1043: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1039: raise OKC_API.G_EXCEPTION_ERROR;
1040: END IF;
1041: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1042: EXCEPTION
1043: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1044: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1045: (l_api_name
1046: ,G_PKG_NAME
1047: ,'OKC_API.G_RET_STS_ERROR'

Line 1044: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1040: END IF;
1041: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1042: EXCEPTION
1043: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1044: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1045: (l_api_name
1046: ,G_PKG_NAME
1047: ,'OKC_API.G_RET_STS_ERROR'
1048: ,x_msg_count

Line 1047: ,'OKC_API.G_RET_STS_ERROR'

1043: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1044: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1045: (l_api_name
1046: ,G_PKG_NAME
1047: ,'OKC_API.G_RET_STS_ERROR'
1048: ,x_msg_count
1049: ,x_msg_data
1050: ,'_PUB');
1051: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1051: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1047: ,'OKC_API.G_RET_STS_ERROR'
1048: ,x_msg_count
1049: ,x_msg_data
1050: ,'_PUB');
1051: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1052: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1053: (l_api_name
1054: ,G_PKG_NAME
1055: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 1052: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1048: ,x_msg_count
1049: ,x_msg_data
1050: ,'_PUB');
1051: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1052: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1053: (l_api_name
1054: ,G_PKG_NAME
1055: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1056: ,x_msg_count

Line 1055: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

1051: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1052: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1053: (l_api_name
1054: ,G_PKG_NAME
1055: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1056: ,x_msg_count
1057: ,x_msg_data
1058: ,'_PUB');
1059: WHEN OTHERS THEN

Line 1060: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1056: ,x_msg_count
1057: ,x_msg_data
1058: ,'_PUB');
1059: WHEN OTHERS THEN
1060: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1061: (l_api_name
1062: ,G_PKG_NAME
1063: ,'OTHERS'
1064: ,x_msg_count

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

1076: x_msg_count OUT NOCOPY NUMBER,
1077: x_msg_data OUT NOCOPY VARCHAR2,
1078: p_qlpv_tbl IN qlpv_tbl_type) IS
1079: i NUMBER := 0;
1080: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1081: BEGIN
1082: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1083: IF p_qlpv_tbl.COUNT > 0 THEN
1084: i := p_qlpv_tbl.FIRST;

Line 1082: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1078: p_qlpv_tbl IN qlpv_tbl_type) IS
1079: i NUMBER := 0;
1080: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1081: BEGIN
1082: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1083: IF p_qlpv_tbl.COUNT > 0 THEN
1084: i := p_qlpv_tbl.FIRST;
1085: LOOP
1086: delete_qa_process(

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

1089: x_return_status => l_return_status,
1090: x_msg_count => x_msg_count,
1091: x_msg_data => x_msg_data,
1092: p_qlpv_rec => p_qlpv_tbl(i));
1093: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1094: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1095: x_return_status := l_return_status;
1096: raise G_EXCEPTION_HALT_VALIDATION;
1097: ELSE

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

1090: x_msg_count => x_msg_count,
1091: x_msg_data => x_msg_data,
1092: p_qlpv_rec => p_qlpv_tbl(i));
1093: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1094: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1095: x_return_status := l_return_status;
1096: raise G_EXCEPTION_HALT_VALIDATION;
1097: ELSE
1098: x_return_status := l_return_status;

Line 1110: OKC_API.SET_MESSAGE(

1106: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1107: NULL;
1108: WHEN OTHERS THEN
1109: -- store SQL error message on message stack
1110: OKC_API.SET_MESSAGE(
1111: p_app_name => G_APP_NAME,
1112: p_msg_name => G_UNEXPECTED_ERROR,
1113: p_token1 => G_SQLCODE_TOKEN,
1114: p_token1_value => SQLCODE,

Line 1118: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1114: p_token1_value => SQLCODE,
1115: p_token2 => G_SQLERRM_TOKEN,
1116: p_token2_value => SQLERRM);
1117: -- notify caller of an error as UNEXPETED error
1118: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1119: END delete_qa_process;
1120:
1121: --------------------------------------
1122: -- PROCEDURE lock_qa_process

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

1148: x_msg_count OUT NOCOPY NUMBER,
1149: x_msg_data OUT NOCOPY VARCHAR2,
1150: p_qlpv_tbl IN qlpv_tbl_type) IS
1151: i NUMBER := 0;
1152: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1153: BEGIN
1154: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1155: IF p_qlpv_tbl.COUNT > 0 THEN
1156: i := p_qlpv_tbl.FIRST;

Line 1154: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1150: p_qlpv_tbl IN qlpv_tbl_type) IS
1151: i NUMBER := 0;
1152: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1153: BEGIN
1154: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1155: IF p_qlpv_tbl.COUNT > 0 THEN
1156: i := p_qlpv_tbl.FIRST;
1157: LOOP
1158: lock_qa_process(

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

1161: x_return_status => l_return_status,
1162: x_msg_count => x_msg_count,
1163: x_msg_data => x_msg_data,
1164: p_qlpv_rec => p_qlpv_tbl(i));
1165: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1166: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1167: x_return_status := l_return_status;
1168: raise G_EXCEPTION_HALT_VALIDATION;
1169: ELSE

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

1162: x_msg_count => x_msg_count,
1163: x_msg_data => x_msg_data,
1164: p_qlpv_rec => p_qlpv_tbl(i));
1165: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1166: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1167: x_return_status := l_return_status;
1168: raise G_EXCEPTION_HALT_VALIDATION;
1169: ELSE
1170: x_return_status := l_return_status;

Line 1182: OKC_API.SET_MESSAGE(

1178: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1179: NULL;
1180: WHEN OTHERS THEN
1181: -- store SQL error message on message stack
1182: OKC_API.SET_MESSAGE(
1183: p_app_name => G_APP_NAME,
1184: p_msg_name => G_UNEXPECTED_ERROR,
1185: p_token1 => G_SQLCODE_TOKEN,
1186: p_token1_value => SQLCODE,

Line 1190: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1186: p_token1_value => SQLCODE,
1187: p_token2 => G_SQLERRM_TOKEN,
1188: p_token2_value => SQLERRM);
1189: -- notify caller of an error as UNEXPETED error
1190: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1191: END lock_qa_process;
1192:
1193: --------------------------------------
1194: -- PROCEDURE validate_qa_process

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

1199: x_return_status OUT NOCOPY VARCHAR2,
1200: x_msg_count OUT NOCOPY NUMBER,
1201: x_msg_data OUT NOCOPY VARCHAR2,
1202: p_qlpv_rec IN qlpv_rec_type) IS
1203: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1204: l_api_name CONSTANT VARCHAR2(30) := 'validate_qa_process';
1205: l_qlpv_rec qlpv_rec_type := p_qlpv_rec;
1206: BEGIN
1207: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1203: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1204: l_api_name CONSTANT VARCHAR2(30) := 'validate_qa_process';
1205: l_qlpv_rec qlpv_rec_type := p_qlpv_rec;
1206: BEGIN
1207: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1208: p_init_msg_list,
1209: '_PUB',
1210: x_return_status);
1211: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1207: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1208: p_init_msg_list,
1209: '_PUB',
1210: x_return_status);
1211: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1212: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1213: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1214: raise OKC_API.G_EXCEPTION_ERROR;
1215: END IF;

Line 1212: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1208: p_init_msg_list,
1209: '_PUB',
1210: x_return_status);
1211: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1212: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1213: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1214: raise OKC_API.G_EXCEPTION_ERROR;
1215: END IF;
1216: -- Call user hook for BEFORE

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

1209: '_PUB',
1210: x_return_status);
1211: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1212: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1213: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1214: raise OKC_API.G_EXCEPTION_ERROR;
1215: END IF;
1216: -- Call user hook for BEFORE
1217: g_qlpv_rec := p_qlpv_rec;

Line 1214: raise OKC_API.G_EXCEPTION_ERROR;

1210: x_return_status);
1211: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1212: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1213: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1214: raise OKC_API.G_EXCEPTION_ERROR;
1215: END IF;
1216: -- Call user hook for BEFORE
1217: g_qlpv_rec := p_qlpv_rec;
1218: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1215: END IF;
1216: -- Call user hook for BEFORE
1217: g_qlpv_rec := p_qlpv_rec;
1218: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1219: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1220: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1221: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1222: raise OKC_API.G_EXCEPTION_ERROR;
1223: END IF;

Line 1220: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1216: -- Call user hook for BEFORE
1217: g_qlpv_rec := p_qlpv_rec;
1218: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1219: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1220: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1221: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1222: raise OKC_API.G_EXCEPTION_ERROR;
1223: END IF;
1224:

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

1217: g_qlpv_rec := p_qlpv_rec;
1218: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1219: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1220: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1221: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1222: raise OKC_API.G_EXCEPTION_ERROR;
1223: END IF;
1224:
1225: OKC_QA_CHECK_LIST_PVT.validate_qa_process(

Line 1222: raise OKC_API.G_EXCEPTION_ERROR;

1218: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1219: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1220: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1221: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1222: raise OKC_API.G_EXCEPTION_ERROR;
1223: END IF;
1224:
1225: OKC_QA_CHECK_LIST_PVT.validate_qa_process(
1226: p_api_version => p_api_version,

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

1229: x_msg_count => x_msg_count,
1230: x_msg_data => x_msg_data,
1231: p_qlpv_rec => p_qlpv_rec);
1232:
1233: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1234: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1235: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1236: raise OKC_API.G_EXCEPTION_ERROR;
1237: END IF;

Line 1234: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1230: x_msg_data => x_msg_data,
1231: p_qlpv_rec => p_qlpv_rec);
1232:
1233: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1234: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1235: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1236: raise OKC_API.G_EXCEPTION_ERROR;
1237: END IF;
1238:

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

1231: p_qlpv_rec => p_qlpv_rec);
1232:
1233: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1234: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1235: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1236: raise OKC_API.G_EXCEPTION_ERROR;
1237: END IF;
1238:
1239: -- Call user hook for AFTER

Line 1236: raise OKC_API.G_EXCEPTION_ERROR;

1232:
1233: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1234: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1235: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1236: raise OKC_API.G_EXCEPTION_ERROR;
1237: END IF;
1238:
1239: -- Call user hook for AFTER
1240: g_qlpv_rec := l_qlpv_rec;

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

1238:
1239: -- Call user hook for AFTER
1240: g_qlpv_rec := l_qlpv_rec;
1241: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1242: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1243: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1244: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1245: raise OKC_API.G_EXCEPTION_ERROR;
1246: END IF;

Line 1243: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1239: -- Call user hook for AFTER
1240: g_qlpv_rec := l_qlpv_rec;
1241: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1242: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1243: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1244: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1245: raise OKC_API.G_EXCEPTION_ERROR;
1246: END IF;
1247: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1240: g_qlpv_rec := l_qlpv_rec;
1241: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1242: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1243: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1244: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1245: raise OKC_API.G_EXCEPTION_ERROR;
1246: END IF;
1247: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1248: EXCEPTION

Line 1245: raise OKC_API.G_EXCEPTION_ERROR;

1241: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1242: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1243: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1244: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1245: raise OKC_API.G_EXCEPTION_ERROR;
1246: END IF;
1247: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1248: EXCEPTION
1249: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1243: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1244: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1245: raise OKC_API.G_EXCEPTION_ERROR;
1246: END IF;
1247: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1248: EXCEPTION
1249: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1250: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1251: (l_api_name

Line 1249: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1245: raise OKC_API.G_EXCEPTION_ERROR;
1246: END IF;
1247: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1248: EXCEPTION
1249: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1250: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1251: (l_api_name
1252: ,G_PKG_NAME
1253: ,'OKC_API.G_RET_STS_ERROR'

Line 1250: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1246: END IF;
1247: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1248: EXCEPTION
1249: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1250: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1251: (l_api_name
1252: ,G_PKG_NAME
1253: ,'OKC_API.G_RET_STS_ERROR'
1254: ,x_msg_count

Line 1253: ,'OKC_API.G_RET_STS_ERROR'

1249: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1250: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1251: (l_api_name
1252: ,G_PKG_NAME
1253: ,'OKC_API.G_RET_STS_ERROR'
1254: ,x_msg_count
1255: ,x_msg_data
1256: ,'_PUB');
1257: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1257: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1253: ,'OKC_API.G_RET_STS_ERROR'
1254: ,x_msg_count
1255: ,x_msg_data
1256: ,'_PUB');
1257: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1258: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1259: (l_api_name
1260: ,G_PKG_NAME
1261: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 1258: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1254: ,x_msg_count
1255: ,x_msg_data
1256: ,'_PUB');
1257: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1258: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1259: (l_api_name
1260: ,G_PKG_NAME
1261: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1262: ,x_msg_count

Line 1261: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

1257: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1258: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1259: (l_api_name
1260: ,G_PKG_NAME
1261: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1262: ,x_msg_count
1263: ,x_msg_data
1264: ,'_PUB');
1265: WHEN OTHERS THEN

Line 1266: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1262: ,x_msg_count
1263: ,x_msg_data
1264: ,'_PUB');
1265: WHEN OTHERS THEN
1266: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1267: (l_api_name
1268: ,G_PKG_NAME
1269: ,'OTHERS'
1270: ,x_msg_count

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

1282: x_msg_count OUT NOCOPY NUMBER,
1283: x_msg_data OUT NOCOPY VARCHAR2,
1284: p_qlpv_tbl IN qlpv_tbl_type) IS
1285: i NUMBER := 0;
1286: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1287: BEGIN
1288: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1289: IF p_qlpv_tbl.COUNT > 0 THEN
1290: i := p_qlpv_tbl.FIRST;

Line 1288: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1284: p_qlpv_tbl IN qlpv_tbl_type) IS
1285: i NUMBER := 0;
1286: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1287: BEGIN
1288: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1289: IF p_qlpv_tbl.COUNT > 0 THEN
1290: i := p_qlpv_tbl.FIRST;
1291: LOOP
1292: validate_qa_process(

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

1295: x_return_status => l_return_status,
1296: x_msg_count => x_msg_count,
1297: x_msg_data => x_msg_data,
1298: p_qlpv_rec => p_qlpv_tbl(i));
1299: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1300: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1301: x_return_status := l_return_status;
1302: raise G_EXCEPTION_HALT_VALIDATION;
1303: ELSE

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

1296: x_msg_count => x_msg_count,
1297: x_msg_data => x_msg_data,
1298: p_qlpv_rec => p_qlpv_tbl(i));
1299: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1300: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1301: x_return_status := l_return_status;
1302: raise G_EXCEPTION_HALT_VALIDATION;
1303: ELSE
1304: x_return_status := l_return_status;

Line 1316: OKC_API.SET_MESSAGE(

1312: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1313: NULL;
1314: WHEN OTHERS THEN
1315: -- store SQL error message on message stack
1316: OKC_API.SET_MESSAGE(
1317: p_app_name => G_APP_NAME,
1318: p_msg_name => G_UNEXPECTED_ERROR,
1319: p_token1 => G_SQLCODE_TOKEN,
1320: p_token1_value => SQLCODE,

Line 1324: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1320: p_token1_value => SQLCODE,
1321: p_token2 => G_SQLERRM_TOKEN,
1322: p_token2_value => SQLERRM);
1323: -- notify caller of an error as UNEXPETED error
1324: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1325: END validate_qa_process;
1326:
1327: ---------------------------------------------------------------------------
1328: -- FUNCTION migrate_qppv

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

1374: x_msg_count OUT NOCOPY NUMBER,
1375: x_msg_data OUT NOCOPY VARCHAR2,
1376: p_qppv_rec IN qppv_rec_type,
1377: x_qppv_rec OUT NOCOPY qppv_rec_type) IS
1378: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1379: l_api_name CONSTANT VARCHAR2(30) := 'create_qa_parm';
1380: l_qppv_rec qppv_rec_type := p_qppv_rec;
1381: BEGIN
1382: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1378: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1379: l_api_name CONSTANT VARCHAR2(30) := 'create_qa_parm';
1380: l_qppv_rec qppv_rec_type := p_qppv_rec;
1381: BEGIN
1382: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1383: p_init_msg_list,
1384: '_PUB',
1385: x_return_status);
1386: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1382: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1383: p_init_msg_list,
1384: '_PUB',
1385: x_return_status);
1386: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1387: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1388: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1389: raise OKC_API.G_EXCEPTION_ERROR;
1390: END IF;

Line 1387: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1383: p_init_msg_list,
1384: '_PUB',
1385: x_return_status);
1386: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1387: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1388: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1389: raise OKC_API.G_EXCEPTION_ERROR;
1390: END IF;
1391: -- Call user hook for BEFORE

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

1384: '_PUB',
1385: x_return_status);
1386: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1387: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1388: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1389: raise OKC_API.G_EXCEPTION_ERROR;
1390: END IF;
1391: -- Call user hook for BEFORE
1392: g_qppv_rec := p_qppv_rec;

Line 1389: raise OKC_API.G_EXCEPTION_ERROR;

1385: x_return_status);
1386: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1387: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1388: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1389: raise OKC_API.G_EXCEPTION_ERROR;
1390: END IF;
1391: -- Call user hook for BEFORE
1392: g_qppv_rec := p_qppv_rec;
1393: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1390: END IF;
1391: -- Call user hook for BEFORE
1392: g_qppv_rec := p_qppv_rec;
1393: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1394: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1395: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1396: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1397: raise OKC_API.G_EXCEPTION_ERROR;
1398: END IF;

Line 1395: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1391: -- Call user hook for BEFORE
1392: g_qppv_rec := p_qppv_rec;
1393: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1394: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1395: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1396: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1397: raise OKC_API.G_EXCEPTION_ERROR;
1398: END IF;
1399: l_qppv_rec := migrate_qppv(l_qppv_rec, g_qppv_rec);

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

1392: g_qppv_rec := p_qppv_rec;
1393: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1394: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1395: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1396: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1397: raise OKC_API.G_EXCEPTION_ERROR;
1398: END IF;
1399: l_qppv_rec := migrate_qppv(l_qppv_rec, g_qppv_rec);
1400:

Line 1397: raise OKC_API.G_EXCEPTION_ERROR;

1393: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1394: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1395: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1396: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1397: raise OKC_API.G_EXCEPTION_ERROR;
1398: END IF;
1399: l_qppv_rec := migrate_qppv(l_qppv_rec, g_qppv_rec);
1400:
1401: OKC_QA_CHECK_LIST_PVT.create_qa_parm(

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

1406: x_msg_data => x_msg_data,
1407: p_qppv_rec => l_qppv_rec,
1408: x_qppv_rec => x_qppv_rec);
1409:
1410: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1411: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1412: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1413: raise OKC_API.G_EXCEPTION_ERROR;
1414: END IF;

Line 1411: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1407: p_qppv_rec => l_qppv_rec,
1408: x_qppv_rec => x_qppv_rec);
1409:
1410: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1411: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1412: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1413: raise OKC_API.G_EXCEPTION_ERROR;
1414: END IF;
1415:

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

1408: x_qppv_rec => x_qppv_rec);
1409:
1410: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1411: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1412: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1413: raise OKC_API.G_EXCEPTION_ERROR;
1414: END IF;
1415:
1416: -- Call user hook for AFTER

Line 1413: raise OKC_API.G_EXCEPTION_ERROR;

1409:
1410: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1411: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1412: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1413: raise OKC_API.G_EXCEPTION_ERROR;
1414: END IF;
1415:
1416: -- Call user hook for AFTER
1417: g_qppv_rec := x_qppv_rec;

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

1415:
1416: -- Call user hook for AFTER
1417: g_qppv_rec := x_qppv_rec;
1418: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1419: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1420: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1421: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1422: raise OKC_API.G_EXCEPTION_ERROR;
1423: END IF;

Line 1420: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1416: -- Call user hook for AFTER
1417: g_qppv_rec := x_qppv_rec;
1418: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1419: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1420: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1421: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1422: raise OKC_API.G_EXCEPTION_ERROR;
1423: END IF;
1424: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1417: g_qppv_rec := x_qppv_rec;
1418: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1419: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1420: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1421: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1422: raise OKC_API.G_EXCEPTION_ERROR;
1423: END IF;
1424: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1425: EXCEPTION

Line 1422: raise OKC_API.G_EXCEPTION_ERROR;

1418: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1419: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1420: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1421: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1422: raise OKC_API.G_EXCEPTION_ERROR;
1423: END IF;
1424: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1425: EXCEPTION
1426: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1420: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1421: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1422: raise OKC_API.G_EXCEPTION_ERROR;
1423: END IF;
1424: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1425: EXCEPTION
1426: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1427: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1428: (l_api_name

Line 1426: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1422: raise OKC_API.G_EXCEPTION_ERROR;
1423: END IF;
1424: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1425: EXCEPTION
1426: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1427: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1428: (l_api_name
1429: ,G_PKG_NAME
1430: ,'OKC_API.G_RET_STS_ERROR'

Line 1427: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1423: END IF;
1424: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1425: EXCEPTION
1426: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1427: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1428: (l_api_name
1429: ,G_PKG_NAME
1430: ,'OKC_API.G_RET_STS_ERROR'
1431: ,x_msg_count

Line 1430: ,'OKC_API.G_RET_STS_ERROR'

1426: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1427: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1428: (l_api_name
1429: ,G_PKG_NAME
1430: ,'OKC_API.G_RET_STS_ERROR'
1431: ,x_msg_count
1432: ,x_msg_data
1433: ,'_PUB');
1434: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1434: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1430: ,'OKC_API.G_RET_STS_ERROR'
1431: ,x_msg_count
1432: ,x_msg_data
1433: ,'_PUB');
1434: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1435: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1436: (l_api_name
1437: ,G_PKG_NAME
1438: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 1435: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1431: ,x_msg_count
1432: ,x_msg_data
1433: ,'_PUB');
1434: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1435: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1436: (l_api_name
1437: ,G_PKG_NAME
1438: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1439: ,x_msg_count

Line 1438: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

1434: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1435: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1436: (l_api_name
1437: ,G_PKG_NAME
1438: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1439: ,x_msg_count
1440: ,x_msg_data
1441: ,'_PUB');
1442: WHEN OTHERS THEN

Line 1443: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1439: ,x_msg_count
1440: ,x_msg_data
1441: ,'_PUB');
1442: WHEN OTHERS THEN
1443: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1444: (l_api_name
1445: ,G_PKG_NAME
1446: ,'OTHERS'
1447: ,x_msg_count

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

1460: x_msg_data OUT NOCOPY VARCHAR2,
1461: p_qppv_tbl IN qppv_tbl_type,
1462: x_qppv_tbl OUT NOCOPY qppv_tbl_type) IS
1463: i NUMBER := 0;
1464: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1465: BEGIN
1466: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1467: IF p_qppv_tbl.COUNT > 0 THEN
1468: i := p_qppv_tbl.FIRST;

Line 1466: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1462: x_qppv_tbl OUT NOCOPY qppv_tbl_type) IS
1463: i NUMBER := 0;
1464: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1465: BEGIN
1466: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1467: IF p_qppv_tbl.COUNT > 0 THEN
1468: i := p_qppv_tbl.FIRST;
1469: LOOP
1470: create_qa_parm(

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

1474: x_msg_count => x_msg_count,
1475: x_msg_data => x_msg_data,
1476: p_qppv_rec => p_qppv_tbl(i),
1477: x_qppv_rec => x_qppv_tbl(i));
1478: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1479: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1480: x_return_status := l_return_status;
1481: raise G_EXCEPTION_HALT_VALIDATION;
1482: ELSE

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

1475: x_msg_data => x_msg_data,
1476: p_qppv_rec => p_qppv_tbl(i),
1477: x_qppv_rec => x_qppv_tbl(i));
1478: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1479: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1480: x_return_status := l_return_status;
1481: raise G_EXCEPTION_HALT_VALIDATION;
1482: ELSE
1483: x_return_status := l_return_status;

Line 1495: OKC_API.SET_MESSAGE(

1491: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1492: NULL;
1493: WHEN OTHERS THEN
1494: -- store SQL error message on message stack
1495: OKC_API.SET_MESSAGE(
1496: p_app_name => G_APP_NAME,
1497: p_msg_name => G_UNEXPECTED_ERROR,
1498: p_token1 => G_SQLCODE_TOKEN,
1499: p_token1_value => SQLCODE,

Line 1503: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1499: p_token1_value => SQLCODE,
1500: p_token2 => G_SQLERRM_TOKEN,
1501: p_token2_value => SQLERRM);
1502: -- notify caller of an error as UNEXPETED error
1503: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1504: END create_qa_parm;
1505:
1506: --------------------------------------
1507: -- PROCEDURE update_qa_parm

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

1513: x_msg_count OUT NOCOPY NUMBER,
1514: x_msg_data OUT NOCOPY VARCHAR2,
1515: p_qppv_rec IN qppv_rec_type,
1516: x_qppv_rec OUT NOCOPY qppv_rec_type) IS
1517: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1518: l_api_name CONSTANT VARCHAR2(30) := 'update_qa_parm';
1519: l_qppv_rec qppv_rec_type := p_qppv_rec;
1520: BEGIN
1521: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1517: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1518: l_api_name CONSTANT VARCHAR2(30) := 'update_qa_parm';
1519: l_qppv_rec qppv_rec_type := p_qppv_rec;
1520: BEGIN
1521: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1522: p_init_msg_list,
1523: '_PUB',
1524: x_return_status);
1525: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1521: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1522: p_init_msg_list,
1523: '_PUB',
1524: x_return_status);
1525: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1526: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1527: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1528: raise OKC_API.G_EXCEPTION_ERROR;
1529: END IF;

Line 1526: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1522: p_init_msg_list,
1523: '_PUB',
1524: x_return_status);
1525: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1526: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1527: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1528: raise OKC_API.G_EXCEPTION_ERROR;
1529: END IF;
1530: -- Call user hook for BEFORE

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

1523: '_PUB',
1524: x_return_status);
1525: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1526: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1527: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1528: raise OKC_API.G_EXCEPTION_ERROR;
1529: END IF;
1530: -- Call user hook for BEFORE
1531: g_qppv_rec := p_qppv_rec;

Line 1528: raise OKC_API.G_EXCEPTION_ERROR;

1524: x_return_status);
1525: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1526: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1527: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1528: raise OKC_API.G_EXCEPTION_ERROR;
1529: END IF;
1530: -- Call user hook for BEFORE
1531: g_qppv_rec := p_qppv_rec;
1532: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1529: END IF;
1530: -- Call user hook for BEFORE
1531: g_qppv_rec := p_qppv_rec;
1532: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1533: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1534: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1535: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1536: raise OKC_API.G_EXCEPTION_ERROR;
1537: END IF;

Line 1534: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1530: -- Call user hook for BEFORE
1531: g_qppv_rec := p_qppv_rec;
1532: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1533: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1534: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1535: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1536: raise OKC_API.G_EXCEPTION_ERROR;
1537: END IF;
1538: l_qppv_rec := migrate_qppv(l_qppv_rec, g_qppv_rec);

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

1531: g_qppv_rec := p_qppv_rec;
1532: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1533: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1534: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1535: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1536: raise OKC_API.G_EXCEPTION_ERROR;
1537: END IF;
1538: l_qppv_rec := migrate_qppv(l_qppv_rec, g_qppv_rec);
1539:

Line 1536: raise OKC_API.G_EXCEPTION_ERROR;

1532: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1533: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1534: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1535: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1536: raise OKC_API.G_EXCEPTION_ERROR;
1537: END IF;
1538: l_qppv_rec := migrate_qppv(l_qppv_rec, g_qppv_rec);
1539:
1540: OKC_QA_CHECK_LIST_PVT.update_qa_parm(

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

1545: x_msg_data => x_msg_data,
1546: p_qppv_rec => l_qppv_rec,
1547: x_qppv_rec => x_qppv_rec);
1548:
1549: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1550: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1551: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1552: raise OKC_API.G_EXCEPTION_ERROR;
1553: END IF;

Line 1550: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1546: p_qppv_rec => l_qppv_rec,
1547: x_qppv_rec => x_qppv_rec);
1548:
1549: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1550: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1551: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1552: raise OKC_API.G_EXCEPTION_ERROR;
1553: END IF;
1554:

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

1547: x_qppv_rec => x_qppv_rec);
1548:
1549: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1550: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1551: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1552: raise OKC_API.G_EXCEPTION_ERROR;
1553: END IF;
1554:
1555: -- Call user hook for AFTER

Line 1552: raise OKC_API.G_EXCEPTION_ERROR;

1548:
1549: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1550: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1551: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1552: raise OKC_API.G_EXCEPTION_ERROR;
1553: END IF;
1554:
1555: -- Call user hook for AFTER
1556: g_qppv_rec := x_qppv_rec;

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

1554:
1555: -- Call user hook for AFTER
1556: g_qppv_rec := x_qppv_rec;
1557: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1558: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1559: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1560: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1561: raise OKC_API.G_EXCEPTION_ERROR;
1562: END IF;

Line 1559: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1555: -- Call user hook for AFTER
1556: g_qppv_rec := x_qppv_rec;
1557: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1558: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1559: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1560: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1561: raise OKC_API.G_EXCEPTION_ERROR;
1562: END IF;
1563: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1556: g_qppv_rec := x_qppv_rec;
1557: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1558: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1559: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1560: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1561: raise OKC_API.G_EXCEPTION_ERROR;
1562: END IF;
1563: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1564: EXCEPTION

Line 1561: raise OKC_API.G_EXCEPTION_ERROR;

1557: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1558: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1559: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1560: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1561: raise OKC_API.G_EXCEPTION_ERROR;
1562: END IF;
1563: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1564: EXCEPTION
1565: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1559: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1560: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1561: raise OKC_API.G_EXCEPTION_ERROR;
1562: END IF;
1563: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1564: EXCEPTION
1565: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1566: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1567: (l_api_name

Line 1565: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1561: raise OKC_API.G_EXCEPTION_ERROR;
1562: END IF;
1563: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1564: EXCEPTION
1565: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1566: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1567: (l_api_name
1568: ,G_PKG_NAME
1569: ,'OKC_API.G_RET_STS_ERROR'

Line 1566: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1562: END IF;
1563: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1564: EXCEPTION
1565: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1566: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1567: (l_api_name
1568: ,G_PKG_NAME
1569: ,'OKC_API.G_RET_STS_ERROR'
1570: ,x_msg_count

Line 1569: ,'OKC_API.G_RET_STS_ERROR'

1565: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1566: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1567: (l_api_name
1568: ,G_PKG_NAME
1569: ,'OKC_API.G_RET_STS_ERROR'
1570: ,x_msg_count
1571: ,x_msg_data
1572: ,'_PUB');
1573: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1573: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1569: ,'OKC_API.G_RET_STS_ERROR'
1570: ,x_msg_count
1571: ,x_msg_data
1572: ,'_PUB');
1573: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1574: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1575: (l_api_name
1576: ,G_PKG_NAME
1577: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 1574: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1570: ,x_msg_count
1571: ,x_msg_data
1572: ,'_PUB');
1573: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1574: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1575: (l_api_name
1576: ,G_PKG_NAME
1577: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1578: ,x_msg_count

Line 1577: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

1573: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1574: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1575: (l_api_name
1576: ,G_PKG_NAME
1577: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1578: ,x_msg_count
1579: ,x_msg_data
1580: ,'_PUB');
1581: WHEN OTHERS THEN

Line 1582: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1578: ,x_msg_count
1579: ,x_msg_data
1580: ,'_PUB');
1581: WHEN OTHERS THEN
1582: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1583: (l_api_name
1584: ,G_PKG_NAME
1585: ,'OTHERS'
1586: ,x_msg_count

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

1599: x_msg_data OUT NOCOPY VARCHAR2,
1600: p_qppv_tbl IN qppv_tbl_type,
1601: x_qppv_tbl OUT NOCOPY qppv_tbl_type) IS
1602: i NUMBER := 0;
1603: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1604: BEGIN
1605: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1606: IF p_qppv_tbl.COUNT > 0 THEN
1607: i := p_qppv_tbl.FIRST;

Line 1605: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1601: x_qppv_tbl OUT NOCOPY qppv_tbl_type) IS
1602: i NUMBER := 0;
1603: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1604: BEGIN
1605: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1606: IF p_qppv_tbl.COUNT > 0 THEN
1607: i := p_qppv_tbl.FIRST;
1608: LOOP
1609: update_qa_parm(

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

1613: x_msg_count => x_msg_count,
1614: x_msg_data => x_msg_data,
1615: p_qppv_rec => p_qppv_tbl(i),
1616: x_qppv_rec => x_qppv_tbl(i));
1617: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1618: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1619: x_return_status := l_return_status;
1620: raise G_EXCEPTION_HALT_VALIDATION;
1621: ELSE

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

1614: x_msg_data => x_msg_data,
1615: p_qppv_rec => p_qppv_tbl(i),
1616: x_qppv_rec => x_qppv_tbl(i));
1617: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1618: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1619: x_return_status := l_return_status;
1620: raise G_EXCEPTION_HALT_VALIDATION;
1621: ELSE
1622: x_return_status := l_return_status;

Line 1634: OKC_API.SET_MESSAGE(

1630: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1631: NULL;
1632: WHEN OTHERS THEN
1633: -- store SQL error message on message stack
1634: OKC_API.SET_MESSAGE(
1635: p_app_name => G_APP_NAME,
1636: p_msg_name => G_UNEXPECTED_ERROR,
1637: p_token1 => G_SQLCODE_TOKEN,
1638: p_token1_value => SQLCODE,

Line 1642: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1638: p_token1_value => SQLCODE,
1639: p_token2 => G_SQLERRM_TOKEN,
1640: p_token2_value => SQLERRM);
1641: -- notify caller of an error as UNEXPETED error
1642: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1643: END update_qa_parm;
1644:
1645: --------------------------------------
1646: -- PROCEDURE delete_qa_parm

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

1651: x_return_status OUT NOCOPY VARCHAR2,
1652: x_msg_count OUT NOCOPY NUMBER,
1653: x_msg_data OUT NOCOPY VARCHAR2,
1654: p_qppv_rec IN qppv_rec_type) IS
1655: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1656: l_api_name CONSTANT VARCHAR2(30) := 'delete_qa_parm';
1657: l_qppv_rec qppv_rec_type := p_qppv_rec;
1658: BEGIN
1659: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1655: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1656: l_api_name CONSTANT VARCHAR2(30) := 'delete_qa_parm';
1657: l_qppv_rec qppv_rec_type := p_qppv_rec;
1658: BEGIN
1659: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1660: p_init_msg_list,
1661: '_PUB',
1662: x_return_status);
1663: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1659: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1660: p_init_msg_list,
1661: '_PUB',
1662: x_return_status);
1663: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1664: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1665: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1666: raise OKC_API.G_EXCEPTION_ERROR;
1667: END IF;

Line 1664: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1660: p_init_msg_list,
1661: '_PUB',
1662: x_return_status);
1663: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1664: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1665: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1666: raise OKC_API.G_EXCEPTION_ERROR;
1667: END IF;
1668: -- Call user hook for BEFORE

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

1661: '_PUB',
1662: x_return_status);
1663: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1664: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1665: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1666: raise OKC_API.G_EXCEPTION_ERROR;
1667: END IF;
1668: -- Call user hook for BEFORE
1669: g_qppv_rec := p_qppv_rec;

Line 1666: raise OKC_API.G_EXCEPTION_ERROR;

1662: x_return_status);
1663: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1664: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1665: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1666: raise OKC_API.G_EXCEPTION_ERROR;
1667: END IF;
1668: -- Call user hook for BEFORE
1669: g_qppv_rec := p_qppv_rec;
1670: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1667: END IF;
1668: -- Call user hook for BEFORE
1669: g_qppv_rec := p_qppv_rec;
1670: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1671: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1672: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1673: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1674: raise OKC_API.G_EXCEPTION_ERROR;
1675: END IF;

Line 1672: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1668: -- Call user hook for BEFORE
1669: g_qppv_rec := p_qppv_rec;
1670: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1671: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1672: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1673: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1674: raise OKC_API.G_EXCEPTION_ERROR;
1675: END IF;
1676:

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

1669: g_qppv_rec := p_qppv_rec;
1670: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1671: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1672: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1673: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1674: raise OKC_API.G_EXCEPTION_ERROR;
1675: END IF;
1676:
1677: OKC_QA_CHECK_LIST_PVT.delete_qa_parm(

Line 1674: raise OKC_API.G_EXCEPTION_ERROR;

1670: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1671: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1672: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1673: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1674: raise OKC_API.G_EXCEPTION_ERROR;
1675: END IF;
1676:
1677: OKC_QA_CHECK_LIST_PVT.delete_qa_parm(
1678: p_api_version => p_api_version,

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

1681: x_msg_count => x_msg_count,
1682: x_msg_data => x_msg_data,
1683: p_qppv_rec => p_qppv_rec);
1684:
1685: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1686: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1687: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1688: raise OKC_API.G_EXCEPTION_ERROR;
1689: END IF;

Line 1686: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1682: x_msg_data => x_msg_data,
1683: p_qppv_rec => p_qppv_rec);
1684:
1685: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1686: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1687: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1688: raise OKC_API.G_EXCEPTION_ERROR;
1689: END IF;
1690:

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

1683: p_qppv_rec => p_qppv_rec);
1684:
1685: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1686: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1687: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1688: raise OKC_API.G_EXCEPTION_ERROR;
1689: END IF;
1690:
1691: -- Call user hook for AFTER

Line 1688: raise OKC_API.G_EXCEPTION_ERROR;

1684:
1685: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1686: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1687: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1688: raise OKC_API.G_EXCEPTION_ERROR;
1689: END IF;
1690:
1691: -- Call user hook for AFTER
1692: g_qppv_rec := l_qppv_rec;

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

1690:
1691: -- Call user hook for AFTER
1692: g_qppv_rec := l_qppv_rec;
1693: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1694: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1695: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1696: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1697: raise OKC_API.G_EXCEPTION_ERROR;
1698: END IF;

Line 1695: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1691: -- Call user hook for AFTER
1692: g_qppv_rec := l_qppv_rec;
1693: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1694: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1695: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1696: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1697: raise OKC_API.G_EXCEPTION_ERROR;
1698: END IF;
1699: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1692: g_qppv_rec := l_qppv_rec;
1693: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1694: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1695: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1696: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1697: raise OKC_API.G_EXCEPTION_ERROR;
1698: END IF;
1699: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1700: EXCEPTION

Line 1697: raise OKC_API.G_EXCEPTION_ERROR;

1693: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1694: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1695: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1696: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1697: raise OKC_API.G_EXCEPTION_ERROR;
1698: END IF;
1699: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1700: EXCEPTION
1701: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1695: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1696: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1697: raise OKC_API.G_EXCEPTION_ERROR;
1698: END IF;
1699: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1700: EXCEPTION
1701: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1702: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1703: (l_api_name

Line 1701: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1697: raise OKC_API.G_EXCEPTION_ERROR;
1698: END IF;
1699: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1700: EXCEPTION
1701: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1702: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1703: (l_api_name
1704: ,G_PKG_NAME
1705: ,'OKC_API.G_RET_STS_ERROR'

Line 1702: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1698: END IF;
1699: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1700: EXCEPTION
1701: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1702: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1703: (l_api_name
1704: ,G_PKG_NAME
1705: ,'OKC_API.G_RET_STS_ERROR'
1706: ,x_msg_count

Line 1705: ,'OKC_API.G_RET_STS_ERROR'

1701: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1702: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1703: (l_api_name
1704: ,G_PKG_NAME
1705: ,'OKC_API.G_RET_STS_ERROR'
1706: ,x_msg_count
1707: ,x_msg_data
1708: ,'_PUB');
1709: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1709: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1705: ,'OKC_API.G_RET_STS_ERROR'
1706: ,x_msg_count
1707: ,x_msg_data
1708: ,'_PUB');
1709: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1710: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1711: (l_api_name
1712: ,G_PKG_NAME
1713: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 1710: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1706: ,x_msg_count
1707: ,x_msg_data
1708: ,'_PUB');
1709: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1710: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1711: (l_api_name
1712: ,G_PKG_NAME
1713: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1714: ,x_msg_count

Line 1713: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

1709: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1710: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1711: (l_api_name
1712: ,G_PKG_NAME
1713: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1714: ,x_msg_count
1715: ,x_msg_data
1716: ,'_PUB');
1717: WHEN OTHERS THEN

Line 1718: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1714: ,x_msg_count
1715: ,x_msg_data
1716: ,'_PUB');
1717: WHEN OTHERS THEN
1718: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1719: (l_api_name
1720: ,G_PKG_NAME
1721: ,'OTHERS'
1722: ,x_msg_count

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

1734: x_msg_count OUT NOCOPY NUMBER,
1735: x_msg_data OUT NOCOPY VARCHAR2,
1736: p_qppv_tbl IN qppv_tbl_type) IS
1737: i NUMBER := 0;
1738: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1739: BEGIN
1740: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1741: IF p_qppv_tbl.COUNT > 0 THEN
1742: i := p_qppv_tbl.FIRST;

Line 1740: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1736: p_qppv_tbl IN qppv_tbl_type) IS
1737: i NUMBER := 0;
1738: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1739: BEGIN
1740: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1741: IF p_qppv_tbl.COUNT > 0 THEN
1742: i := p_qppv_tbl.FIRST;
1743: LOOP
1744: delete_qa_parm(

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

1747: x_return_status => l_return_status,
1748: x_msg_count => x_msg_count,
1749: x_msg_data => x_msg_data,
1750: p_qppv_rec => p_qppv_tbl(i));
1751: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1752: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1753: x_return_status := l_return_status;
1754: raise G_EXCEPTION_HALT_VALIDATION;
1755: ELSE

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

1748: x_msg_count => x_msg_count,
1749: x_msg_data => x_msg_data,
1750: p_qppv_rec => p_qppv_tbl(i));
1751: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1752: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1753: x_return_status := l_return_status;
1754: raise G_EXCEPTION_HALT_VALIDATION;
1755: ELSE
1756: x_return_status := l_return_status;

Line 1768: OKC_API.SET_MESSAGE(

1764: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1765: NULL;
1766: WHEN OTHERS THEN
1767: -- store SQL error message on message stack
1768: OKC_API.SET_MESSAGE(
1769: p_app_name => G_APP_NAME,
1770: p_msg_name => G_UNEXPECTED_ERROR,
1771: p_token1 => G_SQLCODE_TOKEN,
1772: p_token1_value => SQLCODE,

Line 1776: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1772: p_token1_value => SQLCODE,
1773: p_token2 => G_SQLERRM_TOKEN,
1774: p_token2_value => SQLERRM);
1775: -- notify caller of an error as UNEXPETED error
1776: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1777: END delete_qa_parm;
1778:
1779: --------------------------------------
1780: -- PROCEDURE lock_qa_parm

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

1806: x_msg_count OUT NOCOPY NUMBER,
1807: x_msg_data OUT NOCOPY VARCHAR2,
1808: p_qppv_tbl IN qppv_tbl_type) IS
1809: i NUMBER := 0;
1810: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1811: BEGIN
1812: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1813: IF p_qppv_tbl.COUNT > 0 THEN
1814: i := p_qppv_tbl.FIRST;

Line 1812: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1808: p_qppv_tbl IN qppv_tbl_type) IS
1809: i NUMBER := 0;
1810: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1811: BEGIN
1812: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1813: IF p_qppv_tbl.COUNT > 0 THEN
1814: i := p_qppv_tbl.FIRST;
1815: LOOP
1816: lock_qa_parm(

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

1819: x_return_status => l_return_status,
1820: x_msg_count => x_msg_count,
1821: x_msg_data => x_msg_data,
1822: p_qppv_rec => p_qppv_tbl(i));
1823: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1824: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1825: x_return_status := l_return_status;
1826: raise G_EXCEPTION_HALT_VALIDATION;
1827: ELSE

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

1820: x_msg_count => x_msg_count,
1821: x_msg_data => x_msg_data,
1822: p_qppv_rec => p_qppv_tbl(i));
1823: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1824: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1825: x_return_status := l_return_status;
1826: raise G_EXCEPTION_HALT_VALIDATION;
1827: ELSE
1828: x_return_status := l_return_status;

Line 1840: OKC_API.SET_MESSAGE(

1836: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1837: NULL;
1838: WHEN OTHERS THEN
1839: -- store SQL error message on message stack
1840: OKC_API.SET_MESSAGE(
1841: p_app_name => G_APP_NAME,
1842: p_msg_name => G_UNEXPECTED_ERROR,
1843: p_token1 => G_SQLCODE_TOKEN,
1844: p_token1_value => SQLCODE,

Line 1848: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1844: p_token1_value => SQLCODE,
1845: p_token2 => G_SQLERRM_TOKEN,
1846: p_token2_value => SQLERRM);
1847: -- notify caller of an error as UNEXPETED error
1848: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1849: END lock_qa_parm;
1850:
1851: --------------------------------------
1852: -- PROCEDURE validate_qa_parm

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

1857: x_return_status OUT NOCOPY VARCHAR2,
1858: x_msg_count OUT NOCOPY NUMBER,
1859: x_msg_data OUT NOCOPY VARCHAR2,
1860: p_qppv_rec IN qppv_rec_type) IS
1861: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1862: l_api_name CONSTANT VARCHAR2(30) := 'validate_qa_parm';
1863: l_qppv_rec qppv_rec_type := p_qppv_rec;
1864: BEGIN
1865: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1861: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1862: l_api_name CONSTANT VARCHAR2(30) := 'validate_qa_parm';
1863: l_qppv_rec qppv_rec_type := p_qppv_rec;
1864: BEGIN
1865: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1866: p_init_msg_list,
1867: '_PUB',
1868: x_return_status);
1869: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN

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

1865: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1866: p_init_msg_list,
1867: '_PUB',
1868: x_return_status);
1869: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1870: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1871: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1872: raise OKC_API.G_EXCEPTION_ERROR;
1873: END IF;

Line 1870: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1866: p_init_msg_list,
1867: '_PUB',
1868: x_return_status);
1869: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1870: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1871: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1872: raise OKC_API.G_EXCEPTION_ERROR;
1873: END IF;
1874: -- Call user hook for BEFORE

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

1867: '_PUB',
1868: x_return_status);
1869: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1870: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1871: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1872: raise OKC_API.G_EXCEPTION_ERROR;
1873: END IF;
1874: -- Call user hook for BEFORE
1875: g_qppv_rec := p_qppv_rec;

Line 1872: raise OKC_API.G_EXCEPTION_ERROR;

1868: x_return_status);
1869: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1870: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1871: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1872: raise OKC_API.G_EXCEPTION_ERROR;
1873: END IF;
1874: -- Call user hook for BEFORE
1875: g_qppv_rec := p_qppv_rec;
1876: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');

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

1873: END IF;
1874: -- Call user hook for BEFORE
1875: g_qppv_rec := p_qppv_rec;
1876: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1877: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1878: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1879: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1880: raise OKC_API.G_EXCEPTION_ERROR;
1881: END IF;

Line 1878: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1874: -- Call user hook for BEFORE
1875: g_qppv_rec := p_qppv_rec;
1876: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1877: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1878: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1879: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1880: raise OKC_API.G_EXCEPTION_ERROR;
1881: END IF;
1882:

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

1875: g_qppv_rec := p_qppv_rec;
1876: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1877: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1878: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1879: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1880: raise OKC_API.G_EXCEPTION_ERROR;
1881: END IF;
1882:
1883: OKC_QA_CHECK_LIST_PVT.validate_qa_parm(

Line 1880: raise OKC_API.G_EXCEPTION_ERROR;

1876: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1877: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1878: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1879: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1880: raise OKC_API.G_EXCEPTION_ERROR;
1881: END IF;
1882:
1883: OKC_QA_CHECK_LIST_PVT.validate_qa_parm(
1884: p_api_version => p_api_version,

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

1887: x_msg_count => x_msg_count,
1888: x_msg_data => x_msg_data,
1889: p_qppv_rec => p_qppv_rec);
1890:
1891: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1892: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1893: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1894: raise OKC_API.G_EXCEPTION_ERROR;
1895: END IF;

Line 1892: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1888: x_msg_data => x_msg_data,
1889: p_qppv_rec => p_qppv_rec);
1890:
1891: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1892: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1893: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1894: raise OKC_API.G_EXCEPTION_ERROR;
1895: END IF;
1896:

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

1889: p_qppv_rec => p_qppv_rec);
1890:
1891: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1892: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1893: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1894: raise OKC_API.G_EXCEPTION_ERROR;
1895: END IF;
1896:
1897: -- Call user hook for AFTER

Line 1894: raise OKC_API.G_EXCEPTION_ERROR;

1890:
1891: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1892: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1893: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1894: raise OKC_API.G_EXCEPTION_ERROR;
1895: END IF;
1896:
1897: -- Call user hook for AFTER
1898: g_qppv_rec := l_qppv_rec;

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

1896:
1897: -- Call user hook for AFTER
1898: g_qppv_rec := l_qppv_rec;
1899: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1900: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1901: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1902: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1903: raise OKC_API.G_EXCEPTION_ERROR;
1904: END IF;

Line 1901: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1897: -- Call user hook for AFTER
1898: g_qppv_rec := l_qppv_rec;
1899: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1900: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1901: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1902: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1903: raise OKC_API.G_EXCEPTION_ERROR;
1904: END IF;
1905: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1898: g_qppv_rec := l_qppv_rec;
1899: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1900: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1901: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1902: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1903: raise OKC_API.G_EXCEPTION_ERROR;
1904: END IF;
1905: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1906: EXCEPTION

Line 1903: raise OKC_API.G_EXCEPTION_ERROR;

1899: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1900: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1901: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1902: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1903: raise OKC_API.G_EXCEPTION_ERROR;
1904: END IF;
1905: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1906: EXCEPTION
1907: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1901: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1902: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1903: raise OKC_API.G_EXCEPTION_ERROR;
1904: END IF;
1905: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1906: EXCEPTION
1907: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1908: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1909: (l_api_name

Line 1907: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1903: raise OKC_API.G_EXCEPTION_ERROR;
1904: END IF;
1905: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1906: EXCEPTION
1907: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1908: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1909: (l_api_name
1910: ,G_PKG_NAME
1911: ,'OKC_API.G_RET_STS_ERROR'

Line 1908: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1904: END IF;
1905: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1906: EXCEPTION
1907: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1908: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1909: (l_api_name
1910: ,G_PKG_NAME
1911: ,'OKC_API.G_RET_STS_ERROR'
1912: ,x_msg_count

Line 1911: ,'OKC_API.G_RET_STS_ERROR'

1907: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1908: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1909: (l_api_name
1910: ,G_PKG_NAME
1911: ,'OKC_API.G_RET_STS_ERROR'
1912: ,x_msg_count
1913: ,x_msg_data
1914: ,'_PUB');
1915: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

Line 1915: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1911: ,'OKC_API.G_RET_STS_ERROR'
1912: ,x_msg_count
1913: ,x_msg_data
1914: ,'_PUB');
1915: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1916: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1917: (l_api_name
1918: ,G_PKG_NAME
1919: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

Line 1916: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1912: ,x_msg_count
1913: ,x_msg_data
1914: ,'_PUB');
1915: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1916: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1917: (l_api_name
1918: ,G_PKG_NAME
1919: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1920: ,x_msg_count

Line 1919: ,'OKC_API.G_RET_STS_UNEXP_ERROR'

1915: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1916: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1917: (l_api_name
1918: ,G_PKG_NAME
1919: ,'OKC_API.G_RET_STS_UNEXP_ERROR'
1920: ,x_msg_count
1921: ,x_msg_data
1922: ,'_PUB');
1923: WHEN OTHERS THEN

Line 1924: x_return_status :=OKC_API.HANDLE_EXCEPTIONS

1920: ,x_msg_count
1921: ,x_msg_data
1922: ,'_PUB');
1923: WHEN OTHERS THEN
1924: x_return_status :=OKC_API.HANDLE_EXCEPTIONS
1925: (l_api_name
1926: ,G_PKG_NAME
1927: ,'OTHERS'
1928: ,x_msg_count

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

1940: x_msg_count OUT NOCOPY NUMBER,
1941: x_msg_data OUT NOCOPY VARCHAR2,
1942: p_qppv_tbl IN qppv_tbl_type) IS
1943: i NUMBER := 0;
1944: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1945: BEGIN
1946: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1947: IF p_qppv_tbl.COUNT > 0 THEN
1948: i := p_qppv_tbl.FIRST;

Line 1946: x_return_status := OKC_API.G_RET_STS_SUCCESS;

1942: p_qppv_tbl IN qppv_tbl_type) IS
1943: i NUMBER := 0;
1944: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1945: BEGIN
1946: x_return_status := OKC_API.G_RET_STS_SUCCESS;
1947: IF p_qppv_tbl.COUNT > 0 THEN
1948: i := p_qppv_tbl.FIRST;
1949: LOOP
1950: validate_qa_parm(

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

1953: x_return_status => l_return_status,
1954: x_msg_count => x_msg_count,
1955: x_msg_data => x_msg_data,
1956: p_qppv_rec => p_qppv_tbl(i));
1957: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1958: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1959: x_return_status := l_return_status;
1960: raise G_EXCEPTION_HALT_VALIDATION;
1961: ELSE

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

1954: x_msg_count => x_msg_count,
1955: x_msg_data => x_msg_data,
1956: p_qppv_rec => p_qppv_tbl(i));
1957: IF (l_return_status <> OKC_API.G_RET_STS_SUCCESS) THEN
1958: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1959: x_return_status := l_return_status;
1960: raise G_EXCEPTION_HALT_VALIDATION;
1961: ELSE
1962: x_return_status := l_return_status;

Line 1974: OKC_API.SET_MESSAGE(

1970: WHEN G_EXCEPTION_HALT_VALIDATION THEN
1971: NULL;
1972: WHEN OTHERS THEN
1973: -- store SQL error message on message stack
1974: OKC_API.SET_MESSAGE(
1975: p_app_name => G_APP_NAME,
1976: p_msg_name => G_UNEXPECTED_ERROR,
1977: p_token1 => G_SQLCODE_TOKEN,
1978: p_token1_value => SQLCODE,

Line 1982: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;

1978: p_token1_value => SQLCODE,
1979: p_token2 => G_SQLERRM_TOKEN,
1980: p_token2_value => SQLERRM);
1981: -- notify caller of an error as UNEXPETED error
1982: x_return_status := OKC_API.G_RET_STS_UNEXP_ERROR;
1983: END validate_qa_parm;
1984:
1985: --------------------------------------
1986: -- PROCEDURE add_language