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

APPS.CN_IMP_RULE_PVT dependencies on CN_MESSAGE_PKG

Line 86: cn_message_pkg.begin_batch

82: FROM cn_imp_headers
83: WHERE imp_header_id = p_imp_header_id;
84:
85: -- open process audit batch
86: cn_message_pkg.begin_batch
87: ( x_process_type => l_imp_header.import_type_code,
88: x_parent_proc_audit_id => l_imp_header.imp_header_id,
89: x_process_audit_id => l_process_audit_id,
90: x_request_id => null,

Line 93: cn_message_pkg.write

89: x_process_audit_id => l_process_audit_id,
90: x_request_id => null,
91: p_org_id =>l_org_id);
92:
93: cn_message_pkg.write
94: (p_message_text => 'RULES: Start Transfer Data. imp_header_id = ' || To_char(p_imp_header_id),
95: p_message_type => 'MILESTONE');
96:
97: -- get the details for the ruleset

Line 99: cn_message_pkg.debug('Rules_Import: #### START OF ruleset for loop');

95: p_message_type => 'MILESTONE');
96:
97: -- get the details for the ruleset
98: FOR detail_rec IN c_ruleset_details_csr LOOP
99: cn_message_pkg.debug('Rules_Import: #### START OF ruleset for loop');
100:
101: -- check for the required fields
102: IF (detail_rec.ruleset_name IS NULL) OR (detail_rec.start_date IS NULL) OR (detail_rec.end_date IS NULL) OR
103: (detail_rec.ruleset_type IS NULL) OR (detail_rec.ruleset_type <>'REVCLS' AND detail_rec.ruleset_type <> 'ACCGEN') THEN

Line 104: cn_message_pkg.debug('Rules_Import: Failed Test : All the required fields have not been entered');

100:
101: -- check for the required fields
102: IF (detail_rec.ruleset_name IS NULL) OR (detail_rec.start_date IS NULL) OR (detail_rec.end_date IS NULL) OR
103: (detail_rec.ruleset_type IS NULL) OR (detail_rec.ruleset_type <>'REVCLS' AND detail_rec.ruleset_type <> 'ACCGEN') THEN
104: cn_message_pkg.debug('Rules_Import: Failed Test : All the required fields have not been entered');
105: cn_message_pkg.debug('Rules_Import: detail_rec.ruleset_name: ' || detail_rec.ruleset_name);
106: cn_message_pkg.debug('Rules_Import: detail_rec.start_date: ' || detail_rec.start_date);
107: cn_message_pkg.debug('Rules_Import: detail_rec.end_date: ' || detail_rec.end_date);
108: cn_message_pkg.debug('Rules_Import: detail_rec.ruleset_type: ' || detail_rec.ruleset_type);

Line 105: cn_message_pkg.debug('Rules_Import: detail_rec.ruleset_name: ' || detail_rec.ruleset_name);

101: -- check for the required fields
102: IF (detail_rec.ruleset_name IS NULL) OR (detail_rec.start_date IS NULL) OR (detail_rec.end_date IS NULL) OR
103: (detail_rec.ruleset_type IS NULL) OR (detail_rec.ruleset_type <>'REVCLS' AND detail_rec.ruleset_type <> 'ACCGEN') THEN
104: cn_message_pkg.debug('Rules_Import: Failed Test : All the required fields have not been entered');
105: cn_message_pkg.debug('Rules_Import: detail_rec.ruleset_name: ' || detail_rec.ruleset_name);
106: cn_message_pkg.debug('Rules_Import: detail_rec.start_date: ' || detail_rec.start_date);
107: cn_message_pkg.debug('Rules_Import: detail_rec.end_date: ' || detail_rec.end_date);
108: cn_message_pkg.debug('Rules_Import: detail_rec.ruleset_type: ' || detail_rec.ruleset_type);
109:

Line 106: cn_message_pkg.debug('Rules_Import: detail_rec.start_date: ' || detail_rec.start_date);

102: IF (detail_rec.ruleset_name IS NULL) OR (detail_rec.start_date IS NULL) OR (detail_rec.end_date IS NULL) OR
103: (detail_rec.ruleset_type IS NULL) OR (detail_rec.ruleset_type <>'REVCLS' AND detail_rec.ruleset_type <> 'ACCGEN') THEN
104: cn_message_pkg.debug('Rules_Import: Failed Test : All the required fields have not been entered');
105: cn_message_pkg.debug('Rules_Import: detail_rec.ruleset_name: ' || detail_rec.ruleset_name);
106: cn_message_pkg.debug('Rules_Import: detail_rec.start_date: ' || detail_rec.start_date);
107: cn_message_pkg.debug('Rules_Import: detail_rec.end_date: ' || detail_rec.end_date);
108: cn_message_pkg.debug('Rules_Import: detail_rec.ruleset_type: ' || detail_rec.ruleset_type);
109:
110: update_imp_lines

Line 107: cn_message_pkg.debug('Rules_Import: detail_rec.end_date: ' || detail_rec.end_date);

103: (detail_rec.ruleset_type IS NULL) OR (detail_rec.ruleset_type <>'REVCLS' AND detail_rec.ruleset_type <> 'ACCGEN') THEN
104: cn_message_pkg.debug('Rules_Import: Failed Test : All the required fields have not been entered');
105: cn_message_pkg.debug('Rules_Import: detail_rec.ruleset_name: ' || detail_rec.ruleset_name);
106: cn_message_pkg.debug('Rules_Import: detail_rec.start_date: ' || detail_rec.start_date);
107: cn_message_pkg.debug('Rules_Import: detail_rec.end_date: ' || detail_rec.end_date);
108: cn_message_pkg.debug('Rules_Import: detail_rec.ruleset_type: ' || detail_rec.ruleset_type);
109:
110: update_imp_lines
111: (p_status => 'FAIL',

Line 108: cn_message_pkg.debug('Rules_Import: detail_rec.ruleset_type: ' || detail_rec.ruleset_type);

104: cn_message_pkg.debug('Rules_Import: Failed Test : All the required fields have not been entered');
105: cn_message_pkg.debug('Rules_Import: detail_rec.ruleset_name: ' || detail_rec.ruleset_name);
106: cn_message_pkg.debug('Rules_Import: detail_rec.start_date: ' || detail_rec.start_date);
107: cn_message_pkg.debug('Rules_Import: detail_rec.end_date: ' || detail_rec.end_date);
108: cn_message_pkg.debug('Rules_Import: detail_rec.ruleset_type: ' || detail_rec.ruleset_type);
109:
110: update_imp_lines
111: (p_status => 'FAIL',
112: p_imp_line_id => G_INVALID_IMP_LINE_ID,

Line 127: cn_message_pkg.debug('ERROR: Ruleset Name too long');

123: END IF;
124:
125: -- the length is as specified in the JSP
126: IF LENGTH(detail_rec.ruleset_name) > 60 THEN
127: cn_message_pkg.debug('ERROR: Ruleset Name too long');
128:
129: update_imp_lines
130: (p_status => 'FAIL',
131: p_imp_line_id => G_INVALID_IMP_LINE_ID,

Line 151: cn_message_pkg.debug('### IMP ### EXCEPTION : error parsing date');

147: l_ruleset_rec.start_date := TO_DATE (detail_rec.start_date,'DD/MM/YYYY');
148: l_ruleset_rec.end_date := TO_DATE (detail_rec.end_date,'DD/MM/YYYY');
149: EXCEPTION
150: WHEN OTHERS THEN
151: cn_message_pkg.debug('### IMP ### EXCEPTION : error parsing date');
152:
153: update_imp_lines
154: (p_status => 'FAIL',
155: p_imp_line_id => G_INVALID_IMP_LINE_ID,

Line 179: cn_message_pkg.debug('value of l_current_ruleset_id:' || l_current_ruleset_id);

175: l_current_ruleset_id := 0;
176: END IF;
177: CLOSE c_is_ruleset_present_csr;
178:
179: cn_message_pkg.debug('value of l_current_ruleset_id:' || l_current_ruleset_id);
180:
181: IF l_current_ruleset_id = 0 THEN
182: l_return_status := FND_API.G_RET_STS_SUCCESS;
183: cn_message_pkg.debug('Rules_Import: Before calling CN_RULESET_PVT.create_ruleset, ruleset name: ' || detail_rec.ruleset_name);

Line 183: cn_message_pkg.debug('Rules_Import: Before calling CN_RULESET_PVT.create_ruleset, ruleset name: ' || detail_rec.ruleset_name);

179: cn_message_pkg.debug('value of l_current_ruleset_id:' || l_current_ruleset_id);
180:
181: IF l_current_ruleset_id = 0 THEN
182: l_return_status := FND_API.G_RET_STS_SUCCESS;
183: cn_message_pkg.debug('Rules_Import: Before calling CN_RULESET_PVT.create_ruleset, ruleset name: ' || detail_rec.ruleset_name);
184:
185: CN_RULESET_PVT.create_ruleset
186: ( p_api_version => 1.0,
187: p_init_msg_list => fnd_api.g_true,

Line 197: cn_message_pkg.debug('Rules_Import: After CN_RULESET_PVT.create_ruleset call, return status: ' || l_return_status);

193: x_loading_status => l_loading_status,
194: x_ruleset_id => l_current_ruleset_id,
195: p_ruleset_rec => l_ruleset_rec);
196:
197: cn_message_pkg.debug('Rules_Import: After CN_RULESET_PVT.create_ruleset call, return status: ' || l_return_status);
198: cn_message_pkg.debug('After CN_RULESET_PVT.create_ruleset call, l_message: ' || l_message);
199:
200: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
201: cn_message_pkg.debug('Rules_Import: Error after returning from CN_RULESET_PVT.create_ruleset');

Line 198: cn_message_pkg.debug('After CN_RULESET_PVT.create_ruleset call, l_message: ' || l_message);

194: x_ruleset_id => l_current_ruleset_id,
195: p_ruleset_rec => l_ruleset_rec);
196:
197: cn_message_pkg.debug('Rules_Import: After CN_RULESET_PVT.create_ruleset call, return status: ' || l_return_status);
198: cn_message_pkg.debug('After CN_RULESET_PVT.create_ruleset call, l_message: ' || l_message);
199:
200: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
201: cn_message_pkg.debug('Rules_Import: Error after returning from CN_RULESET_PVT.create_ruleset');
202: retcode := 2;

Line 201: cn_message_pkg.debug('Rules_Import: Error after returning from CN_RULESET_PVT.create_ruleset');

197: cn_message_pkg.debug('Rules_Import: After CN_RULESET_PVT.create_ruleset call, return status: ' || l_return_status);
198: cn_message_pkg.debug('After CN_RULESET_PVT.create_ruleset call, l_message: ' || l_message);
199:
200: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
201: cn_message_pkg.debug('Rules_Import: Error after returning from CN_RULESET_PVT.create_ruleset');
202: retcode := 2;
203: errbuf:= l_message;
204: -- update all the rows related to the ruleset with a general message
205: update_imp_lines

Line 219: cn_message_pkg.write

215: x_failed_row => l_failed_row,
216: x_processed_row => l_processed_row);
217:
218: GOTO end_of_ruleset_loop;
219: cn_message_pkg.write
220: (p_message_text => 'Completed creating a ruleset, name: ' || detail_rec.ruleset_name,
221: p_message_type => 'MILESTONE');
222: END IF;
223: ELSE

Line 224: cn_message_pkg.debug('Ruleset exists in the Database');

220: (p_message_text => 'Completed creating a ruleset, name: ' || detail_rec.ruleset_name,
221: p_message_type => 'MILESTONE');
222: END IF;
223: ELSE
224: cn_message_pkg.debug('Ruleset exists in the Database');
225: END IF; -- end IF l_current_ruleset_id = 0 THEN
226:
227: l_err_imp_line_id := NULL;
228:

Line 229: cn_message_pkg.debug('Rules_Import: Before call to load_rules, ruleset: ' || detail_rec.ruleset_name);

225: END IF; -- end IF l_current_ruleset_id = 0 THEN
226:
227: l_err_imp_line_id := NULL;
228:
229: cn_message_pkg.debug('Rules_Import: Before call to load_rules, ruleset: ' || detail_rec.ruleset_name);
230: -- now process the rules for this ruleset
231: load_rules
232: (p_ruleset_id => l_current_ruleset_id,
233: p_ruleset_name => detail_rec.ruleset_name,

Line 245: cn_message_pkg.debug('Rules_Import: After loading rules, x_retcode: ' || retcode);

241: x_failed_row => l_failed_row,
242: x_processed_row => l_processed_row,
243: p_org_id => l_org_id);
244:
245: cn_message_pkg.debug('Rules_Import: After loading rules, x_retcode: ' || retcode);
246:
247: IF retcode = 2 THEN
248: cn_message_pkg.debug('Error loading rules, ruleset: ' || detail_rec.ruleset_name);
249: GOTO end_of_ruleset_loop;

Line 248: cn_message_pkg.debug('Error loading rules, ruleset: ' || detail_rec.ruleset_name);

244:
245: cn_message_pkg.debug('Rules_Import: After loading rules, x_retcode: ' || retcode);
246:
247: IF retcode = 2 THEN
248: cn_message_pkg.debug('Error loading rules, ruleset: ' || detail_rec.ruleset_name);
249: GOTO end_of_ruleset_loop;
250: END IF;
251:
252: cn_message_pkg.debug('Rules_Import: After call to load_rules, ruleset :' || detail_rec.ruleset_name);

Line 252: cn_message_pkg.debug('Rules_Import: After call to load_rules, ruleset :' || detail_rec.ruleset_name);

248: cn_message_pkg.debug('Error loading rules, ruleset: ' || detail_rec.ruleset_name);
249: GOTO end_of_ruleset_loop;
250: END IF;
251:
252: cn_message_pkg.debug('Rules_Import: After call to load_rules, ruleset :' || detail_rec.ruleset_name);
253: cn_message_pkg.debug ('Rules_Import: Before synchronize, l_current_ruleset_id :' || l_current_ruleset_id);
254:
255: IF CN_Ruleset_PVT.check_sync_allowed
256: ( detail_rec.ruleset_name,

Line 253: cn_message_pkg.debug ('Rules_Import: Before synchronize, l_current_ruleset_id :' || l_current_ruleset_id);

249: GOTO end_of_ruleset_loop;
250: END IF;
251:
252: cn_message_pkg.debug('Rules_Import: After call to load_rules, ruleset :' || detail_rec.ruleset_name);
253: cn_message_pkg.debug ('Rules_Import: Before synchronize, l_current_ruleset_id :' || l_current_ruleset_id);
254:
255: IF CN_Ruleset_PVT.check_sync_allowed
256: ( detail_rec.ruleset_name,
257: l_current_ruleset_id,

Line 262: cn_message_pkg.debug ('Rules_Import: Error synchronizing the ruleset :' || detail_rec.ruleset_name);

258: l_org_id,
259: x_loading_status,
260: x_loading_status ) = fnd_api.g_true
261: THEN
262: cn_message_pkg.debug ('Rules_Import: Error synchronizing the ruleset :' || detail_rec.ruleset_name);
263: GOTO end_of_ruleset_loop;
264:
265: END IF;
266: -- synchronize the package

Line 272: cn_message_pkg.debug ('Rules_Import: Completed synchronize, l_return_status :' || l_return_status);

268: (x_ruleset_id_in => l_current_ruleset_id,
269: x_ruleset_status_in => l_return_status,
270: x_org_id => l_org_id);
271:
272: cn_message_pkg.debug ('Rules_Import: Completed synchronize, l_return_status :' || l_return_status);
273: IF l_return_status = 'UNSYNC' THEN
274: cn_message_pkg.debug ('Rules_Import: Error synchronizing the ruleset :' || detail_rec.ruleset_name);
275: GOTO end_of_ruleset_loop;
276: END IF;

Line 274: cn_message_pkg.debug ('Rules_Import: Error synchronizing the ruleset :' || detail_rec.ruleset_name);

270: x_org_id => l_org_id);
271:
272: cn_message_pkg.debug ('Rules_Import: Completed synchronize, l_return_status :' || l_return_status);
273: IF l_return_status = 'UNSYNC' THEN
274: cn_message_pkg.debug ('Rules_Import: Error synchronizing the ruleset :' || detail_rec.ruleset_name);
275: GOTO end_of_ruleset_loop;
276: END IF;
277:
278: cn_message_pkg.debug ('Rules_Import: Classify the l_current_ruleset_id: ' || l_current_ruleset_id);

Line 278: cn_message_pkg.debug ('Rules_Import: Classify the l_current_ruleset_id: ' || l_current_ruleset_id);

274: cn_message_pkg.debug ('Rules_Import: Error synchronizing the ruleset :' || detail_rec.ruleset_name);
275: GOTO end_of_ruleset_loop;
276: END IF;
277:
278: cn_message_pkg.debug ('Rules_Import: Classify the l_current_ruleset_id: ' || l_current_ruleset_id);
279: cn_classification_gen.Classification_Install
280: (x_errbuf => l_message,
281: x_retcode => l_return_status,
282: x_ruleset_id => l_current_ruleset_id,

Line 285: cn_message_pkg.debug ('Rules_Import: value returned by cn_classification_gen.Classification_Install: ' || l_return_status);

281: x_retcode => l_return_status,
282: x_ruleset_id => l_current_ruleset_id,
283: x_org_id => l_org_id);
284:
285: cn_message_pkg.debug ('Rules_Import: value returned by cn_classification_gen.Classification_Install: ' || l_return_status);
286: IF l_return_status = 1 THEN
287: cn_message_pkg.debug ('Rules_Import: Error classifying the ruleset: ' || detail_rec.ruleset_name);
288: GOTO end_of_ruleset_loop;
289: ELSE

Line 287: cn_message_pkg.debug ('Rules_Import: Error classifying the ruleset: ' || detail_rec.ruleset_name);

283: x_org_id => l_org_id);
284:
285: cn_message_pkg.debug ('Rules_Import: value returned by cn_classification_gen.Classification_Install: ' || l_return_status);
286: IF l_return_status = 1 THEN
287: cn_message_pkg.debug ('Rules_Import: Error classifying the ruleset: ' || detail_rec.ruleset_name);
288: GOTO end_of_ruleset_loop;
289: ELSE
290: cn_message_pkg.debug ('Rules_Import: No errors for this ruleset COMMIT: ' || detail_rec.ruleset_name);
291: update_imp_lines

Line 290: cn_message_pkg.debug ('Rules_Import: No errors for this ruleset COMMIT: ' || detail_rec.ruleset_name);

286: IF l_return_status = 1 THEN
287: cn_message_pkg.debug ('Rules_Import: Error classifying the ruleset: ' || detail_rec.ruleset_name);
288: GOTO end_of_ruleset_loop;
289: ELSE
290: cn_message_pkg.debug ('Rules_Import: No errors for this ruleset COMMIT: ' || detail_rec.ruleset_name);
291: update_imp_lines
292: (p_status => 'COMPLETE',
293: p_imp_line_id => G_INVALID_IMP_LINE_ID,
294: p_ruleset_name => detail_rec.ruleset_name,

Line 304: cn_message_pkg.write

300: p_error_mssg => '',
301: x_failed_row => l_failed_row,
302: x_processed_row => l_processed_row);
303:
304: cn_message_pkg.write
305: (p_message_text => 'Completed Synchronizing Ruleset name = ' || detail_rec.ruleset_name,
306: p_message_type => 'MILESTONE');
307: END IF;
308:

Line 315: cn_message_pkg.debug ('Rules_Import: #### OUTSIDE THE LOOP, retcode: ' || retcode);

311: -- ruleset complete
312: COMMIT;
313: END LOOP; -- end of ruleset cursor
314:
315: cn_message_pkg.debug ('Rules_Import: #### OUTSIDE THE LOOP, retcode: ' || retcode);
316:
317: IF retcode = 2 THEN
318: CN_IMPORT_PVT.update_imp_headers
319: (p_imp_header_id => p_imp_header_id,

Line 331: cn_message_pkg.write

327: p_processed_row => l_processed_row,
328: p_failed_row => l_failed_row);
329: END IF;
330:
331: cn_message_pkg.write
332: (p_message_text => 'Completed Transfer of data from staging table to destination tables for imp_header_id = ' || To_char(p_imp_header_id),
333: p_message_type => 'MILESTONE');
334:
335: -- close process batch

Line 336: cn_message_pkg.end_batch(l_process_audit_id);

332: (p_message_text => 'Completed Transfer of data from staging table to destination tables for imp_header_id = ' || To_char(p_imp_header_id),
333: p_message_type => 'MILESTONE');
334:
335: -- close process batch
336: cn_message_pkg.end_batch(l_process_audit_id);
337:
338: EXCEPTION
339: WHEN OTHERS THEN
340: cn_message_pkg.debug ('### IMP ### EXCEPTION : ERROR CODE: ' || SQLCODE);

Line 340: cn_message_pkg.debug ('### IMP ### EXCEPTION : ERROR CODE: ' || SQLCODE);

336: cn_message_pkg.end_batch(l_process_audit_id);
337:
338: EXCEPTION
339: WHEN OTHERS THEN
340: cn_message_pkg.debug ('### IMP ### EXCEPTION : ERROR CODE: ' || SQLCODE);
341: cn_message_pkg.debug ('ERROR MESSAGE: ' || SQLERRM);
342: err_num := SQLCODE;
343: IF err_num = -6501 THEN
344: retcode := 2;

Line 341: cn_message_pkg.debug ('ERROR MESSAGE: ' || SQLERRM);

337:
338: EXCEPTION
339: WHEN OTHERS THEN
340: cn_message_pkg.debug ('### IMP ### EXCEPTION : ERROR CODE: ' || SQLCODE);
341: cn_message_pkg.debug ('ERROR MESSAGE: ' || SQLERRM);
342: err_num := SQLCODE;
343: IF err_num = -6501 THEN
344: retcode := 2;
345: errbuf := SQLERRM;

Line 363: cn_message_pkg.set_error(l_api_name,errbuf);

359: p_status_code => 'IMPORT_FAIL',
360: p_processed_row => l_processed_row,
361: p_failed_row => l_failed_row);
362:
363: cn_message_pkg.set_error(l_api_name,errbuf);
364: cn_message_pkg.end_batch(l_process_audit_id);
365:
366: END Rules_Import;
367:

Line 364: cn_message_pkg.end_batch(l_process_audit_id);

360: p_processed_row => l_processed_row,
361: p_failed_row => l_failed_row);
362:
363: cn_message_pkg.set_error(l_api_name,errbuf);
364: cn_message_pkg.end_batch(l_process_audit_id);
365:
366: END Rules_Import;
367:
368: -- --------------------------------------------------------+

Line 607: cn_message_pkg.debug ('Ruleset has rules with no rules name/null value');

603: FETCH c_null_rule_name_csr INTO l_temp_count;
604: CLOSE c_null_rule_name_csr;
605:
606: IF l_temp_count > 0 THEN
607: cn_message_pkg.debug ('Ruleset has rules with no rules name/null value');
608: x_err_mssg := fnd_message.get_string('CN','CN_INVLD_RULE_NAME');
609: x_retcode := 2;
610: x_imp_line_id := G_INVALID_IMP_LINE_ID;
611: l_error_code := 'CN_INVLD_RULE_NAME';

Line 633: cn_message_pkg.debug ('Ruleset has level num with null value');

629: FETCH c_null_level_num_csr INTO l_temp_count;
630: CLOSE c_null_level_num_csr;
631:
632: IF l_temp_count > 0 THEN
633: cn_message_pkg.debug ('Ruleset has level num with null value');
634: x_err_mssg := fnd_message.get_string('CN','CN_IMP_MISS_REQUIRED');
635: x_retcode := 2;
636: x_imp_line_id := G_INVALID_IMP_LINE_ID;
637: l_error_code := 'CN_IMP_MISS_REQUIRED';

Line 662: cn_message_pkg.debug ('Rule has multiple RC, libility/exp code value');

658: FETCH c_rules_dtl_csr INTO l_temp_count;
659: CLOSE c_rules_dtl_csr;
660:
661: IF l_temp_count > 1 THEN
662: cn_message_pkg.debug ('Rule has multiple RC, libility/exp code value');
663: x_err_mssg := fnd_message.get_string('CN','CN_MULTI_RULE_DTL');
664: x_retcode := 2;
665: x_imp_line_id := G_INVALID_IMP_LINE_ID;
666: l_error_code := 'CN_MULTI_RULE_DTL';

Line 687: cn_message_pkg.debug ('load_rules: Rule name too long :' || rule_name_rec.rule_name);

683: END IF;
684:
685: -- check rule_name length
686: IF LENGTH(rule_name_rec.rule_name) > 60 THEN
687: cn_message_pkg.debug ('load_rules: Rule name too long :' || rule_name_rec.rule_name);
688: x_err_mssg := fnd_message.get_string('CN','CN_RULE_NAME_TOO_LONG');
689: x_retcode := 2;
690: l_error_code := 'CN_RULE_NAME_TOO_LONG';
691: seterr_imp_rules

Line 714: cn_message_pkg.write

710: rule_name_rec.level_num);
711: FETCH c_rules_csr INTO rules_rec;
712: CLOSE c_rules_csr;
713:
714: cn_message_pkg.write
715: (p_message_text => 'Start to create Rule, name: ' || rule_name_rec.rule_name,
716: p_message_type => 'MILESTONE');
717:
718: -- get the required values to create a new rule

Line 760: cn_message_pkg.debug ('load_rules: Invalid Expense code :' || rules_rec.expense_code);

756: l_rule_rec.expense_ccid := expns_row.code_combination_id;
757: l_value_found := 1;
758: END LOOP;
759: IF l_value_found = 0 THEN
760: cn_message_pkg.debug ('load_rules: Invalid Expense code :' || rules_rec.expense_code);
761: x_err_mssg := fnd_message.get_string('CN','CN_IMP_INVLD_EXPENS_CODE');
762: x_retcode := 2;
763: l_error_code := 'CN_IMP_INVLD_EXPENS_CODE';
764: seterr_imp_rules

Line 790: cn_message_pkg.debug ('load_rules: Invalid liability code :' || rules_rec.liability_code);

786: l_value_found := 1;
787: l_rule_rec.liability_ccid := liabl_row.code_combination_id;
788: END LOOP;
789: IF l_value_found = 0 THEN
790: cn_message_pkg.debug ('load_rules: Invalid liability code :' || rules_rec.liability_code);
791: x_err_mssg := fnd_message.get_string('CN','CN_IMP_INVLD_LIABLTY_CODE');
792: x_retcode := 2;
793: l_error_code := 'CN_IMP_INVLD_LIABLTY_CODE';
794: seterr_imp_rules

Line 822: cn_message_pkg.debug ('load_rules: Invalid Parent Rule name :' || rule_name_rec.parent_rule_name);

818: l_rule_rec.parent_rule_id := parent_rul_row.rule_id;
819: l_value_found := 1;
820: END LOOP;
821: IF l_value_found = 0 THEN
822: cn_message_pkg.debug ('load_rules: Invalid Parent Rule name :' || rule_name_rec.parent_rule_name);
823: x_err_mssg := fnd_message.get_string('CN','CN_IMP_INVLD_PAR_RUL_NM');
824: x_retcode := 2;
825: l_error_code := 'CN_IMP_INVLD_PAR_RUL_NM';
826: seterr_imp_rules

Line 852: cn_message_pkg.debug ('load_rules: Invalid Revenue class name :' || rules_rec.revenue_class_name);

848: l_value_found := 1;
849: l_rule_rec.revenue_class_id := revenue_row.revenue_class_id;
850: END LOOP;
851: IF l_value_found = 0 THEN
852: cn_message_pkg.debug ('load_rules: Invalid Revenue class name :' || rules_rec.revenue_class_name);
853: x_err_mssg := fnd_message.get_string('CN','CN_IMP_INVLD_REVNU_CLASS_NM');
854: x_retcode := 2;
855: l_error_code := 'CN_IMP_INVLD_REVNU_CLASS_NM';
856: seterr_imp_rules

Line 876: cn_message_pkg.debug('load_rules: Creating rule, rule name:' || rule_name_rec.rule_name);

872: END IF;
873: END IF;
874:
875: -- Create rule
876: cn_message_pkg.debug('load_rules: Creating rule, rule name:' || rule_name_rec.rule_name);
877: cn_message_pkg.debug('load_rules: rule_name_rec.parent_rule_name:' || rule_name_rec.parent_rule_name || ' l_rule_rec.parent_rule_id:' || l_rule_rec.parent_rule_id);
878: cn_message_pkg.debug('load_rules: rules_rec.revenue_class_name:' || rules_rec.revenue_class_name || ' l_rule_rec.revenue_class_id:' || l_rule_rec.revenue_class_id);
879: cn_message_pkg.debug('load_rules: rules_rec.expense_code: ' || rules_rec.expense_code || ' l_rule_rec.expense_ccid: ' || l_rule_rec.expense_ccid);
880: cn_message_pkg.debug('load_rules: rules_rec.liability_code: ' || rules_rec.liability_code || ' l_rule_rec.liability_ccid: ' || l_rule_rec.liability_ccid);

Line 877: cn_message_pkg.debug('load_rules: rule_name_rec.parent_rule_name:' || rule_name_rec.parent_rule_name || ' l_rule_rec.parent_rule_id:' || l_rule_rec.parent_rule_id);

873: END IF;
874:
875: -- Create rule
876: cn_message_pkg.debug('load_rules: Creating rule, rule name:' || rule_name_rec.rule_name);
877: cn_message_pkg.debug('load_rules: rule_name_rec.parent_rule_name:' || rule_name_rec.parent_rule_name || ' l_rule_rec.parent_rule_id:' || l_rule_rec.parent_rule_id);
878: cn_message_pkg.debug('load_rules: rules_rec.revenue_class_name:' || rules_rec.revenue_class_name || ' l_rule_rec.revenue_class_id:' || l_rule_rec.revenue_class_id);
879: cn_message_pkg.debug('load_rules: rules_rec.expense_code: ' || rules_rec.expense_code || ' l_rule_rec.expense_ccid: ' || l_rule_rec.expense_ccid);
880: cn_message_pkg.debug('load_rules: rules_rec.liability_code: ' || rules_rec.liability_code || ' l_rule_rec.liability_ccid: ' || l_rule_rec.liability_ccid);
881: cn_message_pkg.debug('load_rules: rules_rec.revenue_class_name: ' || rules_rec.revenue_class_name || ' l_rule_rec.revenue_class_id: ' || l_rule_rec.revenue_class_id);

Line 878: cn_message_pkg.debug('load_rules: rules_rec.revenue_class_name:' || rules_rec.revenue_class_name || ' l_rule_rec.revenue_class_id:' || l_rule_rec.revenue_class_id);

874:
875: -- Create rule
876: cn_message_pkg.debug('load_rules: Creating rule, rule name:' || rule_name_rec.rule_name);
877: cn_message_pkg.debug('load_rules: rule_name_rec.parent_rule_name:' || rule_name_rec.parent_rule_name || ' l_rule_rec.parent_rule_id:' || l_rule_rec.parent_rule_id);
878: cn_message_pkg.debug('load_rules: rules_rec.revenue_class_name:' || rules_rec.revenue_class_name || ' l_rule_rec.revenue_class_id:' || l_rule_rec.revenue_class_id);
879: cn_message_pkg.debug('load_rules: rules_rec.expense_code: ' || rules_rec.expense_code || ' l_rule_rec.expense_ccid: ' || l_rule_rec.expense_ccid);
880: cn_message_pkg.debug('load_rules: rules_rec.liability_code: ' || rules_rec.liability_code || ' l_rule_rec.liability_ccid: ' || l_rule_rec.liability_ccid);
881: cn_message_pkg.debug('load_rules: rules_rec.revenue_class_name: ' || rules_rec.revenue_class_name || ' l_rule_rec.revenue_class_id: ' || l_rule_rec.revenue_class_id);
882:

Line 879: cn_message_pkg.debug('load_rules: rules_rec.expense_code: ' || rules_rec.expense_code || ' l_rule_rec.expense_ccid: ' || l_rule_rec.expense_ccid);

875: -- Create rule
876: cn_message_pkg.debug('load_rules: Creating rule, rule name:' || rule_name_rec.rule_name);
877: cn_message_pkg.debug('load_rules: rule_name_rec.parent_rule_name:' || rule_name_rec.parent_rule_name || ' l_rule_rec.parent_rule_id:' || l_rule_rec.parent_rule_id);
878: cn_message_pkg.debug('load_rules: rules_rec.revenue_class_name:' || rules_rec.revenue_class_name || ' l_rule_rec.revenue_class_id:' || l_rule_rec.revenue_class_id);
879: cn_message_pkg.debug('load_rules: rules_rec.expense_code: ' || rules_rec.expense_code || ' l_rule_rec.expense_ccid: ' || l_rule_rec.expense_ccid);
880: cn_message_pkg.debug('load_rules: rules_rec.liability_code: ' || rules_rec.liability_code || ' l_rule_rec.liability_ccid: ' || l_rule_rec.liability_ccid);
881: cn_message_pkg.debug('load_rules: rules_rec.revenue_class_name: ' || rules_rec.revenue_class_name || ' l_rule_rec.revenue_class_id: ' || l_rule_rec.revenue_class_id);
882:
883: cn_rule_pvt.Create_Rule

Line 880: cn_message_pkg.debug('load_rules: rules_rec.liability_code: ' || rules_rec.liability_code || ' l_rule_rec.liability_ccid: ' || l_rule_rec.liability_ccid);

876: cn_message_pkg.debug('load_rules: Creating rule, rule name:' || rule_name_rec.rule_name);
877: cn_message_pkg.debug('load_rules: rule_name_rec.parent_rule_name:' || rule_name_rec.parent_rule_name || ' l_rule_rec.parent_rule_id:' || l_rule_rec.parent_rule_id);
878: cn_message_pkg.debug('load_rules: rules_rec.revenue_class_name:' || rules_rec.revenue_class_name || ' l_rule_rec.revenue_class_id:' || l_rule_rec.revenue_class_id);
879: cn_message_pkg.debug('load_rules: rules_rec.expense_code: ' || rules_rec.expense_code || ' l_rule_rec.expense_ccid: ' || l_rule_rec.expense_ccid);
880: cn_message_pkg.debug('load_rules: rules_rec.liability_code: ' || rules_rec.liability_code || ' l_rule_rec.liability_ccid: ' || l_rule_rec.liability_ccid);
881: cn_message_pkg.debug('load_rules: rules_rec.revenue_class_name: ' || rules_rec.revenue_class_name || ' l_rule_rec.revenue_class_id: ' || l_rule_rec.revenue_class_id);
882:
883: cn_rule_pvt.Create_Rule
884: ( p_api_version => 1.0,

Line 881: cn_message_pkg.debug('load_rules: rules_rec.revenue_class_name: ' || rules_rec.revenue_class_name || ' l_rule_rec.revenue_class_id: ' || l_rule_rec.revenue_class_id);

877: cn_message_pkg.debug('load_rules: rule_name_rec.parent_rule_name:' || rule_name_rec.parent_rule_name || ' l_rule_rec.parent_rule_id:' || l_rule_rec.parent_rule_id);
878: cn_message_pkg.debug('load_rules: rules_rec.revenue_class_name:' || rules_rec.revenue_class_name || ' l_rule_rec.revenue_class_id:' || l_rule_rec.revenue_class_id);
879: cn_message_pkg.debug('load_rules: rules_rec.expense_code: ' || rules_rec.expense_code || ' l_rule_rec.expense_ccid: ' || l_rule_rec.expense_ccid);
880: cn_message_pkg.debug('load_rules: rules_rec.liability_code: ' || rules_rec.liability_code || ' l_rule_rec.liability_ccid: ' || l_rule_rec.liability_ccid);
881: cn_message_pkg.debug('load_rules: rules_rec.revenue_class_name: ' || rules_rec.revenue_class_name || ' l_rule_rec.revenue_class_id: ' || l_rule_rec.revenue_class_id);
882:
883: cn_rule_pvt.Create_Rule
884: ( p_api_version => 1.0,
885: p_init_msg_list => fnd_api.g_true,

Line 895: cn_message_pkg.debug ('load_rules: completed creating new rule, l_return_status: ' || l_return_status || ' l_current_rule_id: ' || l_current_rule_id);

891: x_loading_status => l_loading_status,
892: p_rule_rec => l_rule_rec,
893: x_rule_id => l_current_rule_id);
894:
895: cn_message_pkg.debug ('load_rules: completed creating new rule, l_return_status: ' || l_return_status || ' l_current_rule_id: ' || l_current_rule_id);
896:
897: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
898: cn_message_pkg.debug ('load_rules: Error in Creating rule, rule name:' || rule_name_rec.rule_name);
899: x_err_mssg := l_msg_data;

Line 898: cn_message_pkg.debug ('load_rules: Error in Creating rule, rule name:' || rule_name_rec.rule_name);

894:
895: cn_message_pkg.debug ('load_rules: completed creating new rule, l_return_status: ' || l_return_status || ' l_current_rule_id: ' || l_current_rule_id);
896:
897: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
898: cn_message_pkg.debug ('load_rules: Error in Creating rule, rule name:' || rule_name_rec.rule_name);
899: x_err_mssg := l_msg_data;
900: x_retcode := 2;
901: l_error_code := 'CN_IMP_INVLD_RULE';
902: seterr_imp_rules

Line 919: cn_message_pkg.write

915: x_processed_row => x_processed_row);
916: GOTO end_load_rule;
917: END IF;
918:
919: cn_message_pkg.write
920: (p_message_text => 'Completed create Rule, name: ' || rule_name_rec.rule_name,
921: p_message_type => 'MILESTONE');
922:
923: cn_message_pkg.debug ('load_rules: Before load_rule_attributes, rule name: ' || rule_name_rec.rule_name);

Line 923: cn_message_pkg.debug ('load_rules: Before load_rule_attributes, rule name: ' || rule_name_rec.rule_name);

919: cn_message_pkg.write
920: (p_message_text => 'Completed create Rule, name: ' || rule_name_rec.rule_name,
921: p_message_type => 'MILESTONE');
922:
923: cn_message_pkg.debug ('load_rules: Before load_rule_attributes, rule name: ' || rule_name_rec.rule_name);
924: -- now create the rule attributes
925: load_rule_attributes
926: ( p_ruleset_id => p_ruleset_id,
927: p_ruleset_name => p_ruleset_name,

Line 943: cn_message_pkg.debug ('load_rules: After load_rule_attributes, x_retcode: ' || x_retcode);

939: x_failed_row => x_failed_row,
940: x_processed_row => x_processed_row,
941: p_org_id => l_org_id);
942:
943: cn_message_pkg.debug ('load_rules: After load_rule_attributes, x_retcode: ' || x_retcode);
944:
945: IF x_retcode = 2 THEN
946: cn_message_pkg.debug ('load_rules: After call to load_rule_attributes for rule: ' || rule_name_rec.rule_name || ' with error msg:' || x_err_mssg);
947: GOTO end_load_rule;

Line 946: cn_message_pkg.debug ('load_rules: After call to load_rule_attributes for rule: ' || rule_name_rec.rule_name || ' with error msg:' || x_err_mssg);

942:
943: cn_message_pkg.debug ('load_rules: After load_rule_attributes, x_retcode: ' || x_retcode);
944:
945: IF x_retcode = 2 THEN
946: cn_message_pkg.debug ('load_rules: After call to load_rule_attributes for rule: ' || rule_name_rec.rule_name || ' with error msg:' || x_err_mssg);
947: GOTO end_load_rule;
948: END IF;
949: << end_load_rule >>
950: NULL;

Line 955: cn_message_pkg.debug ('load_rules: ### IMP ### EXCEPTION : in Creating rule:' || SQLERRM);

951: END LOOP; -- of rules_rec loop
952:
953: EXCEPTION
954: WHEN OTHERS THEN
955: cn_message_pkg.debug ('load_rules: ### IMP ### EXCEPTION : in Creating rule:' || SQLERRM);
956: x_err_mssg := SQLERRM;
957: x_retcode := 2;
958: l_error_code := 'CN_IMP_INVLD_RULE';
959: seterr_imp_rules

Line 1050: cn_message_pkg.write

1046:
1047: attrb_name_row c_rule_attrb_object_name%ROWTYPE;
1048: BEGIN
1049: FOR attr_rec IN c_rule_attrb_csr LOOP
1050: cn_message_pkg.write
1051: (p_message_text => 'Start create Rule Attribute, name: ' || attr_rec.rule_attribute,
1052: p_message_type => 'MILESTONE');
1053:
1054: l_current_imp_line_id := attr_rec.imp_line_id;

Line 1055: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_attribute: ' || attr_rec.rule_attribute);

1051: (p_message_text => 'Start create Rule Attribute, name: ' || attr_rec.rule_attribute,
1052: p_message_type => 'MILESTONE');
1053:
1054: l_current_imp_line_id := attr_rec.imp_line_id;
1055: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_attribute: ' || attr_rec.rule_attribute);
1056: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_value: ' || attr_rec.rule_value);
1057: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_hierarchy: ' || attr_rec.rule_hierarchy);
1058: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_low_value: ' || attr_rec.rule_low_value);
1059: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_high_value: ' || attr_rec.rule_high_value);

Line 1056: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_value: ' || attr_rec.rule_value);

1052: p_message_type => 'MILESTONE');
1053:
1054: l_current_imp_line_id := attr_rec.imp_line_id;
1055: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_attribute: ' || attr_rec.rule_attribute);
1056: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_value: ' || attr_rec.rule_value);
1057: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_hierarchy: ' || attr_rec.rule_hierarchy);
1058: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_low_value: ' || attr_rec.rule_low_value);
1059: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_high_value: ' || attr_rec.rule_high_value);
1060:

Line 1057: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_hierarchy: ' || attr_rec.rule_hierarchy);

1053:
1054: l_current_imp_line_id := attr_rec.imp_line_id;
1055: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_attribute: ' || attr_rec.rule_attribute);
1056: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_value: ' || attr_rec.rule_value);
1057: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_hierarchy: ' || attr_rec.rule_hierarchy);
1058: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_low_value: ' || attr_rec.rule_low_value);
1059: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_high_value: ' || attr_rec.rule_high_value);
1060:
1061: IF (attr_rec.rule_attribute IS NULL) OR

Line 1058: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_low_value: ' || attr_rec.rule_low_value);

1054: l_current_imp_line_id := attr_rec.imp_line_id;
1055: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_attribute: ' || attr_rec.rule_attribute);
1056: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_value: ' || attr_rec.rule_value);
1057: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_hierarchy: ' || attr_rec.rule_hierarchy);
1058: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_low_value: ' || attr_rec.rule_low_value);
1059: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_high_value: ' || attr_rec.rule_high_value);
1060:
1061: IF (attr_rec.rule_attribute IS NULL) OR
1062: (attr_rec.rule_value IS NOT NULL AND attr_rec.rule_low_value IS NOT NULL) OR

Line 1059: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_high_value: ' || attr_rec.rule_high_value);

1055: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_attribute: ' || attr_rec.rule_attribute);
1056: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_value: ' || attr_rec.rule_value);
1057: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_hierarchy: ' || attr_rec.rule_hierarchy);
1058: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_low_value: ' || attr_rec.rule_low_value);
1059: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_high_value: ' || attr_rec.rule_high_value);
1060:
1061: IF (attr_rec.rule_attribute IS NULL) OR
1062: (attr_rec.rule_value IS NOT NULL AND attr_rec.rule_low_value IS NOT NULL) OR
1063: (attr_rec.rule_value IS NOT NULL AND attr_rec.rule_high_value IS NOT NULL)OR

Line 1066: cn_message_pkg.debug ('load_rule_attributes: Invalid rule attribute');

1062: (attr_rec.rule_value IS NOT NULL AND attr_rec.rule_low_value IS NOT NULL) OR
1063: (attr_rec.rule_value IS NOT NULL AND attr_rec.rule_high_value IS NOT NULL)OR
1064: (attr_rec.rule_hierarchy IS NOT NULL AND attr_rec.rule_low_value IS NOT NULL) OR
1065: (attr_rec.rule_hierarchy IS NOT NULL AND attr_rec.rule_high_value IS NOT NULL) THEN
1066: cn_message_pkg.debug ('load_rule_attributes: Invalid rule attribute');
1067: x_err_mssg := fnd_message.get_string('CN', 'CN_IMP_INVLD_RULE_ATTRB');
1068: x_retcode := 2;
1069: x_imp_line_id := attr_rec.imp_line_id;
1070: l_error_code := 'CN_IMP_INVLD_RULE_ATTRB';

Line 1091: cn_message_pkg.debug ('load_rule_attributes: Invalid attr_rec.rule_attribute: ' || attr_rec.rule_attribute);

1087: l_value_found := 1;
1088: l_rule_attrb_rec.object_name := attrb_name_row.name;
1089: END LOOP;
1090: IF l_value_found = 0 THEN
1091: cn_message_pkg.debug ('load_rule_attributes: Invalid attr_rec.rule_attribute: ' || attr_rec.rule_attribute);
1092: x_err_mssg := fnd_message.get_string('CN', 'CN_IMP_INVLD_RUL_ATTR');
1093: x_retcode := 2;
1094: x_imp_line_id := attr_rec.imp_line_id;
1095: l_error_code := 'CN_IMP_INVLD_RUL_ATTR';

Line 1105: cn_message_pkg.debug ('load_rule_attributes: Past the basic validation');

1101: x_failed_row := x_failed_row + 1;
1102: GOTO end_rule_attr;
1103: END IF;
1104:
1105: cn_message_pkg.debug ('load_rule_attributes: Past the basic validation');
1106: cn_message_pkg.debug ('load_rule_attributes: p_ruleset_id: ' || p_ruleset_id);
1107: cn_message_pkg.debug ('load_rule_attributes: p_rule_id: ' || p_rule_id);
1108: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_attribute: ' || attr_rec.rule_attribute);
1109:

Line 1106: cn_message_pkg.debug ('load_rule_attributes: p_ruleset_id: ' || p_ruleset_id);

1102: GOTO end_rule_attr;
1103: END IF;
1104:
1105: cn_message_pkg.debug ('load_rule_attributes: Past the basic validation');
1106: cn_message_pkg.debug ('load_rule_attributes: p_ruleset_id: ' || p_ruleset_id);
1107: cn_message_pkg.debug ('load_rule_attributes: p_rule_id: ' || p_rule_id);
1108: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_attribute: ' || attr_rec.rule_attribute);
1109:
1110: IF attr_rec.not_flag IS NULL OR attr_rec.not_flag = 'N' THEN

Line 1107: cn_message_pkg.debug ('load_rule_attributes: p_rule_id: ' || p_rule_id);

1103: END IF;
1104:
1105: cn_message_pkg.debug ('load_rule_attributes: Past the basic validation');
1106: cn_message_pkg.debug ('load_rule_attributes: p_ruleset_id: ' || p_ruleset_id);
1107: cn_message_pkg.debug ('load_rule_attributes: p_rule_id: ' || p_rule_id);
1108: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_attribute: ' || attr_rec.rule_attribute);
1109:
1110: IF attr_rec.not_flag IS NULL OR attr_rec.not_flag = 'N' THEN
1111: l_rule_attrb_rec.not_flag := 'N';

Line 1108: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_attribute: ' || attr_rec.rule_attribute);

1104:
1105: cn_message_pkg.debug ('load_rule_attributes: Past the basic validation');
1106: cn_message_pkg.debug ('load_rule_attributes: p_ruleset_id: ' || p_ruleset_id);
1107: cn_message_pkg.debug ('load_rule_attributes: p_rule_id: ' || p_rule_id);
1108: cn_message_pkg.debug ('load_rule_attributes: attr_rec.rule_attribute: ' || attr_rec.rule_attribute);
1109:
1110: IF attr_rec.not_flag IS NULL OR attr_rec.not_flag = 'N' THEN
1111: l_rule_attrb_rec.not_flag := 'N';
1112: ELSIF attr_rec.not_flag = 'Y' THEN

Line 1115: cn_message_pkg.debug ('load_rule_attributes: Invalid not flag value: ' || attr_rec.not_flag);

1111: l_rule_attrb_rec.not_flag := 'N';
1112: ELSIF attr_rec.not_flag = 'Y' THEN
1113: l_rule_attrb_rec.not_flag := 'Y';
1114: ELSE
1115: cn_message_pkg.debug ('load_rule_attributes: Invalid not flag value: ' || attr_rec.not_flag);
1116: x_err_mssg := fnd_message.get_string('CN', 'CN_IMP_INVLD_NOT_FLG_VAL');
1117: x_retcode := 2;
1118: x_imp_line_id := attr_rec.imp_line_id;
1119: l_error_code := 'CN_IMP_INVLD_NOT_FLG_VAL';

Line 1129: cn_message_pkg.debug ('load_rule_attributes: attr_rec.not_flag: ' || attr_rec.not_flag);

1125: x_failed_row := x_failed_row + 1;
1126: GOTO end_rule_attr;
1127: END IF;
1128:
1129: cn_message_pkg.debug ('load_rule_attributes: attr_rec.not_flag: ' || attr_rec.not_flag);
1130:
1131: IF attr_rec.rule_value IS NOT NULL AND attr_rec.rule_hierarchy IS NULL THEN
1132: -- this is a Single Value Attribute
1133: cn_message_pkg.debug ('load_rule_attributes: CASE :Single Value Attribute');

Line 1133: cn_message_pkg.debug ('load_rule_attributes: CASE :Single Value Attribute');

1129: cn_message_pkg.debug ('load_rule_attributes: attr_rec.not_flag: ' || attr_rec.not_flag);
1130:
1131: IF attr_rec.rule_value IS NOT NULL AND attr_rec.rule_hierarchy IS NULL THEN
1132: -- this is a Single Value Attribute
1133: cn_message_pkg.debug ('load_rule_attributes: CASE :Single Value Attribute');
1134: l_rule_attrb_rec.value_1 := attr_rec.rule_value;
1135: l_rule_attrb_rec.value_2 := NULL;
1136: l_rule_attrb_rec.data_flag := 'O';
1137: ELSIF attr_rec.rule_value IS NOT NULL AND attr_rec.rule_hierarchy IS NOT NULL THEN

Line 1139: cn_message_pkg.debug ('load_rule_attributes: CASE :Hierarchy Attribute');

1135: l_rule_attrb_rec.value_2 := NULL;
1136: l_rule_attrb_rec.data_flag := 'O';
1137: ELSIF attr_rec.rule_value IS NOT NULL AND attr_rec.rule_hierarchy IS NOT NULL THEN
1138: -- this is a Hierarchy Attribute
1139: cn_message_pkg.debug ('load_rule_attributes: CASE :Hierarchy Attribute');
1140: OPEN c_rule_attrb_hier_id_csr (attr_rec.rule_hierarchy);
1141: FETCH c_rule_attrb_hier_id_csr INTO l_rule_attrb_rec.value_1;
1142: CLOSE c_rule_attrb_hier_id_csr;
1143:

Line 1151: cn_message_pkg.debug ('load_rule_attributes: CASE :Range Value Attribute');

1147:
1148: l_rule_attrb_rec.data_flag := 'H';
1149: ELSE
1150: -- this is a Range Value Attribute
1151: cn_message_pkg.debug ('load_rule_attributes: CASE :Range Value Attribute');
1152: l_rule_attrb_rec.value_1 := attr_rec.rule_low_value;
1153: l_rule_attrb_rec.value_2 := attr_rec.rule_high_value;
1154: l_rule_attrb_rec.data_flag := 'R';
1155: END IF;

Line 1157: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.data_flag:' || l_rule_attrb_rec.data_flag);

1153: l_rule_attrb_rec.value_2 := attr_rec.rule_high_value;
1154: l_rule_attrb_rec.data_flag := 'R';
1155: END IF;
1156:
1157: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.data_flag:' || l_rule_attrb_rec.data_flag);
1158: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.value_2:' || l_rule_attrb_rec.value_2);
1159: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.value_1:' || l_rule_attrb_rec.value_1);
1160:
1161: cn_message_pkg.debug ('load_rule_attributes: Before call to CN_RuleAttribute_PVT.Create_RuleAttribute for attribute: ' || attr_rec.rule_attribute);

Line 1158: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.value_2:' || l_rule_attrb_rec.value_2);

1154: l_rule_attrb_rec.data_flag := 'R';
1155: END IF;
1156:
1157: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.data_flag:' || l_rule_attrb_rec.data_flag);
1158: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.value_2:' || l_rule_attrb_rec.value_2);
1159: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.value_1:' || l_rule_attrb_rec.value_1);
1160:
1161: cn_message_pkg.debug ('load_rule_attributes: Before call to CN_RuleAttribute_PVT.Create_RuleAttribute for attribute: ' || attr_rec.rule_attribute);
1162:

Line 1159: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.value_1:' || l_rule_attrb_rec.value_1);

1155: END IF;
1156:
1157: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.data_flag:' || l_rule_attrb_rec.data_flag);
1158: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.value_2:' || l_rule_attrb_rec.value_2);
1159: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.value_1:' || l_rule_attrb_rec.value_1);
1160:
1161: cn_message_pkg.debug ('load_rule_attributes: Before call to CN_RuleAttribute_PVT.Create_RuleAttribute for attribute: ' || attr_rec.rule_attribute);
1162:
1163: CN_RuleAttribute_PVT.Create_RuleAttribute

Line 1161: cn_message_pkg.debug ('load_rule_attributes: Before call to CN_RuleAttribute_PVT.Create_RuleAttribute for attribute: ' || attr_rec.rule_attribute);

1157: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.data_flag:' || l_rule_attrb_rec.data_flag);
1158: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.value_2:' || l_rule_attrb_rec.value_2);
1159: cn_message_pkg.debug ('load_rule_attributes: l_rule_attrb_rec.value_1:' || l_rule_attrb_rec.value_1);
1160:
1161: cn_message_pkg.debug ('load_rule_attributes: Before call to CN_RuleAttribute_PVT.Create_RuleAttribute for attribute: ' || attr_rec.rule_attribute);
1162:
1163: CN_RuleAttribute_PVT.Create_RuleAttribute
1164: ( p_api_version => 1.0,
1165: p_init_msg_list => fnd_api.g_true,

Line 1174: cn_message_pkg.debug ('load_rule_attributes: Completed creating new rule attribute, l_return_status:' || l_return_status);

1170: x_msg_data => l_msg_data,
1171: x_loading_status => l_loading_status,
1172: p_RuleAttribute_rec => l_rule_attrb_rec);
1173:
1174: cn_message_pkg.debug ('load_rule_attributes: Completed creating new rule attribute, l_return_status:' || l_return_status);
1175:
1176: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
1177: cn_message_pkg.debug ('load_rule_attributes: Error when creating new rule attribute, l_msg_data:' || l_msg_data);
1178: x_err_mssg := l_msg_data;

Line 1177: cn_message_pkg.debug ('load_rule_attributes: Error when creating new rule attribute, l_msg_data:' || l_msg_data);

1173:
1174: cn_message_pkg.debug ('load_rule_attributes: Completed creating new rule attribute, l_return_status:' || l_return_status);
1175:
1176: IF l_return_status <> FND_API.G_RET_STS_SUCCESS THEN
1177: cn_message_pkg.debug ('load_rule_attributes: Error when creating new rule attribute, l_msg_data:' || l_msg_data);
1178: x_err_mssg := l_msg_data;
1179: x_retcode := 2;
1180: x_imp_line_id := attr_rec.imp_line_id;
1181: l_error_code := 'CN_IMP_INVLD_RULE_ATTRB';

Line 1190: cn_message_pkg.write

1186: p_head_id => p_imp_header.imp_header_id);
1187: x_failed_row := x_failed_row + 1;
1188: GOTO end_rule_attr;
1189: END IF;
1190: cn_message_pkg.write
1191: (p_message_text => 'Completed create Rule Attribute, name: ' || attr_rec.rule_attribute,
1192: p_message_type => 'MILESTONE');
1193: -- Set status to Complete
1194: CN_IMPORT_PVT.update_imp_lines

Line 1204: cn_message_pkg.debug ('load_rule_attributes: ### IMP ### EXCEPTIONS :' || SQLERRM);

1200: x_processed_row := x_processed_row + 1;
1201: END LOOP;
1202: EXCEPTION
1203: WHEN OTHERS THEN
1204: cn_message_pkg.debug ('load_rule_attributes: ### IMP ### EXCEPTIONS :' || SQLERRM);
1205: x_err_mssg := SQLERRM;
1206: x_retcode := 2;
1207: x_imp_line_id := l_current_imp_line_id;
1208: l_error_code := 'CN_IMP_INVLD_RULE_ATTRB';

Line 1267: cn_message_pkg.debug('Updating cn_rules_imp_v with status:' || p_status);

1263: l_temp NUMBER := 0;
1264:
1265: PRAGMA AUTONOMOUS_TRANSACTION;
1266: BEGIN
1267: cn_message_pkg.debug('Updating cn_rules_imp_v with status:' || p_status);
1268: cn_message_pkg.debug('p_ruleset_name:' || p_ruleset_name);
1269: cn_message_pkg.debug('p_start_date:' || p_start_date);
1270: cn_message_pkg.debug('p_end_date:' || p_end_date);
1271: cn_message_pkg.debug('p_ruleset_type:' || p_ruleset_type);

Line 1268: cn_message_pkg.debug('p_ruleset_name:' || p_ruleset_name);

1264:
1265: PRAGMA AUTONOMOUS_TRANSACTION;
1266: BEGIN
1267: cn_message_pkg.debug('Updating cn_rules_imp_v with status:' || p_status);
1268: cn_message_pkg.debug('p_ruleset_name:' || p_ruleset_name);
1269: cn_message_pkg.debug('p_start_date:' || p_start_date);
1270: cn_message_pkg.debug('p_end_date:' || p_end_date);
1271: cn_message_pkg.debug('p_ruleset_type:' || p_ruleset_type);
1272: cn_message_pkg.debug('p_head_id:' || p_head_id);

Line 1269: cn_message_pkg.debug('p_start_date:' || p_start_date);

1265: PRAGMA AUTONOMOUS_TRANSACTION;
1266: BEGIN
1267: cn_message_pkg.debug('Updating cn_rules_imp_v with status:' || p_status);
1268: cn_message_pkg.debug('p_ruleset_name:' || p_ruleset_name);
1269: cn_message_pkg.debug('p_start_date:' || p_start_date);
1270: cn_message_pkg.debug('p_end_date:' || p_end_date);
1271: cn_message_pkg.debug('p_ruleset_type:' || p_ruleset_type);
1272: cn_message_pkg.debug('p_head_id:' || p_head_id);
1273: cn_message_pkg.debug('p_imp_line_id:' || p_imp_line_id);

Line 1270: cn_message_pkg.debug('p_end_date:' || p_end_date);

1266: BEGIN
1267: cn_message_pkg.debug('Updating cn_rules_imp_v with status:' || p_status);
1268: cn_message_pkg.debug('p_ruleset_name:' || p_ruleset_name);
1269: cn_message_pkg.debug('p_start_date:' || p_start_date);
1270: cn_message_pkg.debug('p_end_date:' || p_end_date);
1271: cn_message_pkg.debug('p_ruleset_type:' || p_ruleset_type);
1272: cn_message_pkg.debug('p_head_id:' || p_head_id);
1273: cn_message_pkg.debug('p_imp_line_id:' || p_imp_line_id);
1274:

Line 1271: cn_message_pkg.debug('p_ruleset_type:' || p_ruleset_type);

1267: cn_message_pkg.debug('Updating cn_rules_imp_v with status:' || p_status);
1268: cn_message_pkg.debug('p_ruleset_name:' || p_ruleset_name);
1269: cn_message_pkg.debug('p_start_date:' || p_start_date);
1270: cn_message_pkg.debug('p_end_date:' || p_end_date);
1271: cn_message_pkg.debug('p_ruleset_type:' || p_ruleset_type);
1272: cn_message_pkg.debug('p_head_id:' || p_head_id);
1273: cn_message_pkg.debug('p_imp_line_id:' || p_imp_line_id);
1274:
1275: OPEN c_check_imp_line_id_csr;

Line 1272: cn_message_pkg.debug('p_head_id:' || p_head_id);

1268: cn_message_pkg.debug('p_ruleset_name:' || p_ruleset_name);
1269: cn_message_pkg.debug('p_start_date:' || p_start_date);
1270: cn_message_pkg.debug('p_end_date:' || p_end_date);
1271: cn_message_pkg.debug('p_ruleset_type:' || p_ruleset_type);
1272: cn_message_pkg.debug('p_head_id:' || p_head_id);
1273: cn_message_pkg.debug('p_imp_line_id:' || p_imp_line_id);
1274:
1275: OPEN c_check_imp_line_id_csr;
1276: FETCH c_check_imp_line_id_csr INTO l_temp;

Line 1273: cn_message_pkg.debug('p_imp_line_id:' || p_imp_line_id);

1269: cn_message_pkg.debug('p_start_date:' || p_start_date);
1270: cn_message_pkg.debug('p_end_date:' || p_end_date);
1271: cn_message_pkg.debug('p_ruleset_type:' || p_ruleset_type);
1272: cn_message_pkg.debug('p_head_id:' || p_head_id);
1273: cn_message_pkg.debug('p_imp_line_id:' || p_imp_line_id);
1274:
1275: OPEN c_check_imp_line_id_csr;
1276: FETCH c_check_imp_line_id_csr INTO l_temp;
1277: CLOSE c_check_imp_line_id_csr;

Line 1286: cn_message_pkg.debug('l_temp:' || l_temp);

1282: ELSE
1283: l_temp := p_imp_line_id;
1284: END IF;
1285:
1286: cn_message_pkg.debug('l_temp:' || l_temp);
1287:
1288: UPDATE cn_rules_imp_v
1289: SET status_code=p_status, error_code=p_error_code, error_msg=p_error_mssg
1290: WHERE nvl(ruleset_name,FND_API.g_miss_char) = nvl(p_ruleset_name ,FND_API.g_miss_char)

Line 1309: cn_message_pkg.debug ('SQL%rowcount:' || SQL%rowcount || ' x_processed_row:' || x_processed_row || ' x_failed_row:' || x_failed_row);

1305: END IF;
1306:
1307: x_processed_row := x_processed_row + SQL%rowcount;
1308:
1309: cn_message_pkg.debug ('SQL%rowcount:' || SQL%rowcount || ' x_processed_row:' || x_processed_row || ' x_failed_row:' || x_failed_row);
1310: COMMIT;
1311: EXCEPTION
1312: WHEN OTHERS THEN
1313: cn_message_pkg.debug ('### IMP ### EXCEPTION: ' || SQLERRM);

Line 1313: cn_message_pkg.debug ('### IMP ### EXCEPTION: ' || SQLERRM);

1309: cn_message_pkg.debug ('SQL%rowcount:' || SQL%rowcount || ' x_processed_row:' || x_processed_row || ' x_failed_row:' || x_failed_row);
1310: COMMIT;
1311: EXCEPTION
1312: WHEN OTHERS THEN
1313: cn_message_pkg.debug ('### IMP ### EXCEPTION: ' || SQLERRM);
1314: END update_imp_lines;
1315:
1316: END CN_IMP_RULE_PVT;
1317: