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.ZPB_ACVAL_PVT dependencies on ZPB_LOG

Line 264: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, 'Running Validations for business process ' || to_char(l_edt_ac_id) || '.');

260: -- API body
261: l_edt_ac_id := p_analysis_cycle_id;
262:
263:
264: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, 'Running Validations for business process ' || to_char(l_edt_ac_id) || '.');
265:
266: -- get the published_ac_id
267: open published_ac;
268: fetch published_ac into l_pub_ac_id;

Line 294: zpb_log.write_statement(G_PKG_NAME,'pub id is '||to_char(l_pub_ac_id));

290: end if;
291:
292:
293: -- verify that no changes were made to dataset settings
294: zpb_log.write_statement(G_PKG_NAME,'pub id is '||to_char(l_pub_ac_id));
295: open data_set;
296: fetch data_set into dummy_var;
297: if (data_set%found) then
298: close data_set;

Line 305: zpb_log.write_statement(G_PKG_NAME,'data set succeeded');

301: end if;
302: close data_set;
303:
304: -- verify that no changes were made to horizon settings
305: zpb_log.write_statement(G_PKG_NAME,'data set succeeded');
306: for i in 4..17 loop
307: open cycle_params(i);
308: fetch cycle_params into dummy_var;
309: if cycle_params%found then

Line 328: zpb_log.write_statement(G_PKG_NAME,'Horizon params succeeded');

324: end if;
325: close cycle_params;
326:
327:
328: zpb_log.write_statement(G_PKG_NAME,'Horizon params succeeded');
329:
330: -- verify that no changes are made to dimensions in composite
331: open cycle_params(52);
332: fetch cycle_params into dummy_var;

Line 350: zpb_log.write_statement(G_PKG_NAME,'Published cycle does not have more dims than temp');

346: x_changeCurrentRun := 'N';
347: return;
348: end if;
349:
350: zpb_log.write_statement(G_PKG_NAME,'Published cycle does not have more dims than temp');
351: open model_dimensions_edt;
352: fetch model_dimensions_edt into l_cycle_dim,l_dataset_dim,l_removed_dim;
353: if (model_dimensions_edt%found) then
354: close model_dimensions_edt;

Line 359: zpb_log.write_statement(G_PKG_NAME,'Tmp cycle does not have more dims than published');

355: x_changeCurrentRun := 'N';
356: return;
357: end if;
358:
359: zpb_log.write_statement(G_PKG_NAME,'Tmp cycle does not have more dims than published');
360:
361: -- verify that no changes were made to Solve source type to Input/Input and Init
362: open source_type;
363: fetch source_type into dummy_var;

Line 370: zpb_log.write_statement(G_PKG_NAME,'Tmp cycle does not have any line members that changed to input and initialized');

366: x_changeCurrentRun := 'N';
367: return;
368: end if;
369: close source_type;
370: zpb_log.write_statement(G_PKG_NAME,'Tmp cycle does not have any line members that changed to input and initialized');
371:
372: -- verify that no changes were made to Solve initialization source view
373: open source_view_cur;
374: fetch source_view_cur into dummy_var;

Line 381: zpb_log.write_statement(G_PKG_NAME,'Tmp cycle does not have any input line members that have changed initialization source');

