APPS.OKS_REP_PUB dependencies on OKC_API

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

50: p_repv_rec IN repv_rec_type) IS
51:
52: l_api_version CONSTANT NUMBER := 1;
53: l_api_name CONSTANT VARCHAR2(30) := 'V_validate_row';
54: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
55: l_repv_rec repv_rec_type := p_repv_rec;
56: l_rep_rec rep_rec_type;
57:
58: BEGIN

Line 59: l_return_status := OKC_API.START_ACTIVITY

55: l_repv_rec repv_rec_type := p_repv_rec;
56: l_rep_rec rep_rec_type;
57:
58: BEGIN
59: l_return_status := OKC_API.START_ACTIVITY
60: ( l_api_name
61: ,p_init_msg_list
62: ,'_PUB'
63: ,x_return_status

Line 66: If l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then

62: ,'_PUB'
63: ,x_return_status
64: );
65:
66: If l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
67: Raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
68: ElsIf l_return_status = OKC_API.G_RET_STS_ERROR Then
69: Raise OKC_API.G_EXCEPTION_ERROR;
70: End If;

Line 67: Raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

63: ,x_return_status
64: );
65:
66: If l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
67: Raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
68: ElsIf l_return_status = OKC_API.G_RET_STS_ERROR Then
69: Raise OKC_API.G_EXCEPTION_ERROR;
70: End If;
71:

Line 68: ElsIf l_return_status = OKC_API.G_RET_STS_ERROR Then

64: );
65:
66: If l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
67: Raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
68: ElsIf l_return_status = OKC_API.G_RET_STS_ERROR Then
69: Raise OKC_API.G_EXCEPTION_ERROR;
70: End If;
71:
72: g_repv_rec := p_repv_rec;

Line 69: Raise OKC_API.G_EXCEPTION_ERROR;

65:
66: If l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR Then
67: Raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
68: ElsIf l_return_status = OKC_API.G_RET_STS_ERROR Then
69: Raise OKC_API.G_EXCEPTION_ERROR;
70: End If;
71:
72: g_repv_rec := p_repv_rec;
73:

Line 82: If (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) Then

78: p_procedure_name => l_api_name,
79: p_before_after => 'B'
80: );
81:
82: If (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) Then
83: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
84: ElsIf (x_return_status = OKC_API.G_RET_STS_ERROR) Then
85: raise OKC_API.G_EXCEPTION_ERROR;
86: End If;

Line 83: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

79: p_before_after => 'B'
80: );
81:
82: If (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) Then
83: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
84: ElsIf (x_return_status = OKC_API.G_RET_STS_ERROR) Then
85: raise OKC_API.G_EXCEPTION_ERROR;
86: End If;
87:

Line 84: ElsIf (x_return_status = OKC_API.G_RET_STS_ERROR) Then

80: );
81:
82: If (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) Then
83: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
84: ElsIf (x_return_status = OKC_API.G_RET_STS_ERROR) Then
85: raise OKC_API.G_EXCEPTION_ERROR;
86: End If;
87:
88: OKS_REP_PVT.validate_row(

Line 85: raise OKC_API.G_EXCEPTION_ERROR;

81:
82: If (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) Then
83: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
84: ElsIf (x_return_status = OKC_API.G_RET_STS_ERROR) Then
85: raise OKC_API.G_EXCEPTION_ERROR;
86: End If;
87:
88: OKS_REP_PVT.validate_row(
89: p_api_version ,

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

93: x_msg_data,
94: g_repv_rec
95: );
96:
97: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
98: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
99: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
100: RAISE OKC_API.G_EXCEPTION_ERROR;
101: END IF;

Line 98: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

94: g_repv_rec
95: );
96:
97: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
98: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
99: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
100: RAISE OKC_API.G_EXCEPTION_ERROR;
101: END IF;
102: --

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

95: );
96:
97: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
98: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
99: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
100: RAISE OKC_API.G_EXCEPTION_ERROR;
101: END IF;
102: --
103: -- Call After Logic Hook

Line 100: RAISE OKC_API.G_EXCEPTION_ERROR;

96:
97: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
98: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
99: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
100: RAISE OKC_API.G_EXCEPTION_ERROR;
101: END IF;
102: --
103: -- Call After Logic Hook
104: --

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

102: --
103: -- Call After Logic Hook
104: --
105: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
106: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
107: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
108: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
109: raise OKC_API.G_EXCEPTION_ERROR;
110: END IF;

Line 107: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

103: -- Call After Logic Hook
104: --
105: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
106: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
107: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
108: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
109: raise OKC_API.G_EXCEPTION_ERROR;
110: END IF;
111: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

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

Line 109: raise OKC_API.G_EXCEPTION_ERROR;

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

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

107: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
108: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
109: raise OKC_API.G_EXCEPTION_ERROR;
110: END IF;
111: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
112: EXCEPTION
113: WHEN OKC_API.G_EXCEPTION_ERROR THEN
114: x_return_status := OKC_API.HANDLE_EXCEPTIONS
115: (substr(l_api_name,1,26),

Line 113: WHEN OKC_API.G_EXCEPTION_ERROR THEN

109: raise OKC_API.G_EXCEPTION_ERROR;
110: END IF;
111: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
112: EXCEPTION
113: WHEN OKC_API.G_EXCEPTION_ERROR THEN
114: x_return_status := OKC_API.HANDLE_EXCEPTIONS
115: (substr(l_api_name,1,26),
116: G_PKG_NAME,
117: 'OKC_API.G_RET_STS_ERROR',

Line 114: x_return_status := OKC_API.HANDLE_EXCEPTIONS

110: END IF;
111: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
112: EXCEPTION
113: WHEN OKC_API.G_EXCEPTION_ERROR THEN
114: x_return_status := OKC_API.HANDLE_EXCEPTIONS
115: (substr(l_api_name,1,26),
116: G_PKG_NAME,
117: 'OKC_API.G_RET_STS_ERROR',
118: x_msg_count,

Line 117: 'OKC_API.G_RET_STS_ERROR',

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

Line 121: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

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

Line 122: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 125: 'OKC_API.G_RET_STS_UNEXP_ERROR',

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

Line 130: x_return_status := OKC_API.HANDLE_EXCEPTIONS

126: x_msg_count,
127: x_msg_data,
128: '_PUB');
129: WHEN OTHERS THEN
130: x_return_status := OKC_API.HANDLE_EXCEPTIONS
131: (substr(l_api_name,1,26),
132: G_PKG_NAME,
133: 'OTHERS',
134: x_msg_count,

Line 149: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS

145: x_return_status OUT NOCOPY VARCHAR2,
146: x_msg_count OUT NOCOPY NUMBER,
147: x_msg_data OUT NOCOPY VARCHAR2,
148: p_repv_tbl IN repv_tbl_type,
149: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
150:
151: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
152: l_api_version CONSTANT NUMBER := 1;
153: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_validate_row';

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

147: x_msg_data OUT NOCOPY VARCHAR2,
148: p_repv_tbl IN repv_tbl_type,
149: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
150:
151: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
152: l_api_version CONSTANT NUMBER := 1;
153: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_validate_row';
154:
155: BEGIN

Line 156: l_return_status := OKC_API.START_ACTIVITY(substr(l_api_name,1,26),

152: l_api_version CONSTANT NUMBER := 1;
153: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_validate_row';
154:
155: BEGIN
156: l_return_status := OKC_API.START_ACTIVITY(substr(l_api_name,1,26),
157: G_PKG_NAME,
158: p_init_msg_list,
159: l_api_version,
160: p_api_version,

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

159: l_api_version,
160: p_api_version,
161: '_PUB',
162: x_return_status);
163: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
164: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
165: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
166: RAISE OKC_API.G_EXCEPTION_ERROR;
167: END IF;

Line 164: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

160: p_api_version,
161: '_PUB',
162: x_return_status);
163: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
164: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
165: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
166: RAISE OKC_API.G_EXCEPTION_ERROR;
167: END IF;
168: --

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

161: '_PUB',
162: x_return_status);
163: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
164: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
165: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
166: RAISE OKC_API.G_EXCEPTION_ERROR;
167: END IF;
168: --
169: -- Call Before Logic Hook

Line 166: RAISE OKC_API.G_EXCEPTION_ERROR;

162: x_return_status);
163: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
164: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
165: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
166: RAISE OKC_API.G_EXCEPTION_ERROR;
167: END IF;
168: --
169: -- Call Before Logic Hook
170: --

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

170: --
171: g_repv_tbl := p_repv_tbl;
172: gx_error_tbl := px_error_tbl;
173: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
174: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
175: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
176: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
177: raise OKC_API.G_EXCEPTION_ERROR;
178: END IF;

Line 175: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

171: g_repv_tbl := p_repv_tbl;
172: gx_error_tbl := px_error_tbl;
173: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
174: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
175: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
176: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
177: raise OKC_API.G_EXCEPTION_ERROR;
178: END IF;
179:

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

172: gx_error_tbl := px_error_tbl;
173: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
174: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
175: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
176: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
177: raise OKC_API.G_EXCEPTION_ERROR;
178: END IF;
179:
180: oks_rep_pvt.validate_row(

Line 177: raise OKC_API.G_EXCEPTION_ERROR;

173: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
174: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
175: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
176: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
177: raise OKC_API.G_EXCEPTION_ERROR;
178: END IF;
179:
180: oks_rep_pvt.validate_row(
181: p_api_version ,

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

185: x_msg_data ,
186: g_repv_tbl,
187: gx_error_tbl);
188:
189: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
190: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
191: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
192: RAISE OKC_API.G_EXCEPTION_ERROR;
193: END IF;

Line 190: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

186: g_repv_tbl,
187: gx_error_tbl);
188:
189: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
190: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
191: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
192: RAISE OKC_API.G_EXCEPTION_ERROR;
193: END IF;
194: --

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

187: gx_error_tbl);
188:
189: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
190: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
191: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
192: RAISE OKC_API.G_EXCEPTION_ERROR;
193: END IF;
194: --
195: -- Call After Logic Hook

Line 192: RAISE OKC_API.G_EXCEPTION_ERROR;

188:
189: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
190: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
191: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
192: RAISE OKC_API.G_EXCEPTION_ERROR;
193: END IF;
194: --
195: -- Call After Logic Hook
196: --

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

194: --
195: -- Call After Logic Hook
196: --
197: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
198: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
199: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
200: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
201: raise OKC_API.G_EXCEPTION_ERROR;
202: END IF;

Line 199: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

195: -- Call After Logic Hook
196: --
197: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
198: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
199: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
200: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
201: raise OKC_API.G_EXCEPTION_ERROR;
202: END IF;
203:

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

196: --
197: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
198: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
199: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
200: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
201: raise OKC_API.G_EXCEPTION_ERROR;
202: END IF;
203:
204: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

Line 201: raise OKC_API.G_EXCEPTION_ERROR;

197: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
198: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
199: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
200: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
201: raise OKC_API.G_EXCEPTION_ERROR;
202: END IF;
203:
204: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
205:

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

200: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
201: raise OKC_API.G_EXCEPTION_ERROR;
202: END IF;
203:
204: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
205:
206: EXCEPTION
207: WHEN OKC_API.G_EXCEPTION_ERROR THEN
208: x_return_status := OKC_API.HANDLE_EXCEPTIONS

Line 207: WHEN OKC_API.G_EXCEPTION_ERROR THEN

203:
204: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
205:
206: EXCEPTION
207: WHEN OKC_API.G_EXCEPTION_ERROR THEN
208: x_return_status := OKC_API.HANDLE_EXCEPTIONS
209: (
210: l_api_name,
211: G_PKG_NAME,

Line 208: x_return_status := OKC_API.HANDLE_EXCEPTIONS

204: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
205:
206: EXCEPTION
207: WHEN OKC_API.G_EXCEPTION_ERROR THEN
208: x_return_status := OKC_API.HANDLE_EXCEPTIONS
209: (
210: l_api_name,
211: G_PKG_NAME,
212: 'OKC_API.G_RET_STS_ERROR',

Line 212: 'OKC_API.G_RET_STS_ERROR',

208: x_return_status := OKC_API.HANDLE_EXCEPTIONS
209: (
210: l_api_name,
211: G_PKG_NAME,
212: 'OKC_API.G_RET_STS_ERROR',
213: x_msg_count,
214: x_msg_data,
215: '_PUB'
216: );

Line 217: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

213: x_msg_count,
214: x_msg_data,
215: '_PUB'
216: );
217: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
218: x_return_status := OKC_API.HANDLE_EXCEPTIONS
219: (
220: l_api_name,
221: G_PKG_NAME,

Line 218: x_return_status := OKC_API.HANDLE_EXCEPTIONS

214: x_msg_data,
215: '_PUB'
216: );
217: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
218: x_return_status := OKC_API.HANDLE_EXCEPTIONS
219: (
220: l_api_name,
221: G_PKG_NAME,
222: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 222: 'OKC_API.G_RET_STS_UNEXP_ERROR',

218: x_return_status := OKC_API.HANDLE_EXCEPTIONS
219: (
220: l_api_name,
221: G_PKG_NAME,
222: 'OKC_API.G_RET_STS_UNEXP_ERROR',
223: x_msg_count,
224: x_msg_data,
225: '_PUB'
226: );

Line 228: x_return_status := OKC_API.HANDLE_EXCEPTIONS

224: x_msg_data,
225: '_PUB'
226: );
227: WHEN OTHERS THEN
228: x_return_status := OKC_API.HANDLE_EXCEPTIONS
229: (
230: l_api_name,
231: G_PKG_NAME,
232: 'OTHERS',

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

248: p_repv_tbl IN repv_tbl_type) IS
249:
250: l_api_version CONSTANT NUMBER := 1;
251: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_validate_row';
252: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
253: l_error_tbl OKC_API.ERROR_TBL_TYPE;
254: BEGIN
255: l_return_status := OKC_API.START_ACTIVITY(substr(l_api_name,1,26),
256: G_PKG_NAME,

Line 253: l_error_tbl OKC_API.ERROR_TBL_TYPE;

249:
250: l_api_version CONSTANT NUMBER := 1;
251: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_validate_row';
252: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
253: l_error_tbl OKC_API.ERROR_TBL_TYPE;
254: BEGIN
255: l_return_status := OKC_API.START_ACTIVITY(substr(l_api_name,1,26),
256: G_PKG_NAME,
257: p_init_msg_list,

Line 255: l_return_status := OKC_API.START_ACTIVITY(substr(l_api_name,1,26),

251: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_validate_row';
252: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
253: l_error_tbl OKC_API.ERROR_TBL_TYPE;
254: BEGIN
255: l_return_status := OKC_API.START_ACTIVITY(substr(l_api_name,1,26),
256: G_PKG_NAME,
257: p_init_msg_list,
258: l_api_version,
259: p_api_version,

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

258: l_api_version,
259: p_api_version,
260: '_PUB',
261: x_return_status);
262: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
263: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
264: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
265: RAISE OKC_API.G_EXCEPTION_ERROR;
266: END IF;

Line 263: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

259: p_api_version,
260: '_PUB',
261: x_return_status);
262: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
263: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
264: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
265: RAISE OKC_API.G_EXCEPTION_ERROR;
266: END IF;
267: --

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

260: '_PUB',
261: x_return_status);
262: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
263: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
264: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
265: RAISE OKC_API.G_EXCEPTION_ERROR;
266: END IF;
267: --
268: -- Call Before Logic Hook

Line 265: RAISE OKC_API.G_EXCEPTION_ERROR;

261: x_return_status);
262: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
263: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
264: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
265: RAISE OKC_API.G_EXCEPTION_ERROR;
266: END IF;
267: --
268: -- Call Before Logic Hook
269: --

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

269: --
270: g_repv_tbl := p_repv_tbl;
271:
272: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
273: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
274: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
275: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
276: raise OKC_API.G_EXCEPTION_ERROR;
277: END IF;

Line 274: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

270: g_repv_tbl := p_repv_tbl;
271:
272: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
273: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
274: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
275: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
276: raise OKC_API.G_EXCEPTION_ERROR;
277: END IF;
278:

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

271:
272: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
273: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
274: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
275: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
276: raise OKC_API.G_EXCEPTION_ERROR;
277: END IF;
278:
279: oks_rep_pvt.validate_row(

Line 276: raise OKC_API.G_EXCEPTION_ERROR;

272: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
273: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
274: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
275: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
276: raise OKC_API.G_EXCEPTION_ERROR;
277: END IF;
278:
279: oks_rep_pvt.validate_row(
280: p_api_version ,

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

284: x_msg_data ,
285: g_repv_tbl
286: );
287:
288: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
289: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
290: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
291: RAISE OKC_API.G_EXCEPTION_ERROR;
292: END IF;

Line 289: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

285: g_repv_tbl
286: );
287:
288: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
289: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
290: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
291: RAISE OKC_API.G_EXCEPTION_ERROR;
292: END IF;
293: --

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

286: );
287:
288: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
289: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
290: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
291: RAISE OKC_API.G_EXCEPTION_ERROR;
292: END IF;
293: --
294: -- Call After Logic Hook

Line 291: RAISE OKC_API.G_EXCEPTION_ERROR;

287:
288: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
289: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
290: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
291: RAISE OKC_API.G_EXCEPTION_ERROR;
292: END IF;
293: --
294: -- Call After Logic Hook
295: --

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

293: --
294: -- Call After Logic Hook
295: --
296: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
297: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
298: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
299: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
300: raise OKC_API.G_EXCEPTION_ERROR;
301: END IF;

Line 298: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

294: -- Call After Logic Hook
295: --
296: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
297: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
298: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
299: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
300: raise OKC_API.G_EXCEPTION_ERROR;
301: END IF;
302: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

295: --
296: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
297: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
298: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
299: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
300: raise OKC_API.G_EXCEPTION_ERROR;
301: END IF;
302: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
303: EXCEPTION

Line 300: raise OKC_API.G_EXCEPTION_ERROR;

296: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
297: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
298: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
299: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
300: raise OKC_API.G_EXCEPTION_ERROR;
301: END IF;
302: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
303: EXCEPTION
304: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

298: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
299: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
300: raise OKC_API.G_EXCEPTION_ERROR;
301: END IF;
302: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
303: EXCEPTION
304: WHEN OKC_API.G_EXCEPTION_ERROR THEN
305: x_return_status := OKC_API.HANDLE_EXCEPTIONS
306: (

Line 304: WHEN OKC_API.G_EXCEPTION_ERROR THEN

300: raise OKC_API.G_EXCEPTION_ERROR;
301: END IF;
302: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
303: EXCEPTION
304: WHEN OKC_API.G_EXCEPTION_ERROR THEN
305: x_return_status := OKC_API.HANDLE_EXCEPTIONS
306: (
307: l_api_name,
308: G_PKG_NAME,

Line 305: x_return_status := OKC_API.HANDLE_EXCEPTIONS

301: END IF;
302: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
303: EXCEPTION
304: WHEN OKC_API.G_EXCEPTION_ERROR THEN
305: x_return_status := OKC_API.HANDLE_EXCEPTIONS
306: (
307: l_api_name,
308: G_PKG_NAME,
309: 'OKC_API.G_RET_STS_ERROR',

Line 309: 'OKC_API.G_RET_STS_ERROR',

305: x_return_status := OKC_API.HANDLE_EXCEPTIONS
306: (
307: l_api_name,
308: G_PKG_NAME,
309: 'OKC_API.G_RET_STS_ERROR',
310: x_msg_count,
311: x_msg_data,
312: '_PUB'
313: );

Line 314: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

310: x_msg_count,
311: x_msg_data,
312: '_PUB'
313: );
314: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
315: x_return_status := OKC_API.HANDLE_EXCEPTIONS
316: (
317: l_api_name,
318: G_PKG_NAME,

Line 315: x_return_status := OKC_API.HANDLE_EXCEPTIONS

311: x_msg_data,
312: '_PUB'
313: );
314: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
315: x_return_status := OKC_API.HANDLE_EXCEPTIONS
316: (
317: l_api_name,
318: G_PKG_NAME,
319: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 319: 'OKC_API.G_RET_STS_UNEXP_ERROR',

315: x_return_status := OKC_API.HANDLE_EXCEPTIONS
316: (
317: l_api_name,
318: G_PKG_NAME,
319: 'OKC_API.G_RET_STS_UNEXP_ERROR',
320: x_msg_count,
321: x_msg_data,
322: '_PUB'
323: );

Line 325: x_return_status := OKC_API.HANDLE_EXCEPTIONS

321: x_msg_data,
322: '_PUB'
323: );
324: WHEN OTHERS THEN
325: x_return_status := OKC_API.HANDLE_EXCEPTIONS
326: (
327: l_api_name,
328: G_PKG_NAME,
329: 'OTHERS',

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

347: x_repv_rec OUT NOCOPY repv_rec_type) IS
348:
349: l_api_version CONSTANT NUMBER := 1;
350: l_api_name CONSTANT VARCHAR2(30) := 'V_insert_row';
351: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
352: l_repv_rec repv_rec_type := p_repv_rec;
353: l_def_repv_rec repv_rec_type;
354: l_rep_rec rep_rec_type;
355: lx_rep_rec rep_rec_type;

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

354: l_rep_rec rep_rec_type;
355: lx_rep_rec rep_rec_type;
356:
357: BEGIN
358: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
359: G_PKG_NAME,
360: p_init_msg_list,
361: l_api_version,
362: p_api_version,

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

361: l_api_version,
362: p_api_version,
363: '_PUB',
364: x_return_status);
365: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
366: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
367: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
368: RAISE OKC_API.G_EXCEPTION_ERROR;
369: END IF;

Line 366: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

362: p_api_version,
363: '_PUB',
364: x_return_status);
365: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
366: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
367: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
368: RAISE OKC_API.G_EXCEPTION_ERROR;
369: END IF;
370: --

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

363: '_PUB',
364: x_return_status);
365: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
366: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
367: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
368: RAISE OKC_API.G_EXCEPTION_ERROR;
369: END IF;
370: --
371: -- Call Before Logic Hook

Line 368: RAISE OKC_API.G_EXCEPTION_ERROR;

364: x_return_status);
365: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
366: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
367: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
368: RAISE OKC_API.G_EXCEPTION_ERROR;
369: END IF;
370: --
371: -- Call Before Logic Hook
372: --

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

372: --
373: g_repv_rec := p_repv_rec;
374:
375: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
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: g_repv_rec := p_repv_rec;
374:
375: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
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:

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

374:
375: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
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:
382: oks_rep_pvt.insert_row(

Line 379: raise OKC_API.G_EXCEPTION_ERROR;

375: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
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:
382: oks_rep_pvt.insert_row(
383: p_api_version ,

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

388: g_repv_rec,
389: x_repv_rec
390: );
391:
392: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
393: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
394: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
395: RAISE OKC_API.G_EXCEPTION_ERROR;
396: END IF;

Line 393: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

389: x_repv_rec
390: );
391:
392: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
393: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
394: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
395: RAISE OKC_API.G_EXCEPTION_ERROR;
396: END IF;
397: --

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

390: );
391:
392: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
393: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
394: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
395: RAISE OKC_API.G_EXCEPTION_ERROR;
396: END IF;
397: --
398: -- Call After Logic Hook

Line 395: RAISE OKC_API.G_EXCEPTION_ERROR;

391:
392: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
393: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
394: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
395: RAISE OKC_API.G_EXCEPTION_ERROR;
396: END IF;
397: --
398: -- Call After Logic Hook
399: --

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

397: --
398: -- Call After Logic Hook
399: --
400: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
401: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
402: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
403: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
404: raise OKC_API.G_EXCEPTION_ERROR;
405: END IF;

Line 402: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

398: -- Call After Logic Hook
399: --
400: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
401: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
402: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
403: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
404: raise OKC_API.G_EXCEPTION_ERROR;
405: END IF;
406: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

399: --
400: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
401: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
402: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
403: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
404: raise OKC_API.G_EXCEPTION_ERROR;
405: END IF;
406: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
407: EXCEPTION

Line 404: raise OKC_API.G_EXCEPTION_ERROR;

400: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
401: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
402: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
403: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
404: raise OKC_API.G_EXCEPTION_ERROR;
405: END IF;
406: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
407: EXCEPTION
408: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

402: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
403: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
404: raise OKC_API.G_EXCEPTION_ERROR;
405: END IF;
406: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
407: EXCEPTION
408: WHEN OKC_API.G_EXCEPTION_ERROR THEN
409: x_return_status := OKC_API.HANDLE_EXCEPTIONS
410: (

Line 408: WHEN OKC_API.G_EXCEPTION_ERROR THEN

404: raise OKC_API.G_EXCEPTION_ERROR;
405: END IF;
406: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
407: EXCEPTION
408: WHEN OKC_API.G_EXCEPTION_ERROR THEN
409: x_return_status := OKC_API.HANDLE_EXCEPTIONS
410: (
411: l_api_name,
412: G_PKG_NAME,

Line 409: x_return_status := OKC_API.HANDLE_EXCEPTIONS

405: END IF;
406: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
407: EXCEPTION
408: WHEN OKC_API.G_EXCEPTION_ERROR THEN
409: x_return_status := OKC_API.HANDLE_EXCEPTIONS
410: (
411: l_api_name,
412: G_PKG_NAME,
413: 'OKC_API.G_RET_STS_ERROR',

Line 413: 'OKC_API.G_RET_STS_ERROR',

409: x_return_status := OKC_API.HANDLE_EXCEPTIONS
410: (
411: l_api_name,
412: G_PKG_NAME,
413: 'OKC_API.G_RET_STS_ERROR',
414: x_msg_count,
415: x_msg_data,
416: '_PUB'
417: );

Line 418: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

414: x_msg_count,
415: x_msg_data,
416: '_PUB'
417: );
418: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
419: x_return_status := OKC_API.HANDLE_EXCEPTIONS
420: (
421: l_api_name,
422: G_PKG_NAME,

Line 419: x_return_status := OKC_API.HANDLE_EXCEPTIONS

415: x_msg_data,
416: '_PUB'
417: );
418: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
419: x_return_status := OKC_API.HANDLE_EXCEPTIONS
420: (
421: l_api_name,
422: G_PKG_NAME,
423: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 423: 'OKC_API.G_RET_STS_UNEXP_ERROR',

419: x_return_status := OKC_API.HANDLE_EXCEPTIONS
420: (
421: l_api_name,
422: G_PKG_NAME,
423: 'OKC_API.G_RET_STS_UNEXP_ERROR',
424: x_msg_count,
425: x_msg_data,
426: '_PUB'
427: );

Line 429: x_return_status := OKC_API.HANDLE_EXCEPTIONS

425: x_msg_data,
426: '_PUB'
427: );
428: WHEN OTHERS THEN
429: x_return_status := OKC_API.HANDLE_EXCEPTIONS
430: (
431: l_api_name,
432: G_PKG_NAME,
433: 'OTHERS',

Line 452: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS

448: x_msg_count OUT NOCOPY NUMBER,
449: x_msg_data OUT NOCOPY VARCHAR2,
450: p_repv_tbl IN repv_tbl_type,
451: x_repv_tbl OUT NOCOPY repv_tbl_type,
452: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
453:
454: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
455: l_api_version CONSTANT NUMBER := 1;
456: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_insert_row';

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

450: p_repv_tbl IN repv_tbl_type,
451: x_repv_tbl OUT NOCOPY repv_tbl_type,
452: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
453:
454: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
455: l_api_version CONSTANT NUMBER := 1;
456: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_insert_row';
457:
458: BEGIN

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

455: l_api_version CONSTANT NUMBER := 1;
456: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_insert_row';
457:
458: BEGIN
459: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
460: G_PKG_NAME,
461: p_init_msg_list,
462: l_api_version,
463: p_api_version,

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

462: l_api_version,
463: p_api_version,
464: '_PUB',
465: x_return_status);
466: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
467: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
468: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
469: RAISE OKC_API.G_EXCEPTION_ERROR;
470: END IF;

Line 467: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

463: p_api_version,
464: '_PUB',
465: x_return_status);
466: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
467: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
468: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
469: RAISE OKC_API.G_EXCEPTION_ERROR;
470: END IF;
471: --

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

464: '_PUB',
465: x_return_status);
466: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
467: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
468: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
469: RAISE OKC_API.G_EXCEPTION_ERROR;
470: END IF;
471: --
472: -- Call Before Logic Hook

Line 469: RAISE OKC_API.G_EXCEPTION_ERROR;

465: x_return_status);
466: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
467: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
468: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
469: RAISE OKC_API.G_EXCEPTION_ERROR;
470: END IF;
471: --
472: -- Call Before Logic Hook
473: --

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

474: g_repv_tbl := p_repv_tbl;
475: gx_error_tbl := px_error_tbl;
476:
477: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
478: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
479: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
480: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
481: raise OKC_API.G_EXCEPTION_ERROR;
482: END IF;

Line 479: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

475: gx_error_tbl := px_error_tbl;
476:
477: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
478: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
479: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
480: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
481: raise OKC_API.G_EXCEPTION_ERROR;
482: END IF;
483:

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

476:
477: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
478: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
479: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
480: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
481: raise OKC_API.G_EXCEPTION_ERROR;
482: END IF;
483:
484: oks_rep_pvt.insert_row(

Line 481: raise OKC_API.G_EXCEPTION_ERROR;

477: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
478: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
479: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
480: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
481: raise OKC_API.G_EXCEPTION_ERROR;
482: END IF;
483:
484: oks_rep_pvt.insert_row(
485: p_api_version ,

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

491: x_repv_tbl,
492: gx_error_tbl
493: );
494:
495: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
496: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
497: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
498: RAISE OKC_API.G_EXCEPTION_ERROR;
499: END IF;

Line 496: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

492: gx_error_tbl
493: );
494:
495: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
496: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
497: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
498: RAISE OKC_API.G_EXCEPTION_ERROR;
499: END IF;
500: --

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

493: );
494:
495: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
496: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
497: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
498: RAISE OKC_API.G_EXCEPTION_ERROR;
499: END IF;
500: --
501: -- Call After Logic Hook

Line 498: RAISE OKC_API.G_EXCEPTION_ERROR;

494:
495: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
496: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
497: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
498: RAISE OKC_API.G_EXCEPTION_ERROR;
499: END IF;
500: --
501: -- Call After Logic Hook
502: --

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

500: --
501: -- Call After Logic Hook
502: --
503: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
504: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
505: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
506: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
507: raise OKC_API.G_EXCEPTION_ERROR;
508: END IF;

Line 505: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

501: -- Call After Logic Hook
502: --
503: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
504: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
505: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
506: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
507: raise OKC_API.G_EXCEPTION_ERROR;
508: END IF;
509: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

502: --
503: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
504: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
505: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
506: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
507: raise OKC_API.G_EXCEPTION_ERROR;
508: END IF;
509: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
510: EXCEPTION

Line 507: raise OKC_API.G_EXCEPTION_ERROR;

503: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
504: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
505: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
506: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
507: raise OKC_API.G_EXCEPTION_ERROR;
508: END IF;
509: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
510: EXCEPTION
511: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

505: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
506: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
507: raise OKC_API.G_EXCEPTION_ERROR;
508: END IF;
509: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
510: EXCEPTION
511: WHEN OKC_API.G_EXCEPTION_ERROR THEN
512: x_return_status := OKC_API.HANDLE_EXCEPTIONS
513: (

Line 511: WHEN OKC_API.G_EXCEPTION_ERROR THEN

507: raise OKC_API.G_EXCEPTION_ERROR;
508: END IF;
509: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
510: EXCEPTION
511: WHEN OKC_API.G_EXCEPTION_ERROR THEN
512: x_return_status := OKC_API.HANDLE_EXCEPTIONS
513: (
514: l_api_name,
515: G_PKG_NAME,

Line 512: x_return_status := OKC_API.HANDLE_EXCEPTIONS

508: END IF;
509: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
510: EXCEPTION
511: WHEN OKC_API.G_EXCEPTION_ERROR THEN
512: x_return_status := OKC_API.HANDLE_EXCEPTIONS
513: (
514: l_api_name,
515: G_PKG_NAME,
516: 'OKC_API.G_RET_STS_ERROR',

Line 516: 'OKC_API.G_RET_STS_ERROR',

512: x_return_status := OKC_API.HANDLE_EXCEPTIONS
513: (
514: l_api_name,
515: G_PKG_NAME,
516: 'OKC_API.G_RET_STS_ERROR',
517: x_msg_count,
518: x_msg_data,
519: '_PUB'
520: );

Line 521: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

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

Line 522: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 526: 'OKC_API.G_RET_STS_UNEXP_ERROR',

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

Line 532: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

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

554: x_repv_tbl OUT NOCOPY repv_tbl_type) IS
555:
556: l_api_version CONSTANT NUMBER := 1;
557: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_insert_row';
558: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
559: l_error_tbl OKC_API.ERROR_TBL_TYPE;
560: BEGIN
561: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
562: G_PKG_NAME,

Line 559: l_error_tbl OKC_API.ERROR_TBL_TYPE;

555:
556: l_api_version CONSTANT NUMBER := 1;
557: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_insert_row';
558: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
559: l_error_tbl OKC_API.ERROR_TBL_TYPE;
560: BEGIN
561: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
562: G_PKG_NAME,
563: p_init_msg_list,

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

557: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_insert_row';
558: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
559: l_error_tbl OKC_API.ERROR_TBL_TYPE;
560: BEGIN
561: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
562: G_PKG_NAME,
563: p_init_msg_list,
564: l_api_version,
565: p_api_version,

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

564: l_api_version,
565: p_api_version,
566: '_PUB',
567: x_return_status);
568: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
569: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
570: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
571: RAISE OKC_API.G_EXCEPTION_ERROR;
572: END IF;

Line 569: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

565: p_api_version,
566: '_PUB',
567: x_return_status);
568: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
569: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
570: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
571: RAISE OKC_API.G_EXCEPTION_ERROR;
572: END IF;
573: --

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

566: '_PUB',
567: x_return_status);
568: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
569: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
570: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
571: RAISE OKC_API.G_EXCEPTION_ERROR;
572: END IF;
573: --
574: -- Call Before Logic Hook

Line 571: RAISE OKC_API.G_EXCEPTION_ERROR;

567: x_return_status);
568: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
569: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
570: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
571: RAISE OKC_API.G_EXCEPTION_ERROR;
572: END IF;
573: --
574: -- Call Before Logic Hook
575: --

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

575: --
576: g_repv_tbl := p_repv_tbl;
577:
578: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
579: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
580: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
581: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
582: raise OKC_API.G_EXCEPTION_ERROR;
583: END IF;

Line 580: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

576: g_repv_tbl := p_repv_tbl;
577:
578: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
579: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
580: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
581: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
582: raise OKC_API.G_EXCEPTION_ERROR;
583: END IF;
584:

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

577:
578: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
579: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
580: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
581: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
582: raise OKC_API.G_EXCEPTION_ERROR;
583: END IF;
584:
585: oks_rep_pvt.insert_row(

Line 582: raise OKC_API.G_EXCEPTION_ERROR;

578: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
579: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
580: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
581: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
582: raise OKC_API.G_EXCEPTION_ERROR;
583: END IF;
584:
585: oks_rep_pvt.insert_row(
586: p_api_version ,

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

591: g_repv_tbl,
592: x_repv_tbl
593: );
594:
595: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
596: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
597: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
598: RAISE OKC_API.G_EXCEPTION_ERROR;
599: END IF;

Line 596: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

592: x_repv_tbl
593: );
594:
595: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
596: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
597: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
598: RAISE OKC_API.G_EXCEPTION_ERROR;
599: END IF;
600: --

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

593: );
594:
595: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
596: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
597: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
598: RAISE OKC_API.G_EXCEPTION_ERROR;
599: END IF;
600: --
601: -- Call After Logic Hook

Line 598: RAISE OKC_API.G_EXCEPTION_ERROR;

594:
595: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
596: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
597: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
598: RAISE OKC_API.G_EXCEPTION_ERROR;
599: END IF;
600: --
601: -- Call After Logic Hook
602: --

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

600: --
601: -- Call After Logic Hook
602: --
603: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
604: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
605: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
606: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
607: raise OKC_API.G_EXCEPTION_ERROR;
608: END IF;

Line 605: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

601: -- Call After Logic Hook
602: --
603: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
604: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
605: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
606: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
607: raise OKC_API.G_EXCEPTION_ERROR;
608: END IF;
609: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

602: --
603: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
604: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
605: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
606: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
607: raise OKC_API.G_EXCEPTION_ERROR;
608: END IF;
609: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
610: EXCEPTION

Line 607: raise OKC_API.G_EXCEPTION_ERROR;

603: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
604: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
605: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
606: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
607: raise OKC_API.G_EXCEPTION_ERROR;
608: END IF;
609: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
610: EXCEPTION
611: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

605: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
606: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
607: raise OKC_API.G_EXCEPTION_ERROR;
608: END IF;
609: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
610: EXCEPTION
611: WHEN OKC_API.G_EXCEPTION_ERROR THEN
612: x_return_status := OKC_API.HANDLE_EXCEPTIONS
613: (

Line 611: WHEN OKC_API.G_EXCEPTION_ERROR THEN

607: raise OKC_API.G_EXCEPTION_ERROR;
608: END IF;
609: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
610: EXCEPTION
611: WHEN OKC_API.G_EXCEPTION_ERROR THEN
612: x_return_status := OKC_API.HANDLE_EXCEPTIONS
613: (
614: l_api_name,
615: G_PKG_NAME,

Line 612: x_return_status := OKC_API.HANDLE_EXCEPTIONS

608: END IF;
609: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
610: EXCEPTION
611: WHEN OKC_API.G_EXCEPTION_ERROR THEN
612: x_return_status := OKC_API.HANDLE_EXCEPTIONS
613: (
614: l_api_name,
615: G_PKG_NAME,
616: 'OKC_API.G_RET_STS_ERROR',

Line 616: 'OKC_API.G_RET_STS_ERROR',

612: x_return_status := OKC_API.HANDLE_EXCEPTIONS
613: (
614: l_api_name,
615: G_PKG_NAME,
616: 'OKC_API.G_RET_STS_ERROR',
617: x_msg_count,
618: x_msg_data,
619: '_PUB'
620: );

Line 621: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

617: x_msg_count,
618: x_msg_data,
619: '_PUB'
620: );
621: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
622: x_return_status := OKC_API.HANDLE_EXCEPTIONS
623: (
624: l_api_name,
625: G_PKG_NAME,

Line 622: x_return_status := OKC_API.HANDLE_EXCEPTIONS

618: x_msg_data,
619: '_PUB'
620: );
621: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
622: x_return_status := OKC_API.HANDLE_EXCEPTIONS
623: (
624: l_api_name,
625: G_PKG_NAME,
626: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 626: 'OKC_API.G_RET_STS_UNEXP_ERROR',

622: x_return_status := OKC_API.HANDLE_EXCEPTIONS
623: (
624: l_api_name,
625: G_PKG_NAME,
626: 'OKC_API.G_RET_STS_UNEXP_ERROR',
627: x_msg_count,
628: x_msg_data,
629: '_PUB'
630: );

Line 632: x_return_status := OKC_API.HANDLE_EXCEPTIONS

628: x_msg_data,
629: '_PUB'
630: );
631: WHEN OTHERS THEN
632: x_return_status := OKC_API.HANDLE_EXCEPTIONS
633: (
634: l_api_name,
635: G_PKG_NAME,
636: 'OTHERS',

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

654: p_repv_rec IN repv_rec_type) IS
655:
656: l_api_version CONSTANT NUMBER := 1;
657: l_api_name CONSTANT VARCHAR2(30) := 'V_lock_row';
658: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
659:
660: BEGIN
661: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
662: G_PKG_NAME,

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

657: l_api_name CONSTANT VARCHAR2(30) := 'V_lock_row';
658: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
659:
660: BEGIN
661: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
662: G_PKG_NAME,
663: p_init_msg_list,
664: l_api_version,
665: p_api_version,

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

664: l_api_version,
665: p_api_version,
666: '_PUB',
667: x_return_status);
668: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
669: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
670: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
671: RAISE OKC_API.G_EXCEPTION_ERROR;
672: END IF;

Line 669: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

665: p_api_version,
666: '_PUB',
667: x_return_status);
668: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
669: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
670: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
671: RAISE OKC_API.G_EXCEPTION_ERROR;
672: END IF;
673: --

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

666: '_PUB',
667: x_return_status);
668: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
669: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
670: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
671: RAISE OKC_API.G_EXCEPTION_ERROR;
672: END IF;
673: --
674: -- Call Before Logic Hook

Line 671: RAISE OKC_API.G_EXCEPTION_ERROR;

667: x_return_status);
668: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
669: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
670: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
671: RAISE OKC_API.G_EXCEPTION_ERROR;
672: END IF;
673: --
674: -- Call Before Logic Hook
675: --

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

675: --
676: g_repv_rec := p_repv_rec;
677:
678: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
679: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
680: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
681: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
682: raise OKC_API.G_EXCEPTION_ERROR;
683: END IF;

Line 680: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

676: g_repv_rec := p_repv_rec;
677:
678: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
679: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
680: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
681: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
682: raise OKC_API.G_EXCEPTION_ERROR;
683: END IF;
684:

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

677:
678: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
679: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
680: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
681: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
682: raise OKC_API.G_EXCEPTION_ERROR;
683: END IF;
684:
685: oks_rep_pvt.lock_row(

Line 682: raise OKC_API.G_EXCEPTION_ERROR;

678: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
679: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
680: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
681: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
682: raise OKC_API.G_EXCEPTION_ERROR;
683: END IF;
684:
685: oks_rep_pvt.lock_row(
686: p_api_version ,

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

690: x_msg_data ,
691: g_repv_rec
692: );
693:
694: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
695: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
696: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
697: RAISE OKC_API.G_EXCEPTION_ERROR;
698: END IF;

Line 695: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

691: g_repv_rec
692: );
693:
694: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
695: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
696: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
697: RAISE OKC_API.G_EXCEPTION_ERROR;
698: END IF;
699: --

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

692: );
693:
694: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
695: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
696: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
697: RAISE OKC_API.G_EXCEPTION_ERROR;
698: END IF;
699: --
700: -- Call After Logic Hook

Line 697: RAISE OKC_API.G_EXCEPTION_ERROR;

693:
694: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
695: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
696: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
697: RAISE OKC_API.G_EXCEPTION_ERROR;
698: END IF;
699: --
700: -- Call After Logic Hook
701: --

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

699: --
700: -- Call After Logic Hook
701: --
702: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
703: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
704: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
705: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
706: raise OKC_API.G_EXCEPTION_ERROR;
707: END IF;

Line 704: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

700: -- Call After Logic Hook
701: --
702: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
703: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
704: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
705: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
706: raise OKC_API.G_EXCEPTION_ERROR;
707: END IF;
708: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

701: --
702: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
703: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
704: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
705: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
706: raise OKC_API.G_EXCEPTION_ERROR;
707: END IF;
708: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
709: EXCEPTION

Line 706: raise OKC_API.G_EXCEPTION_ERROR;

702: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
703: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
704: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
705: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
706: raise OKC_API.G_EXCEPTION_ERROR;
707: END IF;
708: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
709: EXCEPTION
710: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

704: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
705: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
706: raise OKC_API.G_EXCEPTION_ERROR;
707: END IF;
708: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
709: EXCEPTION
710: WHEN OKC_API.G_EXCEPTION_ERROR THEN
711: x_return_status := OKC_API.HANDLE_EXCEPTIONS
712: (

Line 710: WHEN OKC_API.G_EXCEPTION_ERROR THEN

706: raise OKC_API.G_EXCEPTION_ERROR;
707: END IF;
708: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
709: EXCEPTION
710: WHEN OKC_API.G_EXCEPTION_ERROR THEN
711: x_return_status := OKC_API.HANDLE_EXCEPTIONS
712: (
713: l_api_name,
714: G_PKG_NAME,

Line 711: x_return_status := OKC_API.HANDLE_EXCEPTIONS

707: END IF;
708: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
709: EXCEPTION
710: WHEN OKC_API.G_EXCEPTION_ERROR THEN
711: x_return_status := OKC_API.HANDLE_EXCEPTIONS
712: (
713: l_api_name,
714: G_PKG_NAME,
715: 'OKC_API.G_RET_STS_ERROR',

Line 715: 'OKC_API.G_RET_STS_ERROR',

711: x_return_status := OKC_API.HANDLE_EXCEPTIONS
712: (
713: l_api_name,
714: G_PKG_NAME,
715: 'OKC_API.G_RET_STS_ERROR',
716: x_msg_count,
717: x_msg_data,
718: '_PUB'
719: );

Line 720: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

716: x_msg_count,
717: x_msg_data,
718: '_PUB'
719: );
720: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
721: x_return_status := OKC_API.HANDLE_EXCEPTIONS
722: (
723: l_api_name,
724: G_PKG_NAME,

Line 721: x_return_status := OKC_API.HANDLE_EXCEPTIONS

717: x_msg_data,
718: '_PUB'
719: );
720: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
721: x_return_status := OKC_API.HANDLE_EXCEPTIONS
722: (
723: l_api_name,
724: G_PKG_NAME,
725: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 725: 'OKC_API.G_RET_STS_UNEXP_ERROR',

721: x_return_status := OKC_API.HANDLE_EXCEPTIONS
722: (
723: l_api_name,
724: G_PKG_NAME,
725: 'OKC_API.G_RET_STS_UNEXP_ERROR',
726: x_msg_count,
727: x_msg_data,
728: '_PUB'
729: );

Line 731: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 751: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS

747: x_return_status OUT NOCOPY VARCHAR2,
748: x_msg_count OUT NOCOPY NUMBER,
749: x_msg_data OUT NOCOPY VARCHAR2,
750: p_repv_tbl IN repv_tbl_type,
751: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
752:
753: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
754: l_api_version CONSTANT NUMBER := 1;
755: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_lock_row';

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

749: x_msg_data OUT NOCOPY VARCHAR2,
750: p_repv_tbl IN repv_tbl_type,
751: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
752:
753: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
754: l_api_version CONSTANT NUMBER := 1;
755: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_lock_row';
756: i NUMBER := 0;
757: BEGIN

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

754: l_api_version CONSTANT NUMBER := 1;
755: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_lock_row';
756: i NUMBER := 0;
757: BEGIN
758: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
759: G_PKG_NAME,
760: p_init_msg_list,
761: l_api_version,
762: p_api_version,

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

761: l_api_version,
762: p_api_version,
763: '_PUB',
764: x_return_status);
765: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
766: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
767: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
768: RAISE OKC_API.G_EXCEPTION_ERROR;
769: END IF;

Line 766: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

762: p_api_version,
763: '_PUB',
764: x_return_status);
765: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
766: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
767: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
768: RAISE OKC_API.G_EXCEPTION_ERROR;
769: END IF;
770: --

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

763: '_PUB',
764: x_return_status);
765: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
766: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
767: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
768: RAISE OKC_API.G_EXCEPTION_ERROR;
769: END IF;
770: --
771: -- Call Before Logic Hook

Line 768: RAISE OKC_API.G_EXCEPTION_ERROR;

764: x_return_status);
765: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
766: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
767: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
768: RAISE OKC_API.G_EXCEPTION_ERROR;
769: END IF;
770: --
771: -- Call Before Logic Hook
772: --

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

773: g_repv_tbl := p_repv_tbl;
774: gx_error_tbl := px_error_tbl;
775:
776: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
777: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
778: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
779: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
780: raise OKC_API.G_EXCEPTION_ERROR;
781: END IF;

Line 778: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

774: gx_error_tbl := px_error_tbl;
775:
776: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
777: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
778: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
779: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
780: raise OKC_API.G_EXCEPTION_ERROR;
781: END IF;
782:

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

775:
776: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
777: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
778: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
779: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
780: raise OKC_API.G_EXCEPTION_ERROR;
781: END IF;
782:
783: oks_rep_pvt.lock_row(

Line 780: raise OKC_API.G_EXCEPTION_ERROR;

776: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
777: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
778: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
779: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
780: raise OKC_API.G_EXCEPTION_ERROR;
781: END IF;
782:
783: oks_rep_pvt.lock_row(
784: p_api_version ,

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

789: g_repv_tbl,
790: gx_error_tbl
791: );
792:
793: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
794: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
795: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
796: RAISE OKC_API.G_EXCEPTION_ERROR;
797: END IF;

Line 794: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

790: gx_error_tbl
791: );
792:
793: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
794: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
795: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
796: RAISE OKC_API.G_EXCEPTION_ERROR;
797: END IF;
798: --

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

791: );
792:
793: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
794: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
795: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
796: RAISE OKC_API.G_EXCEPTION_ERROR;
797: END IF;
798: --
799: -- Call After Logic Hook

Line 796: RAISE OKC_API.G_EXCEPTION_ERROR;

792:
793: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
794: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
795: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
796: RAISE OKC_API.G_EXCEPTION_ERROR;
797: END IF;
798: --
799: -- Call After Logic Hook
800: --

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

798: --
799: -- Call After Logic Hook
800: --
801: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
802: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
803: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
804: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
805: raise OKC_API.G_EXCEPTION_ERROR;
806: END IF;

Line 803: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

799: -- Call After Logic Hook
800: --
801: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
802: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
803: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
804: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
805: raise OKC_API.G_EXCEPTION_ERROR;
806: END IF;
807: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

800: --
801: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
802: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
803: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
804: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
805: raise OKC_API.G_EXCEPTION_ERROR;
806: END IF;
807: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
808: EXCEPTION

Line 805: raise OKC_API.G_EXCEPTION_ERROR;

801: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
802: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
803: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
804: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
805: raise OKC_API.G_EXCEPTION_ERROR;
806: END IF;
807: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
808: EXCEPTION
809: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

803: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
804: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
805: raise OKC_API.G_EXCEPTION_ERROR;
806: END IF;
807: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
808: EXCEPTION
809: WHEN OKC_API.G_EXCEPTION_ERROR THEN
810: x_return_status := OKC_API.HANDLE_EXCEPTIONS
811: (

Line 809: WHEN OKC_API.G_EXCEPTION_ERROR THEN

805: raise OKC_API.G_EXCEPTION_ERROR;
806: END IF;
807: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
808: EXCEPTION
809: WHEN OKC_API.G_EXCEPTION_ERROR THEN
810: x_return_status := OKC_API.HANDLE_EXCEPTIONS
811: (
812: l_api_name,
813: G_PKG_NAME,

Line 810: x_return_status := OKC_API.HANDLE_EXCEPTIONS

806: END IF;
807: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
808: EXCEPTION
809: WHEN OKC_API.G_EXCEPTION_ERROR THEN
810: x_return_status := OKC_API.HANDLE_EXCEPTIONS
811: (
812: l_api_name,
813: G_PKG_NAME,
814: 'OKC_API.G_RET_STS_ERROR',

Line 814: 'OKC_API.G_RET_STS_ERROR',

810: x_return_status := OKC_API.HANDLE_EXCEPTIONS
811: (
812: l_api_name,
813: G_PKG_NAME,
814: 'OKC_API.G_RET_STS_ERROR',
815: x_msg_count,
816: x_msg_data,
817: '_PUB'
818: );

Line 819: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

815: x_msg_count,
816: x_msg_data,
817: '_PUB'
818: );
819: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
820: x_return_status := OKC_API.HANDLE_EXCEPTIONS
821: (
822: l_api_name,
823: G_PKG_NAME,

Line 820: x_return_status := OKC_API.HANDLE_EXCEPTIONS

816: x_msg_data,
817: '_PUB'
818: );
819: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
820: x_return_status := OKC_API.HANDLE_EXCEPTIONS
821: (
822: l_api_name,
823: G_PKG_NAME,
824: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 824: 'OKC_API.G_RET_STS_UNEXP_ERROR',

820: x_return_status := OKC_API.HANDLE_EXCEPTIONS
821: (
822: l_api_name,
823: G_PKG_NAME,
824: 'OKC_API.G_RET_STS_UNEXP_ERROR',
825: x_msg_count,
826: x_msg_data,
827: '_PUB'
828: );

Line 830: x_return_status := OKC_API.HANDLE_EXCEPTIONS

826: x_msg_data,
827: '_PUB'
828: );
829: WHEN OTHERS THEN
830: x_return_status := OKC_API.HANDLE_EXCEPTIONS
831: (
832: l_api_name,
833: G_PKG_NAME,
834: 'OTHERS',

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

849: p_repv_tbl IN repv_tbl_type) IS
850:
851: l_api_version CONSTANT NUMBER := 1;
852: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_lock_row';
853: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
854: l_error_tbl OKC_API.ERROR_TBL_TYPE;
855: BEGIN
856: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
857: G_PKG_NAME,

Line 854: l_error_tbl OKC_API.ERROR_TBL_TYPE;

850:
851: l_api_version CONSTANT NUMBER := 1;
852: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_lock_row';
853: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
854: l_error_tbl OKC_API.ERROR_TBL_TYPE;
855: BEGIN
856: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
857: G_PKG_NAME,
858: p_init_msg_list,

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

852: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_lock_row';
853: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
854: l_error_tbl OKC_API.ERROR_TBL_TYPE;
855: BEGIN
856: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
857: G_PKG_NAME,
858: p_init_msg_list,
859: l_api_version,
860: p_api_version,

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

859: l_api_version,
860: p_api_version,
861: '_PUB',
862: x_return_status);
863: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
864: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
865: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
866: RAISE OKC_API.G_EXCEPTION_ERROR;
867: END IF;

Line 864: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

860: p_api_version,
861: '_PUB',
862: x_return_status);
863: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
864: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
865: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
866: RAISE OKC_API.G_EXCEPTION_ERROR;
867: END IF;
868: --

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

861: '_PUB',
862: x_return_status);
863: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
864: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
865: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
866: RAISE OKC_API.G_EXCEPTION_ERROR;
867: END IF;
868: --
869: -- Call Before Logic Hook

Line 866: RAISE OKC_API.G_EXCEPTION_ERROR;

862: x_return_status);
863: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
864: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
865: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
866: RAISE OKC_API.G_EXCEPTION_ERROR;
867: END IF;
868: --
869: -- Call Before Logic Hook
870: --

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

870: --
871: g_repv_tbl := p_repv_tbl;
872:
873: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
874: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
875: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
876: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
877: raise OKC_API.G_EXCEPTION_ERROR;
878: END IF;

Line 875: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

871: g_repv_tbl := p_repv_tbl;
872:
873: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
874: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
875: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
876: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
877: raise OKC_API.G_EXCEPTION_ERROR;
878: END IF;
879:

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

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

Line 877: raise OKC_API.G_EXCEPTION_ERROR;

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

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

885: x_msg_data ,
886: g_repv_tbl
887: );
888:
889: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
891: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
892: RAISE OKC_API.G_EXCEPTION_ERROR;
893: END IF;

Line 890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

886: g_repv_tbl
887: );
888:
889: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
891: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
892: RAISE OKC_API.G_EXCEPTION_ERROR;
893: END IF;
894: --

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

887: );
888:
889: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
891: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
892: RAISE OKC_API.G_EXCEPTION_ERROR;
893: END IF;
894: --
895: -- Call After Logic Hook

Line 892: RAISE OKC_API.G_EXCEPTION_ERROR;

888:
889: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
890: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
891: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
892: RAISE OKC_API.G_EXCEPTION_ERROR;
893: END IF;
894: --
895: -- Call After Logic Hook
896: --

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

894: --
895: -- Call After Logic Hook
896: --
897: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
898: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
899: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
900: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
901: raise OKC_API.G_EXCEPTION_ERROR;
902: END IF;

Line 899: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

895: -- Call After Logic Hook
896: --
897: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
898: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
899: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
900: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
901: raise OKC_API.G_EXCEPTION_ERROR;
902: END IF;
903:

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

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

Line 901: raise OKC_API.G_EXCEPTION_ERROR;

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

Line 905: WHEN OKC_API.G_EXCEPTION_ERROR THEN

901: raise OKC_API.G_EXCEPTION_ERROR;
902: END IF;
903:
904: EXCEPTION
905: WHEN OKC_API.G_EXCEPTION_ERROR THEN
906: x_return_status := OKC_API.HANDLE_EXCEPTIONS
907: (
908: l_api_name,
909: G_PKG_NAME,

Line 906: x_return_status := OKC_API.HANDLE_EXCEPTIONS

902: END IF;
903:
904: EXCEPTION
905: WHEN OKC_API.G_EXCEPTION_ERROR THEN
906: x_return_status := OKC_API.HANDLE_EXCEPTIONS
907: (
908: l_api_name,
909: G_PKG_NAME,
910: 'OKC_API.G_RET_STS_ERROR',

Line 910: 'OKC_API.G_RET_STS_ERROR',

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

Line 915: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

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

Line 916: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

Line 920: 'OKC_API.G_RET_STS_UNEXP_ERROR',

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

Line 926: x_return_status := OKC_API.HANDLE_EXCEPTIONS

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

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

948: x_repv_rec OUT NOCOPY repv_rec_type) IS
949:
950: l_api_version CONSTANT NUMBER := 1;
951: l_api_name CONSTANT VARCHAR2(30) := 'V_update_row';
952: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
953: l_repv_rec repv_rec_type := p_repv_rec;
954: l_def_repv_rec repv_rec_type;
955: l_db_repv_rec repv_rec_type;
956: l_rep_rec rep_rec_type;

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

956: l_rep_rec rep_rec_type;
957: lx_rep_rec rep_rec_type;
958:
959: BEGIN
960: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
961: G_PKG_NAME,
962: p_init_msg_list,
963: l_api_version,
964: p_api_version,

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

963: l_api_version,
964: p_api_version,
965: '_PUB',
966: x_return_status);
967: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
968: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
969: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
970: RAISE OKC_API.G_EXCEPTION_ERROR;
971: END IF;

Line 968: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

964: p_api_version,
965: '_PUB',
966: x_return_status);
967: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
968: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
969: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
970: RAISE OKC_API.G_EXCEPTION_ERROR;
971: END IF;
972: --

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

965: '_PUB',
966: x_return_status);
967: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
968: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
969: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
970: RAISE OKC_API.G_EXCEPTION_ERROR;
971: END IF;
972: --
973: -- Call Before Logic Hook

Line 970: RAISE OKC_API.G_EXCEPTION_ERROR;

966: x_return_status);
967: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
968: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
969: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
970: RAISE OKC_API.G_EXCEPTION_ERROR;
971: END IF;
972: --
973: -- Call Before Logic Hook
974: --

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

974: --
975: g_repv_rec := p_repv_rec;
976:
977: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
981: raise OKC_API.G_EXCEPTION_ERROR;
982: END IF;

Line 979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

975: g_repv_rec := p_repv_rec;
976:
977: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
981: raise OKC_API.G_EXCEPTION_ERROR;
982: END IF;
983:

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

976:
977: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
981: raise OKC_API.G_EXCEPTION_ERROR;
982: END IF;
983:
984: oks_rep_pvt.update_row(

Line 981: raise OKC_API.G_EXCEPTION_ERROR;

977: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
978: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
979: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
980: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
981: raise OKC_API.G_EXCEPTION_ERROR;
982: END IF;
983:
984: oks_rep_pvt.update_row(
985: p_api_version ,

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

990: g_repv_rec,
991: x_repv_rec
992: );
993:
994: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
995: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
996: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
997: RAISE OKC_API.G_EXCEPTION_ERROR;
998: END IF;

Line 995: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

991: x_repv_rec
992: );
993:
994: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
995: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
996: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
997: RAISE OKC_API.G_EXCEPTION_ERROR;
998: END IF;
999: --

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

992: );
993:
994: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
995: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
996: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
997: RAISE OKC_API.G_EXCEPTION_ERROR;
998: END IF;
999: --
1000: -- Call After Logic Hook

Line 997: RAISE OKC_API.G_EXCEPTION_ERROR;

993:
994: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
995: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
996: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
997: RAISE OKC_API.G_EXCEPTION_ERROR;
998: END IF;
999: --
1000: -- Call After Logic Hook
1001: --

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

999: --
1000: -- Call After Logic Hook
1001: --
1002: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1003: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1004: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1005: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1006: raise OKC_API.G_EXCEPTION_ERROR;
1007: END IF;

Line 1004: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1000: -- Call After Logic Hook
1001: --
1002: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1003: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1004: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1005: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1006: raise OKC_API.G_EXCEPTION_ERROR;
1007: END IF;
1008: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1001: --
1002: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1003: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1004: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1005: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1006: raise OKC_API.G_EXCEPTION_ERROR;
1007: END IF;
1008: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1009: EXCEPTION

Line 1006: raise OKC_API.G_EXCEPTION_ERROR;

1002: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1003: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1004: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1005: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1006: raise OKC_API.G_EXCEPTION_ERROR;
1007: END IF;
1008: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1009: EXCEPTION
1010: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1004: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1005: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1006: raise OKC_API.G_EXCEPTION_ERROR;
1007: END IF;
1008: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1009: EXCEPTION
1010: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1011: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1012: (

Line 1010: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1006: raise OKC_API.G_EXCEPTION_ERROR;
1007: END IF;
1008: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1009: EXCEPTION
1010: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1011: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1012: (
1013: l_api_name,
1014: G_PKG_NAME,

Line 1011: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1007: END IF;
1008: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1009: EXCEPTION
1010: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1011: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1012: (
1013: l_api_name,
1014: G_PKG_NAME,
1015: 'OKC_API.G_RET_STS_ERROR',

Line 1015: 'OKC_API.G_RET_STS_ERROR',

1011: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1012: (
1013: l_api_name,
1014: G_PKG_NAME,
1015: 'OKC_API.G_RET_STS_ERROR',
1016: x_msg_count,
1017: x_msg_data,
1018: '_PUB'
1019: );

Line 1020: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1016: x_msg_count,
1017: x_msg_data,
1018: '_PUB'
1019: );
1020: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1021: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1022: (
1023: l_api_name,
1024: G_PKG_NAME,

Line 1021: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1017: x_msg_data,
1018: '_PUB'
1019: );
1020: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1021: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1022: (
1023: l_api_name,
1024: G_PKG_NAME,
1025: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1025: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1021: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1022: (
1023: l_api_name,
1024: G_PKG_NAME,
1025: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1026: x_msg_count,
1027: x_msg_data,
1028: '_PUB'
1029: );

Line 1031: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1027: x_msg_data,
1028: '_PUB'
1029: );
1030: WHEN OTHERS THEN
1031: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1032: (
1033: l_api_name,
1034: G_PKG_NAME,
1035: 'OTHERS',

Line 1052: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS

1048: x_msg_count OUT NOCOPY NUMBER,
1049: x_msg_data OUT NOCOPY VARCHAR2,
1050: p_repv_tbl IN repv_tbl_type,
1051: x_repv_tbl OUT NOCOPY repv_tbl_type,
1052: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
1053:
1054: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1055: l_api_version CONSTANT NUMBER := 1;
1056: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_update_row';

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

1050: p_repv_tbl IN repv_tbl_type,
1051: x_repv_tbl OUT NOCOPY repv_tbl_type,
1052: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
1053:
1054: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1055: l_api_version CONSTANT NUMBER := 1;
1056: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_update_row';
1057: i NUMBER := 0;
1058: BEGIN

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

1055: l_api_version CONSTANT NUMBER := 1;
1056: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_update_row';
1057: i NUMBER := 0;
1058: BEGIN
1059: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1060: G_PKG_NAME,
1061: p_init_msg_list,
1062: l_api_version,
1063: p_api_version,

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

1062: l_api_version,
1063: p_api_version,
1064: '_PUB',
1065: x_return_status);
1066: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1067: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1068: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1069: RAISE OKC_API.G_EXCEPTION_ERROR;
1070: END IF;

Line 1067: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1063: p_api_version,
1064: '_PUB',
1065: x_return_status);
1066: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1067: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1068: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1069: RAISE OKC_API.G_EXCEPTION_ERROR;
1070: END IF;
1071: --

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

1064: '_PUB',
1065: x_return_status);
1066: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1067: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1068: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1069: RAISE OKC_API.G_EXCEPTION_ERROR;
1070: END IF;
1071: --
1072: -- Call Before Logic Hook

Line 1069: RAISE OKC_API.G_EXCEPTION_ERROR;

1065: x_return_status);
1066: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1067: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1068: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1069: RAISE OKC_API.G_EXCEPTION_ERROR;
1070: END IF;
1071: --
1072: -- Call Before Logic Hook
1073: --

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

1074: g_repv_tbl := p_repv_tbl;
1075: gx_error_tbl := px_error_tbl;
1076:
1077: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1078: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1079: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1080: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1081: raise OKC_API.G_EXCEPTION_ERROR;
1082: END IF;

Line 1079: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1075: gx_error_tbl := px_error_tbl;
1076:
1077: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1078: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1079: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1080: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1081: raise OKC_API.G_EXCEPTION_ERROR;
1082: END IF;
1083:

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

1076:
1077: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1078: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1079: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1080: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1081: raise OKC_API.G_EXCEPTION_ERROR;
1082: END IF;
1083:
1084: oks_rep_pvt.update_row(

Line 1081: raise OKC_API.G_EXCEPTION_ERROR;

1077: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1078: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1079: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1080: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1081: raise OKC_API.G_EXCEPTION_ERROR;
1082: END IF;
1083:
1084: oks_rep_pvt.update_row(
1085: p_api_version ,

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

1091: x_repv_tbl,
1092: gx_error_tbl
1093: );
1094:
1095: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1096: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1097: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1098: RAISE OKC_API.G_EXCEPTION_ERROR;
1099: END IF;

Line 1096: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1092: gx_error_tbl
1093: );
1094:
1095: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1096: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1097: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1098: RAISE OKC_API.G_EXCEPTION_ERROR;
1099: END IF;
1100: --

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

1093: );
1094:
1095: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1096: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1097: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1098: RAISE OKC_API.G_EXCEPTION_ERROR;
1099: END IF;
1100: --
1101: -- Call After Logic Hook

Line 1098: RAISE OKC_API.G_EXCEPTION_ERROR;

1094:
1095: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1096: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1097: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1098: RAISE OKC_API.G_EXCEPTION_ERROR;
1099: END IF;
1100: --
1101: -- Call After Logic Hook
1102: --

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

1100: --
1101: -- Call After Logic Hook
1102: --
1103: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1104: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1105: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1106: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1107: raise OKC_API.G_EXCEPTION_ERROR;
1108: END IF;

Line 1105: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1101: -- Call After Logic Hook
1102: --
1103: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1104: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1105: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1106: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1107: raise OKC_API.G_EXCEPTION_ERROR;
1108: END IF;
1109: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1102: --
1103: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1104: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1105: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1106: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1107: raise OKC_API.G_EXCEPTION_ERROR;
1108: END IF;
1109: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1110: EXCEPTION

Line 1107: raise OKC_API.G_EXCEPTION_ERROR;

1103: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1104: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1105: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1106: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1107: raise OKC_API.G_EXCEPTION_ERROR;
1108: END IF;
1109: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1110: EXCEPTION
1111: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1105: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1106: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1107: raise OKC_API.G_EXCEPTION_ERROR;
1108: END IF;
1109: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1110: EXCEPTION
1111: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1112: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1113: (

Line 1111: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1107: raise OKC_API.G_EXCEPTION_ERROR;
1108: END IF;
1109: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1110: EXCEPTION
1111: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1112: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1113: (
1114: l_api_name,
1115: G_PKG_NAME,

Line 1112: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1108: END IF;
1109: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1110: EXCEPTION
1111: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1112: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1113: (
1114: l_api_name,
1115: G_PKG_NAME,
1116: 'OKC_API.G_RET_STS_ERROR',

Line 1116: 'OKC_API.G_RET_STS_ERROR',

1112: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1113: (
1114: l_api_name,
1115: G_PKG_NAME,
1116: 'OKC_API.G_RET_STS_ERROR',
1117: x_msg_count,
1118: x_msg_data,
1119: '_PUB'
1120: );

Line 1121: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1117: x_msg_count,
1118: x_msg_data,
1119: '_PUB'
1120: );
1121: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1122: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1123: (
1124: l_api_name,
1125: G_PKG_NAME,

Line 1122: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1118: x_msg_data,
1119: '_PUB'
1120: );
1121: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1122: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1123: (
1124: l_api_name,
1125: G_PKG_NAME,
1126: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1126: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1122: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1123: (
1124: l_api_name,
1125: G_PKG_NAME,
1126: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1127: x_msg_count,
1128: x_msg_data,
1129: '_PUB'
1130: );

Line 1132: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1128: x_msg_data,
1129: '_PUB'
1130: );
1131: WHEN OTHERS THEN
1132: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1133: (
1134: l_api_name,
1135: G_PKG_NAME,
1136: 'OTHERS',

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

1155: x_repv_tbl OUT NOCOPY repv_tbl_type) IS
1156:
1157: l_api_version CONSTANT NUMBER := 1;
1158: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_update_row';
1159: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1160: l_error_tbl OKC_API.ERROR_TBL_TYPE;
1161: BEGIN
1162: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1163: G_PKG_NAME,

Line 1160: l_error_tbl OKC_API.ERROR_TBL_TYPE;

1156:
1157: l_api_version CONSTANT NUMBER := 1;
1158: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_update_row';
1159: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1160: l_error_tbl OKC_API.ERROR_TBL_TYPE;
1161: BEGIN
1162: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1163: G_PKG_NAME,
1164: p_init_msg_list,

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

1158: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_update_row';
1159: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1160: l_error_tbl OKC_API.ERROR_TBL_TYPE;
1161: BEGIN
1162: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1163: G_PKG_NAME,
1164: p_init_msg_list,
1165: l_api_version,
1166: p_api_version,

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

1165: l_api_version,
1166: p_api_version,
1167: '_PUB',
1168: x_return_status);
1169: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1170: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1171: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1172: RAISE OKC_API.G_EXCEPTION_ERROR;
1173: END IF;

Line 1170: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1166: p_api_version,
1167: '_PUB',
1168: x_return_status);
1169: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1170: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1171: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1172: RAISE OKC_API.G_EXCEPTION_ERROR;
1173: END IF;
1174: --

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

1167: '_PUB',
1168: x_return_status);
1169: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1170: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1171: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1172: RAISE OKC_API.G_EXCEPTION_ERROR;
1173: END IF;
1174: --
1175: -- Call Before Logic Hook

Line 1172: RAISE OKC_API.G_EXCEPTION_ERROR;

1168: x_return_status);
1169: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1170: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1171: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1172: RAISE OKC_API.G_EXCEPTION_ERROR;
1173: END IF;
1174: --
1175: -- Call Before Logic Hook
1176: --

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

1176: --
1177: g_repv_tbl := p_repv_tbl;
1178:
1179: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1180: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1181: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1182: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1183: raise OKC_API.G_EXCEPTION_ERROR;
1184: END IF;

Line 1181: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1177: g_repv_tbl := p_repv_tbl;
1178:
1179: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1180: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1181: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1182: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1183: raise OKC_API.G_EXCEPTION_ERROR;
1184: END IF;
1185:

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

1178:
1179: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1180: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1181: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1182: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1183: raise OKC_API.G_EXCEPTION_ERROR;
1184: END IF;
1185:
1186: oks_rep_pvt.update_row(

Line 1183: raise OKC_API.G_EXCEPTION_ERROR;

1179: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1180: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1181: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1182: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1183: raise OKC_API.G_EXCEPTION_ERROR;
1184: END IF;
1185:
1186: oks_rep_pvt.update_row(
1187: p_api_version ,

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

1192: g_repv_tbl,
1193: x_repv_tbl
1194: );
1195:
1196: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1197: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1198: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1199: RAISE OKC_API.G_EXCEPTION_ERROR;
1200: END IF;

Line 1197: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1193: x_repv_tbl
1194: );
1195:
1196: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1197: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1198: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1199: RAISE OKC_API.G_EXCEPTION_ERROR;
1200: END IF;
1201: --

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

1194: );
1195:
1196: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1197: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1198: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1199: RAISE OKC_API.G_EXCEPTION_ERROR;
1200: END IF;
1201: --
1202: -- Call After Logic Hook

Line 1199: RAISE OKC_API.G_EXCEPTION_ERROR;

1195:
1196: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1197: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1198: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1199: RAISE OKC_API.G_EXCEPTION_ERROR;
1200: END IF;
1201: --
1202: -- Call After Logic Hook
1203: --

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

1201: --
1202: -- Call After Logic Hook
1203: --
1204: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1205: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1206: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1207: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1208: raise OKC_API.G_EXCEPTION_ERROR;
1209: END IF;

Line 1206: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1202: -- Call After Logic Hook
1203: --
1204: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1205: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1206: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1207: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1208: raise OKC_API.G_EXCEPTION_ERROR;
1209: END IF;
1210: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1203: --
1204: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1205: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1206: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1207: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1208: raise OKC_API.G_EXCEPTION_ERROR;
1209: END IF;
1210: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1211: EXCEPTION

Line 1208: raise OKC_API.G_EXCEPTION_ERROR;

1204: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1205: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1206: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1207: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1208: raise OKC_API.G_EXCEPTION_ERROR;
1209: END IF;
1210: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1211: EXCEPTION
1212: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1206: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1207: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1208: raise OKC_API.G_EXCEPTION_ERROR;
1209: END IF;
1210: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1211: EXCEPTION
1212: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1213: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1214: (

Line 1212: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1208: raise OKC_API.G_EXCEPTION_ERROR;
1209: END IF;
1210: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1211: EXCEPTION
1212: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1213: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1214: (
1215: l_api_name,
1216: G_PKG_NAME,

Line 1213: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1209: END IF;
1210: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1211: EXCEPTION
1212: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1213: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1214: (
1215: l_api_name,
1216: G_PKG_NAME,
1217: 'OKC_API.G_RET_STS_ERROR',

Line 1217: 'OKC_API.G_RET_STS_ERROR',

1213: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1214: (
1215: l_api_name,
1216: G_PKG_NAME,
1217: 'OKC_API.G_RET_STS_ERROR',
1218: x_msg_count,
1219: x_msg_data,
1220: '_PUB'
1221: );

Line 1222: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1218: x_msg_count,
1219: x_msg_data,
1220: '_PUB'
1221: );
1222: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1223: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1224: (
1225: l_api_name,
1226: G_PKG_NAME,

Line 1223: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1219: x_msg_data,
1220: '_PUB'
1221: );
1222: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1223: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1224: (
1225: l_api_name,
1226: G_PKG_NAME,
1227: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1227: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1223: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1224: (
1225: l_api_name,
1226: G_PKG_NAME,
1227: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1228: x_msg_count,
1229: x_msg_data,
1230: '_PUB'
1231: );

Line 1233: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1229: x_msg_data,
1230: '_PUB'
1231: );
1232: WHEN OTHERS THEN
1233: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1234: (
1235: l_api_name,
1236: G_PKG_NAME,
1237: 'OTHERS',

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

1254: p_repv_rec IN repv_rec_type) IS
1255:
1256: l_api_version CONSTANT NUMBER := 1;
1257: l_api_name CONSTANT VARCHAR2(30) := 'V_delete_row';
1258: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1259: l_repv_rec repv_rec_type := p_repv_rec;
1260: l_rep_rec rep_rec_type;
1261: BEGIN
1262: l_return_status := OKC_API.START_ACTIVITY(l_api_name,

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

1258: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1259: l_repv_rec repv_rec_type := p_repv_rec;
1260: l_rep_rec rep_rec_type;
1261: BEGIN
1262: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1263: G_PKG_NAME,
1264: p_init_msg_list,
1265: l_api_version,
1266: p_api_version,

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

1265: l_api_version,
1266: p_api_version,
1267: '_PUB',
1268: x_return_status);
1269: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1270: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1271: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1272: RAISE OKC_API.G_EXCEPTION_ERROR;
1273: END IF;

Line 1270: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1266: p_api_version,
1267: '_PUB',
1268: x_return_status);
1269: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1270: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1271: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1272: RAISE OKC_API.G_EXCEPTION_ERROR;
1273: END IF;
1274: --

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

1267: '_PUB',
1268: x_return_status);
1269: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1270: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1271: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1272: RAISE OKC_API.G_EXCEPTION_ERROR;
1273: END IF;
1274: --
1275: -- Call Before Logic Hook

Line 1272: RAISE OKC_API.G_EXCEPTION_ERROR;

1268: x_return_status);
1269: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1270: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1271: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1272: RAISE OKC_API.G_EXCEPTION_ERROR;
1273: END IF;
1274: --
1275: -- Call Before Logic Hook
1276: --

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

1276: --
1277: g_repv_rec := p_repv_rec;
1278:
1279: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1280: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1281: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1282: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1283: raise OKC_API.G_EXCEPTION_ERROR;
1284: END IF;

Line 1281: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1277: g_repv_rec := p_repv_rec;
1278:
1279: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1280: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1281: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1282: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1283: raise OKC_API.G_EXCEPTION_ERROR;
1284: END IF;
1285:

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

1278:
1279: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1280: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1281: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1282: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1283: raise OKC_API.G_EXCEPTION_ERROR;
1284: END IF;
1285:
1286: oks_rep_pvt.delete_row(

Line 1283: raise OKC_API.G_EXCEPTION_ERROR;

1279: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1280: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1281: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1282: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1283: raise OKC_API.G_EXCEPTION_ERROR;
1284: END IF;
1285:
1286: oks_rep_pvt.delete_row(
1287: p_api_version ,

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

1291: x_msg_data ,
1292: g_repv_rec
1293: );
1294:
1295: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1296: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1297: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1298: RAISE OKC_API.G_EXCEPTION_ERROR;
1299: END IF;

Line 1296: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1292: g_repv_rec
1293: );
1294:
1295: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1296: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1297: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1298: RAISE OKC_API.G_EXCEPTION_ERROR;
1299: END IF;
1300: --

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

1293: );
1294:
1295: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1296: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1297: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1298: RAISE OKC_API.G_EXCEPTION_ERROR;
1299: END IF;
1300: --
1301: -- Call After Logic Hook

Line 1298: RAISE OKC_API.G_EXCEPTION_ERROR;

1294:
1295: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1296: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1297: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1298: RAISE OKC_API.G_EXCEPTION_ERROR;
1299: END IF;
1300: --
1301: -- Call After Logic Hook
1302: --

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

1300: --
1301: -- Call After Logic Hook
1302: --
1303: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1304: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1305: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1306: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1307: raise OKC_API.G_EXCEPTION_ERROR;
1308: END IF;

Line 1305: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1301: -- Call After Logic Hook
1302: --
1303: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1304: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1305: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1306: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1307: raise OKC_API.G_EXCEPTION_ERROR;
1308: END IF;
1309: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1302: --
1303: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1304: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1305: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1306: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1307: raise OKC_API.G_EXCEPTION_ERROR;
1308: END IF;
1309: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1310: EXCEPTION

Line 1307: raise OKC_API.G_EXCEPTION_ERROR;

1303: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1304: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1305: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1306: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1307: raise OKC_API.G_EXCEPTION_ERROR;
1308: END IF;
1309: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1310: EXCEPTION
1311: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1305: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1306: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1307: raise OKC_API.G_EXCEPTION_ERROR;
1308: END IF;
1309: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1310: EXCEPTION
1311: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1312: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1313: (

Line 1311: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1307: raise OKC_API.G_EXCEPTION_ERROR;
1308: END IF;
1309: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1310: EXCEPTION
1311: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1312: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1313: (
1314: l_api_name,
1315: G_PKG_NAME,

Line 1312: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1308: END IF;
1309: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1310: EXCEPTION
1311: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1312: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1313: (
1314: l_api_name,
1315: G_PKG_NAME,
1316: 'OKC_API.G_RET_STS_ERROR',

Line 1316: 'OKC_API.G_RET_STS_ERROR',

1312: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1313: (
1314: l_api_name,
1315: G_PKG_NAME,
1316: 'OKC_API.G_RET_STS_ERROR',
1317: x_msg_count,
1318: x_msg_data,
1319: '_PUB'
1320: );

Line 1321: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1317: x_msg_count,
1318: x_msg_data,
1319: '_PUB'
1320: );
1321: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1322: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1323: (
1324: l_api_name,
1325: G_PKG_NAME,

Line 1322: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1318: x_msg_data,
1319: '_PUB'
1320: );
1321: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1322: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1323: (
1324: l_api_name,
1325: G_PKG_NAME,
1326: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1326: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1322: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1323: (
1324: l_api_name,
1325: G_PKG_NAME,
1326: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1327: x_msg_count,
1328: x_msg_data,
1329: '_PUB'
1330: );

Line 1332: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1328: x_msg_data,
1329: '_PUB'
1330: );
1331: WHEN OTHERS THEN
1332: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1333: (
1334: l_api_name,
1335: G_PKG_NAME,
1336: 'OTHERS',

Line 1352: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS

1348: x_return_status OUT NOCOPY VARCHAR2,
1349: x_msg_count OUT NOCOPY NUMBER,
1350: x_msg_data OUT NOCOPY VARCHAR2,
1351: p_repv_tbl IN repv_tbl_type,
1352: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
1353:
1354: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1355: l_api_version CONSTANT NUMBER := 1;
1356: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_delete_row';

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

1350: x_msg_data OUT NOCOPY VARCHAR2,
1351: p_repv_tbl IN repv_tbl_type,
1352: px_error_tbl IN OUT NOCOPY OKC_API.ERROR_TBL_TYPE) IS
1353:
1354: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1355: l_api_version CONSTANT NUMBER := 1;
1356: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_delete_row';
1357: i NUMBER := 0;
1358: BEGIN

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

1355: l_api_version CONSTANT NUMBER := 1;
1356: l_api_name CONSTANT VARCHAR2(30) := 'V_error_tbl_delete_row';
1357: i NUMBER := 0;
1358: BEGIN
1359: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1360: G_PKG_NAME,
1361: p_init_msg_list,
1362: l_api_version,
1363: p_api_version,

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

1362: l_api_version,
1363: p_api_version,
1364: '_PUB',
1365: x_return_status);
1366: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1367: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1368: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1369: RAISE OKC_API.G_EXCEPTION_ERROR;
1370: END IF;

Line 1367: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1363: p_api_version,
1364: '_PUB',
1365: x_return_status);
1366: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1367: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1368: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1369: RAISE OKC_API.G_EXCEPTION_ERROR;
1370: END IF;
1371: --

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

1364: '_PUB',
1365: x_return_status);
1366: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1367: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1368: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1369: RAISE OKC_API.G_EXCEPTION_ERROR;
1370: END IF;
1371: --
1372: -- Call Before Logic Hook

Line 1369: RAISE OKC_API.G_EXCEPTION_ERROR;

1365: x_return_status);
1366: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1367: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1368: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1369: RAISE OKC_API.G_EXCEPTION_ERROR;
1370: END IF;
1371: --
1372: -- Call Before Logic Hook
1373: --

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

1374: g_repv_tbl := p_repv_tbl;
1375: gx_error_tbl := px_error_tbl;
1376:
1377: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1378: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1379: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1380: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1381: raise OKC_API.G_EXCEPTION_ERROR;
1382: END IF;

Line 1379: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1375: gx_error_tbl := px_error_tbl;
1376:
1377: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1378: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1379: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1380: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1381: raise OKC_API.G_EXCEPTION_ERROR;
1382: END IF;
1383:

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

1376:
1377: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1378: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1379: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1380: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1381: raise OKC_API.G_EXCEPTION_ERROR;
1382: END IF;
1383:
1384: oks_rep_pvt.delete_row(

Line 1381: raise OKC_API.G_EXCEPTION_ERROR;

1377: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1378: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1379: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1380: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1381: raise OKC_API.G_EXCEPTION_ERROR;
1382: END IF;
1383:
1384: oks_rep_pvt.delete_row(
1385: p_api_version ,

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

1390: g_repv_tbl,
1391: gx_error_tbl
1392: );
1393:
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: gx_error_tbl
1392: );
1393:
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: --

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

1392: );
1393:
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: --
1400: -- Call After Logic Hook

Line 1397: RAISE OKC_API.G_EXCEPTION_ERROR;

1393:
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: --
1400: -- Call After Logic Hook
1401: --

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

1399: --
1400: -- Call After Logic Hook
1401: --
1402: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1403: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1404: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1405: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1406: raise OKC_API.G_EXCEPTION_ERROR;
1407: END IF;

Line 1404: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1400: -- Call After Logic Hook
1401: --
1402: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1403: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1404: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1405: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1406: raise OKC_API.G_EXCEPTION_ERROR;
1407: END IF;
1408: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1401: --
1402: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1403: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1404: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1405: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1406: raise OKC_API.G_EXCEPTION_ERROR;
1407: END IF;
1408: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1409: EXCEPTION

Line 1406: raise OKC_API.G_EXCEPTION_ERROR;

1402: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1403: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1404: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1405: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1406: raise OKC_API.G_EXCEPTION_ERROR;
1407: END IF;
1408: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1409: EXCEPTION
1410: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1404: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1405: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1406: raise OKC_API.G_EXCEPTION_ERROR;
1407: END IF;
1408: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1409: EXCEPTION
1410: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1411: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1412: (

Line 1410: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1406: raise OKC_API.G_EXCEPTION_ERROR;
1407: END IF;
1408: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1409: EXCEPTION
1410: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1411: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1412: (
1413: l_api_name,
1414: G_PKG_NAME,

Line 1411: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1407: END IF;
1408: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1409: EXCEPTION
1410: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1411: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1412: (
1413: l_api_name,
1414: G_PKG_NAME,
1415: 'OKC_API.G_RET_STS_ERROR',

Line 1415: 'OKC_API.G_RET_STS_ERROR',

1411: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1412: (
1413: l_api_name,
1414: G_PKG_NAME,
1415: 'OKC_API.G_RET_STS_ERROR',
1416: x_msg_count,
1417: x_msg_data,
1418: '_PUB'
1419: );

Line 1420: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1416: x_msg_count,
1417: x_msg_data,
1418: '_PUB'
1419: );
1420: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1421: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1422: (
1423: l_api_name,
1424: G_PKG_NAME,

Line 1421: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1417: x_msg_data,
1418: '_PUB'
1419: );
1420: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1421: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1422: (
1423: l_api_name,
1424: G_PKG_NAME,
1425: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1425: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1421: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1422: (
1423: l_api_name,
1424: G_PKG_NAME,
1425: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1426: x_msg_count,
1427: x_msg_data,
1428: '_PUB'
1429: );

Line 1431: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1427: x_msg_data,
1428: '_PUB'
1429: );
1430: WHEN OTHERS THEN
1431: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1432: (
1433: l_api_name,
1434: G_PKG_NAME,
1435: 'OTHERS',

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

1451: p_repv_tbl IN repv_tbl_type) IS
1452:
1453: l_api_version CONSTANT NUMBER := 1;
1454: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_delete_row';
1455: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1456: l_error_tbl OKC_API.ERROR_TBL_TYPE;
1457: BEGIN
1458: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1459: G_PKG_NAME,

Line 1456: l_error_tbl OKC_API.ERROR_TBL_TYPE;

1452:
1453: l_api_version CONSTANT NUMBER := 1;
1454: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_delete_row';
1455: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1456: l_error_tbl OKC_API.ERROR_TBL_TYPE;
1457: BEGIN
1458: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1459: G_PKG_NAME,
1460: p_init_msg_list,

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

1454: l_api_name CONSTANT VARCHAR2(30) := 'V_tbl_delete_row';
1455: l_return_status VARCHAR2(1) := OKC_API.G_RET_STS_SUCCESS;
1456: l_error_tbl OKC_API.ERROR_TBL_TYPE;
1457: BEGIN
1458: l_return_status := OKC_API.START_ACTIVITY(l_api_name,
1459: G_PKG_NAME,
1460: p_init_msg_list,
1461: l_api_version,
1462: p_api_version,

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

1461: l_api_version,
1462: p_api_version,
1463: '_PUB',
1464: x_return_status);
1465: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1466: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1467: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1468: RAISE OKC_API.G_EXCEPTION_ERROR;
1469: END IF;

Line 1466: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1462: p_api_version,
1463: '_PUB',
1464: x_return_status);
1465: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1466: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1467: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1468: RAISE OKC_API.G_EXCEPTION_ERROR;
1469: END IF;
1470: --

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

1463: '_PUB',
1464: x_return_status);
1465: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1466: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1467: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1468: RAISE OKC_API.G_EXCEPTION_ERROR;
1469: END IF;
1470: --
1471: -- Call Before Logic Hook

Line 1468: RAISE OKC_API.G_EXCEPTION_ERROR;

1464: x_return_status);
1465: IF (l_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1466: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1467: ELSIF (l_return_status = OKC_API.G_RET_STS_ERROR) THEN
1468: RAISE OKC_API.G_EXCEPTION_ERROR;
1469: END IF;
1470: --
1471: -- Call Before Logic Hook
1472: --

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

1472: --
1473: g_repv_tbl := p_repv_tbl;
1474:
1475: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1476: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1477: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1478: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1479: raise OKC_API.G_EXCEPTION_ERROR;
1480: END IF;

Line 1477: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1473: g_repv_tbl := p_repv_tbl;
1474:
1475: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1476: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1477: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1478: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1479: raise OKC_API.G_EXCEPTION_ERROR;
1480: END IF;
1481:

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

1474:
1475: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1476: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1477: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1478: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1479: raise OKC_API.G_EXCEPTION_ERROR;
1480: END IF;
1481:
1482: oks_rep_pvt.delete_row(

Line 1479: raise OKC_API.G_EXCEPTION_ERROR;

1475: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'B');
1476: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1477: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1478: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1479: raise OKC_API.G_EXCEPTION_ERROR;
1480: END IF;
1481:
1482: oks_rep_pvt.delete_row(
1483: p_api_version ,

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

1487: x_msg_data ,
1488: g_repv_tbl
1489: );
1490:
1491: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1492: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1493: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1494: RAISE OKC_API.G_EXCEPTION_ERROR;
1495: END IF;

Line 1492: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1488: g_repv_tbl
1489: );
1490:
1491: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1492: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1493: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1494: RAISE OKC_API.G_EXCEPTION_ERROR;
1495: END IF;
1496: --

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

1489: );
1490:
1491: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1492: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1493: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1494: RAISE OKC_API.G_EXCEPTION_ERROR;
1495: END IF;
1496: --
1497: -- Call After Logic Hook

Line 1494: RAISE OKC_API.G_EXCEPTION_ERROR;

1490:
1491: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1492: RAISE OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1493: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1494: RAISE OKC_API.G_EXCEPTION_ERROR;
1495: END IF;
1496: --
1497: -- Call After Logic Hook
1498: --

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

1496: --
1497: -- Call After Logic Hook
1498: --
1499: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1500: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1501: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1502: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1503: raise OKC_API.G_EXCEPTION_ERROR;
1504: END IF;

Line 1501: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;

1497: -- Call After Logic Hook
1498: --
1499: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1500: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1501: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1502: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1503: raise OKC_API.G_EXCEPTION_ERROR;
1504: END IF;
1505: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);

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

1498: --
1499: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1500: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1501: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1502: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1503: raise OKC_API.G_EXCEPTION_ERROR;
1504: END IF;
1505: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1506: EXCEPTION

Line 1503: raise OKC_API.G_EXCEPTION_ERROR;

1499: okc_util.call_user_hook(x_return_status, g_pkg_name, l_api_name, 'A');
1500: IF (x_return_status = OKC_API.G_RET_STS_UNEXP_ERROR) THEN
1501: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1502: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1503: raise OKC_API.G_EXCEPTION_ERROR;
1504: END IF;
1505: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1506: EXCEPTION
1507: WHEN OKC_API.G_EXCEPTION_ERROR THEN

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

1501: raise OKC_API.G_EXCEPTION_UNEXPECTED_ERROR;
1502: ELSIF (x_return_status = OKC_API.G_RET_STS_ERROR) THEN
1503: raise OKC_API.G_EXCEPTION_ERROR;
1504: END IF;
1505: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1506: EXCEPTION
1507: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1508: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1509: (

Line 1507: WHEN OKC_API.G_EXCEPTION_ERROR THEN

1503: raise OKC_API.G_EXCEPTION_ERROR;
1504: END IF;
1505: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1506: EXCEPTION
1507: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1508: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1509: (
1510: l_api_name,
1511: G_PKG_NAME,

Line 1508: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1504: END IF;
1505: OKC_API.END_ACTIVITY(x_msg_count, x_msg_data);
1506: EXCEPTION
1507: WHEN OKC_API.G_EXCEPTION_ERROR THEN
1508: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1509: (
1510: l_api_name,
1511: G_PKG_NAME,
1512: 'OKC_API.G_RET_STS_ERROR',

Line 1512: 'OKC_API.G_RET_STS_ERROR',

1508: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1509: (
1510: l_api_name,
1511: G_PKG_NAME,
1512: 'OKC_API.G_RET_STS_ERROR',
1513: x_msg_count,
1514: x_msg_data,
1515: '_PUB'
1516: );

Line 1517: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN

1513: x_msg_count,
1514: x_msg_data,
1515: '_PUB'
1516: );
1517: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1518: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1519: (
1520: l_api_name,
1521: G_PKG_NAME,

Line 1518: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1514: x_msg_data,
1515: '_PUB'
1516: );
1517: WHEN OKC_API.G_EXCEPTION_UNEXPECTED_ERROR THEN
1518: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1519: (
1520: l_api_name,
1521: G_PKG_NAME,
1522: 'OKC_API.G_RET_STS_UNEXP_ERROR',

Line 1522: 'OKC_API.G_RET_STS_UNEXP_ERROR',

1518: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1519: (
1520: l_api_name,
1521: G_PKG_NAME,
1522: 'OKC_API.G_RET_STS_UNEXP_ERROR',
1523: x_msg_count,
1524: x_msg_data,
1525: '_PUB'
1526: );

Line 1528: x_return_status := OKC_API.HANDLE_EXCEPTIONS

1524: x_msg_data,
1525: '_PUB'
1526: );
1527: WHEN OTHERS THEN
1528: x_return_status := OKC_API.HANDLE_EXCEPTIONS
1529: (
1530: l_api_name,
1531: G_PKG_NAME,
1532: 'OTHERS',