377: x_changeCurrentRun := 'N';
378: return;
379: end if;
380: close source_view_cur;
381: zpb_log.write_statement(G_PKG_NAME,'Tmp cycle does not have any input line members that have changed initialization source');
382:
383: -- initialize solve strcutures for published id to enable comparison
384: initialize_solve_object(l_pub_ac_id);
385: if zpb_aw.interp('show vl.inseldiff(''' || l_pub_ac_id || ''',''' || l_edt_ac_id || ''')') > 0 then

Line 399: zpb_log.write_statement(G_PKG_NAME,'Temp cycle does not have any line members that have different output levels from published');

395: x_changeCurrentRun := 'N';
396: return;
397: end if;
398: close output_selections_edt;
399: zpb_log.write_statement(G_PKG_NAME,'Temp cycle does not have any line members that have different output levels from published');
400:
401: open output_selections_pub;
402: fetch output_selections_pub into dummy_var;
403: if (output_selections_pub%found) then

Line 409: zpb_log.write_statement(G_PKG_NAME,'Published cycle does not have any line members that have different output levels from edt');

405: x_changeCurrentRun := 'N';
406: return;
407: end if;
408: close output_selections_pub;
409: zpb_log.write_statement(G_PKG_NAME,'Published cycle does not have any line members that have different output levels from edt');
410:
411: -- verify that no changes were made to Solve allocation definitions
412: open allocation_def_edt;
413: fetch allocation_def_edt into dummy_var;

Line 420: zpb_log.write_statement(G_PKG_NAME,'Temp cycle does not have any line members that have different allocation definition from published');

416: x_changeCurrentRun := 'N';
417: return;
418: end if;
419: close allocation_def_edt;
420: zpb_log.write_statement(G_PKG_NAME,'Temp cycle does not have any line members that have different allocation definition from published');
421:
422: open allocation_def_pub;
423: fetch allocation_def_pub into dummy_var;
424: if (allocation_def_pub%found) then

Line 430: zpb_log.write_statement(G_PKG_NAME,'Published cycle does not have any line members that have different allocation definition from edt');

426: x_changeCurrentRun := 'N';
427: return;
428: end if;
429: close allocation_def_pub;
430: zpb_log.write_statement(G_PKG_NAME,'Published cycle does not have any line members that have different allocation definition from edt');
431:
432: -- verify that no changes were made to order of existing tasks
433: open task_list;
434: fetch task_list into dummy_var;

Line 441: zpb_log.write_statement(G_PKG_NAME,'Published cycle does not have any tasks that are different in edt');

437: x_changeCurrentRun := 'N';
438: return;
439: end if;
440: close task_list;
441: zpb_log.write_statement(G_PKG_NAME,'Published cycle does not have any tasks that are different in edt');
442:
443:
444: open task_list_pub;
445: fetch task_list_pub into dummy_var;

Line 452: zpb_log.write_statement(G_PKG_NAME,'Published cycle does not have any tasks that do not exist in edt');

448: x_changeCurrentRun := 'N';
449: return;
450: end if;
451: close task_list_pub;
452: zpb_log.write_statement(G_PKG_NAME,'Published cycle does not have any tasks that do not exist in edt');
453:
454: open query_identifier(l_edt_ac_id);
455: fetch query_identifier into l_edt_query_path;
456: close query_identifier;

Line 461: zpb_log.write_statement(G_PKG_NAME,'Published path:'||l_pub_query_path);

457:
458: open query_identifier(l_pub_ac_id);
459: fetch query_identifier into l_pub_query_path;
460: close query_identifier;
461: zpb_log.write_statement(G_PKG_NAME,'Published path:'||l_pub_query_path);
462: zpb_log.write_statement(G_PKG_NAME,'Temporary path:'||l_edt_query_path);
463:
464: compare_line_members(l_pub_query_path, l_edt_query_path,l_lines_compare);
465: if l_lines_compare <> 0 then

Line 462: zpb_log.write_statement(G_PKG_NAME,'Temporary path:'||l_edt_query_path);

458: open query_identifier(l_pub_ac_id);
459: fetch query_identifier into l_pub_query_path;
460: close query_identifier;
461: zpb_log.write_statement(G_PKG_NAME,'Published path:'||l_pub_query_path);
462: zpb_log.write_statement(G_PKG_NAME,'Temporary path:'||l_edt_query_path);
463:
464: compare_line_members(l_pub_query_path, l_edt_query_path,l_lines_compare);
465: if l_lines_compare <> 0 then
466: x_changeCurrentRun := 'N';

Line 470: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, ' Validation completed for Analysis Cycle' || l_edt_ac_id || '.');

466: x_changeCurrentRun := 'N';
467: return;
468: end if;
469:
470: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, ' Validation completed for Analysis Cycle' || l_edt_ac_id || '.');
471:
472: /*
473: EXCEPTION
474: WHEN FND_API.G_EXC_ERROR THEN

Line 476: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

472: /*
473: EXCEPTION
474: WHEN FND_API.G_EXC_ERROR THEN
475: ROLLBACK TO zpb_acval_pvt_validate;
476: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
477: x_changeCurrentRun := 'Y';
478: return;
479: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
480: ROLLBACK TO zpb_acval_pvt_validate;

Line 481: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

477: x_changeCurrentRun := 'Y';
478: return;
479: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
480: ROLLBACK TO zpb_acval_pvt_validate;
481: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
482: x_changeCurrentRun := 'Y';
483: return;
484:
485: WHEN OTHERS THEN

Line 487: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

483: return;
484:
485: WHEN OTHERS THEN
486: ROLLBACK TO zpb_acval_pvt_validate;
487: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
488: x_changeCurrentRun := 'Y';
489: return;
490: */
491: END validate_currentrun_helper;

Line 545: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'valueset name:' ||l_vs);

541: zpb_aw_status.get_status(p_dataAw,p_first_query);
542: -- get the valuseset name
543: l_vs := '&' || 'joinchars('''||l_dataAwQual||''' obj(prp ''LASTQUERYVS'' '||''''
544: ||l_dataAwQual||p_line_dim ||'''))';
545: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'valueset name:' ||l_vs);
546:
547: -- initialize
548: zpb_aw.execute('push oknullstatus '||l_dataAwQual ||p_line_dim);
549: zpb_aw.execute('oknullstatus=y');

Line 562: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr w 40 values('||l_dataAwQual ||'l_temp_vs)'),1,254));

558: -- generate the valuseset for the second query
559: zpb_aw_status.get_status(p_dataAw,p_second_query);
560:
561:
562: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr w 40 values('||l_dataAwQual ||'l_temp_vs)'),1,254));
563: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr w 40 values('||l_vs||')'),1,254));
564:
565: -- check if the two valusesets are identical
566: l_first_superset := zpb_aw.interpbool('shw inlist(values('||l_dataAwQual||'l_temp_vs)'

Line 563: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr w 40 values('||l_vs||')'),1,254));

559: zpb_aw_status.get_status(p_dataAw,p_second_query);
560:
561:
562: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr w 40 values('||l_dataAwQual ||'l_temp_vs)'),1,254));
563: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr w 40 values('||l_vs||')'),1,254));
564:
565: -- check if the two valusesets are identical
566: l_first_superset := zpb_aw.interpbool('shw inlist(values('||l_dataAwQual||'l_temp_vs)'
567: || ' values('||l_vs||'))');

Line 590: zpb_log.write_event(G_PKG_NAME,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

586:
587: exception
588: when others then
589: l_equal := 0;
590: zpb_log.write_event(G_PKG_NAME,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
591: return l_equal;
592:
593: end ;
594: -- this procedure returns can return 4 different values in the output variable

Line 616: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'line_dim:' ||l_dataAwQual || l_line_dim);

612: l_dataAwQual := l_dataAw ||'!';
613:
614: -- get line dimension name
615: l_line_dim := zpb_aw.interp('shw CM.GETLINEDIM('''||l_dataAw||''')');
616: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'line_dim:' ||l_dataAwQual || l_line_dim);
617:
618: x_equal := compare_queries(l_dataAw,p_first_query,p_second_query,l_line_dim);
619: -- cleanup and return
620: if (not zpb_aw.interpbool('shw exists(''l_temp_vs'')')) then

Line 627: zpb_log.write_event(G_PKG_NAME,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

623:
624: exception
625: when others then
626: x_equal := 0;
627: zpb_log.write_event(G_PKG_NAME,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
628:
629: end compare_line_members;
630:
631:

Line 655: zpb_log.write_event(G_PKG_NAME||l_api_name,zpb_aw.interp('rpr w 30 aw(list)'));

651: zpb_aw.initialize_workspace(1.0, FND_API.G_FALSE,
652: FND_API.G_VALID_LEVEL_FULL, return_status, msg_count,
653: msg_data, fnd_global.user_id, 'ZPB_MANAGER_RESP');
654: */
655: zpb_log.write_event(G_PKG_NAME||l_api_name,zpb_aw.interp('rpr w 30 aw(list)'));
656: zpb_aw.execute('call sv.get.solvedef('''||p_analysis_cycle_id||''' NA yes)');
657: zpb_aw.execute('call cm.setinsels('''||p_analysis_cycle_id||''')');
658: zpb_aw.execute('call cm.setoutsels('''||p_analysis_cycle_id||''', '''||p_analysis_cycle_id||''')');
659:

Line 676: zpb_log.write_statement(G_PKG_NAME||l_api_name,zpb_aw.interp('rpr w 30 aw(list)'));

672: zpb_aw.execute('pop oknullstatus');
673: -- zpb_aw.execute('aw detach '|| zpb_aw.get_schema||'.'||p_data_aw );
674: -- zpb_aw.execute('aw detach '|| zpb_aw.get_schema||'.'||zpb_aw.get_code_aw(fnd_global.user_id) );
675:
676: zpb_log.write_statement(G_PKG_NAME||l_api_name,zpb_aw.interp('rpr w 30 aw(list)'));
677:
678: -- dont call clean_workspace because it resets the context also. Will have to fix this later.
679: -- zpb_aw.clean_workspace(1.0, FND_API.G_FALSE, FND_API.G_VALID_LEVEL_FULL, return_status, msg_count, msg_data);
680:

Line 712: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, 'Validating if solve is equal to model ' || to_char(p_analysis_cycle_id) || '.');

708: and analysis_cycle_id = p_analysis_cycle_id;
709:
710: begin
711:
712: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, 'Validating if solve is equal to model ' || to_char(p_analysis_cycle_id) || '.');
713: -- initialize_solve_object(p_analysis_cycle_id);
714: zpb_aw.execute('push SV.LN.DIM ');
715: l_pushed_solve := 'Y';
716: l_dataAw := zpb_aw.get_schema||'.'||zpb_aw.get_shared_aw;

Line 738: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);

734: end if;
735:
736: close query_identifier;
737:
738: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);
739:
740: zpb_aw_status.get_status(l_dataAw,l_query_name);
741:
742: if zpb_aw.interpbool('shw inlist(values(SV.LN.DIM) values('||

Line 756: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );

752: else
753: x_comparision := '3';
754: end if;
755: end if;
756: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );
757: zpb_aw.execute('pop SV.LN.DIM ');
758: return;
759:
760: exception

Line 766: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

762: x_comparision := 4;
763: if l_pushed_solve = 'Y' then
764: zpb_aw.execute('pop SV.LN.DIM ');
765: end if;
766: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
767:
768: end val_solve_eq_model;
769:
770: -- this procedure returns two possible output values

Line 854: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);

850:
851: l_query_name := l_query_path ||'/' || l_query_name;
852: -- l_query_name := 'System Private/Controller/AC11736/MODEL_QUERY_5894';
853:
854: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);
855: zpb_aw_status.get_status(l_dataAw,l_query_name);
856:
857: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );
858:

Line 857: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );

853:
854: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);
855: zpb_aw_status.get_status(l_dataAw,l_query_name);
856:
857: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );
858:
859: zpb_aw.execute(' lmt SV.LN.DIM keep filterlines(values(sv.ln.dim) if inlist(values('||l_vs||') value) then na else value)');
860: end loop;
861:

Line 863: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values(SV.LN.DIM)'),1,255) );

859: zpb_aw.execute(' lmt SV.LN.DIM keep filterlines(values(sv.ln.dim) if inlist(values('||l_vs||') value) then na else value)');
860: end loop;
861:
862:
863: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values(SV.LN.DIM)'),1,255) );
864:
865: if zpb_aw.interpbool('shw statlen(SV.LN.DIM) gt 0 ') then
866: x_isvalid := 'N';
867: x_dim_members := zpb_aw.interp('shw joinchars(joincols(filterlines(values(SV.LN.DIM) joinchars(''\'''' value ''\'''')) '',''))');

Line 870: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(x_dim_members,1,254));

866: x_isvalid := 'N';
867: x_dim_members := zpb_aw.interp('shw joinchars(joincols(filterlines(values(SV.LN.DIM) joinchars(''\'''' value ''\'''')) '',''))');
868: if length(x_dim_members) > 0 then
869: x_dim_members := substr(x_dim_members,1,length(x_dim_members)-1);
870: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(x_dim_members,1,254));
871: end if;
872: else
873: x_isvalid := 'Y';
874: end if;

Line 886: zpb_log.write_event(G_PKG_NAME,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

882: if l_pushed_solve = 'Y' then
883: zpb_aw.execute('pop SV.LN.DIM ');
884: end if;
885:
886: zpb_log.write_event(G_PKG_NAME,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
887:
888: end val_solve_eq_data_load;
889:
890:

Line 930: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, 'Validating if generate worksheet tasks have input line member ' || to_char(p_analysis_cycle_id) || '.');

926: and name in ('QUERY_OBJECT_PATH','QUERY_OBJECT_NAME','DATA_SELECTION_TYPE');
927:
928: begin
929:
930: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, 'Validating if generate worksheet tasks have input line member ' || to_char(p_analysis_cycle_id) || '.');
931: zpb_aw.execute('push SV.LN.DIM ');
932: l_pushed_solve := 'Y';
933: x_isvalid := 'Y';
934: l_dataAw := zpb_aw.get_schema||'.'||zpb_aw.get_shared_aw;

Line 957: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,to_char(l_task_id));

953: l_path_exists := 'n';
954: l_name_exists := 'n';
955: l_task_id := each.task_id;
956: l_task_name := each.task_name;
957: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,to_char(l_task_id));
958:
959: for each in load_data_query loop
960: if (each.name = 'QUERY_OBJECT_PATH') then
961: l_path_exists := 'y';

Line 990: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);

986:
987: if l_selection_type <> 'ALL_LINE_ITEMS_SELECTION_TYPE' then
988: l_query_name := l_query_path ||'/' || l_query_name;
989:
990: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);
991: zpb_aw_status.get_status(l_dataAw,l_query_name);
992:
993: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );
994: if not zpb_aw.interpbool('shw inlist(values(SV.LN.DIM) values('||

Line 993: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );

989:
990: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);
991: zpb_aw_status.get_status(l_dataAw,l_query_name);
992:
993: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );
994: if not zpb_aw.interpbool('shw inlist(values(SV.LN.DIM) values('||
995: l_vs||'))') then
996:
997: x_isvalid := 'N';

Line 1002: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(l_dim_members,1,254));

998: zpb_aw.execute('lmt '||l_vs||' remove values(SV.LN.DIM)');
999: l_dim_members := zpb_aw.interp('shw joinchars(joincols(filterlines(values('||l_vs||') joinchars(''\'''' value ''\'''')) '',''))');
1000: if length(l_dim_members) > 0 then
1001: l_dim_members := substr(l_dim_members,1,length(l_dim_members)-1);
1002: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(l_dim_members,1,254));
1003: end if;
1004: -- construct the list. Also check for the max length case(highly unlikely)
1005: if nvl(length(x_dim_members),0) + length(l_dim_members) < MAX_LENGTH then
1006: x_dim_members := x_dim_members || ',' ||l_dim_members;

Line 1031: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(x_task_name,1,254));

1027: zpb_aw.execute('pop '||l_vs);
1028:
1029: if length(x_task_name) > 0 then
1030: x_task_name := substr(x_task_name,1,length(x_task_name)-1);
1031: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(x_task_name,1,254));
1032: end if;
1033: if length(x_dim_members) > 0 then
1034: x_dim_members := substr(x_dim_members,2,length(x_dim_members)-1);
1035: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(x_dim_members,1,254));

Line 1035: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(x_dim_members,1,254));

1031: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(x_task_name,1,254));
1032: end if;
1033: if length(x_dim_members) > 0 then
1034: x_dim_members := substr(x_dim_members,2,length(x_dim_members)-1);
1035: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(x_dim_members,1,254));
1036: end if;
1037: return;
1038:
1039: exception

Line 1047: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

1043: zpb_aw.execute('pop SV.LN.DIM ');
1044: -- for bug 4771735
1045: zpb_aw.execute('pop '||l_vs);
1046: end if;
1047: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
1048:
1049: end val_solve_gt_than_load;
1050:
1051: -- this procedure returns two possible output values

Line 1087: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, 'Validating if all generate worksheet tasks have an input line member ' || to_char(p_analysis_cycle_id));

1083: where task_id = l_task_id
1084: and name in ('TEMPLATE_DATAENTRY_OBJ_PATH','TEMPLATE_DATAENTRY_OBJ_NAME');
1085: begin
1086:
1087: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, 'Validating if all generate worksheet tasks have an input line member ' || to_char(p_analysis_cycle_id));
1088: zpb_aw.execute('push SV.LN.DIM ');
1089: l_pushed_solve := 'Y';
1090: x_invalid_tasks_list := '';
1091: l_dataAw := zpb_aw.get_schema||'.'||zpb_aw.get_shared_aw;

Line 1109: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,to_char(l_task_id));

1105: l_path_exists := 'n';
1106: l_name_exists := 'n';
1107: l_task_id := each.task_id;
1108: l_task_name := each.task_name;
1109: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,to_char(l_task_id));
1110:
1111: for each in generate_worksheet_query loop
1112: if (each.name = 'TEMPLATE_DATAENTRY_OBJ_PATH') then
1113: l_path_exists := 'y';

Line 1133: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);

1129:
1130: l_query_name := l_query_path ||'/' || l_query_name;
1131: -- l_query_name := 'System Private/Controller/AC11736/MODEL_QUERY_5894';
1132:
1133: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);
1134: zpb_aw_status.get_status(l_dataAw,l_query_name);
1135:
1136: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );
1137: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values(SV.LN.DIM)'),1,254) );

Line 1136: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );

1132:
1133: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);
1134: zpb_aw_status.get_status(l_dataAw,l_query_name);
1135:
1136: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );
1137: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values(SV.LN.DIM)'),1,254) );
1138: zpb_aw.execute('lmt '|| l_vs || ' keep values(SV.LN.DIM)');
1139:
1140: -- add to the list of invalid tasks if the validation fails

Line 1137: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values(SV.LN.DIM)'),1,254) );

1133: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);
1134: zpb_aw_status.get_status(l_dataAw,l_query_name);
1135:
1136: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );
1137: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values(SV.LN.DIM)'),1,254) );
1138: zpb_aw.execute('lmt '|| l_vs || ' keep values(SV.LN.DIM)');
1139:
1140: -- add to the list of invalid tasks if the validation fails
1141: if zpb_aw.interpbool('shw statlen('||l_vs||') gt 0 ') then

Line 1162: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'invalid tasks:'|| x_invalid_tasks_list);

1158: if x_isvalid = 'N' and length(x_invalid_tasks_list) > 0 then
1159: x_invalid_tasks_list := substr(x_invalid_tasks_list,2);
1160: end if;
1161:
1162: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'invalid tasks:'|| x_invalid_tasks_list);
1163: return;
1164:
1165: exception
1166: when others then

Line 1171: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

1167: x_isvalid := 'Y';
1168: if l_pushed_solve = 'Y' then
1169: zpb_aw.execute('pop SV.LN.DIM ');
1170: end if;
1171: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
1172:
1173: end validate_generate_worksheet;
1174:
1175: PROCEDURE validate_input_selections(

Line 1364: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name,'validating solve input levels');

1360:
1361: -- Initialize API return status to success
1362: x_return_status := FND_API.G_RET_STS_SUCCESS;
1363: x_isvalid := 'Y';
1364: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name,'validating solve input levels');
1365: l_dataAw := zpb_aw.get_schema||'.'||zpb_aw.get_shared_aw || '!';
1366: l_alldims_invalid := 'N';
1367: zpb_aw.execute('lmt ' || l_dataAw ||'instance to '''|| p_analysis_cycle_id ||'''');
1368: l_lineDim := zpb_aw.interp('shw CM.GETLINEDIM(''SHARED'')');

Line 1460: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name, 'cur line = '

1456: open selection_member_c(l_currentDim,l_inputSelection);
1457: fetch selection_member_c into l_currentLine;
1458: close selection_member_c;
1459:
1460: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name, 'cur line = '
1461: || l_currentLine||l_currentDim||l_inputSelection );
1462:
1463:
1464: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'cuminputvs ' ||

Line 1464: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'cuminputvs ' ||

1460: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name, 'cur line = '
1461: || l_currentLine||l_currentDim||l_inputSelection );
1462:
1463:
1464: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'cuminputvs ' ||
1465: substr(zpb_aw.interp('shw values('||
1466: l_dataAw|| l_cuminputvs||')'),1,200));
1467:
1468:

Line 1525: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,'Returning :' || x_isvalid);

1521: -- traverse the input dim list
1522: l_currpos := l_nextpos + 1;
1523: end loop; -- outer loop for dim list
1524:
1525: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,'Returning :' || x_isvalid);
1526: -- remove the extra comma
1527: if x_isvalid = 'N' then
1528: x_invalid_dim_list := substr(x_invalid_dim_list,2,length(x_invalid_dim_list)-1);
1529: x_invalid_linemem_list := substr(x_invalid_linemem_list,2,length(x_invalid_linemem_list)-1);

Line 1552: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

1548: ROLLBACK TO validate_input_selections;
1549: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1550: x_isvalid := 'N';
1551: --dbms_output.put_line(to_char(sqlcode) || substr(sqlerrm,1,200));
1552: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
1553: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
1554: FND_MSG_PUB.Add_Exc_Msg(
1555: G_PKG_NAME,
1556: l_api_name

Line 1716: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name,'validating solve levels');

1712: -- Initialize API return status to success
1713: x_return_status := FND_API.G_RET_STS_SUCCESS;
1714: x_isvalid := 'Y';
1715:
1716: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name,'validating solve levels');
1717:
1718: l_timedim := zpb_aw.interp('shw dl.gettimedim');
1719:
1720: l_dataAw := zpb_aw.get_schema||'.'||zpb_aw.get_shared_aw || '!';

Line 1769: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name, 'cur line = '

1765: open selection_member_c(l_currentDim,l_outputSelection);
1766: fetch selection_member_c into l_currentLine;
1767: close selection_member_c;
1768:
1769: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name, 'cur line = '
1770: || l_currentLine||l_currentDim||l_outputSelection );
1771:
1772: zpb_aw.execute('lmt ' || l_dataAw ||l_lineDim || ' to ''' ||
1773: l_currentLine||'''');

Line 1846: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

1842: --dbms_output.put_line(to_char(sqlcode) || substr(sqlerrm,1,190));
1843: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
1844: x_isvalid := 'N';
1845: --dbms_output.put_line(to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
1846: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
1847: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
1848: FND_MSG_PUB.Add_Exc_Msg(
1849: G_PKG_NAME,
1850: l_api_name

Line 1927: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, 'Validating if template lines exist in model ' || to_char(p_analysis_cycle_id) || '.');

1923:
1924: -- Initialize API return status to success
1925: x_return_status := FND_API.G_RET_STS_SUCCESS;
1926:
1927: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, 'Validating if template lines exist in model ' || to_char(p_analysis_cycle_id) || '.');
1928: x_isvalid := 'Y';
1929: -- initialize_solve_object(p_analysis_cycle_id);
1930: l_dataAw := zpb_aw.get_schema||'.'||zpb_aw.get_shared_aw;
1931:

Line 1946: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_model_query);

1942: end if;
1943:
1944: close query_model;
1945:
1946: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_model_query);
1947:
1948: l_task_exists := 'n';
1949: for each in generate_task loop
1950: l_task_exists := 'y';

Line 1955: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,to_char(l_task_id));

1951: l_path_exists := 'n';
1952: l_name_exists := 'n';
1953: l_task_id := each.task_id;
1954: l_task_name := each.task_name;
1955: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,to_char(l_task_id));
1956:
1957: for each in generate_worksheet_query loop
1958: if (each.name = 'TEMPLATE_DATAENTRY_OBJ_PATH') then
1959: l_path_exists := 'y';

Line 1978: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_template_query);

1974:
1975: l_template_query := l_template_path ||'/' || l_template_query;
1976: -- l_query_name := 'System Private/Controller/AC11736/MODEL_QUERY_5894';
1977:
1978: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_template_query);
1979:
1980: l_lines_compare := compare_queries(l_dataAw,l_model_query, l_template_query,l_line_dim);
1981: if l_lines_compare = 3 OR l_lines_compare = 2 then
1982: x_isvalid := 'N';

Line 1997: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'invalid tasks:'|| x_invalid_tasks_list);

1993: if x_isvalid = 'N' and length(x_invalid_tasks_list) > 0 then
1994: x_invalid_tasks_list := substr(x_invalid_tasks_list,2);
1995: end if;
1996:
1997: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'invalid tasks:'|| x_invalid_tasks_list);
1998: return;
1999:
2000:
2001: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, ' Validation completed for Analysis Cycle' || p_analysis_cycle_id || '.');

Line 2001: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, ' Validation completed for Analysis Cycle' || p_analysis_cycle_id || '.');

1997: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'invalid tasks:'|| x_invalid_tasks_list);
1998: return;
1999:
2000:
2001: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, ' Validation completed for Analysis Cycle' || p_analysis_cycle_id || '.');
2002:
2003: exception
2004: WHEN FND_API.G_EXC_ERROR THEN
2005: ROLLBACK TO val_gentemp_le_model;

Line 2022: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

2018: WHEN OTHERS THEN
2019: ROLLBACK TO val_gentemp_le_model;
2020: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2021: x_isvalid := 'N';
2022: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
2023: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
2024: FND_MSG_PUB.Add_Exc_Msg(
2025: G_PKG_NAME,
2026: l_api_name

Line 2144: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);

2140:
2141: l_query_name := l_query_path ||'/' || l_query_name;
2142: -- l_query_name := 'System Private/Controller/AC11736/MODEL_QUERY_5894';
2143:
2144: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);
2145: zpb_aw_status.get_status(l_dataAw,l_query_name);
2146:
2147: --zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );
2148:

Line 2147: --zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );

2143:
2144: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,'query is :' ||l_query_name);
2145: zpb_aw_status.get_status(l_dataAw,l_query_name);
2146:
2147: --zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values('||l_vs||')'),1,254) );
2148:
2149: zpb_aw.execute(' lmt SV.LN.DIM keep filterlines(values(sv.ln.dim) if inlist(values('||l_vs||') value) then na else value)');
2150: end loop;
2151:

Line 2153: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values(SV.LN.DIM)'),1,255) );

2149: zpb_aw.execute(' lmt SV.LN.DIM keep filterlines(values(sv.ln.dim) if inlist(values('||l_vs||') value) then na else value)');
2150: end loop;
2151:
2152:
2153: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(zpb_aw.interp('rpr values(SV.LN.DIM)'),1,255) );
2154:
2155: if zpb_aw.interpbool('shw statlen(SV.LN.DIM) gt 0 ') then
2156: x_isvalid := 'N';
2157: x_dim_members := zpb_aw.interp('shw joinchars(joincols(filterlines(values(SV.LN.DIM) joinchars(''\'''' value ''\'''')) '',''))');

Line 2160: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(x_dim_members,1,254));

2156: x_isvalid := 'N';
2157: x_dim_members := zpb_aw.interp('shw joinchars(joincols(filterlines(values(SV.LN.DIM) joinchars(''\'''' value ''\'''')) '',''))');
2158: if length(x_dim_members) > 0 then
2159: x_dim_members := substr(x_dim_members,1,length(x_dim_members)-1);
2160: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,substr(x_dim_members,1,254));
2161: end if;
2162: else
2163: x_isvalid := 'Y';
2164: end if;

Line 2188: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

2184: WHEN OTHERS THEN
2185: ROLLBACK TO val_gentemp_le_model;
2186: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2187: x_isvalid := 'N';
2188: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
2189: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
2190: FND_MSG_PUB.Add_Exc_Msg(
2191: G_PKG_NAME,
2192: l_api_name

Line 2275: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name,'validating solve levels');

2271: -- Initialize API return status to success
2272: x_return_status := FND_API.G_RET_STS_SUCCESS;
2273:
2274:
2275: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name,'validating solve levels');
2276: l_dataAw := zpb_aw.get_schema||'.'||zpb_aw.get_shared_aw(fnd_global.user_id);
2277: x_isvalid := 'Y';
2278: l_timedim := zpb_aw.interp('shw dl.gettimedim');
2279:

Line 2353: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

2349: WHEN OTHERS THEN
2350: ROLLBACK TO val_solve_input_higher_levels;
2351: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2352: x_isvalid := 'N';
2353: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
2354: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
2355: FND_MSG_PUB.Add_Exc_Msg(
2356: G_PKG_NAME,
2357: l_api_name

Line 2569: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name,'validating solve output levels');

2565:
2566: -- Initialize API return status to success
2567: x_return_status := FND_API.G_RET_STS_SUCCESS;
2568: x_isvalid := 'Y';
2569: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name,'validating solve output levels');
2570: l_dataAw := zpb_aw.get_schema||'.'||zpb_aw.get_shared_aw || '!';
2571: l_alldims_invalid := 'N';
2572: zpb_aw.execute('lmt ' || l_dataAw ||'instance to '''|| p_analysis_cycle_id ||'''');
2573: l_lineDim := zpb_aw.interp('shw CM.GETLINEDIM(''SHARED'')');

Line 2672: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,zpb_aw.interp('shw statlen(' || l_outputvs ||') ne statlen('||

2668:
2669:
2670:
2671:
2672: zpb_log.write_statement(G_PKG_NAME||'.'||l_api_name,zpb_aw.interp('shw statlen(' || l_outputvs ||') ne statlen('||
2673: 'lmt(' || l_outputvs|| ' remove lmt(lmt('
2674: ||l_cuminputvs || ' add ancestors using '||l_parentRel||
2675: ') remove ' || l_cuminputvs ||')))'));
2676:

Line 2732: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,'Returning :' || x_isvalid);

2728: if x_isvalid = 'N' then
2729: x_invalid_dim_list := substr(x_invalid_dim_list,2,length(x_invalid_dim_list)-1);
2730: x_invalid_linemem_list := substr(x_invalid_linemem_list,2,length(x_invalid_linemem_list)-1);
2731: end if;
2732: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,'Returning :' || x_isvalid);
2733:
2734: exception
2735: WHEN FND_API.G_EXC_ERROR THEN
2736: ROLLBACK TO validate_output_selections;

Line 2753: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

2749: WHEN OTHERS THEN
2750: ROLLBACK TO validate_output_selections;
2751: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2752: x_isvalid := 'N';
2753: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
2754: -- dbms_output.put_line(to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
2755: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
2756: FND_MSG_PUB.Add_Exc_Msg(
2757: G_PKG_NAME,

Line 2823: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name,'validating solve levels');

2819:
2820: -- Initialize API return status to success
2821: x_return_status := FND_API.G_RET_STS_SUCCESS;
2822:
2823: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name,'validating solve levels');
2824: l_dataAw := zpb_aw.get_schema||'.'||zpb_aw.get_shared_aw||'!';
2825: x_isvalid := 'Y';
2826: l_timedim := zpb_aw.interp('shw dl.gettimedim');
2827:

Line 2911: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

2907: x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
2908: x_isvalid := 'N';
2909: -- dbms_output.put_line(to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
2910:
2911: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
2912: IF FND_MSG_PUB.Check_Msg_Level(FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
2913: FND_MSG_PUB.Add_Exc_Msg(
2914: G_PKG_NAME,
2915: l_api_name

Line 2955: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, ' View Deleted with Analysis Cycleid' || p_analysis_cycle_id || '.');

2951: delete FROM zpb_measure_scope WHERE instance_ac_id = p_analysis_cycle_id;
2952: delete FROM zpb_measure_scope_exempt_users WHERE BUSINESS_PROCESS_ENTITY_ID = p_analysis_cycle_id;
2953:
2954:
2955: ZPB_LOG.WRITE(G_PKG_NAME || '.' || l_api_name, ' View Deleted with Analysis Cycleid' || p_analysis_cycle_id || '.');
2956:
2957: EXCEPTION
2958: WHEN FND_API.G_EXC_ERROR THEN
2959: ROLLBACK TO zpb_acval_pvt_delete_view;

Line 2960: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

2956:
2957: EXCEPTION
2958: WHEN FND_API.G_EXC_ERROR THEN
2959: ROLLBACK TO zpb_acval_pvt_delete_view;
2960: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
2961:
2962: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2963: ROLLBACK TO zpb_acval_pvt_delete_view;
2964: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

Line 2964: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

2960: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
2961:
2962: WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2963: ROLLBACK TO zpb_acval_pvt_delete_view;
2964: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
2965:
2966:
2967: WHEN OTHERS THEN
2968: ROLLBACK TO zpb_acval_pvt_delete_view;

Line 2969: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));

2965:
2966:
2967: WHEN OTHERS THEN
2968: ROLLBACK TO zpb_acval_pvt_delete_view;
2969: zpb_log.write_event(G_PKG_NAME||'.'||l_api_name,to_char(sqlcode) ||':'|| substr(sqlerrm,1,90));
2970:
2971: end delete_view;
2972: -------------------------------------------------------------------------------
2973: