[Home] [Help]
PACKAGE BODY: APPS.QP_PREQ_PUB
Source
1 PACKAGE BODY QP_PREQ_PUB AS
2 /* $Header: QPXPPREB.pls 120.48.12020000.6 2013/01/31 18:34:46 jputta ship $ */
3
4 l_debug VARCHAR2(3);
5 G_VERSION VARCHAR2(240) := '/* $Header: QPXPPREB.pls 120.48.12020000.6 2013/01/31 18:34:46 jputta ship $ */';
6 G_ATTR_MGR_INSTALLED CONSTANT VARCHAR2(1) := QP_UTIL.Attrmgr_Installed;
7
8 G_ROUNDING_OPTIONS VARCHAR2(30);
9 G_USE_MULTI_CURRENCY_PUB VARCHAR2(1); -- bug 2943033
10 G_ROUND_INDIVIDUAL_ADJ VARCHAR2(30);
11 G_CALCULATE_FLAG VARCHAR2(30); --3401941
12
13 G_NO_ROUND CONSTANT VARCHAR2(30) := 'NO_ROUND';
14 G_ROUND_ADJ CONSTANT VARCHAR2(30) := 'ROUND_ADJ';
15 G_NO_ROUND_ADJ CONSTANT VARCHAR2(30) := 'NO_ROUND_ADJ';
16 G_ROUNDING_PROFILE CONSTANT VARCHAR2(1) := 'Q';
17
18 G_POST_ROUND CONSTANT VARCHAR2(30) := 'POST'; --[prarasto:Post Round] constant for post rounding
19
20 G_LIMITS_INSTALLED CONSTANT VARCHAR2(1) := FND_PROFILE.VALUE('QP_LIMITS_INSTALLED');
21
22 --prg processing pl/sql tbl
23 G_PRG_UNCH_CALC_PRICE_TBL QP_PREQ_GRP.NUMBER_TYPE;
24 G_PRG_UNCH_LINE_ID_TBL QP_PREQ_GRP.NUMBER_TYPE;
25 G_PRG_UNCH_LINE_IND_TBL QP_PREQ_GRP.NUMBER_TYPE;
26 G_prg_unch_new_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
27 G_prg_unch_line_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
28 G_prg_unch_process_sts_tbl QP_PREQ_GRP.VARCHAR_TYPE;
29
30 G_ldet_plsql_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
31 G_BACK_CALCULATION_CODE VARCHAR2(30);
32
33 G_NO_ADJ_PROCESSING VARCHAR2(1); --3169430
34 G_QP_INSTALL_STATUS VARCHAR2(1) := QP_UTIL.get_qp_status; --3169430
35
36
37 TYPE BACK_CALC_REC_TYPE IS RECORD
38 (LINE_INDEX NUMBER
39 , LINE_DETAIL_INDEX NUMBER
40 , LIST_LINE_ID NUMBER
41 , LIST_LINE_TYPE_CODE VARCHAR2(30)
42 , ADJUSTMENT_AMOUNT NUMBER
43 , MODIFIER_LEVEL_CODE VARCHAR2(30)
44 , OPERAND_VALUE NUMBER
45 , APPLIED_FLAG VARCHAR2(1)
46 , UPDATED_FLAG VARCHAR2(1)
47 , PROCESS_CODE VARCHAR2(30)
48 , PRICING_STATUS_CODE VARCHAR2(30)
49 , PRICING_STATUS_TEXT VARCHAR2(240)
50 , ROUNDING_FACTOR NUMBER
51 , CALCULATION_CODE VARCHAR2(30)
52 , LINE_QUANTITY NUMBER
53 , LIST_HEADER_ID NUMBER
54 , LIST_TYPE_CODE VARCHAR2(30)
55 , PRICE_BREAK_TYPE_CODE VARCHAR2(30)
56 , CHARGE_TYPE_CODE VARCHAR2(30)
57 , CHARGE_SUBTYPE_CODE VARCHAR2(30)
58 , AUTOMATIC_FLAG VARCHAR2(1)
59 , PRICING_PHASE_ID NUMBER
60 , LIMIT_CODE VARCHAR2(30)
61 , LIMIT_TEXT VARCHAR2(2000)
62 , OPERAND_CALCULATION_CODE VARCHAR2(30)
63 , PRICING_GROUP_SEQUENCE NUMBER
64 , LIST_LINE_NO VARCHAR2(240));
65
66
67 G_NOT_MAX_FRT_CHARGE CONSTANT VARCHAR2(100) := 'QP_PREQ_PUB:DELETED TO RETURN MAX/OVERRID FREIGHT CHARGE';
68 G_FREEZE_OVERRIDE_FLAG VARCHAR2(1) := '';
69 G_GSA_ENABLED_FLAG VARCHAR2(1) := NULL; --FND_API.G_MISS_CHAR;
70
71 FUNCTION Get_Version RETURN VARCHAR2 IS
72 BEGIN
73 RETURN G_Version;
74 END Get_Version;
75
76 PROCEDURE INITIALIZE_CONSTANTS(p_control_rec IN QP_PREQ_GRP.CONTROL_RECORD_TYPE
77 , x_return_status_text OUT NOCOPY VARCHAR2
78 , x_return_status OUT NOCOPY VARCHAR2) IS
79 /*
80 indxno index used
81 */
82 CURSOR l_init_pricelist_phase_cur IS
83 SELECT PHASE_SEQUENCE, PRICING_PHASE_ID
84 FROM QP_PRICING_PHASES
85 WHERE LIST_TYPE_CODE = 'PRL'
86 AND ROWNUM < 2;
87
88 /*
89 INDX,QP_PREQ_PUB.initialize_constants.l_check_pricing_phase_exists,QP_PRICING_PHASES_U1,PRICING_PHASE_ID,1
90 INDX,QP_PREQ_PUB.initialize_constants.l_check_pricing_phase_exists,QP_EVENT_PHASES_U1,PRICING_EVENT_CODE,1
91 INDX,QP_PREQ_PUB.initialize_constants.l_check_pricing_phase_exists,QP_EVENT_PHASES_U1,PRICING_PHASE_ID,1
92 */
93 CURSOR l_check_pricing_phase_exists(p_event VARCHAR2) IS
94 SELECT b.pricing_phase_id
95 , nvl(b.user_freeze_override_flag, b.freeze_override_flag)
96 FROM qp_event_phases a, qp_pricing_phases b
97 WHERE instr(p_event, a.pricing_event_code || ',') > 0
98 AND ((G_GET_FREIGHT_FLAG = G_YES AND b.freight_exists = G_YES)
99 OR (G_GET_FREIGHT_FLAG = G_NO))
100 AND a.pricing_phase_id = G_PRICE_LIST_PHASE_ID
101 AND b.pricing_phase_id = G_PRICE_LIST_PHASE_ID;
102
103 /*
104 indxno index used
105 */
106 CURSOR l_currency_code_cur IS
107 SELECT currency_code
108 FROM qp_npreq_lines_tmp;
109
110 /*
111 indxno index used
112 */
113 CURSOR l_min_max_eff_date_cur IS
114 SELECT MIN(pricing_effective_date)
115 , MAX(pricing_effective_date)
116 FROM qp_npreq_lines_tmp;
117
118 /*
119 indxno index used
120 */
121 CURSOR l_attr_sourcing_cur IS
122 SELECT line_index
123 , line_quantity
124 , priced_quantity
125 , unit_price
126 FROM qp_npreq_lines_tmp;
127
128 l_attr_sourcing_rec l_attr_sourcing_cur%ROWTYPE;
129
130 l_bypass_pricing VARCHAR2(30);
131 l_FIXED_PRICE CONSTANT NUMBER := 11.99;
132 l_pricing_phase NUMBER;
133 l_price_phase_flag VARCHAR2(1) := G_NO;
134 l_freeze_override_flag VARCHAR2(3);
135 l_null_eff_date_line NUMBER;
136 l_currency_code VARCHAR2(30);
137 l_status_text VARCHAR2(30);
138 l_routine VARCHAR2(50) := 'QP_PREQ_PUB.Initialize_Constants';
139 --sourcing volume attributes performance changes
140 l_source_qty_flag VARCHAR2(1);
141 l_source_amt_flag VARCHAR2(1);
142 l_null_price_req_code VARCHAR2(1) := G_NO;
143 l_missing_header VARCHAR2(30) := 'MISSING HEADER';
144 l_order_header_id NUMBER := 0;
145
146
147 E_CURRENCY_CODE_IS_NULL EXCEPTION;
148 E_INVALID_PHASE EXCEPTION;
149 E_INVALID_CONTROL_RECORD EXCEPTION;
150 E_BYPASS_PRICING EXCEPTION;
151 E_OTHER_ERRORS EXCEPTION;
152
153 BEGIN
154 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
155 IF l_debug = FND_API.G_TRUE THEN
156 QP_PREQ_GRP.engine_debug('begin initialize_constants');
157
158 END IF;
159
160
161 l_bypass_pricing := FND_PROFILE.VALUE(G_BYPASS_PRICING);
162
163 --pricing event can be null when applying manual adjustments
164 --IF(p_control_rec.PRICING_EVENT IS NULL
165 IF (p_control_rec.calculate_flag = NULL
166 OR UPPER(p_control_rec.SIMULATION_FLAG) NOT IN (G_YES, G_NO)
167 ) THEN
168 RAISE E_INVALID_CONTROL_RECORD;
169 END IF;
170
171
172 --update request_type_code to lines_tmp
173
174 UPDATE qp_npreq_lines_tmp
175 SET request_type_code = p_control_rec.request_type_code
176 WHERE request_type_code IS NULL;
177
178 IF l_debug = FND_API.G_TRUE THEN
179 QP_PREQ_GRP.engine_debug('1 initialize_constants');
180
181 END IF;
182 --populate G_PRICE_LIST_SEQUENCE,G_PRICE_LIST_PHASE_ID
183 OPEN l_init_pricelist_phase_cur;
184 FETCH l_init_pricelist_phase_cur INTO G_PRICE_LIST_SEQUENCE, G_PRICE_LIST_PHASE_ID;
185 CLOSE l_init_pricelist_phase_cur;
186
187
188 IF(G_PRICE_LIST_SEQUENCE = NULL OR G_PRICE_LIST_SEQUENCE = FND_API.G_MISS_NUM
189 OR G_PRICE_LIST_PHASE_ID = NULL OR G_PRICE_LIST_PHASE_ID = FND_API.G_MISS_NUM) THEN
190 RAISE E_INVALID_PHASE;
191 END IF;
192
193 IF l_debug = FND_API.G_TRUE THEN
194 QP_PREQ_GRP.engine_debug('2 initialize_constants');
195
196 END IF;
197 IF (l_bypass_pricing = 'Y' ) THEN
198
199 BEGIN
200 /*
201 indx no index used
202 */
203 UPDATE qp_npreq_lines_tmp SET
204 unit_price = l_FIXED_PRICE,
205 adjusted_unit_price = l_FIXED_PRICE,
206 pricing_status_code = G_STATUS_UPDATED
207 WHERE unit_price IS NULL
208 OR adjusted_unit_price IS NULL
209 OR unit_price = FND_API.G_MISS_NUM
210 OR adjusted_unit_price = FND_API.G_MISS_NUM;
211 EXCEPTION
212 WHEN OTHERS THEN
213 IF l_debug = FND_API.G_TRUE THEN
214 QP_PREQ_GRP.engine_debug('QP_PREQ_PUB: Init_cons update status '|| SQLERRM);
215 END IF;
216 x_return_status_text := SQLERRM;
217 RAISE E_OTHER_ERRORS;
218 END;
219 RAISE E_BYPASS_PRICING;
220
221 END IF;
222 IF l_debug = FND_API.G_TRUE THEN
223 QP_PREQ_GRP.engine_debug('3 initialize_constants');
224
225 END IF;
226 OPEN l_check_pricing_phase_exists(p_control_rec.PRICING_EVENT);
227 FETCH l_check_pricing_phase_exists INTO l_pricing_phase, l_freeze_override_flag;
228 CLOSE l_check_pricing_phase_exists;
229
230 IF (l_pricing_phase IS NOT NULL) THEN
231 l_price_phase_flag := G_YES;
232 G_PRICE_PHASE_FLAG := TRUE;
233 ELSE
234 l_price_phase_flag := G_NO;
235 G_PRICE_PHASE_FLAG := FALSE;
236 END IF;
237
238 G_FREEZE_OVERRIDE_FLAG := l_freeze_override_flag;
239
240 IF l_debug = FND_API.G_TRUE THEN
241 QP_PREQ_GRP.engine_debug('4 initialize_constants');
242
243
244 END IF;
245 OPEN l_CURRENCY_CODE_CUR;
246 FETCH l_CURRENCY_CODE_CUR INTO G_CURRENCY_CODE;
247 CLOSE l_CURRENCY_CODE_CUR;
248 --We expect that the user will pass currency code
249 --if not the engine will not return right price
250 IF G_CURRENCY_CODE IS NULL THEN
251 RAISE E_CURRENCY_CODE_IS_NULL;
252 END IF;
253
254 IF l_debug = FND_API.G_TRUE THEN
255 QP_PREQ_GRP.engine_debug('5 initialize_constants');
256
257 END IF;
258 OPEN l_min_max_eff_date_cur;
259 FETCH l_min_max_eff_date_cur INTO G_MIN_PRICING_DATE, G_MAX_PRICING_DATE;
260 CLOSE l_min_max_eff_date_cur;
261
262
263 IF l_debug = FND_API.G_TRUE THEN
264 QP_PREQ_GRP.engine_debug('5.5 initialize_constants');
265 END IF;
266 --update the price flag on summary line to 'P' if there is at least
267 --one line with price flag 'P'
268 --This is to avoid any more order level adjustments applied
269 --if any line has price_flag N/P
270 -- Not needed as this is being done in OM. Also OC folks got affected by this change wherein order level
271 -- adjustments were not getting applied on a service line pricing
272 -- Talked to Amy 01/14/03 and she confirmed that we can comment out this update
273
274 /* update qp_npreq_lines_tmp set price_flag = G_PHASE
275 where line_type_code = G_ORDER_LEVEL
276 and exists(select 'Y' from qp_npreq_lines_tmp
277 where price_flag in (G_PHASE,G_NO,G_CALCULATE_ONLY)
278 and line_type_code = G_LINE_LEVEL); */
279
280 IF l_debug = FND_API.G_TRUE THEN
281 QP_PREQ_GRP.engine_debug('5.6 initialize_constants');
282 END IF;
283 --fix for bug 2374591 ask for promotions not getting applied
284 --updating the list_header_id in the attribute where list_line_id is passed
285 UPDATE qp_npreq_line_attrs_tmp attr SET attr.list_header_id =
286 (SELECT qpl.list_header_id FROM
287 qp_list_lines qpl WHERE qpl.list_line_id = to_number(attr.value_from))
288 WHERE attr.context = 'MODLIST'
289 AND attribute = 'QUALIFIER_ATTRIBUTE2'
290 AND pricing_status_code = 'X';
291
292 IF l_debug = FND_API.G_TRUE THEN
293 QP_PREQ_GRP.engine_debug('6 initialize_constants');
294 QP_PREQ_GRP.engine_debug('Before update_rounding_factor:calculate_flag '
295 || p_control_rec.calculate_flag ||' rounding_flag '
296 || p_control_rec.rounding_flag);
297
298 END IF;
299 --This is to populate rounding factor based on price list on the line
300 --when engine is called with calculate_only as the calling appln does not
301 --store rounding_fac hence rounding factor will be null
302 IF p_control_rec.calculate_flag = G_CALCULATE_ONLY
303 AND nvl(p_control_rec.rounding_flag, G_YES) IN ('Q', 'U', G_YES, 'P') --[prarasto:Post Round] Added check to
304 --update rounding factor for Post Rounding
305 THEN
306 QP_PREQ_GRP.update_rounding_factor(G_USE_MULTI_CURRENCY_PUB,
307 x_return_status,
308 x_return_status_text);
309 IF x_return_status = FND_API.G_RET_STS_ERROR
310 THEN
311 RAISE E_OTHER_ERRORS;
312 END IF;
313 END IF;
314
315 IF l_debug = FND_API.G_TRUE THEN
316 QP_PREQ_GRP.engine_debug('6.5 initialize_constants');
317
318 END IF;
319 BEGIN
320 IF l_debug = FND_API.G_TRUE THEN
321 QP_PREQ_GRP.engine_debug('QP_PREQ_PUB before insert source line quantity ');
322 END IF;
323 --sourcing volume attributes performance changes
324 l_source_qty_flag := QP_BUILD_SOURCING_PVT.Is_Attribute_Used('VOLUME', 'PRICING_ATTRIBUTE10');
325 IF l_source_qty_flag = G_YES
326 THEN
327 IF l_debug = FND_API.G_TRUE THEN
328 QP_PREQ_GRP.engine_debug('Sourcing Line Quantity');
329
330 END IF;
331 /*
332 indxno index used
333 */
334 INSERT INTO qp_npreq_line_attrs_tmp
335 (LINE_INDEX
336 , LINE_DETAIL_INDEX
337 , ATTRIBUTE_LEVEL
338 , NO_QUALIFIERS_IN_GRP
339 , COMPARISON_OPERATOR_TYPE_CODE
340 , VALIDATED_FLAG
341 , APPLIED_FLAG
342 , PRICING_STATUS_CODE
343 , PRICING_STATUS_TEXT
344 , QUALIFIER_PRECEDENCE
345 , PRICING_ATTR_FLAG
346 , QUALIFIER_TYPE
347 , DATATYPE
348 , PRODUCT_UOM_CODE
349 , VALUE_TO
350 , SETUP_VALUE_TO
351 , GROUPING_NUMBER
352 , GROUP_AMOUNT
353 , DISTINCT_QUALIFIER_FLAG
354 , SETUP_VALUE_FROM
355 , ATTRIBUTE_TYPE
356 , LIST_HEADER_ID
357 , LIST_LINE_ID
358 , CONTEXT
359 , ATTRIBUTE
360 , VALUE_FROM
361 , PROCESSED_CODE
362 , EXCLUDER_FLAG
363 , GROUP_QUANTITY
364 )
365 SELECT
366 LINE_INDEX
367 , NULL
368 , G_LINE_LEVEL
369 , NULL
370 , NULL
371 , G_NO
372 , G_LIST_NOT_APPLIED
373 , G_STATUS_UNCHANGED
374 , NULL
375 , NULL
376 , G_YES
377 , NULL
378 , NULL
379 , NULL
380 , NULL
381 , NULL
382 , NULL
383 , NULL
384 , NULL
385 , NULL
386 , G_PRICING_TYPE
387 , NULL
388 , NULL
389 , G_PRIC_VOLUME_CONTEXT
390 , G_QUANTITY_ATTRIBUTE
391 , decode(l_price_phase_flag, G_YES, qp_number.number_to_canonical(nvl(LINE_QUANTITY, 0)), G_NO, qp_number.number_to_canonical(NVL(nvl(PRICED_QUANTITY, LINE_QUANTITY), 0)), 0)
392 , NULL
393 , NULL
394 , NULL
395 FROM qp_npreq_lines_tmp;
396
397 IF l_debug = FND_API.G_TRUE THEN
398 QP_PREQ_GRP.engine_debug('QP_PREQ_PUB after insert source line quantity ');
399 END IF;
400 END IF; --sourcing volume attributes performance changes
401 EXCEPTION
402 WHEN OTHERS THEN
403 IF l_debug = FND_API.G_TRUE THEN
404 QP_PREQ_GRP.engine_debug('QP_PREQ_PUB init_cons sourceqty exp '|| SQLERRM);
405 END IF;
406 x_return_status_text := SQLERRM;
407 RAISE E_OTHER_ERRORS;
408 END;
409
410
411
412 BEGIN
413 IF l_debug = FND_API.G_TRUE THEN
414 QP_PREQ_GRP.engine_debug('QP_PREQ_PUB before insert source line amt ');
415 END IF;
416 --sourcing volume attributes performance changes
417 l_source_amt_flag := QP_BUILD_SOURCING_PVT.Is_Attribute_Used('VOLUME', 'PRICING_ATTRIBUTE12');
418 IF l_source_amt_flag = G_YES
419 THEN
420 IF l_debug = FND_API.G_TRUE THEN
421 QP_PREQ_GRP.engine_debug('Sourcing Line Amount');
422 END IF;
423 /*
424 indxno index used
425 */
426 INSERT INTO qp_npreq_line_attrs_tmp
427 (LINE_INDEX
428 , LINE_DETAIL_INDEX
429 , ATTRIBUTE_LEVEL
430 , NO_QUALIFIERS_IN_GRP
431 , COMPARISON_OPERATOR_TYPE_CODE
432 , VALIDATED_FLAG
433 , APPLIED_FLAG
434 , PRICING_STATUS_CODE
435 , PRICING_STATUS_TEXT
436 , QUALIFIER_PRECEDENCE
437 , PRICING_ATTR_FLAG
438 , QUALIFIER_TYPE
439 , DATATYPE
440 , PRODUCT_UOM_CODE
441 , VALUE_TO
442 , SETUP_VALUE_TO
443 , GROUPING_NUMBER
444 , GROUP_AMOUNT
445 , DISTINCT_QUALIFIER_FLAG
446 , SETUP_VALUE_FROM
447 , ATTRIBUTE_TYPE
448 , LIST_HEADER_ID
449 , LIST_LINE_ID
450 , CONTEXT
451 , ATTRIBUTE
452 , VALUE_FROM
453 , PROCESSED_CODE
454 , EXCLUDER_FLAG
455 , GROUP_QUANTITY
456 )
457 SELECT
458 LINE_INDEX
459 , NULL
460 , LINE_TYPE_CODE
461 , NULL
462 , NULL
463 , G_NO
464 , QP_PREQ_GRP.G_LIST_NOT_APPLIED
465 , G_STATUS_UNCHANGED
466 , NULL
467 , NULL
468 , G_YES
469 , NULL
470 , NULL
471 , NULL
472 , NULL
473 , NULL
474 , NULL
475 , NULL
476 , NULL
477 , NULL
478 , G_PRICING_TYPE
479 , NULL
480 , NULL
481 , G_PRIC_VOLUME_CONTEXT
482 , G_LINE_AMT_ATTRIBUTE
483 , decode(l_price_phase_flag, G_YES, qp_number.number_to_canonical(nvl(LINE_QUANTITY * UNIT_PRICE, 0)), G_NO, qp_number.number_to_canonical(NVL(nvl(PRICED_QUANTITY, LINE_QUANTITY), 0) * nvl(UNIT_PRICE, 0)), 0)
484 , NULL
485 , NULL
486 , NULL
487 FROM qp_npreq_lines_tmp;
488 IF l_debug = FND_API.G_TRUE THEN
489 QP_PREQ_GRP.engine_debug('QP_PREQ_PUB after insert source line amt ');
490 END IF;
491 END IF; --sourcing volume attributes performance changes
492 EXCEPTION
493 WHEN OTHERS THEN
494 IF l_debug = FND_API.G_TRUE THEN
495 QP_PREQ_GRP.engine_debug('QP_PREQ_PUB init_cons sourceamt exp '|| SQLERRM);
496 END IF;
497 x_return_status_text := SQLERRM;
498 RAISE E_OTHER_ERRORS;
499 END;
500
501 -- limits check commented out per Ravi, part of accum range break changes
502 --IF G_LIMITS_INSTALLED = G_YES THEN
503 IF l_debug = FND_API.G_TRUE THEN
504 QP_PREQ_GRP.engine_debug('7.5 initialize_constants');
505 END IF;
506 BEGIN
507 --populate G_ORDER_PRICE_REQUEST_CODE for limits
508 SELECT line_id
509 INTO l_order_header_id
510 FROM qp_npreq_lines_tmp
511 WHERE line_type_code = G_ORDER_LEVEL;
512 IF l_debug = FND_API.G_TRUE THEN
513 QP_PREQ_GRP.engine_debug('l_order_header_id '|| l_order_header_id);
514 END IF;
515 QP_PREQ_GRP.G_ORDER_ID := l_order_header_id; -- accum range break
516 QP_PREQ_GRP.G_LINE_ID := null; -- 5706129, accum range break
517 IF l_order_header_id = 0 THEN
518 QP_PREQ_GRP.G_ORDER_PRICE_REQUEST_CODE := G_REQUEST_TYPE_CODE || '-' || l_missing_header;
519 ELSE
520 QP_PREQ_GRP.G_ORDER_PRICE_REQUEST_CODE := G_REQUEST_TYPE_CODE || '-' || l_order_header_id;
521 END IF; --l_order_header_id
522 IF l_debug = FND_API.G_TRUE THEN
523 QP_PREQ_GRP.engine_debug('QP_PREQ_GRP.G_ORDER_PRICE_REQUEST_CODE '|| QP_PREQ_GRP.G_ORDER_PRICE_REQUEST_CODE);
524 END IF;
525 EXCEPTION
526 WHEN OTHERS THEN
527 --this is not an error may be the summary line was not passed
528 QP_PREQ_GRP.G_ORDER_PRICE_REQUEST_CODE := G_REQUEST_TYPE_CODE || '-' || l_missing_header;
529 END;
530 --END IF;--G_LIMITS_INSTALLED
531
532 IF G_LIMITS_INSTALLED = G_YES THEN
533 IF l_debug = FND_API.G_TRUE THEN
534 QP_PREQ_GRP.engine_debug('7.6 initialize_constants');
535 END IF;
536 BEGIN
537 --populate price_request_code if not passed
538 SELECT G_YES INTO l_null_price_req_code
539 FROM qp_npreq_lines_tmp
540 WHERE --price_request_code IS NULL AND bug#14102682
541 price_flag IN (G_YES, G_PHASE)
542 AND ROWNUM = 1;
543
544 IF l_null_price_req_code = G_YES THEN
545 UPDATE qp_npreq_lines_tmp SET
546 price_request_code = decode(line_type_code,
547 G_ORDER_LEVEL, QP_PREQ_GRP.G_ORDER_PRICE_REQUEST_CODE
548 , G_LINE_LEVEL, QP_PREQ_GRP.G_ORDER_PRICE_REQUEST_CODE || '-' || nvl(line_id, qp_limit_price_request_code_s.NEXTVAL))
549 WHERE --price_request_code IS NULL AND bug#14102682
550 price_flag IN (G_YES, G_PHASE);
551 END IF; --l_null_price_req_code
552 EXCEPTION
553 WHEN OTHERS THEN
554 --this is not an error
555 IF l_debug = FND_API.G_TRUE THEN
556 QP_PREQ_GRP.engine_debug('populate price_request_code excep '|| SQLERRM);
557 END IF;
558 NULL;
559 END;
560 END IF; --G_LIMITS_INSTALLED
561
562
563 IF l_debug = FND_API.G_TRUE THEN
564 QP_PREQ_GRP.engine_debug('8.0 initialize_constants');
565 END IF;
566 -------------------------------------------------------------------------
567 EXCEPTION
568 WHEN E_CURRENCY_CODE_IS_NULL THEN
569 IF l_debug = FND_API.G_TRUE THEN
570 QP_PREQ_GRP.engine_debug('Currency code can not be null');
571 END IF;
572 x_return_status := FND_API.G_RET_STS_ERROR;
573 x_return_status_text := l_routine ||' Error : Currency can not be null';
574 WHEN E_INVALID_CONTROL_RECORD THEN
575 x_return_status := FND_API.G_RET_STS_ERROR;
576 x_return_status_text := l_routine ||' INVALID CONTROL RECORD';
577 IF l_debug = FND_API.G_TRUE THEN
578 QP_PREQ_GRP.engine_debug(x_return_status_text);
579 END IF;
580 WHEN E_INVALID_PHASE THEN
581 x_return_status := FND_API.G_RET_STS_ERROR;
582 x_return_status_text := l_routine ||' Invalid phase sequence for Price List phase, Check setup data';
583 IF l_debug = FND_API.G_TRUE THEN
584 QP_PREQ_GRP.engine_debug('Invalid phase sequence for Price List phase');
585 END IF;
586 WHEN E_BYPASS_PRICING THEN
587 x_return_status := 'BYPASS_PRICING';
588 x_return_status_text := l_routine ||' Pricing Bypassed';
589 WHEN E_OTHER_ERRORS THEN
590 x_return_status := FND_API.G_RET_STS_ERROR;
591 x_return_status_text := l_routine ||' '|| x_return_status_text;
592 WHEN OTHERS THEN
593 IF l_debug = FND_API.G_TRUE THEN
594 QP_PREQ_GRP.engine_debug(l_routine || l_status_text ||' '|| SQLERRM);
595 END IF;
596 x_return_status := FND_API.G_RET_STS_ERROR;
597 x_return_status_text := l_routine ||' '|| SQLERRM;
598 END INITIALIZE_CONSTANTS;
599
600
601 --4900095 service item lumpsum discount
602 --procedure to evaluate the quantity to prorate lumpsum
603 --to include the parent quantity
604
605 PROCEDURE Determine_svc_item_quantity IS
606 i NUMBER;
607 l_line_index NUMBER;
608 l_lgrp_vol_attr VARCHAR2(240);
609 --need to use index by varchar as the index used is list_line_id
610 --which is a number and can go beyond the binary integer bounds
611 TYPE num_indxbyvarchar_type IS TABLE OF NUMBER INDEX BY VARCHAR2(2000);
612 l_lumpsum_qty num_indxbyvarchar_type;
613 BEGIN
614 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
615 IF l_debug = FND_API.G_TRUE THEN
616 QP_PREQ_GRP.engine_debug('Begin Determine_svc_item_quantity');
617 END IF;
618 --bug 4900095 get service qty for lumpsum
619 i:= QP_PREQ_GRP.G_service_line_ind_tbl.FIRST;
620 IF l_debug = FND_API.G_TRUE THEN
621 QP_PREQ_GRP.engine_debug('loop index '||i);
622 END IF;
623 While i IS NOT NULL and QP_PREQ_GRP.G_service_line_ind_tbl(i) IS NOT NULL
624 LOOP
625 l_line_index := QP_PREQ_GRP.G_service_line_ind_tbl(i);
626 IF l_debug = FND_API.G_TRUE THEN
627 QP_PREQ_GRP.engine_debug('line_index of svc line: '||l_line_index);
628 END IF;--l_debug
629
630 for cl in
631 (select line.line_index, ldet.line_detail_index,
632 ldet.created_from_list_line_id, ldet.modifier_level_code,
633 line.priced_quantity, line.parent_quantity, line.unit_price
634 from qp_npreq_lines_tmp line, qp_npreq_ldets_tmp ldet
635 where line.line_index = l_line_index
636 and line.pricing_status_code in (G_STATUS_NEW, G_STATUS_UPDATED)
637 and line.price_flag in (G_YES, G_PHASE)
638 and line.line_type_code = G_LINE_LEVEL
639 and ldet.line_index = line.line_index
640 and ldet.pricing_status_code in
641 (QP_PREQ_GRP.G_STATUS_NEW, G_STATUS_UNCHANGED)
642 and ldet.applied_flag = G_YES
643 and nvl(ldet.operand_calculation_code,
644 QP_PREQ_GRP.G_LUMPSUM_DISCOUNT) = QP_PREQ_GRP.G_LUMPSUM_DISCOUNT
645 and ldet.created_from_list_line_type in
646 ('DIS', 'SUR', 'PBH', 'FREIGHT_CHARGE')
647 and ldet.modifier_level_code in
648 (QP_PREQ_GRP.G_LINE_LEVEL, QP_PREQ_GRP.G_LINE_GROUP))
649 loop
650 IF l_debug = FND_API.G_TRUE THEN
651 QP_PREQ_GRP.engine_debug('line_dtl_index of lumpsum adj '
652 ||cl.line_detail_index||' list_line_id '||cl.created_from_list_line_id
653 ||' modlevel '||cl.modifier_level_code||' parent_qty '
654 ||cl.parent_quantity||' priced_qty '||cl.priced_quantity
655 ||' unit_price '||cl.unit_price);
656 END IF;--l_debug
657 QP_PREQ_GRP.G_service_line_qty_tbl(cl.line_index) :=
658 cl.parent_quantity * cl.priced_quantity;
659 IF l_debug = FND_API.G_TRUE THEN
660 IF QP_PREQ_GRP.G_service_line_qty_tbl.exists(cl.line_index) THEN
661 QP_PREQ_GRP.engine_debug('service_qty of lumpsum adj '
662 ||QP_PREQ_GRP.G_service_line_qty_tbl(cl.line_index));
663 END IF;--QP_PREQ_GRP.G_service_line_qty_tbl
664 END IF;--l_debug
665
666 --for linegroup modifiers, need to evaluate group lumpsum qty
667 IF cl.modifier_level_code = QP_PREQ_GRP.G_LINE_GROUP
668 THEN
669 IF l_lumpsum_qty.exists(cl.created_from_list_line_id) THEN
670 QP_PREQ_GRP.G_Service_ldet_qty_tbl(cl.line_detail_index) :=
671 l_lumpsum_qty(cl.created_from_list_line_id);
672 ELSE--new list_line_id
673 BEGIN
674 --determine the volume attribute on the linegrp modifier
675 select attribute
676 into l_lgrp_vol_attr
677 from qp_npreq_line_attrs_tmp
678 where line_detail_index = cl.line_detail_index
679 and context = QP_PREQ_GRP.G_PRIC_VOLUME_CONTEXT;
680
681 IF l_debug = FND_API.G_TRUE THEN
682 QP_PREQ_GRP.engine_debug('vol attr for linegrp modifier'
683 ||l_lgrp_vol_attr);
684 END IF;--l_debug
685 EXCEPTION
686 When OTHERS then
687 l_lgrp_vol_attr := NULL;
688 IF l_debug = FND_API.G_TRUE THEN
689 QP_PREQ_GRP.engine_debug('null vol attr for linegrp modifier');
690 END IF;--l_debug
691 END;
692 --initialize lumpsum_qty for list_line_id
693 l_lumpsum_qty(cl.created_from_list_line_id) := 0;
694 --loop thru all the occurences of the linegrp modifier
695 --to total the group quantity as volattrval * parent_qty
696 --for svc lines and volattrval for non-svc lines
697 --this lumpsum_qty will be used to prorate the lumpsum adj_amt
698 for cl1 in (select line.line_index, lattr.value_from,
699 line.parent_quantity, ldet.line_detail_index
700 from qp_npreq_ldets_tmp ldet,
701 qp_npreq_lines_tmp line,
702 qp_npreq_line_attrs_tmp lattr
703 where ldet.created_from_list_line_id = cl.created_from_list_line_id
704 and ldet.pricing_status_code = G_STATUS_NEW
705 and ldet.applied_flag = G_YES
706 and line.line_index = ldet.line_index
707 and lattr.context = QP_PREQ_GRP.G_PRIC_VOLUME_CONTEXT
708 and lattr.attribute = l_lgrp_vol_attr
709 and lattr.line_index = line.line_index
710 and lattr.line_detail_index is null)
711 loop
712 IF QP_PREQ_GRP.G_service_line_ind_tbl.exists(cl1.line_index) THEN
713 --this is a service line linegroup lumpsum
714 l_lumpsum_qty(cl.created_from_list_line_id) :=
715 l_lumpsum_qty(cl.created_from_list_line_id) +
716 cl1.parent_quantity * cl1.value_from;
717 ELSE
718 --this is a non-service line linegroup lumpsum
719 l_lumpsum_qty(cl.created_from_list_line_id) :=
720 l_lumpsum_qty(cl.created_from_list_line_id) +
721 cl1.value_from;
722 END IF;--QP_PREQ_GRP.G_service_line_ind_tbl.exists
723
724 IF l_debug = FND_API.G_TRUE THEN
725 QP_PREQ_GRP.engine_debug('lumpsum dtls for this pass '
726 ||'llid '||cl.created_from_list_line_id
727 ||' line_index '||cl1.line_index
728 ||' dtl_index '||cl1.line_detail_index
729 ||' parent_qty '||cl1.parent_quantity
730 ||' vol_attr '||cl1.value_from
731 ||' qty running total '
732 ||l_lumpsum_qty(cl.created_from_list_line_id));
733 END IF;
734 end loop; --cl1
735 IF l_lgrp_vol_attr = G_LINE_AMT_ATTRIBUTE THEN
736 G_Service_pbh_lg_amt_qty(cl.line_detail_index) :=
737 l_lumpsum_qty(cl.created_from_list_line_id)/cl.unit_price;
738 QP_PREQ_GRP.G_Service_ldet_qty_tbl(cl.line_detail_index) :=
739 l_lumpsum_qty(cl.created_from_list_line_id);
740 ELSE
741 QP_PREQ_GRP.G_Service_ldet_qty_tbl(cl.line_detail_index) :=
742 l_lumpsum_qty(cl.created_from_list_line_id);
743 END IF;
744 IF l_debug = FND_API.G_TRUE THEN
745 IF QP_PREQ_GRP.G_Service_ldet_qty_tbl.exists(cl.line_detail_index)
746 THEN
747 QP_PREQ_GRP.engine_debug('linegrp lumpsum qty for list_line_id '
748 ||cl.created_from_list_line_id||' dtl_index '
749 ||cl.line_detail_index||' qty '
750 ||QP_PREQ_GRP.G_Service_ldet_qty_tbl(cl.line_detail_index));
751 END IF;--QP_PREQ_GRP.G_Service_ldet_qty_tbl.exists
752 END IF;
753 END IF;--l_lumpsum_qty.exists
754 END IF;--cl.modifier_level_code
755 end loop;--cl
756 --go to next line
757 i := QP_PREQ_GRP.G_service_line_ind_tbl.next(i);
758 END LOOP;--while
759
760 /*
761 for cl3 in (select sum(line.parent_quantity) lumpsum_qty
762 from qp_npreq_lines_tmp line
763 --qp_npreq_line_attrs_tmp ldetattr, qp_npreq_line_attrs_tmp lattr,
764 where ldetattr.line_index = cl.line_index
765 and line.priced_uom_code <> line.line_uom_code
766 and ldetattr.context = QP_PREQ_GRP.G_PRIC_VOLUME_CONTEXT
767 and ldetattr.line_detail_index = cl.line_detail_index
768 and lattr.line_index = cl.line_index
769 and lattr.context = QP_PREQ_GRP.G_PRIC_VOLUME_CONTEXT
770 and lattr.attribute = ldetattr.attribute
771 and exists (select 'Y'
772 from qp_npreq_ldets_tmp ldet
773 where ldet.created_from_list_line_id = cl.created_from_list_line_id
774 and ldet.modifier_level_code = QP_PREQ_GRP.G_LINE_GROUP
775 and ldet.pricing_status_code = QP_PREQ_GRP.G_STATUS_NEW))
776 loop
777 IF l_debug = FND_API.G_TRUE THEN
778 QP_PREQ_GRP.engine_debug('dtl_index '||cl.line_detail_index||' sum '||cl3.lumpsum_qty);
779 END IF;
780 QP_PREQ_GRP.G_Service_ldet_qty_tbl(cl.line_detail_index) := cl3.lumpsum_qty;
781 end loop; --cl3
782 */
783 EXCEPTION
784 When OTHERS Then
785 IF l_debug = FND_API.G_TRUE THEN
786 QP_PREQ_GRP.engine_debug('EXCEPTION Determine_svc_item_quantity');
787 END IF;
788 null;
789 END Determine_svc_item_quantity;
790
791 PROCEDURE CALCULATE_BUCKET_PRICE(
792 p_list_line_type_code IN QP_LIST_LINES.LIST_LINE_TYPE_CODE%TYPE
793 , p_price IN NUMBER
794 , p_priced_quantity NUMBER := 1
795 , p_operand_calculation_code IN QP_LIST_LINES.ARITHMETIC_OPERATOR%TYPE
796 , p_operand_value IN NUMBER
797 , x_calc_adjustment OUT NOCOPY NUMBER
798 , x_return_status OUT NOCOPY VARCHAR2 --DEFAULT FND_API.G_RET_STS_SUCCESS
799 , x_return_status_text OUT NOCOPY VARCHAR2)
800 IS
801
802 l_routine VARCHAR2(50) := 'QP_PREQ_PUB.CALCULATE_BUCKET_PRICE';
803 BEGIN
804 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
805 IF l_debug = FND_API.G_TRUE THEN
806 QP_PREQ_GRP.ENGINE_DEBUG('begin calculate bucket price qty'
807 || p_priced_quantity ||' operator '|| p_operand_calculation_code);
808
809 END IF;
810
811
812 IF p_operand_calculation_code = G_PERCENT_DISCOUNT
813 THEN
814 --fix for bug 2245528
815 --included abs function for -ve price to get right adj amt
816 -- Bug#3002549 reverted the fix done for bug 2245528
817 x_calc_adjustment := p_price * p_operand_value / 100;
818 IF l_debug = FND_API.G_TRUE THEN
819 QP_PREQ_GRP.ENGINE_DEBUG('calculate % price ' || x_calc_adjustment);
820 END IF;
821 ELSIF p_operand_calculation_code = G_AMOUNT_DISCOUNT
822 THEN
823 x_calc_adjustment := p_operand_value;
824 IF l_debug = FND_API.G_TRUE THEN
825 QP_PREQ_GRP.ENGINE_DEBUG('calculate amt price '|| x_calc_adjustment);
826 END IF;
827 ELSIF p_operand_calculation_code = G_NEWPRICE_DISCOUNT
828 THEN
829 --removed absolute value to account for negative newprice
830 --bug 2065609
831 x_calc_adjustment := - 1 * (p_price - (p_operand_value));
832 IF l_debug = FND_API.G_TRUE THEN
833 QP_PREQ_GRP.ENGINE_DEBUG('calculate newp price '|| x_calc_adjustment);
834 END IF;
835 ELSIF p_operand_calculation_code = G_LUMPSUM_DISCOUNT
836 THEN
837 --fix for bug 2394680 for zero list price qty can be 0
838 --in case of line group lumpsum based on item amount
839 -- [julin/4571612/4671446] explicitly set FND_API.G_NULL_NUM qty means infinity; this qty and zero qty yield no adj
840 IF (p_priced_quantity = FND_API.G_NULL_NUM or p_priced_quantity = 0) THEN
841 x_calc_adjustment := 0;
842 ELSE
843 x_calc_adjustment := p_operand_value / nvl(p_priced_quantity, 1);
844 END IF;
845 IF l_debug = FND_API.G_TRUE THEN
846 QP_PREQ_GRP.ENGINE_DEBUG('calculate lump price qty '
847 || p_priced_quantity || x_calc_adjustment);
848 END IF;
849 ELSE NULL;
850 END IF; --p_operand_calculation_code
851
852 X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;
853 X_RETURN_STATUS_TEXT := l_routine ||' SUCCESS';
854
855
856 x_calc_adjustment := nvl(x_calc_adjustment, 0);
857
858
859 IF l_debug = FND_API.G_TRUE THEN
860 QP_PREQ_GRP.ENGINE_DEBUG('end calculate bucket price: passed price '
861 || p_price ||' passed_operand '|| p_operand_value ||
862 ' calculated rounded adjustment '|| x_calc_adjustment);
863
864 END IF;
865 EXCEPTION
866 WHEN OTHERS THEN
867 IF l_debug = FND_API.G_TRUE THEN
868 QP_PREQ_GRP.ENGINE_DEBUG('Error in calculating bucket price '|| SQLERRM);
869 END IF;
870 x_return_status := FND_API.G_RET_STS_ERROR;
871 x_return_status_text := l_routine ||' '|| SQLERRM;
872 END CALCULATE_BUCKET_PRICE;
873
874
875 PROCEDURE BACK_CALCULATE_PRICE(p_operand_calculation_code IN VARCHAR2
876 , p_operand_value IN NUMBER
877 , p_applied_flag IN VARCHAR2
878 , p_amount_changed IN NUMBER
879 , p_adjustment_amount IN NUMBER
880 , p_priced_quantity IN NUMBER
881 , p_list_price IN NUMBER
882 , p_adjustment_type IN VARCHAR2
883 , x_adjustment_amount OUT NOCOPY NUMBER
884 , x_operand_value OUT NOCOPY NUMBER
885 , x_process_code OUT NOCOPY BOOLEAN
886 , x_return_status OUT NOCOPY VARCHAR2 --DEFAULT FND_API.G_RET_STS_SUCCESS
887 , x_return_status_text OUT NOCOPY VARCHAR2) IS --DEFAULT FND_API.G_RET_STS_SUCCESS) IS
888
889 l_routine VARCHAR2(50) := 'QP_PREQ_PUB.BACK_CALCULATE_PRICE';
890 ZERO_LIST_PRICE EXCEPTION;
891
892 BEGIN
893 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
894 IF l_debug = FND_API.G_TRUE THEN
895 QP_PREQ_GRP.ENGINE_DEBUG('start back calculate adjustment:
896 adjustment type '|| p_adjustment_type ||
897 ' amount changed passed '|| p_amount_changed ||
898 ' price passed '|| p_list_price ||
899 ' adjustment_amount_passed '|| p_adjustment_amount ||
900 ' applied flag '|| p_applied_flag);
901
902
903
904 END IF;
905 --do not check for applied_flag, bcoz we are passing effective
906 --amount_changed each time --for bug 2043442
907 x_adjustment_amount := p_amount_changed;
908
909 IF p_operand_calculation_code = G_PERCENT_DISCOUNT THEN
910 IF p_list_price = 0 THEN
911 RAISE ZERO_LIST_PRICE;
912 END IF;
913 x_operand_value := ABS(x_adjustment_amount * 100 / p_list_price);
914 ELSIF p_operand_calculation_code = G_AMOUNT_DISCOUNT THEN
915 x_operand_value := ABS(x_adjustment_amount);
916 ELSIF p_operand_calculation_code = G_NEWPRICE_DISCOUNT THEN
917 x_operand_value := p_list_price + nvl(x_adjustment_amount, 0);
918 ELSIF p_operand_calculation_code = G_LUMPSUM_DISCOUNT THEN
919 x_operand_value := ABS(x_adjustment_amount) * p_priced_quantity;
920 END IF;
921
922 IF l_debug = FND_API.G_TRUE THEN
923 QP_PREQ_GRP.ENGINE_DEBUG('adjustment amt calculated'
924 || x_adjustment_amount);
925
926 END IF;
927 IF p_adjustment_type = G_DISCOUNT AND (x_adjustment_amount <= 0
928 OR p_operand_calculation_code = G_NEWPRICE_DISCOUNT) THEN
929 IF l_debug = FND_API.G_TRUE THEN
930 QP_PREQ_GRP.ENGINE_DEBUG('Manual Adjustment is Discount '|| p_adjustment_type);
931 END IF;
932 x_process_code := TRUE;
933 ELSIF p_adjustment_type = G_SURCHARGE AND x_adjustment_amount >= 0 THEN
934 IF l_debug = FND_API.G_TRUE THEN
935 QP_PREQ_GRP.ENGINE_DEBUG('Manual Adjustment is Surcharge '|| p_adjustment_type);
936 END IF;
937 x_process_code := TRUE;
938 ELSE
939 IF l_debug = FND_API.G_TRUE THEN
940 QP_PREQ_GRP.ENGINE_DEBUG('Manual Adjustment is not DIS/SUR'|| p_adjustment_type);
941 END IF;
942 x_process_code := FALSE;
943 END IF;
944
945
946
947 X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;
948 X_RETURN_STATUS_TEXT := l_routine ||' SUCCESS';
949
950
951 IF l_debug = FND_API.G_TRUE THEN
952 QP_PREQ_GRP.ENGINE_DEBUG('end back calculate adjustment:
953 adjustment amoutn calculated '|| x_adjustment_amount ||
954 ' operand calculated '|| x_operand_value);
955
956 END IF;
957 EXCEPTION
958 WHEN ZERO_LIST_PRICE THEN
959 IF l_debug = FND_API.G_TRUE THEN
960 QP_PREQ_GRP.ENGINE_DEBUG('exception back calculate adj '|| SQLERRM);
961 END IF;
962 x_return_status := FND_API.G_RET_STS_ERROR;
963 x_return_status_text := l_routine ||' '||'CANNOT OVERRIDE ZERO OR NULL LIST PRICE WITH % BASED ADJUSTMENT';
964 WHEN OTHERS THEN
965 IF l_debug = FND_API.G_TRUE THEN
966 QP_PREQ_GRP.ENGINE_DEBUG('exception back calculate adj '|| SQLERRM);
967 END IF;
968 x_return_status := FND_API.G_RET_STS_ERROR;
969 x_return_status_text := l_routine ||' '|| SQLERRM;
970
971 END BACK_CALCULATE_PRICE;
972
973 --this procedure is to calculate the unit_selling_price
974 --operand and adjustment_amount in ordered_qty
975 --the reason we do this is because when calling applications
976 --do this, the rounding is lost
977 --catchweight_qty is the quantity in catchweight pricing
978 --where user orders 1 Chicken and 1 chicken = 10 lbs
979 --the priced_qty is 10lbs and lineqty is 1 chicken
980 --the price of the chicken and adjustments are calculated based
981 --on priced_qty = 10 lbs
982 --at the time of shipping the actual weight of chicken might be
983 --12lbs, so they do not want to change the price at that point
984 --but display the unit_price in catchweight_qty
985 PROCEDURE GET_ORDERQTY_VALUES(p_ordered_qty IN NUMBER,
986 p_priced_qty IN NUMBER,
987 p_catchweight_qty IN NUMBER,
988 p_actual_order_qty IN NUMBER,
989 p_unit_price IN NUMBER DEFAULT NULL,
990 p_adjusted_unit_price IN NUMBER DEFAULT NULL,
991 p_line_unit_price IN NUMBER DEFAULT NULL,
992 p_operand IN NUMBER DEFAULT NULL,
993 p_adjustment_amt IN NUMBER DEFAULT NULL,
994 p_operand_calculation_code IN VARCHAR2 DEFAULT NULL,
995 p_input_type IN VARCHAR2,
996 x_ordqty_output1 OUT NOCOPY NUMBER,
997 x_ordqty_output2 OUT NOCOPY NUMBER,
998 x_return_status OUT NOCOPY VARCHAR2,
999 x_return_status_text OUT NOCOPY VARCHAR2) IS
1000 BEGIN
1001 --we need not treat null adj_unit_price or zero adj_unit_price
1002 --as adj_unit_price cannot be null and if it is zero, x_ordqty_selling_price
1003 --needs to be zero
1004 --we will default the null qty to 1 so that we can avoid divide_by_zero
1005
1006 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
1007 x_return_status := FND_API.G_RET_STS_SUCCESS;
1008
1009 IF l_debug = FND_API.G_TRUE THEN
1010 QP_PREQ_GRP.engine_debug('BEGIN GET_ORDERQTY_VALUES: line_qty '
1011 || p_ordered_qty ||' priced_qty '|| p_priced_qty ||' catchwtqty '
1012 || p_catchweight_qty || 'actual order qty ' || p_actual_order_qty || ' unitprice '
1013 || p_unit_price ||' sellingprice '
1014 || p_adjusted_unit_price ||' lineunitprice '|| p_line_unit_price
1015 ||' operand '|| p_operand ||' operator '|| p_operand_calculation_code
1016 ||' adjamt '|| p_adjustment_amt ||' inputtype '|| p_input_type);
1017 END IF;
1018
1019 --this procedure will be called for every adjustment
1020 --but we need calculate G_ORDQTY_SELLING_PRICE only once
1021 --for each order line
1022 IF p_input_type = 'SELLING_PRICE' THEN
1023
1024 /* x_ordqty_output2 := ((p_adjusted_unit_price * p_priced_qty / p_ordered_qty) *
1025 (nvl(p_catchweight_qty, p_ordered_qty) / p_ordered_qty)); */
1026
1027 IF (p_catchweight_qty IS NOT NULL) THEN
1028 --line_unit_price
1029 x_ordqty_output1 := (p_unit_price * (p_priced_qty / p_actual_order_qty) * (p_catchweight_qty / p_ordered_qty));
1030 --order_uom_selling_price
1031 x_ordqty_output2 := (p_adjusted_unit_price * (p_priced_qty / p_actual_order_qty) * (p_catchweight_qty / p_ordered_qty));
1032 ELSIF (p_actual_order_qty IS NOT NULL) THEN
1033 --line_unit_price
1034 x_ordqty_output1 := (p_unit_price * (p_priced_qty / p_actual_order_qty));
1035 --order_uom_selling_price
1036 x_ordqty_output2 := (p_adjusted_unit_price * (p_priced_qty / p_actual_order_qty));
1037 ELSE
1038 --line_unit_price
1039 -- x_ordqty_output1 := p_line_unit_price;
1040 -- x_ordqty_output1 := (p_unit_price * (p_priced_qty / p_ordered_qty));
1041 -- bug 3006661 for OC
1042 x_ordqty_output1 := (p_unit_price * (nvl(p_priced_qty, p_ordered_qty) / p_ordered_qty));
1043 --order_uom_selling_price
1044 -- x_ordqty_output2 := (p_adjusted_unit_price * (p_priced_qty/p_ordered_qty));
1045 -- bug 3006661 for OC
1046 x_ordqty_output2 := (p_adjusted_unit_price * (nvl(p_priced_qty, p_ordered_qty) / p_ordered_qty));
1047 END IF;
1048
1049 /* IF p_catchweight_qty IS NOT NULL THEN
1050 x_ordqty_output1 := ((p_unit_price * p_priced_qty / p_ordered_qty) *
1051 (nvl(p_catchweight_qty, p_ordered_qty) / p_ordered_qty));
1052 ELSE
1053 x_ordqty_output1 := p_line_unit_price;
1054 END IF;--p_catchweight_qty */
1055
1056
1057 ELSE --input_type is OPERAND
1058 IF p_operand_calculation_code IN (G_PERCENT_DISCOUNT, G_LUMPSUM_DISCOUNT) THEN
1059 --x_ordqty_operand same as operand for % and LUMPSUM based modifiers
1060 x_ordqty_output1 := p_operand;
1061 ELSE
1062 -- Ravi
1063 /*x_ordqty_output1 := ((p_unit_price * p_priced_qty / p_ordered_qty) *
1064 (nvl(p_catchweight_qty, p_ordered_qty) / p_ordered_qty));*/
1065 /* x_ordqty_output1 := ((p_operand * p_priced_qty / p_ordered_qty) *
1066 (nvl(p_catchweight_qty, p_ordered_qty) / p_ordered_qty)); */
1067
1068 IF (p_catchweight_qty IS NOT NULL) THEN
1069 x_ordqty_output1 := (p_operand * (p_priced_qty / p_actual_order_qty) * (p_catchweight_qty / p_ordered_qty));
1070 ELSIF (p_actual_order_qty IS NOT NULL) THEN
1071 x_ordqty_output1 := (p_operand * (p_priced_qty / p_actual_order_qty));
1072 ELSE
1073 -- x_ordqty_output1 := (p_operand * (p_priced_qty/p_ordered_qty));
1074 -- bug 3006661 for OC
1075 x_ordqty_output1 := (p_operand * (nvl(p_priced_qty, p_ordered_qty) / p_ordered_qty));
1076 END IF;
1077
1078 END IF; --p_operand_calculation_code
1079
1080 -- Ravi
1081 /*x_ordqty_output2 := ((p_unit_price * p_priced_qty / p_ordered_qty) *
1082 (nvl(p_catchweight_qty, p_ordered_qty) / p_ordered_qty));*/
1083 /* x_ordqty_output2 := ((p_adjustment_amt * p_priced_qty / p_ordered_qty) *
1084 (nvl(p_catchweight_qty, p_ordered_qty) / p_ordered_qty)); */
1085
1086 IF (p_catchweight_qty IS NOT NULL) THEN
1087 x_ordqty_output2 := (p_adjustment_amt * (p_priced_qty / p_actual_order_qty) * (p_catchweight_qty / p_ordered_qty));
1088 ELSIF (p_actual_order_qty IS NOT NULL) THEN
1089 x_ordqty_output2 := (p_adjustment_amt * (p_priced_qty / p_actual_order_qty));
1090 ELSE
1091 -- x_ordqty_output2 := (p_adjustment_amt * (p_priced_qty/p_ordered_qty));
1092 -- bug 3006661 for OC
1093 x_ordqty_output2 := (p_adjustment_amt * (nvl(p_priced_qty, p_ordered_qty) / p_ordered_qty));
1094 END IF;
1095
1096 END IF; --p_input_type
1097
1098 IF l_debug = FND_API.G_TRUE THEN
1099 QP_PREQ_GRP.engine_debug('Output GET_ORDERQTY_VALUES '||'output1 '
1100 || x_ordqty_output1 ||' output2 '|| x_ordqty_output2);
1101 END IF; --l_debug
1102
1103 x_return_status := FND_API.G_RET_STS_SUCCESS;
1104
1105 EXCEPTION
1106 WHEN OTHERS THEN
1107 IF l_debug = FND_API.G_TRUE THEN
1108 QP_PREQ_GRP.engine_debug('Exception in GET_ORDERQTY_VALUES '|| SQLERRM);
1109 END IF; --l_debug
1110 x_ordqty_output1 := 0;
1111 x_ordqty_output2 := 0;
1112 x_return_status := FND_API.G_RET_STS_ERROR;
1113 END GET_ORDERQTY_VALUES;
1114
1115 --This procedure is to update the order_qty_adj_amt and order_qty_operand
1116 --on manual adjustments which do not go through calculation cursor
1117 --as they are not applied
1118 --fix for bug 2816262 where order_qty_operand is not populated for
1119 --manual adjustments are they do not go thru calculation
1120 PROCEDURE Update_Adj_orderqty_cols(x_return_status OUT NOCOPY VARCHAR2,
1121 x_return_status_text OUT NOCOPY VARCHAR2) IS
1122 --[julin/pbperf] tuned to use QP_PREQ_LDETS_TMP_N2
1123 CURSOR l_update_adj_cur IS
1124 SELECT /*+ ORDERED index(ldet QP_PREQ_LDETS_TMP_N2) */ ldet.line_detail_index,
1125 ldet.operand_value,
1126 ldet.operand_calculation_code,
1127 ldet.modifier_level_code,
1128 nvl(ldet.line_quantity, line.priced_quantity) priced_qty,
1129 line.actual_order_quantity actual_order_qty,
1130 line.catchweight_qty,
1131 line.line_quantity ordered_qty
1132 -- line.unit_price,
1133 -- line.adjusted_unit_price
1134 FROM qp_npreq_ldets_tmp ldet,
1135 qp_npreq_lines_tmp line
1136 WHERE ldet.pricing_phase_id > 1
1137 AND ldet.pricing_status_code = G_STATUS_NEW
1138 AND ldet.automatic_flag = G_NO
1139 AND nvl(ldet.applied_flag, G_NO) = G_NO
1140 AND nvl(ldet.updated_flag, G_NO) = G_NO
1141 AND line.line_index = ldet.line_index;
1142
1143 l_ordqty_line_dtl_index QP_PREQ_GRP.NUMBER_TYPE;
1144 l_ordqty_operand QP_PREQ_GRP.NUMBER_TYPE;
1145 l_ordqty_operator QP_PREQ_GRP.VARCHAR_TYPE;
1146 l_ordqty_mod_lvl QP_PREQ_GRP.VARCHAR_TYPE;
1147 l_ordqty_priced_qty QP_PREQ_GRP.NUMBER_TYPE;
1148 l_ordqty_actual_order_qty QP_PREQ_GRP.NUMBER_TYPE;
1149 l_ordqty_catchweight_qty QP_PREQ_GRP.NUMBER_TYPE;
1150 l_ordqty_ordered_qty QP_PREQ_GRP.NUMBER_TYPE;
1151 l_ordqty_ord_qty_operand QP_PREQ_GRP.NUMBER_TYPE;
1152
1153 l_dummy NUMBER;
1154 BEGIN
1155 --initialise
1156 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
1157
1158 IF (l_debug = FND_API.G_TRUE) THEN
1159 QP_PREQ_GRP.engine_debug('Begin Update_Adj_orderqty_cols');
1160 END IF; --l_debug
1161
1162 OPEN l_update_adj_cur;
1163 l_ordqty_line_dtl_index.DELETE;
1164 l_ordqty_operand.DELETE;
1165 l_ordqty_operator.DELETE;
1166 l_ordqty_mod_lvl.DELETE;
1167 l_ordqty_priced_qty.DELETE;
1168 l_ordqty_actual_order_qty.DELETE;
1169 l_ordqty_catchweight_qty.DELETE;
1170 l_ordqty_ordered_qty.DELETE;
1171 l_ordqty_ord_qty_operand.DELETE;
1172 FETCH l_update_adj_cur BULK COLLECT INTO
1173 l_ordqty_line_dtl_index,
1174 l_ordqty_operand,
1175 l_ordqty_operator,
1176 l_ordqty_mod_lvl,
1177 l_ordqty_priced_qty,
1178 l_ordqty_actual_order_qty,
1179 l_ordqty_catchweight_qty,
1180 l_ordqty_ordered_qty;
1181 CLOSE l_update_adj_cur;
1182
1183 IF (l_debug = FND_API.G_TRUE) THEN
1184 QP_PREQ_GRP.engine_debug('After cur Update_Adj_orderqty_cols');
1185 END IF; --l_debug
1186
1187 IF l_ordqty_line_dtl_index.COUNT > 0 THEN
1188 FOR i IN l_ordqty_line_dtl_index.FIRST..l_ordqty_line_dtl_index.LAST
1189 LOOP
1190 IF (l_ordqty_ordered_qty(i) <> 0 OR l_ordqty_mod_lvl(i) = G_ORDER_LEVEL) THEN
1191 IF (l_debug = FND_API.G_TRUE) THEN
1192 QP_PREQ_GRP.engine_debug('Before GET_ORDERQTY_VALUES #5');
1193 END IF;
1194
1195 GET_ORDERQTY_VALUES(p_ordered_qty => l_ordqty_ordered_qty(i),
1196 p_priced_qty => l_ordqty_priced_qty(i),
1197 p_catchweight_qty => l_ordqty_catchweight_qty(i),
1198 p_actual_order_qty => l_ordqty_actual_order_qty(i),
1199 p_operand => l_ordqty_operand(i),
1200 p_adjustment_amt => 0, --we do not need this
1201 -- p_unit_price => l_adj_tbl(j).unit_price,
1202 -- p_adjusted_unit_price => l_sub_total_price,
1203 p_operand_calculation_code => l_ordqty_operator(i),
1204 p_input_type => 'OPERAND',
1205 x_ordqty_output1 => l_ordqty_ord_qty_operand(i),
1206 x_ordqty_output2 => l_dummy,
1207 x_return_status => x_return_status,
1208 x_return_status_text => x_return_status_text);
1209 ELSE --l_ordqty_ordered_qty
1210 IF l_debug = FND_API.G_TRUE THEN
1211 QP_PREQ_GRP.engine_debug('Ordered Qty #5: '|| l_ordqty_ordered_qty(i));
1212 QP_PREQ_GRP.engine_debug('OPERAND Ordered Qty=0 or modlvlcode <> ORDER');
1213 END IF; --l_debug
1214 l_ordqty_ord_qty_operand(i) := 0;
1215 END IF; --l_ordqty_ordered_qty
1216 END LOOP; --i
1217 END IF; --l_ordqty_line_dtl_index
1218
1219 IF l_ordqty_line_dtl_index.COUNT > 0 THEN
1220 IF l_debug = FND_API.G_TRUE THEN
1221 FOR j IN l_ordqty_line_dtl_index.FIRST..l_ordqty_line_dtl_index.LAST
1222 LOOP
1223 QP_PREQ_GRP.engine_debug('Ordqty update line_dtl_index '
1224 || l_ordqty_line_dtl_index(j) ||' ordqty_operand '
1225 || l_ordqty_ord_qty_operand(j));
1226 END LOOP; --j
1227 END IF; --l_debug
1228
1229 FORALL i IN l_ordqty_line_dtl_index.FIRST..l_ordqty_line_dtl_index.LAST
1230 UPDATE qp_npreq_ldets_tmp SET order_qty_operand = l_ordqty_ord_qty_operand(i)
1231 WHERE line_detail_index = l_ordqty_line_dtl_index(i);
1232 END IF; --l_ordqty_line_dtl_index.COUNT
1233
1234 IF (l_debug = FND_API.G_TRUE) THEN
1235 QP_PREQ_GRP.engine_debug('End Update_Adj_orderqty_cols');
1236 END IF; --l_debug
1237
1238 EXCEPTION
1239 WHEN OTHERS THEN
1240 IF l_debug = FND_API.G_TRUE THEN
1241 QP_PREQ_GRP.engine_debug('Exception in Update_Adj_orderqty_cols '|| SQLERRM);
1242 END IF; --l_debug
1243 x_return_status := FND_API.G_RET_STS_ERROR;
1244 x_return_status_text := 'Exception in Update_Adj_orderqty_cols '|| SQLERRM;
1245 END Update_Adj_orderqty_cols;
1246
1247 --For bug 2447181 for changed lines functionality
1248 --to indicate to the calling application to make a subsequent pricing
1249 --call with calculate_only and to pass all lines when they are calling
1250 --with changed lines in case there are new/changed order level modifiers
1251 --this will be indicated in processed_flag = 'C' in qp_npreq_lines_tmp
1252 --on the summary linE
1253 PROCEDURE CHECK_ORDER_LINE_CHANGES(p_request_type_code IN VARCHAR2,
1254 p_full_pricing_call IN VARCHAR2,
1255 x_return_status OUT NOCOPY VARCHAR2,
1256 x_return_status_text OUT NOCOPY VARCHAR2) IS
1257
1258 l_routine VARCHAR2(100) := 'QP_PREQ_PUB.CHECK_ORDER_LINE_CHANGES';
1259
1260 l_exist_changed_order_adj VARCHAR2(1) := G_NO;
1261 l_header_id NUMBER;
1262 l_ldet_sum_operand NUMBER := 0;
1263 l_adj_sum_operand NUMBER := 0;
1264 BEGIN
1265
1266 --initialise
1267 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
1268 l_header_id := NULL;
1269 l_exist_changed_order_adj := G_NO;
1270
1271 IF l_debug = FND_API.G_TRUE THEN
1272 QP_PREQ_GRP.engine_debug('Begin Check_order_lines_change: chk_cust '
1273 || G_CHECK_CUST_VIEW_FLAG ||' full_pricing_call '|| p_full_pricing_call);
1274
1275 END IF;
1276 --do this only if caller has passed changed lines
1277 --IF p_request_type_code = 'ONT'
1278 --bug 3085453 handle pricing availability UI
1279 -- they pass reqtype ONT and insert adj into ldets
1280 IF QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = G_YES
1281 AND p_full_pricing_call = G_NO
1282 THEN
1283 --this is for OM/OC direct insert performance code path
1284 --there cannot be manual adjustments on the order header
1285
1286 IF l_debug = FND_API.G_TRUE THEN
1287 QP_PREQ_GRP.engine_debug('starting order line check ');
1288 END IF;
1289 BEGIN
1290 SELECT line_id INTO l_header_id
1291 FROM qp_npreq_lines_tmp
1292 WHERE line_type_code = G_ORDER_LEVEL
1293 AND pricing_status_code IN (G_STATUS_UPDATED,
1294 G_STATUS_UNCHANGED, G_STATUS_GSA_VIOLATION);
1295 EXCEPTION
1296 WHEN OTHERS THEN
1297 l_header_id := NULL;
1298 END;
1299
1300 IF l_debug = FND_API.G_TRUE THEN
1301 QP_PREQ_GRP.engine_debug('checking header id '|| l_header_id);
1302
1303 END IF;
1304 IF l_header_id IS NOT NULL THEN
1305 BEGIN
1306 SELECT G_YES INTO l_exist_changed_order_adj
1307 FROM qp_npreq_ldets_tmp ldet
1308 WHERE ldet.process_code IN (G_STATUS_UPDATED, G_STATUS_NEW)
1309 AND ldet.pricing_status_code = G_STATUS_NEW
1310 AND ldet.modifier_level_code = G_ORDER_LEVEL
1311 AND ldet.applied_flag = G_YES;
1312 EXCEPTION
1313 WHEN OTHERS THEN
1314 l_exist_changed_order_adj := G_NO;
1315 END;
1316 ELSE --l_header_id
1317 l_exist_changed_order_adj := G_NO;
1318 END IF; --l_header_id
1319
1320 IF l_debug = FND_API.G_TRUE THEN
1321 QP_PREQ_GRP.engine_debug('there are header adj changes '
1322 || l_exist_changed_order_adj);
1323
1324 END IF;
1325 --do this only if the header does not have error status
1326 --and there are new or updated summary level automatic adjustments
1327 -- IF l_header_id is not null
1328 IF l_exist_changed_order_adj = G_YES
1329 THEN
1330 IF l_debug = FND_API.G_TRUE THEN
1331 QP_PREQ_GRP.engine_debug('checking header adj operand changes');
1332 END IF;
1333 BEGIN
1334 SELECT SUM(operand_value) INTO l_ldet_sum_operand
1335 FROM qp_npreq_ldets_tmp ldet
1336 WHERE ldet.modifier_level_code = G_ORDER_LEVEL
1337 AND ldet.pricing_status_code = G_STATUS_NEW
1338 AND ldet.automatic_flag = G_YES
1339 AND applied_flag = G_YES;
1340 EXCEPTION
1341 WHEN OTHERS THEN
1342 l_ldet_sum_operand := 0;
1343 END;
1344
1345 l_adj_sum_operand :=
1346 QP_CLEANUP_ADJUSTMENTS_PVT.get_sum_operand(l_header_id);
1347
1348 IF l_debug = FND_API.G_TRUE THEN
1349 QP_PREQ_GRP.engine_debug('ldet header adj sum operand '
1350 || l_ldet_sum_operand);
1351 QP_PREQ_GRP.engine_debug('oe_price_adj header adj sum operand '
1352 || l_adj_sum_operand);
1353 END IF;
1354 --only if there is a change in the operand from previous
1355 --call, we need to recalculate
1356 --it is OK to sumup operand as order level adj is % based
1357 --so find out the sum from prev call and current call
1358 IF l_ldet_sum_operand <> l_adj_sum_operand
1359 THEN
1360 --order level modifiers are mostly % based
1361 -- so if the total % of order level modifiers do not match
1362 --then caller needs to recalculate
1363 UPDATE qp_npreq_lines_tmp SET
1364 processed_flag = G_CALCULATE_ONLY
1365 WHERE line_type_code = G_ORDER_LEVEL;
1366 END IF;
1367 END IF; --l_exist_changed_order_adj
1368 --ELSIF p_request_type_code <> 'ONT'
1369 --bug 3085453 handle pricing availability UI
1370 -- they pass reqtype ONT and insert adj into ldets
1371 ELSIF QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG <> G_YES
1372 AND p_full_pricing_call = G_NO THEN
1373 --this is for non-OM calling applications
1374 IF l_debug = FND_API.G_TRUE THEN
1375 QP_PREQ_GRP.engine_debug('starting order line check ');
1376 END IF;
1377 --check if there is a summary line passed and it has no errors
1378 BEGIN
1379 SELECT line_id INTO l_header_id
1380 FROM qp_npreq_lines_tmp
1381 WHERE line_type_code = G_ORDER_LEVEL
1382 AND pricing_status_code IN (G_STATUS_UPDATED,
1383 G_STATUS_UNCHANGED, G_STATUS_GSA_VIOLATION);
1384 EXCEPTION
1385 WHEN OTHERS THEN
1386 l_header_id := NULL;
1387 END;
1388
1389 IF l_debug = FND_API.G_TRUE THEN
1390 QP_PREQ_GRP.engine_debug('checking header id '|| l_header_id);
1391 END IF;
1392 --if there is a summary line, make sure there are applied adj against it
1393 IF l_header_id IS NOT NULL THEN
1394 BEGIN
1395 SELECT G_YES INTO l_exist_changed_order_adj
1396 FROM qp_npreq_ldets_tmp ldet
1397 WHERE ldet.pricing_status_code = G_STATUS_NEW
1398 AND ldet.modifier_level_code = G_ORDER_LEVEL
1399 AND ldet.applied_flag = G_YES;
1400 EXCEPTION
1401 WHEN OTHERS THEN
1402 l_exist_changed_order_adj := G_NO;
1403 END;
1404 ELSE --l_header_id
1405 l_exist_changed_order_adj := G_NO;
1406 END IF; --l_header_id
1407
1408 IF l_debug = FND_API.G_TRUE THEN
1409 QP_PREQ_GRP.engine_debug('there are header adj changes '
1410 || l_exist_changed_order_adj);
1411 END IF;
1412 --do this only if the header does not have error status
1413 --and there are new or updated summary level automatic adjustments
1414 -- IF l_header_id is not null
1415 IF l_exist_changed_order_adj = G_YES
1416 THEN
1417 IF l_debug = FND_API.G_TRUE THEN
1418 QP_PREQ_GRP.engine_debug('checking header adj operand changes');
1419 END IF;
1420 BEGIN
1421 SELECT SUM(operand_value) INTO l_ldet_sum_operand
1422 FROM qp_npreq_ldets_tmp ldet
1423 WHERE ldet.modifier_level_code = G_ORDER_LEVEL
1424 AND ldet.pricing_status_code = G_STATUS_NEW
1425 AND ldet.automatic_flag = G_YES
1426 AND applied_flag = G_YES;
1427 EXCEPTION
1428 WHEN OTHERS THEN
1429 l_ldet_sum_operand := 0;
1430 END;
1431
1432 BEGIN
1433 SELECT SUM(operand_value) INTO l_adj_sum_operand
1434 FROM qp_npreq_ldets_tmp ldet
1435 WHERE ldet.modifier_level_code = G_ORDER_LEVEL
1436 AND ldet.pricing_status_code = G_STATUS_UNCHANGED
1437 AND ldet.automatic_flag = G_YES
1438 AND applied_flag = G_YES;
1439 EXCEPTION
1440 WHEN OTHERS THEN
1441 l_adj_sum_operand := 0;
1442 END;
1443
1444 IF l_debug = FND_API.G_TRUE THEN
1445 QP_PREQ_GRP.engine_debug('ldet header adj sum operand '
1446 || l_ldet_sum_operand);
1447 QP_PREQ_GRP.engine_debug('oe_price_adj header adj sum operand '
1448 || l_adj_sum_operand);
1449 END IF; --l_debug
1450 --only if there is a change in the operand from previous
1451 --call, we need to recalculate
1452 --it is OK to sumup operand as order level adj is % based
1453 --so find out the sum from prev call and current call
1454 IF l_ldet_sum_operand <> l_adj_sum_operand
1455 THEN
1456 --order level modifiers are mostly % based
1457 -- so if the total % of order level modifiers do not match
1458 --then caller needs to recalculate
1459 UPDATE qp_npreq_lines_tmp SET
1460 processed_flag = G_CALCULATE_ONLY
1461 WHERE line_type_code = G_ORDER_LEVEL;
1462 END IF; --l_ldet_sum_operand
1463 END IF; --l_exist_changed_order_adj
1464 ELSE
1465 --the p_full_pricing_call is 'Y'
1466 IF l_debug = FND_API.G_TRUE THEN
1467 QP_PREQ_GRP.engine_debug('no change header adj');
1468 END IF;
1469 END IF; --p_request_type_code
1470 x_return_status := FND_API.G_RET_STS_SUCCESS;
1471
1472 EXCEPTION
1473 WHEN OTHERS THEN
1474 x_return_status := FND_API.G_RET_STS_ERROR;
1475 x_return_status_text := l_routine ||' '|| SQLERRM;
1476 IF l_debug = FND_API.G_TRUE THEN
1477 QP_PREQ_GRP.ENGINE_DEBUG(x_return_status_text);
1478 END IF;
1479 END CHECK_ORDER_LINE_CHANGES;
1480
1481 /*
1482 --Preinsert Logic for OM call
1483 --to fetch out-of-phases modifiers and in-phase PRG modifiers
1484 --to fetch rltd information
1485 */
1486 PROCEDURE INT_TABLES_PREINSERT(p_calculate_flag IN VARCHAR2,
1487 p_event_code IN VARCHAR2,
1488 x_return_status OUT NOCOPY VARCHAR2,
1489 x_return_status_text OUT NOCOPY VARCHAR2) IS
1490 CURSOR l_ldets_cur IS
1491 SELECT /*+ ORDERED USE_NL(adj qplh) */
1492 adj.price_adjustment_id line_detail_index
1493 , adj.list_line_type_code line_detail_type_code
1494 , adj.price_break_type_code
1495 , NULL list_price
1496 , line.line_index
1497 , adj.list_header_id created_from_list_header_id
1498 , adj.list_line_id created_from_list_line_id
1499 , adj.list_line_type_code created_from_list_line_type
1500 , '' created_from_list_type_code
1501 , NULL CREATED_FROM_SQL
1502 , adj.pricing_group_sequence
1503 , adj.pricing_phase_id
1504 , adj.arithmetic_operator operand_calculation_code
1505 , nvl(adj.operand_per_pqty, adj.operand) operand_value
1506 , NULL SUBSTITUTION_TYPE_CODE
1507 , NULL SUBSTITUTION_VALUE_FROM
1508 , NULL SUBSTITUTION_VALUE_TO
1509 , NULL ASK_FOR_FLAG
1510 , NULL PRICE_FORMULA_ID
1511 , 'N' pricing_status_code
1512 , ' ' pricing_status_text
1513 , NULL PRODUCT_PRECEDENCE
1514 , NULL INCOMPATABILITY_GRP_CODE
1515 , NULL PROCESSED_FLAG
1516 , adj.applied_flag
1517 , adj.automatic_flag
1518 , adj.update_allowed override_flag
1519 , NULL PRIMARY_UOM_FLAG
1520 , NULL PRINT_ON_INVOICE_FLAG
1521 , adj.modifier_level_code
1522 , adj.BENEFIT_QTY
1523 , adj.BENEFIT_UOM_CODE
1524 , adj.LIST_LINE_NO
1525 , adj.accrual_flag
1526 , adj.ACCRUAL_CONVERSION_RATE
1527 , NULL ESTIM_ACCRUAL_RATE
1528 , NULL RECURRING_FLAG
1529 , NULL SELECTED_VOLUME_ATTR
1530 , line.rounding_factor
1531 , NULL HEADER_LIMIT_EXISTS
1532 , NULL LINE_LIMIT_EXISTS
1533 , adj.charge_type_code
1534 , adj.charge_subtype_code
1535 , NULL CURRENCY_DETAIL_ID
1536 , NULL CURRENCY_HEADER_ID
1537 , NULL SELLING_ROUNDING_FACTOR
1538 , NULL ORDER_CURRENCY
1539 , NULL PRICING_EFFECTIVE_DATE
1540 , NULL BASE_CURRENCY_CODE
1541 --, line.line_quantity
1542 , adj.range_break_quantity line_quantity
1543 , nvl(adj.updated_flag, QP_PREQ_PUB.G_NO) updated_flag
1544 , NULL calculation_code
1545 , adj.CHANGE_REASON_CODE
1546 , adj.CHANGE_REASON_TEXT
1547 , adj.PRICE_ADJUSTMENT_ID
1548 , NULL ACCUM_CONTEXT
1549 , NULL ACCUM_ATTRIBUTE
1550 , NULL ACCUM_FLAG
1551 , NULL BREAK_UOM_CODE
1552 , NULL BREAK_UOM_CONTEXT
1553 , NULL BREAK_UOM_ATTRIBUTE
1554 , NULL PROCESS_CODE -- 3215497
1555 FROM qp_int_lines line, oe_price_adjustments adj,
1556 qp_list_headers_b qplh
1557 WHERE QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = QP_PREQ_PUB.G_YES
1558 AND line.process_status IN (QP_PREQ_PUB.G_STATUS_UPDATED,
1559 QP_PREQ_PUB.G_STATUS_NEW,
1560 QP_PREQ_PUB.G_STATUS_UNCHANGED,
1561 'NEW' || QP_PREQ_PUB.G_STATUS_UNCHANGED,
1562 'OLD' || QP_PREQ_PUB.G_STATUS_UNCHANGED)
1563 AND adj.line_id = line.line_id
1564 AND line.pricing_status_code IN (QP_PREQ_PUB.G_STATUS_UPDATED
1565 , QP_PREQ_PUB.G_STATUS_GSA_VIOLATION
1566 , QP_PREQ_PUB.G_STATUS_UNCHANGED)
1567 AND (line.price_flag IN (QP_PREQ_PUB.G_YES, QP_PREQ_PUB.G_PHASE, QP_PREQ_PUB.G_CALCULATE_ONLY)
1568 OR nvl(line.processed_code, '0') = QP_PREQ_PUB.G_BY_ENGINE)
1569 AND line.line_type_code = QP_PREQ_PUB.G_LINE_LEVEL
1570 AND (adj.updated_flag = QP_PREQ_PUB.G_YES
1571 OR line.price_flag = QP_PREQ_PUB.G_CALCULATE_ONLY
1572 OR (p_event_code IS NULL AND adj.updated_flag IS NULL)
1573 OR (adj.list_line_type_code = 'PRG'
1574 AND adj.pricing_phase_id IN (SELECT ph.pricing_phase_id
1575 FROM qp_event_phases ev, qp_pricing_phases ph
1576 WHERE ph.pricing_phase_id = ev.pricing_phase_id
1577 AND ((QP_PREQ_PUB.G_GET_FREIGHT_FLAG = QP_PREQ_PUB.G_YES
1578 AND ph.freight_exists = QP_PREQ_PUB.G_YES)
1579 OR (QP_PREQ_PUB.G_GET_FREIGHT_FLAG = QP_PREQ_PUB.G_NO))
1580 AND instr(p_event_code, ev.pricing_event_code || ',') > 0
1581 --and (nvl(QP_PREQ_PUB.Get_buy_line_price_flag(adj.line_detail_index),line.price_flag) = QP_PREQ_PUB.G_YES
1582 --or (nvl(QP_PREQ_PUB.Get_buy_line_price_flag(adj.line_detail_index),line.price_flag) = QP_PREQ_PUB.G_PHASE
1583 AND (line.price_flag = QP_PREQ_PUB.G_YES
1584 OR (line.price_flag = QP_PREQ_PUB.G_PHASE
1585 AND nvl(ph.user_freeze_override_flag, ph.freeze_override_flag) = QP_PREQ_PUB.G_YES))))
1586 OR adj.pricing_phase_id NOT IN (SELECT ph.pricing_phase_id
1587 FROM qp_event_phases ev, qp_pricing_phases ph
1588 WHERE ph.pricing_phase_id = ev.pricing_phase_id
1589 AND ((QP_PREQ_PUB.G_GET_FREIGHT_FLAG = QP_PREQ_PUB.G_YES
1590 AND ph.freight_exists = QP_PREQ_PUB.G_YES)
1591 OR (QP_PREQ_PUB.G_GET_FREIGHT_FLAG = QP_PREQ_PUB.G_NO))
1592 AND instr(p_event_code, ev.pricing_event_code || ',') > 0
1593 --and (nvl(QP_PREQ_PUB.Get_buy_line_price_flag(adj.line_detail_index,line.price_flag) = QP_PREQ_PUB.G_YES
1594 --or (nvl(QP_PREQ_PUB.Get_buy_line_price_flag(adj.line_detail_index),line.price_flag) = QP_PREQ_PUB.G_PHASE
1595 AND (line.price_flag = QP_PREQ_PUB.G_YES
1596 OR (line.price_flag = QP_PREQ_PUB.G_PHASE
1597 AND nvl(ph.user_freeze_override_flag, ph.freeze_override_flag) =
1598 QP_PREQ_PUB.G_YES))))
1599 AND adj.modifier_level_code IN (QP_PREQ_PUB.G_LINE_LEVEL, QP_PREQ_PUB.G_LINE_GROUP)
1600 AND qplh.list_header_id = adj.list_header_id
1601 AND qplh.list_type_code NOT IN (QP_PREQ_PUB.G_PRICE_LIST_HEADER,
1602 QP_PREQ_PUB.G_AGR_LIST_HEADER)
1603 --commented out because we want to fetch PBH childs and PRG freeline adjs
1604 --and not exists (select 'x'
1605 -- from oe_price_adj_assocs a
1606 -- where a.RLTD_PRICE_ADJ_ID = adj.price_adjustment_id)
1607 UNION ALL
1608 SELECT /*+ ORDERED USE_NL(adj qplh) */
1609 adj.price_adjustment_id line_detail_index
1610 , adj.list_line_type_code line_detail_type_code
1611 , adj.price_break_type_code
1612 , NULL list_price
1613 , line.line_index
1614 , adj.list_header_id created_from_list_header_id
1615 , adj.list_line_id created_from_list_line_id
1616 , adj.list_line_type_code created_from_list_line_type
1617 , '' created_from_list_type_code
1618 , NULL CREATED_FROM_SQL
1619 , adj.pricing_group_sequence
1620 , adj.pricing_phase_id
1621 , adj.arithmetic_operator operand_calculation_code
1622 , nvl(adj.operand_per_pqty, adj.operand) operand_value
1623 , NULL SUBSTITUTION_TYPE_CODE
1624 , NULL SUBSTITUTION_VALUE_FROM
1625 , NULL SUBSTITUTION_VALUE_TO
1626 , NULL ASK_FOR_FLAG
1627 , NULL PRICE_FORMULA_ID
1628 , 'N' pricing_status_code
1629 , ' ' pricing_status_text
1630 , NULL PRODUCT_PRECEDENCE
1631 , NULL INCOMPATABILITY_GRP_CODE
1632 , NULL PROCESSED_FLAG
1633 , adj.applied_flag
1634 , adj.automatic_flag
1635 , adj.update_allowed override_flag
1636 , NULL PRIMARY_UOM_FLAG
1637 , NULL PRINT_ON_INVOICE_FLAG
1638 , adj.modifier_level_code
1639 , adj.BENEFIT_QTY
1640 , adj.BENEFIT_UOM_CODE
1641 , adj.LIST_LINE_NO
1642 , adj.accrual_flag
1643 , adj.ACCRUAL_CONVERSION_RATE
1644 , NULL ESTIM_ACCRUAL_RATE
1645 , NULL RECURRING_FLAG
1646 , NULL SELECTED_VOLUME_ATTR
1647 , line.rounding_factor
1648 , NULL HEADER_LIMIT_EXISTS
1649 , NULL LINE_LIMIT_EXISTS
1650 , adj.charge_type_code
1651 , adj.charge_subtype_code
1652 , NULL CURRENCY_DETAIL_ID
1653 , NULL CURRENCY_HEADER_ID
1654 , NULL SELLING_ROUNDING_FACTOR
1655 , NULL ORDER_CURRENCY
1656 , NULL PRICING_EFFECTIVE_DATE
1657 , NULL BASE_CURRENCY_CODE
1658 --, line.line_quantity
1659 , adj.range_break_quantity line_quantity
1660 , nvl(adj.updated_flag, QP_PREQ_PUB.G_NO) updated_flag
1661 , NULL calculation_code
1662 , adj.CHANGE_REASON_CODE
1663 , adj.CHANGE_REASON_TEXT
1664 , adj.PRICE_ADJUSTMENT_ID
1665 , NULL ACCUM_CONTEXT
1666 , NULL ACCUM_ATTRIBUTE
1667 , NULL ACCUM_FLAG
1668 , NULL BREAK_UOM_CODE
1669 , NULL BREAK_UOM_CONTEXT
1670 , NULL BREAK_UOM_ATTRIBUTE
1671 , NULL PROCESS_CODE -- 3215497
1672 FROM qp_int_lines line, oe_price_adjustments adj,
1673 qp_list_headers_b qplh
1674 WHERE QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = QP_PREQ_PUB.G_YES
1675 AND line.process_status IN (QP_PREQ_PUB.G_STATUS_UPDATED,
1676 QP_PREQ_PUB.G_STATUS_NEW,
1677 QP_PREQ_PUB.G_STATUS_UNCHANGED,
1678 'NEW' || QP_PREQ_PUB.G_STATUS_UNCHANGED,
1679 'OLD' || QP_PREQ_PUB.G_STATUS_UNCHANGED)
1680 AND adj.header_id = line.line_id
1681 AND line.pricing_status_code IN (QP_PREQ_PUB.G_STATUS_UPDATED
1682 , QP_PREQ_PUB.G_STATUS_GSA_VIOLATION
1683 , QP_PREQ_PUB.G_STATUS_UNCHANGED)
1684 AND line.line_type_code = QP_PREQ_PUB.G_ORDER_LEVEL
1685 AND (line.price_flag IN (QP_PREQ_PUB.G_YES, QP_PREQ_PUB.G_PHASE, QP_PREQ_PUB.G_CALCULATE_ONLY)
1686 OR nvl(line.processed_code, '0') = QP_PREQ_PUB.G_BY_ENGINE)
1687 AND (adj.updated_flag = QP_PREQ_PUB.G_YES
1688 OR line.price_flag = QP_PREQ_PUB.G_CALCULATE_ONLY
1689 OR (p_event_code IS NULL AND adj.updated_flag IS NULL)
1690 OR adj.pricing_phase_id NOT IN
1691 (SELECT ph.pricing_phase_id
1692 FROM qp_event_phases ev, qp_pricing_phases ph
1693 WHERE ph.pricing_phase_id = ev.pricing_phase_id
1694 AND ((QP_PREQ_PUB.G_GET_FREIGHT_FLAG = QP_PREQ_PUB.G_YES
1695 AND ph.freight_exists = QP_PREQ_PUB.G_YES)
1696 OR (QP_PREQ_PUB.G_GET_FREIGHT_FLAG = QP_PREQ_PUB.G_NO))
1697 AND instr(p_event_code, ev.pricing_event_code || ',') > 0
1698 --and (nvl(QP_PREQ_PUB.Get_buy_line_price_flag(adj.line_detail_index),line.price_flag) = QP_PREQ_PUB.G_YES
1699 --or (nvl(QP_PREQ_PUB.Get_buy_line_price_flag(adj.line_detail_index),line.price_flag) = QP_PREQ_PUB.G_PHASE
1700 AND (line.price_flag = QP_PREQ_PUB.G_YES
1701 OR (line.price_flag = QP_PREQ_PUB.G_PHASE
1702 AND nvl(ph.user_freeze_override_flag, ph.freeze_override_flag) = QP_PREQ_PUB.G_YES))))
1703 AND adj.modifier_level_code = QP_PREQ_PUB.G_ORDER_LEVEL
1704 AND adj.line_id IS NULL
1705 AND qplh.list_header_id = adj.list_header_id
1706 AND qplh.list_type_code NOT IN (QP_PREQ_PUB.G_PRICE_LIST_HEADER, QP_PREQ_PUB.G_AGR_LIST_HEADER);
1707
1708 CURSOR l_rltd_lines_cur(pbh_exist_flag VARCHAR2, prg_exist_flag VARCHAR2) IS
1709 SELECT /*+ index(ass OE_PRICE_ADJ_ASSOCS_N1)*/ --[julin/4865213] changed from N3 to N1
1710 line.line_index line_index,
1711 ass.price_adjustment_id line_detail_index,
1712 QP_PREQ_PUB.G_PBH_LINE relationship_type_code,
1713 line.line_index related_line_index,
1714 ass.rltd_price_adj_id related_line_detail_index,
1715 adj_pbh.list_line_id list_line_id,
1716 adj.list_line_id related_list_line_id,
1717 'INSERTED FOR CALCULATION' pricing_status_text
1718 FROM qp_int_lines line
1719 , oe_price_adjustments adj_pbh
1720 , oe_price_adj_assocs ass
1721 , oe_price_adjustments adj
1722 , qp_pricing_attributes attr
1723 WHERE pbh_exist_flag = 'Y'
1724 AND QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = QP_PREQ_PUB.G_YES
1725 AND line.line_type_code = QP_PREQ_PUB.G_LINE_LEVEL
1726 AND line.price_flag IN (QP_PREQ_PUB.G_YES, QP_PREQ_PUB.G_PHASE)
1727 AND line.line_id = adj_pbh.line_id
1728 AND adj_pbh.list_line_type_code = QP_PREQ_PUB.G_PRICE_BREAK_TYPE
1729 AND (p_calculate_flag = QP_PREQ_PUB.G_CALCULATE_ONLY
1730 OR line.price_flag = QP_PREQ_PUB.G_CALCULATE_ONLY
1731 OR adj_pbh.updated_flag = QP_PREQ_PUB.G_YES
1732 OR p_event_code = ',' --we pad comma when it is null
1733 OR adj_pbh.pricing_phase_id NOT IN
1734 (SELECT ph.pricing_phase_id
1735 FROM qp_event_phases evt, qp_pricing_phases ph
1736 WHERE ph.pricing_phase_id = evt.pricing_phase_id
1737 --introduced for freight_rating functionality to return only modifiers in
1738 --phases where freight_exist = 'Y' if G_GET_FREIGHT_FLAG = 'Y'
1739 AND ((QP_PREQ_PUB.G_GET_FREIGHT_FLAG = QP_PREQ_PUB.G_YES
1740 AND ph.freight_exists = QP_PREQ_PUB.G_YES)
1741 OR (QP_PREQ_PUB.G_GET_FREIGHT_FLAG = QP_PREQ_PUB.G_NO))
1742 AND instr(p_event_code, evt.pricing_event_code || ',') > 0
1743 --and (nvl(QP_PREQ_PUB.Get_buy_line_price_flag(adj.line_detail_index),line.price_flag) = QP_PREQ_PUB.G_YES
1744 AND (line.price_flag = QP_PREQ_PUB.G_YES
1745 --or (nvl(QP_PREQ_PUB.Get_buy_line_price_flag(adj.line_detail_index),line.price_flag) = QP_PREQ_PUB.G_PHASE
1746 OR (line.price_flag = QP_PREQ_PUB.G_PHASE
1747 AND nvl(ph.user_freeze_override_flag, ph.freeze_override_flag) =
1748 QP_PREQ_PUB.G_YES))))
1749 AND adj_pbh.price_adjustment_id = ass.price_adjustment_id
1750 AND ass.rltd_price_adj_id = adj.price_adjustment_id
1751 AND attr.list_line_id = adj.list_line_id
1752 AND attr.pricing_attribute_context = QP_PREQ_PUB.G_PRIC_VOLUME_CONTEXT
1753 UNION ALL
1754 SELECT /*+ ordered index(ass OE_PRICE_ADJ_ASSOCS_N1)*/ --[julin/4865213] changed from N3 to N1, ordered
1755 line.line_index line_index,
1756 adj_prg.price_adjustment_id line_detail_index,
1757 QP_PREQ_PUB.G_GENERATED_LINE relationship_type_code,
1758 getline.line_index related_line_index,
1759 ass.rltd_price_adj_id related_line_detail_index,
1760 adj_prg.list_line_id list_line_id,
1761 adj.list_line_id related_list_line_id,
1762 'INSERTED FOR CALCULATION' pricing_status_text
1763 FROM qp_int_lines line
1764 , oe_price_adjustments adj_prg
1765 , oe_price_adj_assocs ass
1766 , oe_price_adjustments adj
1767 , qp_int_lines getline
1768 WHERE prg_exist_flag = 'Y'
1769 AND QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = QP_PREQ_PUB.G_YES
1770 AND line.line_type_code = QP_PREQ_PUB.G_LINE_LEVEL
1771 --and line.price_flag in (QP_PREQ_PUB.G_YES, QP_PREQ_PUB.G_PHASE)
1772 AND line.price_flag = G_YES
1773 AND line.line_id = adj_prg.line_id
1774 AND adj_prg.list_line_type_code = G_PROMO_GOODS_DISCOUNT
1775 AND adj_prg.pricing_phase_id IN
1776 (SELECT ph.pricing_phase_id
1777 FROM qp_event_phases evt, qp_pricing_phases ph
1778 WHERE ph.pricing_phase_id = evt.pricing_phase_id
1779 AND instr(p_event_code, evt.pricing_event_code || ',') > 0
1780 AND (line.price_flag = QP_PREQ_PUB.G_YES
1781 OR (line.price_flag = QP_PREQ_PUB.G_PHASE
1782 AND nvl(ph.user_freeze_override_flag, ph.freeze_override_flag) = QP_PREQ_PUB.G_YES)))
1783 AND ass.price_adjustment_id = adj_prg.price_adjustment_id
1784 AND ass.rltd_price_adj_id = adj.price_adjustment_id
1785 AND adj.list_line_type_code = 'DIS'
1786 AND adj.line_id IS NOT NULL
1787 AND getline.line_id = adj.line_id;
1788 --and getline.price_flag in (QP_PREQ_PUB.G_YES, QP_PREQ_PUB.G_PHASE);
1789
1790 CURSOR l_pbh_adj_exists_cur IS
1791 SELECT /*+ index(adj OE_PRICE_ADJUSTMENTS_N2) */ 'Y'
1792 FROM
1793 qp_int_lines line,
1794 oe_price_adjustments adj
1795 WHERE adj.line_id = line.line_id
1796 AND line.line_type_code = QP_PREQ_PUB.G_LINE_LEVEL
1797 AND adj.list_line_type_code = QP_PREQ_PUB.G_PRICE_BREAK_TYPE
1798 AND (p_calculate_flag = QP_PREQ_PUB.G_CALCULATE_ONLY
1799 OR line.price_flag = QP_PREQ_PUB.G_CALCULATE_ONLY
1800 OR adj.updated_flag = QP_PREQ_PUB.G_YES
1801 OR p_event_code = ',' -- we pad ',' when it is null
1802 OR adj.pricing_phase_id NOT IN
1803 (SELECT ph.pricing_phase_id
1804 FROM qp_event_phases evt, qp_pricing_phases ph
1805 WHERE ph.pricing_phase_id = evt.pricing_phase_id
1806 --introduced for freight_rating functionality to return only modifiers in
1807 --phases where freight_exist = 'Y' if G_GET_FREIGHT_FLAG = 'Y'
1808 AND ((QP_PREQ_PUB.G_GET_FREIGHT_FLAG = QP_PREQ_PUB.G_YES
1809 AND ph.freight_exists = QP_PREQ_PUB.G_YES)
1810 OR (QP_PREQ_PUB.G_GET_FREIGHT_FLAG = QP_PREQ_PUB.G_NO))
1811 AND instr(p_event_code, evt.pricing_event_code || ',') > 0
1812 AND (nvl(QP_PREQ_PUB.Get_buy_line_price_flag(adj.list_line_id, line.line_index), line.price_flag) = QP_PREQ_PUB.G_YES
1813 OR (nvl(QP_PREQ_PUB.Get_buy_line_price_flag(adj.list_line_id, line.line_index), line.price_flag) = QP_PREQ_PUB.G_PHASE
1814 AND nvl(ph.user_freeze_override_flag, ph.freeze_override_flag) =
1815 QP_PREQ_PUB.G_YES))))
1816 UNION
1817 SELECT /*+ index(adj OE_PRICE_ADJUSTMENTS_N1) */ 'Y'
1818 FROM
1819 qp_int_lines line,
1820 oe_price_adjustments adj
1821 WHERE adj.header_id = line.line_id
1822 AND line.line_type_code = QP_PREQ_PUB.G_ORDER_LEVEL
1823 AND adj.list_line_type_code = QP_PREQ_PUB.G_PRICE_BREAK_TYPE
1824 AND (p_calculate_flag = QP_PREQ_PUB.G_CALCULATE_ONLY
1825 OR line.price_flag = QP_PREQ_PUB.G_CALCULATE_ONLY
1826 OR p_event_code = ',' -- we pad ',' when it is null
1827 OR adj.pricing_phase_id NOT IN
1828 (SELECT ph.pricing_phase_id
1829 FROM qp_event_phases evt, qp_pricing_phases ph
1830 WHERE ph.pricing_phase_id = evt.pricing_phase_id
1831 --introduced for freight_rating functionality to return only modifiers in
1832 --phases where freight_exist = 'Y' if G_GET_FREIGHT_FLAG = 'Y'
1833 AND ((QP_PREQ_PUB.G_GET_FREIGHT_FLAG = QP_PREQ_PUB.G_YES
1834 AND ph.freight_exists = QP_PREQ_PUB.G_YES)
1835 OR (QP_PREQ_PUB.G_GET_FREIGHT_FLAG = QP_PREQ_PUB.G_NO))
1836 AND instr(p_event_code, evt.pricing_event_code || ',') > 0
1837 AND (nvl(QP_PREQ_PUB.Get_buy_line_price_flag(adj.list_line_id, line.line_index), line.price_flag) = QP_PREQ_PUB.G_YES
1838 OR (nvl(QP_PREQ_PUB.Get_buy_line_price_flag(adj.list_line_id, line.line_index), line.price_flag) = QP_PREQ_PUB.G_PHASE
1839 AND nvl(ph.user_freeze_override_flag, ph.freeze_override_flag) =
1840 QP_PREQ_PUB.G_YES))));
1841
1842
1843 CURSOR l_prg_adj_exists_cur IS
1844 SELECT /*+ index(adj OE_PRICE_ADJUSTMENTS_N2) */ 'Y'
1845 FROM qp_int_lines line,
1846 oe_price_adjustments adj
1847 WHERE QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = QP_PREQ_PUB.G_YES
1848 AND adj.line_id = line.line_id
1849 AND line.line_type_code = QP_PREQ_PUB.G_LINE_LEVEL
1850 AND adj.list_line_type_code = 'PRG'
1851 AND adj.pricing_phase_id IN
1852 (SELECT ph.pricing_phase_id
1853 FROM qp_event_phases evt, qp_pricing_phases ph
1854 WHERE ph.pricing_phase_id = evt.pricing_phase_id
1855 AND instr(p_event_code, evt.pricing_event_code || ',') > 0
1856 AND (line.price_flag = QP_PREQ_PUB.G_YES
1857 OR (line.price_flag = QP_PREQ_PUB.G_PHASE
1858 AND nvl(ph.user_freeze_override_flag, ph.freeze_override_flag) = QP_PREQ_PUB.G_YES)));
1859
1860 CURSOR l_getline_dis_cur IS
1861 SELECT /*+ ORDERED USE_NL(adj qplh) */
1862 adj.price_adjustment_id line_detail_index
1863 , adj.list_line_type_code line_detail_type_code
1864 , adj.price_break_type_code
1865 , NULL list_price
1866 , getline.line_index
1867 , adj.list_header_id created_from_list_header_id
1868 , adj.list_line_id created_from_list_line_id
1869 , adj.list_line_type_code created_from_list_line_type
1870 , '' created_from_list_type_code
1871 , NULL CREATED_FROM_SQL
1872 , adj.pricing_group_sequence
1873 , adj.pricing_phase_id
1874 , adj.arithmetic_operator operand_calculation_code
1875 , nvl(adj.operand_per_pqty, adj.operand) operand_value
1876 , NULL SUBSTITUTION_TYPE_CODE
1877 , NULL SUBSTITUTION_VALUE_FROM
1878 , NULL SUBSTITUTION_VALUE_TO
1879 , NULL ASK_FOR_FLAG
1880 , NULL PRICE_FORMULA_ID
1881 , 'N' pricing_status_code
1882 , ' ' pricing_status_text
1883 , NULL PRODUCT_PRECEDENCE
1884 , NULL INCOMPATABILITY_GRP_CODE
1885 , NULL PROCESSED_FLAG
1886 , adj.applied_flag
1887 , adj.automatic_flag
1888 , adj.update_allowed override_flag
1889 , NULL PRIMARY_UOM_FLAG
1890 , NULL PRINT_ON_INVOICE_FLAG
1891 , adj.modifier_level_code
1892 , adj.BENEFIT_QTY
1893 , adj.BENEFIT_UOM_CODE
1894 , adj.LIST_LINE_NO
1895 , adj.accrual_flag
1896 , adj.ACCRUAL_CONVERSION_RATE
1897 , NULL ESTIM_ACCRUAL_RATE
1898 , NULL RECURRING_FLAG
1899 , NULL SELECTED_VOLUME_ATTR
1900 , getline.rounding_factor
1901 , NULL HEADER_LIMIT_EXISTS
1902 , NULL LINE_LIMIT_EXISTS
1903 , adj.charge_type_code
1904 , adj.charge_subtype_code
1905 , NULL CURRENCY_DETAIL_ID
1906 , NULL CURRENCY_HEADER_ID
1907 , NULL SELLING_ROUNDING_FACTOR
1908 , NULL ORDER_CURRENCY
1909 , NULL PRICING_EFFECTIVE_DATE
1910 , NULL BASE_CURRENCY_CODE
1911 --, line.line_quantity
1912 , adj.range_break_quantity line_quantity
1913 , nvl(adj.updated_flag, QP_PREQ_PUB.G_NO) updated_flag
1914 , NULL calculation_code
1915 , adj.CHANGE_REASON_CODE
1916 , adj.CHANGE_REASON_TEXT
1917 , adj.PRICE_ADJUSTMENT_ID
1918 , NULL ACCUM_CONTEXT
1919 , NULL ACCUM_ATTRIBUTE
1920 , NULL ACCUM_FLAG
1921 , NULL BREAK_UOM_CODE
1922 , NULL BREAK_UOM_CONTEXT
1923 , NULL BREAK_UOM_ATTRIBUTE
1924 , NULL PROCESS_CODE -- 3215497
1925 FROM qp_int_lines getline, oe_price_adjustments adj,
1926 qp_int_ldets ldet, oe_price_adj_assocs ass
1927 WHERE QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = QP_PREQ_PUB.G_YES
1928 AND ldet.CREATED_FROM_LIST_LINE_TYPE = 'PRG'
1929 AND ass.price_adjustment_id = ldet.price_adjustment_id
1930 AND ass.rltd_price_adj_id = adj.price_adjustment_id
1931 AND adj.line_id = getline.line_id
1932 AND getline.line_index = ldet.line_index -- sql repos
1933 AND getline.process_status IN (QP_PREQ_PUB.G_STATUS_UPDATED,
1934 QP_PREQ_PUB.G_STATUS_NEW,
1935 QP_PREQ_PUB.G_STATUS_UNCHANGED,
1936 'NEW' || QP_PREQ_PUB.G_STATUS_UNCHANGED,
1937 'OLD' || QP_PREQ_PUB.G_STATUS_UNCHANGED)
1938 AND getline.pricing_status_code IN (QP_PREQ_PUB.G_STATUS_UPDATED
1939 , QP_PREQ_PUB.G_STATUS_GSA_VIOLATION
1940 , QP_PREQ_PUB.G_STATUS_UNCHANGED)
1941 AND getline.price_flag = QP_PREQ_PUB.G_NO
1942 AND adj.price_adjustment_id NOT IN (SELECT price_adjustment_id
1943 FROM qp_int_ldets);
1944 --(getline.price_flag in (QP_PREQ_PUB.G_YES, QP_PREQ_PUB.G_PHASE,QP_PREQ_PUB.G_CALCULATE_ONLY)
1945 --OR nvl(line.processed_code,'0') = QP_PREQ_PUB.G_BY_ENGINE)
1946 --and line.line_type_code = QP_PREQ_PUB.G_LINE_LEVEL
1947
1948 l_LINE_DETAIL_index QP_PREQ_GRP.PLS_INTEGER_TYPE;
1949 l_LINE_DETAIL_TYPE_CODE QP_PREQ_GRP.VARCHAR_TYPE;
1950 l_PRICE_BREAK_TYPE_CODE QP_PREQ_GRP.VARCHAR_TYPE;
1951 l_LIST_PRICE QP_PREQ_GRP.NUMBER_TYPE;
1952 l_LINE_INDEX QP_PREQ_GRP.PLS_INTEGER_TYPE;
1953 l_CREATED_FROM_LIST_HEADER_ID QP_PREQ_GRP.NUMBER_TYPE;
1954 l_CREATED_FROM_LIST_LINE_ID QP_PREQ_GRP.NUMBER_TYPE;
1955 l_CREATED_FROM_LIST_LINE_TYPE QP_PREQ_GRP.VARCHAR_TYPE;
1956 l_CREATED_FROM_LIST_TYPE_CODE QP_PREQ_GRP.VARCHAR_TYPE;
1957 l_CREATED_FROM_SQL QP_PREQ_GRP.VARCHAR_TYPE;
1958 l_PRICING_GROUP_SEQUENCE QP_PREQ_GRP.PLS_INTEGER_TYPE;
1959 l_PRICING_PHASE_ID QP_PREQ_GRP.PLS_INTEGER_TYPE;
1960 l_OPERAND_CALCULATION_CODE QP_PREQ_GRP.VARCHAR_TYPE;
1961 l_OPERAND_VALUE QP_PREQ_GRP.VARCHAR_TYPE;
1962 l_SUBSTITUTION_TYPE_CODE QP_PREQ_GRP.VARCHAR_TYPE;
1963 l_SUBSTITUTION_VALUE_FROM QP_PREQ_GRP.VARCHAR_TYPE;
1964 l_SUBSTITUTION_VALUE_TO QP_PREQ_GRP.VARCHAR_TYPE;
1965 l_ASK_FOR_FLAG QP_PREQ_GRP.VARCHAR_TYPE;
1966 l_PRICE_FORMULA_ID QP_PREQ_GRP.NUMBER_TYPE;
1967 l_PRICING_STATUS_CODE QP_PREQ_GRP.VARCHAR_TYPE;
1968 l_PRICING_STATUS_TEXT QP_PREQ_GRP.VARCHAR_TYPE;
1969 l_PRODUCT_PRECEDENCE QP_PREQ_GRP.PLS_INTEGER_TYPE;
1970 l_INCOMPATABLILITY_GRP_CODE QP_PREQ_GRP.VARCHAR_TYPE;
1971 l_PROCESSED_FLAG QP_PREQ_GRP.VARCHAR_TYPE;
1972 l_APPLIED_FLAG QP_PREQ_GRP.VARCHAR_TYPE;
1973 l_AUTOMATIC_FLAG QP_PREQ_GRP.VARCHAR_TYPE;
1974 l_OVERRIDE_FLAG QP_PREQ_GRP.VARCHAR_TYPE;
1975 l_PRIMARY_UOM_FLAG QP_PREQ_GRP.VARCHAR_TYPE;
1976 l_PRINT_ON_INVOICE_FLAG QP_PREQ_GRP.VARCHAR_TYPE;
1977 l_MODIFIER_LEVEL_CODE QP_PREQ_GRP.VARCHAR_TYPE;
1978 l_BENEFIT_QTY QP_PREQ_GRP.NUMBER_TYPE;
1979 l_BENEFIT_UOM_CODE QP_PREQ_GRP.VARCHAR_TYPE;
1980 l_SERVICE_DURATION QP_PREQ_GRP.NUMBER_TYPE; -- service project
1981 l_SERVICE_PERIOD QP_PREQ_GRP.VARCHAR_TYPE; -- service project
1982 l_LIST_LINE_NO QP_PREQ_GRP.VARCHAR_TYPE;
1983 l_ACCRUAL_FLAG QP_PREQ_GRP.VARCHAR_TYPE;
1984 l_ACCRUAL_CONVERSION_RATE QP_PREQ_GRP.NUMBER_TYPE;
1985 l_ESTIM_ACCRUAL_RATE QP_PREQ_GRP.NUMBER_TYPE;
1986 l_RECURRING_FLAG QP_PREQ_GRP.VARCHAR_TYPE;
1987 l_SELECTED_VOLUME_ATTR QP_PREQ_GRP.VARCHAR_TYPE;
1988 l_ROUNDING_FACTOR QP_PREQ_GRP.PLS_INTEGER_TYPE;
1989 l_HEADER_LIMIT_EXISTS QP_PREQ_GRP.VARCHAR_TYPE;
1990 l_LINE_LIMIT_EXISTS QP_PREQ_GRP.VARCHAR_TYPE;
1991 l_CHARGE_TYPE_CODE QP_PREQ_GRP.VARCHAR_TYPE;
1992 l_CHARGE_SUBTYPE_CODE QP_PREQ_GRP.VARCHAR_TYPE;
1993 l_CURRENCY_DETAIL_ID QP_PREQ_GRP.NUMBER_TYPE;
1994 l_CURRENCY_HEADER_ID QP_PREQ_GRP.NUMBER_TYPE;
1995 l_SELLING_ROUNDING_FACTOR QP_PREQ_GRP.NUMBER_TYPE;
1996 l_ORDER_CURRENCY QP_PREQ_GRP.VARCHAR_TYPE;
1997 l_PRICING_EFFECTIVE_DATE QP_PREQ_GRP.DATE_TYPE;
1998 l_BASE_CURRENCY_CODE QP_PREQ_GRP.VARCHAR_TYPE;
1999 l_LINE_QUANTITY QP_PREQ_GRP.NUMBER_TYPE;
2000 l_UPDATED_FLAG QP_PREQ_GRP.VARCHAR_TYPE;
2001 l_CALCULATION_CODE QP_PREQ_GRP.VARCHAR_TYPE;
2002 l_CHANGE_REASON_CODE QP_PREQ_GRP.VARCHAR_TYPE;
2003 l_CHANGE_REASON_TEXT QP_PREQ_GRP.VARCHAR_TYPE;
2004 l_PRICE_ADJUSTMENT_ID QP_PREQ_GRP.NUMBER_TYPE; -- bug 3099847
2005 l_ACCUM_CONTEXT QP_PREQ_GRP.VARCHAR_TYPE; -- accum range break
2006 l_ACCUM_ATTRIBUTE QP_PREQ_GRP.VARCHAR_TYPE; -- accum range break
2007 l_ACCUM_FLAG QP_PREQ_GRP.VARCHAR_TYPE; -- accum range break
2008 l_BREAK_UOM_CODE QP_PREQ_GRP.VARCHAR_TYPE; /* Proration*/
2009 l_BREAK_UOM_CONTEXT QP_PREQ_GRP.VARCHAR_TYPE; /* Proration*/
2010 l_BREAK_UOM_ATTRIBUTE QP_PREQ_GRP.VARCHAR_TYPE; /* Proration*/
2011 l_PROCESS_CODE QP_PREQ_GRP.VARCHAR_TYPE; -- 3215497
2012
2013 l_LINE_INDEX1 QP_PREQ_GRP.PLS_INTEGER_TYPE; -- 3215497
2014 l_LINE_DETAIL_INDEX1 QP_PREQ_GRP.PLS_INTEGER_TYPE; -- 3215497
2015 l_RELATIONSHIP_TYPE_CODE QP_PREQ_GRP.VARCHAR_TYPE;
2016 l_RELATED_LINE_INDEX QP_PREQ_GRP.PLS_INTEGER_TYPE; -- 3215497
2017 l_RELATED_LINE_DETAIL_INDEX QP_PREQ_GRP.PLS_INTEGER_TYPE; -- 3215497
2018 l_LIST_LINE_ID QP_PREQ_GRP.NUMBER_TYPE;
2019 l_RLTD_LIST_LINE_ID QP_PREQ_GRP.NUMBER_TYPE;
2020 --l_pricing_status_code QP_PREQ_GRP.VARCHAR_TYPE;
2021 --l_pricing_status_text QP_PREQ_GRP.VARCHAR_TYPE;
2022
2023 l_debug VARCHAR2(3);
2024 l_pbh_adj_exists VARCHAR2(1) := QP_PREQ_PUB.G_NO;
2025 l_prg_adj_exists VARCHAR2(1) := QP_PREQ_PUB.G_NO;
2026
2027 BEGIN
2028 x_return_status := FND_API.G_RET_STS_SUCCESS;
2029 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
2030
2031 --per bug3238607, no need to check HVOP
2032 IF(QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = QP_PREQ_PUB.G_YES ) THEN
2033 --QP_UTIL_PUB.HVOP_PRICING_ON = QP_PREQ_PUB.G_NO) THEN
2034 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE THEN
2035 QP_PREQ_GRP.ENGINE_DEBUG('QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG=Y and ');
2036 --'QP_BULK_PREQ_GRP.G_HVOP_Pricing_ON=N');
2037 QP_PREQ_GRP.ENGINE_DEBUG('QP_PREQ_PUB.G_GET_FREIGHT_FLAG:' || QP_PREQ_PUB.G_GET_FREIGHT_FLAG);
2038 END IF;
2039
2040 OPEN l_ldets_cur;
2041 LOOP
2042 l_LINE_DETAIL_index.DELETE;
2043 l_LINE_DETAIL_TYPE_CODE.DELETE;
2044 l_PRICE_BREAK_TYPE_CODE.DELETE;
2045 l_LIST_PRICE.DELETE;
2046 l_LINE_INDEX.DELETE;
2047 l_CREATED_FROM_LIST_HEADER_ID.DELETE;
2048 l_CREATED_FROM_LIST_LINE_ID.DELETE;
2049 l_CREATED_FROM_LIST_LINE_TYPE.DELETE;
2050 l_CREATED_FROM_LIST_TYPE_CODE.DELETE;
2051 l_CREATED_FROM_SQL.DELETE;
2052 l_PRICING_GROUP_SEQUENCE.DELETE;
2053 l_PRICING_PHASE_ID.DELETE;
2054 l_OPERAND_CALCULATION_CODE.DELETE;
2055 l_OPERAND_VALUE.DELETE;
2056 l_SUBSTITUTION_TYPE_CODE.DELETE;
2057 l_SUBSTITUTION_VALUE_FROM.DELETE;
2058 l_SUBSTITUTION_VALUE_TO.DELETE;
2059 l_ASK_FOR_FLAG.DELETE;
2060 l_PRICE_FORMULA_ID.DELETE;
2061 l_PRICING_STATUS_CODE.DELETE;
2062 l_PRICING_STATUS_TEXT.DELETE;
2063 l_PRODUCT_PRECEDENCE.DELETE;
2064 l_INCOMPATABLILITY_GRP_CODE.DELETE;
2065 l_PROCESSED_FLAG.DELETE;
2066 l_APPLIED_FLAG.DELETE;
2067 l_AUTOMATIC_FLAG.DELETE;
2068 l_OVERRIDE_FLAG.DELETE;
2069 l_PRIMARY_UOM_FLAG.DELETE;
2070 l_PRINT_ON_INVOICE_FLAG.DELETE;
2071 l_MODIFIER_LEVEL_CODE.DELETE;
2072 l_BENEFIT_QTY.DELETE;
2073 l_BENEFIT_UOM_CODE.DELETE;
2074 l_LIST_LINE_NO.DELETE;
2075 l_ACCRUAL_FLAG.DELETE;
2076 l_ACCRUAL_CONVERSION_RATE.DELETE;
2077 l_ESTIM_ACCRUAL_RATE.DELETE;
2078 l_RECURRING_FLAG.DELETE;
2079 l_SELECTED_VOLUME_ATTR.DELETE;
2080 l_ROUNDING_FACTOR.DELETE;
2081 l_HEADER_LIMIT_EXISTS.DELETE;
2082 l_LINE_LIMIT_EXISTS.DELETE;
2083 l_CHARGE_TYPE_CODE.DELETE;
2084 l_CHARGE_SUBTYPE_CODE.DELETE;
2085 l_CURRENCY_DETAIL_ID.DELETE;
2086 l_CURRENCY_HEADER_ID.DELETE;
2087 l_SELLING_ROUNDING_FACTOR.DELETE;
2088 l_ORDER_CURRENCY.DELETE;
2089 l_PRICING_EFFECTIVE_DATE.DELETE;
2090 l_BASE_CURRENCY_CODE.DELETE;
2091 l_LINE_QUANTITY.DELETE;
2092 l_UPDATED_FLAG.DELETE;
2093 l_CALCULATION_CODE.DELETE;
2094 l_CHANGE_REASON_CODE.DELETE;
2095 l_CHANGE_REASON_TEXT.DELETE;
2096 l_PRICE_ADJUSTMENT_ID.DELETE;
2097 l_ACCUM_CONTEXT.DELETE;
2098 l_ACCUM_ATTRIBUTE.DELETE;
2099 l_ACCUM_FLAG.DELETE;
2100 l_BREAK_UOM_CODE.DELETE;
2101 l_BREAK_UOM_CONTEXT.DELETE;
2102 l_BREAK_UOM_ATTRIBUTE.DELETE;
2103 l_PROCESS_CODE.DELETE; -- 3215497
2104
2105 IF l_debug = FND_API.G_TRUE THEN
2106 QP_PREQ_GRP.engine_debug('fetching l_ldets_cur');
2107 END IF;
2108
2109 FETCH l_ldets_cur
2110 BULK COLLECT INTO
2111 l_LINE_DETAIL_index,
2112 l_LINE_DETAIL_TYPE_CODE,
2113 l_PRICE_BREAK_TYPE_CODE,
2114 l_LIST_PRICE,
2115 l_LINE_INDEX,
2116 l_CREATED_FROM_LIST_HEADER_ID,
2117 l_CREATED_FROM_LIST_LINE_ID,
2118 l_CREATED_FROM_LIST_LINE_TYPE,
2119 l_CREATED_FROM_LIST_TYPE_CODE,
2120 l_CREATED_FROM_SQL,
2121 l_PRICING_GROUP_SEQUENCE,
2122 l_PRICING_PHASE_ID,
2123 l_OPERAND_CALCULATION_CODE,
2124 l_OPERAND_VALUE,
2125 l_SUBSTITUTION_TYPE_CODE,
2126 l_SUBSTITUTION_VALUE_FROM,
2127 l_SUBSTITUTION_VALUE_TO,
2128 l_ASK_FOR_FLAG,
2129 l_PRICE_FORMULA_ID,
2130 l_PRICING_STATUS_CODE,
2131 l_PRICING_STATUS_TEXT,
2132 l_PRODUCT_PRECEDENCE,
2133 l_INCOMPATABLILITY_GRP_CODE,
2134 l_PROCESSED_FLAG,
2135 l_APPLIED_FLAG,
2136 l_AUTOMATIC_FLAG,
2137 l_OVERRIDE_FLAG,
2138 l_PRIMARY_UOM_FLAG,
2139 l_PRINT_ON_INVOICE_FLAG,
2140 l_MODIFIER_LEVEL_CODE,
2141 l_BENEFIT_QTY,
2142 l_BENEFIT_UOM_CODE,
2143 l_LIST_LINE_NO,
2144 l_ACCRUAL_FLAG,
2145 l_ACCRUAL_CONVERSION_RATE,
2146 l_ESTIM_ACCRUAL_RATE,
2147 l_RECURRING_FLAG,
2148 l_SELECTED_VOLUME_ATTR,
2149 l_ROUNDING_FACTOR,
2150 l_HEADER_LIMIT_EXISTS,
2151 l_LINE_LIMIT_EXISTS,
2152 l_CHARGE_TYPE_CODE,
2153 l_CHARGE_SUBTYPE_CODE,
2154 l_CURRENCY_DETAIL_ID,
2155 l_CURRENCY_HEADER_ID,
2156 l_SELLING_ROUNDING_FACTOR,
2157 l_ORDER_CURRENCY,
2158 l_PRICING_EFFECTIVE_DATE,
2159 l_BASE_CURRENCY_CODE,
2160 l_LINE_QUANTITY,
2161 l_UPDATED_FLAG,
2162 l_CALCULATION_CODE,
2163 l_CHANGE_REASON_CODE,
2164 l_CHANGE_REASON_TEXT,
2165 l_PRICE_ADJUSTMENT_ID,
2166 l_ACCUM_CONTEXT,
2167 l_ACCUM_ATTRIBUTE,
2168 l_ACCUM_FLAG,
2169 l_BREAK_UOM_CODE,
2170 l_BREAK_UOM_CONTEXT,
2171 l_BREAK_UOM_ATTRIBUTE,
2172 l_PROCESS_CODE; -- 3215497
2173 -- LIMIT nrows;
2174 EXIT WHEN l_LINE_DETAIL_index.COUNT = 0;
2175
2176 IF l_debug = FND_API.G_TRUE THEN
2177 QP_PREQ_GRP.engine_debug('rows fetched:'|| l_line_detail_index.COUNT);
2178 END IF;
2179
2180 IF l_LINE_DETAIL_index.COUNT > 0
2181 AND l_debug = FND_API.G_TRUE
2182 THEN
2183 FOR i IN l_LINE_DETAIL_index.FIRST..l_LINE_DETAIL_index.LAST
2184 LOOP
2185 QP_PREQ_GRP.engine_debug('=======line_detail_index: '|| l_LINE_DETAIL_index(i) ||
2186 ' line_detail_type_code: '|| l_LINE_DETAIL_TYPE_CODE(i) ||
2187 ' price_break_type_code: '|| l_PRICE_BREAK_TYPE_CODE(i) ||
2188 ' list_price: ' || l_LIST_PRICE(i) ||
2189 ' line_index: '|| l_LINE_INDEX(i));
2190
2191 QP_PREQ_GRP.engine_debug('created_from_list_header_id: '|| l_CREATED_FROM_LIST_HEADER_ID(i) ||
2192 ' created_from_list_line_id: '|| l_CREATED_FROM_LIST_LINE_ID(i) ||
2193 ' created_from_list_line_type: '|| l_CREATED_FROM_LIST_LINE_TYPE(i) ||
2194 ' created_from_list_type_code: '|| l_CREATED_FROM_LIST_TYPE_CODE(i) ||
2195 ' created_from_sql: '|| l_CREATED_FROM_SQL(i) ||
2196 ' pricing_group_sequence: ' || l_PRICING_GROUP_SEQUENCE(i) ||
2197 ' pricing_phase_id: '|| l_PRICING_PHASE_ID(i) ||
2198 ' oprand_calculation_code: ' || l_OPERAND_CALCULATION_CODE(i) ||
2199 ' operand_value: ' || l_OPERAND_VALUE(i));
2200 QP_PREQ_GRP.engine_debug(' substitution_type_code: ' || l_SUBSTITUTION_TYPE_CODE(i) ||
2201 ' substitution_value_from: ' || l_SUBSTITUTION_VALUE_FROM(i) ||
2202 ' substitution_value_to: ' || l_SUBSTITUTION_VALUE_TO(i) ||
2203 ' ask_for_flag: ' || l_ASK_FOR_FLAG(i) ||
2204 ' price_formula_id: '|| l_PRICE_FORMULA_ID(i) ||
2205 ' pricing_status_code: '|| l_PRICING_STATUS_CODE(i) ||
2206 ' pricing_status_text: '|| l_PRICING_STATUS_TEXT(i) ||
2207 ' product_precedence: '|| l_PRODUCT_PRECEDENCE(i) ||
2208 ' incompatability_grp_code: ' || l_INCOMPATABLILITY_GRP_CODE(i));
2209
2210 QP_PREQ_GRP.engine_debug(' processed_flag: '|| l_PROCESSED_FLAG(i) ||
2211 ' applied_flag: '|| l_APPLIED_FLAG(i) ||
2212 ' automatic_flag: '|| l_AUTOMATIC_FLAG(i) ||
2213 ' override_flag: '|| l_OVERRIDE_FLAG(i) ||
2214 ' primary_uom_flag: '|| l_PRIMARY_UOM_FLAG(i) ||
2215 ' print_on_invoice_flag: '|| l_PRINT_ON_INVOICE_FLAG(i) ||
2216 ' MODIFIER_LEVEL_CODE: '|| l_MODIFIER_LEVEL_CODE(i) ||
2217 ' BENEFIT_QTY: '|| l_BENEFIT_QTY(i) ||
2218 ' BENEFIT_UOM_CODE: '|| l_BENEFIT_UOM_CODE(i) ||
2219 ' SERVICE_DURATION: '|| l_SERVICE_DURATION(i) || -- service project
2220 ' SERVICE_PERIOD: '|| l_SERVICE_PERIOD(i)); -- service project
2221
2222 QP_PREQ_GRP.engine_debug(' LIST_LINE_NO: '|| l_LIST_LINE_NO(i) ||
2223 ' ACCRUAL_FLAG: '|| l_ACCRUAL_FLAG(i) ||
2224 ' ACCRUAL_CONVERSION_RATE: '|| l_ACCRUAL_CONVERSION_RATE(i) ||
2225 ' ESTIM_ACCRUAL_RATE: '|| l_ESTIM_ACCRUAL_RATE(i) ||
2226 ' RECURRING_FLAG: '|| l_RECURRING_FLAG(i) ||
2227 ' SELECTED_VOLUME_ATTR: '|| l_SELECTED_VOLUME_ATTR(i) ||
2228 ' ROUNDING_FACTOR: '|| l_ROUNDING_FACTOR(i) ||
2229 ' HEADER_LIMIT_EXISTS: '|| l_HEADER_LIMIT_EXISTS(i) ||
2230 ' LINE_LIMIT_EXISTS: '|| l_LINE_LIMIT_EXISTS(i));
2231
2232 QP_PREQ_GRP.engine_debug(' CHARGE_TYPE_CODE:'|| l_CHARGE_TYPE_CODE(i) ||
2233 ' CHARGE_SUBTYPE_CODE:'|| l_CHARGE_SUBTYPE_CODE(i) ||
2234 ' CURRENCY_DETAIL_ID:'|| l_CURRENCY_DETAIL_ID(i) ||
2235 ' CURRENCY_HEADER_ID:'|| l_CURRENCY_HEADER_ID(i) ||
2236 ' SELLING_ROUNDING_FACTOR:'|| l_SELLING_ROUNDING_FACTOR(i) ||
2237 ' ORDER_CURRENCY:'|| l_ORDER_CURRENCY(i) ||
2238 ' PRICING_EFFECTIVE_DATE:'|| l_PRICING_EFFECTIVE_DATE(i) ||
2239 ' BASE_CURRENCY_CODE:'|| l_BASE_CURRENCY_CODE(i) ||
2240 ' LINE_QUANTITY:'|| l_LINE_QUANTITY(i));
2241
2242 QP_PREQ_GRP.engine_debug(' UPDATED_FLAG:'|| l_UPDATED_FLAG(i) ||
2243 ' CALCULATION_CODE:'|| l_CALCULATION_CODE(i) ||
2244 ' CHANGE_REASON_CODE:'|| l_CHANGE_REASON_CODE(i) ||
2245 ' CHANGE_REASON_TEXT:'|| l_CHANGE_REASON_TEXT(i) ||
2246 ' PRICE_ADJUSTMENT_ID:'|| l_PRICE_ADJUSTMENT_ID(i) ||
2247 ' ACCUM_CONTEXT:'|| l_ACCUM_CONTEXT(i) ||
2248 ' ACCUM_ATTRIBUTE:'|| l_ACCUM_ATTRIBUTE(i) ||
2249 ' ACCUM_FLAG:'|| l_ACCUM_FLAG(i) ||
2250 ' BREAK_UOM_CODE:'|| l_BREAK_UOM_CODE(i) ||
2251 ' BREAK_UOM_CONTEXT:'|| l_BREAK_UOM_CONTEXT(i) ||
2252 ' BREAK_UOM_ATTRIBUTE:'|| l_BREAK_UOM_ATTRIBUTE(i));
2253
2254 END LOOP;
2255 END IF; --l_line_detail_index.COUNT
2256
2257 IF l_LINE_DETAIL_index.COUNT > 0 THEN
2258 IF l_debug = FND_API.G_TRUE THEN
2259 QP_PREQ_GRP.engine_debug('calling INSERT_LDETS2');
2260 END IF;
2261 QP_PREQ_GRP.INSERT_LDETS2
2262 (l_LINE_DETAIL_index,
2263 l_LINE_DETAIL_TYPE_CODE,
2264 l_PRICE_BREAK_TYPE_CODE,
2265 l_LIST_PRICE,
2266 l_LINE_INDEX,
2267 l_CREATED_FROM_LIST_HEADER_ID,
2268 l_CREATED_FROM_LIST_LINE_ID,
2269 l_CREATED_FROM_LIST_LINE_TYPE,
2270 l_CREATED_FROM_LIST_TYPE_CODE,
2271 l_CREATED_FROM_SQL,
2272 l_PRICING_GROUP_SEQUENCE,
2273 l_PRICING_PHASE_ID,
2274 l_OPERAND_CALCULATION_CODE,
2275 l_OPERAND_VALUE,
2276 l_SUBSTITUTION_TYPE_CODE,
2277 l_SUBSTITUTION_VALUE_FROM,
2278 l_SUBSTITUTION_VALUE_TO,
2279 l_ASK_FOR_FLAG,
2280 l_PRICE_FORMULA_ID,
2281 l_PRICING_STATUS_CODE,
2282 l_PRICING_STATUS_TEXT,
2283 l_PRODUCT_PRECEDENCE,
2284 l_INCOMPATABLILITY_GRP_CODE,
2285 l_PROCESSED_FLAG,
2286 l_APPLIED_FLAG,
2287 l_AUTOMATIC_FLAG,
2288 l_OVERRIDE_FLAG,
2289 l_PRIMARY_UOM_FLAG,
2290 l_PRINT_ON_INVOICE_FLAG,
2291 l_MODIFIER_LEVEL_CODE,
2292 l_BENEFIT_QTY,
2293 l_BENEFIT_UOM_CODE,
2294 l_SERVICE_DURATION, -- service project
2295 l_SERVICE_PERIOD, -- service project
2296 l_LIST_LINE_NO,
2297 l_ACCRUAL_FLAG,
2298 l_ACCRUAL_CONVERSION_RATE,
2299 l_ESTIM_ACCRUAL_RATE,
2300 l_RECURRING_FLAG,
2301 l_SELECTED_VOLUME_ATTR,
2302 l_ROUNDING_FACTOR,
2303 l_HEADER_LIMIT_EXISTS,
2304 l_LINE_LIMIT_EXISTS,
2305 l_CHARGE_TYPE_CODE,
2306 l_CHARGE_SUBTYPE_CODE,
2307 l_CURRENCY_DETAIL_ID,
2308 l_CURRENCY_HEADER_ID,
2309 l_SELLING_ROUNDING_FACTOR,
2310 l_ORDER_CURRENCY,
2311 l_PRICING_EFFECTIVE_DATE,
2312 l_BASE_CURRENCY_CODE,
2313 l_LINE_QUANTITY,
2314 l_UPDATED_FLAG,
2315 l_CALCULATION_CODE,
2316 l_CHANGE_REASON_CODE,
2317 l_CHANGE_REASON_TEXT,
2318 l_PRICE_ADJUSTMENT_ID,
2319 l_ACCUM_CONTEXT,
2320 l_ACCUM_ATTRIBUTE,
2321 l_ACCUM_FLAG,
2322 l_BREAK_UOM_CODE,
2323 l_BREAK_UOM_CONTEXT,
2324 l_BREAK_UOM_ATTRIBUTE,
2325 l_PROCESS_CODE, -- 3215497
2326 x_return_status,
2327 x_return_status_text);
2328 END IF;
2329 END LOOP;
2330 CLOSE l_ldets_cur;
2331
2332 IF l_debug = FND_API.G_TRUE THEN
2333 QP_PREQ_GRP.engine_debug('close l_ldets_cur');
2334 END IF;
2335
2336
2337 IF l_debug = FND_API.G_TRUE THEN
2338 QP_PREQ_GRP.engine_debug('Begin Insert rltd lines');
2339 END IF;
2340
2341 OPEN l_pbh_adj_exists_cur;
2342 FETCH l_pbh_adj_exists_cur INTO l_pbh_adj_exists;
2343 CLOSE l_pbh_adj_exists_cur;
2344
2345 OPEN l_prg_adj_exists_cur;
2346 FETCH l_prg_adj_exists_cur INTO l_prg_adj_exists;
2347 CLOSE l_prg_adj_exists_cur;
2348
2349 IF l_debug = FND_API.G_TRUE THEN
2350 QP_PREQ_GRP.engine_debug('Check l_pbh_adj_exists '|| l_pbh_adj_exists);
2351 QP_PREQ_GRP.engine_debug('Check l_prg_adj_exists '|| l_prg_adj_exists);
2352 END IF;
2353
2354 --IF l_pbh_adj_exists = QP_PREQ_PUB.G_YES
2355 --THEN
2356 -- OPEN l_rltd_lines_cur;
2357 OPEN l_rltd_lines_cur(l_pbh_adj_exists, l_prg_adj_exists);
2358 LOOP
2359 l_LINE_index1.DELETE;
2360 l_LINE_DETAIL_INDEX1.DELETE;
2361 l_RELATIONSHIP_TYPE_CODE.DELETE;
2362 l_RELATED_LINE_INDEX.DELETE;
2363 l_RELATED_LINE_DETAIL_INDEX.DELETE;
2364 l_LIST_LINE_ID.DELETE;
2365 l_RLTD_LIST_LINE_ID.DELETE;
2366 l_pricing_status_text.DELETE;
2367
2368 IF l_debug = FND_API.G_TRUE THEN
2369 QP_PREQ_GRP.engine_debug('fetching l_rltd_lines_cur');
2370 END IF;
2371
2372 FETCH l_rltd_lines_cur
2373 BULK COLLECT INTO
2374 l_LINE_index1,
2375 l_LINE_DETAIL_INDEX1,
2376 l_RELATIONSHIP_TYPE_CODE,
2377 l_RELATED_LINE_INDEX,
2378 l_RELATED_LINE_DETAIL_INDEX,
2379 l_LIST_LINE_ID,
2380 l_RLTD_LIST_LINE_ID,
2381 l_pricing_status_text;
2382 -- LIMIT nrows;
2383 EXIT WHEN l_LINE_index1.COUNT = 0;
2384
2385 IF l_debug = FND_API.G_TRUE THEN
2386 QP_PREQ_GRP.engine_debug('rows fetched:'|| l_line_index1.COUNT);
2387 END IF;
2388
2389 IF l_LINE_index1.COUNT > 0
2390 AND l_debug = FND_API.G_TRUE
2391 THEN
2392 FOR i IN l_LINE_index1.FIRST..l_LINE_index1.LAST
2393 LOOP
2394 QP_PREQ_GRP.engine_debug('======line_index: '|| l_LINE_index1(i) ||
2395 ' line_detail_index: '|| l_LINE_DETAIL_index1(i) ||
2396 ' relationship_type_code: '|| l_RELATIONSHIP_TYPE_CODE(i) ||
2397 ' related_line_index: '|| l_RELATED_LINE_INDEX(i) ||
2398 ' related_line_detail_index: ' || l_RELATED_LINE_DETAIL_INDEX(i) ||
2399 ' list_line_id: '|| l_LIST_LINE_ID(i) ||
2400 ' rltd_list_line_id: '|| l_RLTD_LIST_LINE_ID(i) ||
2401 ' pricing_status_text:' || l_pricing_status_text(i));
2402 END LOOP;
2403 END IF; --l_LINE_index1.COUNT
2404
2405 IF l_debug = FND_API.G_TRUE THEN
2406 QP_PREQ_GRP.engine_debug('calling INSERT_RLTD_LDETS2');
2407 END IF;
2408 QP_PREQ_GRP.INSERT_RLTD_LINES2
2409 (l_LINE_INDEX1
2410 , l_LINE_DETAIL_INDEX1
2411 , l_RELATIONSHIP_TYPE_CODE
2412 , l_RELATED_LINE_INDEX
2413 , l_RELATED_LINE_DETAIL_INDEX
2414 , x_return_status
2415 , x_return_status_text
2416 , l_LIST_LINE_ID
2417 , l_RLTD_LIST_LINE_ID
2418 , l_pricing_status_text);
2419 /* delete from qp_npreq_rltd_lines_tmp
2420 where pricing_status_code = QP_PREQ_PUB.G_STATUS_NEW
2421 and relationship_type_code = QP_PREQ_PUB.G_PBH_LINE
2422 and pricing_status_text = G_CALC_INSERT;
2423 */ --need to delete them later
2424 END LOOP;
2425 CLOSE l_rltd_lines_cur;
2426
2427 IF l_debug = FND_API.G_TRUE THEN
2428 QP_PREQ_GRP.engine_debug('close l_rltd_lines_cur');
2429 END IF;
2430
2431 IF l_prg_adj_exists = 'Y' THEN
2432 OPEN l_getline_dis_cur;
2433 LOOP
2434 l_LINE_DETAIL_index.DELETE;
2435 l_LINE_DETAIL_TYPE_CODE.DELETE;
2436 l_PRICE_BREAK_TYPE_CODE.DELETE;
2437 l_LIST_PRICE.DELETE;
2438 l_LINE_INDEX.DELETE;
2439 l_CREATED_FROM_LIST_HEADER_ID.DELETE;
2440 l_CREATED_FROM_LIST_LINE_ID.DELETE;
2441 l_CREATED_FROM_LIST_LINE_TYPE.DELETE;
2442 l_CREATED_FROM_LIST_TYPE_CODE.DELETE;
2443 l_CREATED_FROM_SQL.DELETE;
2444 l_PRICING_GROUP_SEQUENCE.DELETE;
2445 l_PRICING_PHASE_ID.DELETE;
2446 l_OPERAND_CALCULATION_CODE.DELETE;
2447 l_OPERAND_VALUE.DELETE;
2448 l_SUBSTITUTION_TYPE_CODE.DELETE;
2449 l_SUBSTITUTION_VALUE_FROM.DELETE;
2450 l_SUBSTITUTION_VALUE_TO.DELETE;
2451 l_ASK_FOR_FLAG.DELETE;
2452 l_PRICE_FORMULA_ID.DELETE;
2453 l_PRICING_STATUS_CODE.DELETE;
2454 l_PRICING_STATUS_TEXT.DELETE;
2455 l_PRODUCT_PRECEDENCE.DELETE;
2456 l_INCOMPATABLILITY_GRP_CODE.DELETE;
2457 l_PROCESSED_FLAG.DELETE;
2458 l_APPLIED_FLAG.DELETE;
2459 l_AUTOMATIC_FLAG.DELETE;
2460 l_OVERRIDE_FLAG.DELETE;
2461 l_PRIMARY_UOM_FLAG.DELETE;
2462 l_PRINT_ON_INVOICE_FLAG.DELETE;
2463 l_MODIFIER_LEVEL_CODE.DELETE;
2464 l_BENEFIT_QTY.DELETE;
2465 l_BENEFIT_UOM_CODE.DELETE;
2466 l_LIST_LINE_NO.DELETE;
2467 l_ACCRUAL_FLAG.DELETE;
2468 l_ACCRUAL_CONVERSION_RATE.DELETE;
2469 l_ESTIM_ACCRUAL_RATE.DELETE;
2470 l_RECURRING_FLAG.DELETE;
2471 l_SELECTED_VOLUME_ATTR.DELETE;
2472 l_ROUNDING_FACTOR.DELETE;
2473 l_HEADER_LIMIT_EXISTS.DELETE;
2474 l_LINE_LIMIT_EXISTS.DELETE;
2475 l_CHARGE_TYPE_CODE.DELETE;
2476 l_CHARGE_SUBTYPE_CODE.DELETE;
2477 l_CURRENCY_DETAIL_ID.DELETE;
2478 l_CURRENCY_HEADER_ID.DELETE;
2479 l_SELLING_ROUNDING_FACTOR.DELETE;
2480 l_ORDER_CURRENCY.DELETE;
2481 l_PRICING_EFFECTIVE_DATE.DELETE;
2482 l_BASE_CURRENCY_CODE.DELETE;
2483 l_LINE_QUANTITY.DELETE;
2484 l_UPDATED_FLAG.DELETE;
2485 l_CALCULATION_CODE.DELETE;
2486 l_CHANGE_REASON_CODE.DELETE;
2487 l_CHANGE_REASON_TEXT.DELETE;
2488 l_PRICE_ADJUSTMENT_ID.DELETE;
2489 l_ACCUM_CONTEXT.DELETE;
2490 l_ACCUM_ATTRIBUTE.DELETE;
2491 l_ACCUM_FLAG.DELETE;
2492 l_BREAK_UOM_CODE.DELETE;
2493 l_BREAK_UOM_CONTEXT.DELETE;
2494 l_BREAK_UOM_ATTRIBUTE.DELETE;
2495 l_PROCESS_CODE.DELETE; -- 3215497
2496
2497 IF l_debug = FND_API.G_TRUE THEN
2498 QP_PREQ_GRP.engine_debug('fetching l_getline_dis_cur');
2499 END IF;
2500
2501 FETCH l_getline_dis_cur
2502 BULK COLLECT INTO
2503 l_LINE_DETAIL_index,
2504 l_LINE_DETAIL_TYPE_CODE,
2505 l_PRICE_BREAK_TYPE_CODE,
2506 l_LIST_PRICE,
2507 l_LINE_INDEX,
2508 l_CREATED_FROM_LIST_HEADER_ID,
2509 l_CREATED_FROM_LIST_LINE_ID,
2510 l_CREATED_FROM_LIST_LINE_TYPE,
2511 l_CREATED_FROM_LIST_TYPE_CODE,
2512 l_CREATED_FROM_SQL,
2513 l_PRICING_GROUP_SEQUENCE,
2514 l_PRICING_PHASE_ID,
2515 l_OPERAND_CALCULATION_CODE,
2516 l_OPERAND_VALUE,
2517 l_SUBSTITUTION_TYPE_CODE,
2518 l_SUBSTITUTION_VALUE_FROM,
2519 l_SUBSTITUTION_VALUE_TO,
2520 l_ASK_FOR_FLAG,
2521 l_PRICE_FORMULA_ID,
2522 l_PRICING_STATUS_CODE,
2523 l_PRICING_STATUS_TEXT,
2524 l_PRODUCT_PRECEDENCE,
2525 l_INCOMPATABLILITY_GRP_CODE,
2526 l_PROCESSED_FLAG,
2527 l_APPLIED_FLAG,
2528 l_AUTOMATIC_FLAG,
2529 l_OVERRIDE_FLAG,
2530 l_PRIMARY_UOM_FLAG,
2531 l_PRINT_ON_INVOICE_FLAG,
2532 l_MODIFIER_LEVEL_CODE,
2533 l_BENEFIT_QTY,
2534 l_BENEFIT_UOM_CODE,
2535 l_LIST_LINE_NO,
2536 l_ACCRUAL_FLAG,
2537 l_ACCRUAL_CONVERSION_RATE,
2538 l_ESTIM_ACCRUAL_RATE,
2539 l_RECURRING_FLAG,
2540 l_SELECTED_VOLUME_ATTR,
2541 l_ROUNDING_FACTOR,
2542 l_HEADER_LIMIT_EXISTS,
2543 l_LINE_LIMIT_EXISTS,
2544 l_CHARGE_TYPE_CODE,
2545 l_CHARGE_SUBTYPE_CODE,
2546 l_CURRENCY_DETAIL_ID,
2547 l_CURRENCY_HEADER_ID,
2548 l_SELLING_ROUNDING_FACTOR,
2549 l_ORDER_CURRENCY,
2550 l_PRICING_EFFECTIVE_DATE,
2551 l_BASE_CURRENCY_CODE,
2552 l_LINE_QUANTITY,
2553 l_UPDATED_FLAG,
2554 l_CALCULATION_CODE,
2555 l_CHANGE_REASON_CODE,
2556 l_CHANGE_REASON_TEXT,
2557 l_PRICE_ADJUSTMENT_ID,
2558 l_ACCUM_CONTEXT,
2559 l_ACCUM_ATTRIBUTE,
2560 l_ACCUM_FLAG,
2561 l_BREAK_UOM_CODE,
2562 l_BREAK_UOM_CONTEXT,
2563 l_BREAK_UOM_ATTRIBUTE,
2564 l_PROCESS_CODE; -- 3215497
2565 -- LIMIT nrows;
2566 EXIT WHEN l_LINE_DETAIL_index.COUNT = 0;
2567
2568 IF l_debug = FND_API.G_TRUE THEN
2569 QP_PREQ_GRP.engine_debug('rows fetched:'|| l_line_detail_index.COUNT);
2570 END IF;
2571
2572 IF l_LINE_DETAIL_index.COUNT > 0
2573 AND l_debug = FND_API.G_TRUE
2574 THEN
2575 FOR i IN l_LINE_DETAIL_index.FIRST..l_LINE_DETAIL_index.LAST
2576 LOOP
2577 QP_PREQ_GRP.engine_debug('=======line_detail_index: '|| l_LINE_DETAIL_index(i) ||
2578 ' line_detail_type_code: '|| l_LINE_DETAIL_TYPE_CODE(i) ||
2579 ' price_break_type_code: '|| l_PRICE_BREAK_TYPE_CODE(i) ||
2580 ' list_price: ' || l_LIST_PRICE(i) ||
2581 ' line_index: '|| l_LINE_INDEX(i));
2582
2583 QP_PREQ_GRP.engine_debug('created_from_list_header_id: '|| l_CREATED_FROM_LIST_HEADER_ID(i) ||
2584 ' created_from_list_line_id: '|| l_CREATED_FROM_LIST_LINE_ID(i) ||
2585 ' created_from_list_line_type: '|| l_CREATED_FROM_LIST_LINE_TYPE(i) ||
2586 ' created_from_list_type_code: '|| l_CREATED_FROM_LIST_TYPE_CODE(i) ||
2587 ' created_from_sql: '|| l_CREATED_FROM_SQL(i) ||
2588 ' pricing_group_sequence: ' || l_PRICING_GROUP_SEQUENCE(i) ||
2589 ' pricing_phase_id: '|| l_PRICING_PHASE_ID(i) ||
2590 ' oprand_calculation_code: ' || l_OPERAND_CALCULATION_CODE(i) ||
2591 ' operand_value: ' || l_OPERAND_VALUE(i));
2592 QP_PREQ_GRP.engine_debug(' substitution_type_code: ' || l_SUBSTITUTION_TYPE_CODE(i) ||
2593 ' substitution_value_from: ' || l_SUBSTITUTION_VALUE_FROM(i) ||
2594 ' substitution_value_to: ' || l_SUBSTITUTION_VALUE_TO(i) ||
2595 ' ask_for_flag: ' || l_ASK_FOR_FLAG(i) ||
2596 ' price_formula_id: '|| l_PRICE_FORMULA_ID(i) ||
2597 ' pricing_status_code: '|| l_PRICING_STATUS_CODE(i) ||
2598 ' pricing_status_text: '|| l_PRICING_STATUS_TEXT(i) ||
2599 ' product_precedence: '|| l_PRODUCT_PRECEDENCE(i) ||
2600 ' incompatability_grp_code: ' || l_INCOMPATABLILITY_GRP_CODE(i));
2601
2602 QP_PREQ_GRP.engine_debug(' processed_flag: '|| l_PROCESSED_FLAG(i) ||
2603 ' applied_flag: '|| l_APPLIED_FLAG(i) ||
2604 ' automatic_flag: '|| l_AUTOMATIC_FLAG(i) ||
2605 ' override_flag: '|| l_OVERRIDE_FLAG(i) ||
2606 ' primary_uom_flag: '|| l_PRIMARY_UOM_FLAG(i) ||
2607 ' print_on_invoice_flag: '|| l_PRINT_ON_INVOICE_FLAG(i) ||
2608 ' MODIFIER_LEVEL_CODE: '|| l_MODIFIER_LEVEL_CODE(i) ||
2609 ' BENEFIT_QTY: '|| l_BENEFIT_QTY(i) ||
2610 ' BENEFIT_UOM_CODE: '|| l_BENEFIT_UOM_CODE(i) ||
2611 ' SERVICE_DURATION: '|| l_SERVICE_DURATION(i) || -- service project
2612 ' SERVICE_PERIOD: '|| l_SERVICE_PERIOD(i)); -- service project
2613
2614 QP_PREQ_GRP.engine_debug(' LIST_LINE_NO: '|| l_LIST_LINE_NO(i) ||
2615 ' ACCRUAL_FLAG: '|| l_ACCRUAL_FLAG(i) ||
2616 ' ACCRUAL_CONVERSION_RATE: '|| l_ACCRUAL_CONVERSION_RATE(i) ||
2617 ' ESTIM_ACCRUAL_RATE: '|| l_ESTIM_ACCRUAL_RATE(i) ||
2618 ' RECURRING_FLAG: '|| l_RECURRING_FLAG(i) ||
2619 ' SELECTED_VOLUME_ATTR: '|| l_SELECTED_VOLUME_ATTR(i) ||
2620 ' ROUNDING_FACTOR: '|| l_ROUNDING_FACTOR(i) ||
2621 ' HEADER_LIMIT_EXISTS: '|| l_HEADER_LIMIT_EXISTS(i) ||
2622 ' LINE_LIMIT_EXISTS: '|| l_LINE_LIMIT_EXISTS(i));
2623
2624 QP_PREQ_GRP.engine_debug(' CHARGE_TYPE_CODE:'|| l_CHARGE_TYPE_CODE(i) ||
2625 ' CHARGE_SUBTYPE_CODE:'|| l_CHARGE_SUBTYPE_CODE(i) ||
2626 ' CURRENCY_DETAIL_ID:'|| l_CURRENCY_DETAIL_ID(i) ||
2627 ' CURRENCY_HEADER_ID:'|| l_CURRENCY_HEADER_ID(i) ||
2628 ' SELLING_ROUNDING_FACTOR:'|| l_SELLING_ROUNDING_FACTOR(i) ||
2629 ' ORDER_CURRENCY:'|| l_ORDER_CURRENCY(i) ||
2630 ' PRICING_EFFECTIVE_DATE:'|| l_PRICING_EFFECTIVE_DATE(i) ||
2631 ' BASE_CURRENCY_CODE:'|| l_BASE_CURRENCY_CODE(i) ||
2632 ' LINE_QUANTITY:'|| l_LINE_QUANTITY(i));
2633
2634 QP_PREQ_GRP.engine_debug(' UPDATED_FLAG:'|| l_UPDATED_FLAG(i) ||
2635 ' CALCULATION_CODE:'|| l_CALCULATION_CODE(i) ||
2636 ' CHANGE_REASON_CODE:'|| l_CHANGE_REASON_CODE(i) ||
2637 ' CHANGE_REASON_TEXT:'|| l_CHANGE_REASON_TEXT(i) ||
2638 ' PRICE_ADJUSTMENT_ID:'|| l_PRICE_ADJUSTMENT_ID(i) ||
2639 ' ACCUM_CONTEXT:'|| l_ACCUM_CONTEXT(i) ||
2640 ' ACCUM_ATTRIBUTE:'|| l_ACCUM_ATTRIBUTE(i) ||
2641 ' ACCUM_FLAG:'|| l_ACCUM_FLAG(i) ||
2642 ' BREAK_UOM_CODE:'|| l_BREAK_UOM_CODE(i) ||
2643 ' BREAK_UOM_CONTEXT:'|| l_BREAK_UOM_CONTEXT(i) ||
2644 ' BREAK_UOM_ATTRIBUTE:'|| l_BREAK_UOM_ATTRIBUTE(i));
2645
2646 END LOOP;
2647 END IF; --l_line_detail_index.COUNT
2648
2649 IF l_LINE_DETAIL_index.COUNT > 0 THEN
2650 IF l_debug = FND_API.G_TRUE THEN
2651 QP_PREQ_GRP.engine_debug('calling INSERT_LDETS2');
2652 END IF;
2653 QP_PREQ_GRP.INSERT_LDETS2
2654 (l_LINE_DETAIL_index,
2655 l_LINE_DETAIL_TYPE_CODE,
2656 l_PRICE_BREAK_TYPE_CODE,
2657 l_LIST_PRICE,
2658 l_LINE_INDEX,
2659 l_CREATED_FROM_LIST_HEADER_ID,
2660 l_CREATED_FROM_LIST_LINE_ID,
2661 l_CREATED_FROM_LIST_LINE_TYPE,
2662 l_CREATED_FROM_LIST_TYPE_CODE,
2663 l_CREATED_FROM_SQL,
2664 l_PRICING_GROUP_SEQUENCE,
2665 l_PRICING_PHASE_ID,
2666 l_OPERAND_CALCULATION_CODE,
2667 l_OPERAND_VALUE,
2668 l_SUBSTITUTION_TYPE_CODE,
2669 l_SUBSTITUTION_VALUE_FROM,
2670 l_SUBSTITUTION_VALUE_TO,
2671 l_ASK_FOR_FLAG,
2672 l_PRICE_FORMULA_ID,
2673 l_PRICING_STATUS_CODE,
2674 l_PRICING_STATUS_TEXT,
2675 l_PRODUCT_PRECEDENCE,
2676 l_INCOMPATABLILITY_GRP_CODE,
2677 l_PROCESSED_FLAG,
2678 l_APPLIED_FLAG,
2679 l_AUTOMATIC_FLAG,
2680 l_OVERRIDE_FLAG,
2681 l_PRIMARY_UOM_FLAG,
2682 l_PRINT_ON_INVOICE_FLAG,
2683 l_MODIFIER_LEVEL_CODE,
2684 l_BENEFIT_QTY,
2685 l_BENEFIT_UOM_CODE,
2686 l_SERVICE_DURATION, -- service project
2687 l_SERVICE_PERIOD, -- service project
2688 l_LIST_LINE_NO,
2689 l_ACCRUAL_FLAG,
2690 l_ACCRUAL_CONVERSION_RATE,
2691 l_ESTIM_ACCRUAL_RATE,
2692 l_RECURRING_FLAG,
2693 l_SELECTED_VOLUME_ATTR,
2694 l_ROUNDING_FACTOR,
2695 l_HEADER_LIMIT_EXISTS,
2696 l_LINE_LIMIT_EXISTS,
2697 l_CHARGE_TYPE_CODE,
2698 l_CHARGE_SUBTYPE_CODE,
2699 l_CURRENCY_DETAIL_ID,
2700 l_CURRENCY_HEADER_ID,
2701 l_SELLING_ROUNDING_FACTOR,
2702 l_ORDER_CURRENCY,
2703 l_PRICING_EFFECTIVE_DATE,
2704 l_BASE_CURRENCY_CODE,
2705 l_LINE_QUANTITY,
2706 l_UPDATED_FLAG,
2707 l_CALCULATION_CODE,
2708 l_CHANGE_REASON_CODE,
2709 l_CHANGE_REASON_TEXT,
2710 l_PRICE_ADJUSTMENT_ID,
2711 l_ACCUM_CONTEXT,
2712 l_ACCUM_ATTRIBUTE,
2713 l_ACCUM_FLAG,
2714 l_BREAK_UOM_CODE,
2715 l_BREAK_UOM_CONTEXT,
2716 l_BREAK_UOM_ATTRIBUTE,
2717 l_PROCESS_CODE, -- 3215497
2718 x_return_status,
2719 x_return_status_text);
2720 END IF;
2721 END LOOP;
2722 --CLOSE l_ldets_cur;
2723 CLOSE l_getline_dis_cur;
2724
2725 IF l_debug = FND_API.G_TRUE THEN
2726 QP_PREQ_GRP.engine_debug('close l_getline_dis_cur');
2727 END IF;
2728
2729 END IF;
2730
2731 --END IF;--l_pbh_adj_exists = QP_PREQ_PUB.G_YES
2732 END IF; --(QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = QP_PREQ_PUB.G_YES AND
2733 --QP_BULK_PREQ_GRP.G_HVOP_Pricing_ON = QP_PREQ_PUB.G_NO)
2734 END;
2735
2736 --This procedure is to update the passed in overridden pbh modifiers
2737 --with the setup_value_from/to, qualifier_value, price_break_type_code
2738 --etc on the child lines which the price_break_calculation procedure
2739 --looks at to evaluate the breaks
2740 --This procedure will be used in the performance code path when
2741 --the public API is called by non-OM applications
2742 -- Ravi -- Added code to update the line detail type code which will be used
2743 -- in l_calculate_cur to not fetch the child lines as they are already in the qp_npreq_rltd_lines_tmp table
2744 -- Bug was adjustment amt was being calculated for child lines where it is not satisfied also
2745 PROCEDURE Update_passed_in_pbh(x_return_status OUT NOCOPY VARCHAR2,
2746 x_return_status_text OUT NOCOPY VARCHAR2) IS
2747
2748 BEGIN
2749
2750 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
2751
2752 --when any changes are made to this, the similar updated stmt
2753 --in Update_Related_Line_Info procedure in this file also needs to be changed
2754 UPDATE qp_npreq_rltd_lines_tmp rltd
2755 SET (setup_value_from,
2756 setup_value_to,
2757 relationship_type_detail,
2758 list_line_id,
2759 related_list_line_id,
2760 related_list_line_type,
2761 operand_calculation_code,
2762 operand,
2763 pricing_group_sequence,
2764 qualifier_value)
2765 =
2766 (SELECT
2767 qpa.pricing_attr_value_from,
2768 qpa.pricing_attr_value_to,
2769 ldet_pbh.price_break_type_code,
2770 ldet_pbh.created_from_list_line_id,
2771 ldet.created_from_list_line_id,
2772 ldet.created_from_list_line_type,
2773 ldet.operand_calculation_code,
2774 ldet.operand_value,
2775 ldet.pricing_group_sequence,
2776 nvl(ldet.line_quantity,
2777 nvl(line.priced_quantity, line.line_quantity))
2778 FROM
2779 qp_npreq_ldets_tmp ldet,
2780 qp_npreq_ldets_tmp ldet_pbh,
2781 qp_npreq_lines_tmp line,
2782 qp_pricing_attributes qpa
2783 WHERE
2784 ldet.line_detail_index = rltd.related_line_detail_index
2785 AND ldet_pbh.line_detail_index = rltd.line_detail_index
2786 AND line.line_index = ldet.line_index
2787 AND qpa.list_line_id = ldet.created_from_list_line_id
2788 AND ldet.pricing_status_code = G_STATUS_UNCHANGED
2789 AND ldet.updated_flag = G_YES
2790 AND rltd.relationship_type_code = G_PBH_LINE
2791 AND rltd.pricing_status_code = G_STATUS_NEW)
2792 WHERE rltd.line_detail_index IN (SELECT ldet.line_detail_index
2793 FROM qp_npreq_ldets_tmp ldet
2794 WHERE ldet.pricing_status_code = G_STATUS_UNCHANGED
2795 AND ldet.applied_flag = G_YES
2796 AND ldet.updated_flag = G_YES
2797 AND ldet.created_from_list_line_type = G_PRICE_BREAK_TYPE)
2798 AND rltd.relationship_type_code = G_PBH_LINE
2799 AND rltd.pricing_status_code = G_STATUS_NEW;
2800
2801 IF (l_debug = FND_API.G_TRUE) THEN
2802 QP_PREQ_GRP.engine_debug('Updating PBH rltd dlts COUNT: '
2803 || SQL%ROWCOUNT);
2804 QP_PREQ_GRP.engine_debug('Updating the child detail type code');
2805 END IF;
2806
2807 UPDATE qp_npreq_ldets_tmp
2808 SET line_detail_type_code = QP_PREQ_PUB.G_CHILD_DETAIL_TYPE
2809 WHERE line_detail_index IN (SELECT related_line_detail_index
2810 FROM qp_npreq_rltd_lines_tmp
2811 WHERE relationship_type_code = G_PBH_LINE
2812 AND pricing_status_code = G_STATUS_NEW);
2813
2814 IF (l_debug = FND_API.G_TRUE) THEN
2815 FOR i IN (SELECT line_detail_index
2816 FROM qp_npreq_ldets_tmp
2817 WHERE line_detail_type_code = QP_PREQ_PUB.G_CHILD_DETAIL_TYPE)
2818 LOOP
2819 QP_PREQ_GRP.engine_debug(' PBH Child Line Detail Index : ' || i.line_detail_index);
2820 END LOOP;
2821
2822 END IF;
2823
2824
2825 x_return_status := FND_API.G_RET_STS_SUCCESS;
2826 EXCEPTION
2827 WHEN OTHERS THEN
2828 x_return_status := FND_API.G_RET_STS_ERROR;
2829 x_return_status_text := 'Exception in updated_passed_pbh '|| SQLERRM;
2830 END Update_passed_in_pbh;
2831
2832 FUNCTION CHECK_GSA_INDICATOR RETURN VARCHAR2 IS
2833
2834 CURSOR l_check_gsa_ind_cur IS
2835 SELECT 'Y'
2836 FROM qp_npreq_lines_tmp line,
2837 qp_npreq_line_attrs_tmp gsa_attr
2838 WHERE gsa_attr.line_index = line.line_index
2839 AND gsa_attr.pricing_status_code = G_STATUS_UNCHANGED
2840 AND gsa_attr.attribute_type = G_QUALIFIER_TYPE
2841 AND gsa_attr.context = G_CUSTOMER_CONTEXT
2842 AND gsa_attr.attribute = G_GSA_ATTRIBUTE
2843 AND gsa_attr.value_from = G_YES;
2844
2845 l_gsa_indicator VARCHAR2(1) := 'N';
2846 l_routine VARCHAR2(50) := 'QP_PREQ_PUB.CHECK_GSA_INDICATOR';
2847 BEGIN
2848 IF l_debug = FND_API.G_TRUE THEN
2849 QP_PREQ_GRP.engine_debug('Begin CHECK_GSA_INDICATOR '|| l_gsa_indicator);
2850
2851 END IF;
2852 OPEN l_check_gsa_ind_cur;
2853 FETCH l_check_gsa_ind_cur INTO l_gsa_indicator;
2854 CLOSE l_check_gsa_ind_cur;
2855
2856 IF l_debug = FND_API.G_TRUE THEN
2857 QP_PREQ_GRP.engine_debug('Cursor fetched '|| l_gsa_indicator);
2858
2859 END IF;
2860 RETURN l_gsa_indicator;
2861
2862 IF l_debug = FND_API.G_TRUE THEN
2863 QP_PREQ_GRP.engine_debug('END CHECK_GSA_INDICATOR ');
2864 END IF;
2865 EXCEPTION
2866 WHEN OTHERS THEN
2867 IF l_debug = FND_API.G_TRUE THEN
2868 QP_PREQ_GRP.engine_debug('Exception in '|| l_routine ||' '|| SQLERRM);
2869 END IF;
2870 RETURN l_gsa_indicator;
2871 END CHECK_GSA_INDICATOR;
2872
2873 PROCEDURE CHECK_GSA_VIOLATION(
2874 x_return_status OUT NOCOPY VARCHAR2,
2875 x_return_status_text OUT NOCOPY VARCHAR2) IS
2876
2877 -- bug 3804392 - removed the hint qp_list_headers_b_n2 and also rearranged the tables in FROM clause
2878 CURSOR l_gsa_check_cur IS
2879 SELECT /*+ ORDERED USE_NL(req lhdr lattr qpa ql) index(qpa qp_pricing_attributes_n5) */
2880 line.line_index,
2881 line.adjusted_unit_price,
2882 MIN(ql.operand) operand
2883 FROM qp_npreq_lines_tmp line,
2884 qp_price_req_sources req,
2885 qp_list_headers_b lhdr,
2886 qp_npreq_line_attrs_tmp lattr,
2887 qp_pricing_attributes qpa,
2888 qp_list_lines ql
2889 WHERE lattr.line_index = line.line_index
2890 AND lattr.pricing_status_code IN
2891 (G_STATUS_NEW, G_STATUS_UNCHANGED)
2892 AND lattr.attribute_type = G_PRODUCT_TYPE
2893 AND lattr.context = qpa.product_attribute_context
2894 AND lattr.attribute = qpa.product_attribute
2895 AND lattr.value_from = qpa.product_attr_value
2896 AND qpa.excluder_flag = G_NO
2897 AND qpa.pricing_phase_id = 2
2898 AND qpa.qualification_ind = 6
2899 AND lattr.line_index = line.line_index
2900 AND req.request_type_code = line.request_type_code
2901 AND lhdr.list_header_id = qpa.list_header_id
2902 AND lhdr.active_flag = G_YES
2903 AND ((lhdr.currency_code IS NOT NULL AND lhdr.currency_code = line.currency_code)
2904 OR
2905 lhdr.currency_code IS NULL) -- optional currency
2906 AND lhdr.list_type_code = G_DISCOUNT_LIST_HEADER
2907 AND lhdr.source_system_code = req.source_system_code
2908 AND lhdr.gsa_indicator = G_YES
2909 AND trunc(line.pricing_effective_date) BETWEEN
2910 trunc(nvl(lhdr.start_date_active
2911 , line.pricing_effective_date))
2912 AND trunc(nvl(lhdr.End_date_active
2913 , line.pricing_effective_date))
2914 AND qpa.list_line_id = ql.list_line_id
2915 AND trunc(line.pricing_effective_date) BETWEEN
2916 trunc(nvl(ql.start_date_active
2917 , line.pricing_effective_date))
2918 AND trunc(nvl(ql.End_date_active
2919 , line.pricing_effective_date))
2920 GROUP BY line.line_index, line.adjusted_unit_price;
2921
2922 -- bug 3804392 - removed the hint qp_list_headers_b_n2 and also rearranged the tables in FROM clause
2923 CURSOR l_attrmgr_gsa_check_cur IS
2924 SELECT /*+ ORDERED USE_NL(req lhdr lattr qpa ql) index(qpa qp_pricing_attributes_n5) */
2925 line.line_index,
2926 line.adjusted_unit_price,
2927 MIN(ql.operand) operand
2928 FROM qp_npreq_lines_tmp line,
2929 qp_price_req_sources_v req,
2930 qp_list_headers_b lhdr,
2931 qp_npreq_line_attrs_tmp lattr,
2932 qp_pricing_attributes qpa,
2933 qp_list_lines ql
2934 WHERE lattr.line_index = line.line_index
2935 AND lattr.pricing_status_code IN
2936 (G_STATUS_NEW, G_STATUS_UNCHANGED)
2937 AND lattr.attribute_type = G_PRODUCT_TYPE
2938 AND lattr.context = qpa.product_attribute_context
2939 AND lattr.attribute = qpa.product_attribute
2940 AND lattr.value_from = qpa.product_attr_value
2941 AND qpa.excluder_flag = G_NO
2942 AND qpa.pricing_phase_id = 2
2943 AND qpa.qualification_ind = 6
2944 AND lattr.line_index = line.line_index
2945 AND req.request_type_code = line.request_type_code
2946 AND lhdr.list_header_id = qpa.list_header_id
2947 AND lhdr.active_flag = G_YES
2948 AND ((lhdr.currency_code IS NOT NULL AND lhdr.currency_code = line.currency_code)
2949 OR
2950 lhdr.currency_code IS NULL) -- optional currency
2951 AND lhdr.list_type_code = G_DISCOUNT_LIST_HEADER
2952 AND lhdr.source_system_code = req.source_system_code
2953 AND lhdr.gsa_indicator = G_YES
2954 AND trunc(line.pricing_effective_date) BETWEEN
2955 trunc(nvl(lhdr.start_date_active
2956 , line.pricing_effective_date))
2957 AND trunc(nvl(lhdr.End_date_active
2958 , line.pricing_effective_date))
2959 AND qpa.list_line_id = ql.list_line_id
2960 AND trunc(line.pricing_effective_date) BETWEEN
2961 trunc(nvl(ql.start_date_active
2962 , line.pricing_effective_date))
2963 AND trunc(nvl(ql.End_date_active
2964 , line.pricing_effective_date))
2965 GROUP BY line.line_index, line.adjusted_unit_price;
2966
2967
2968 l_gsa_line_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
2969 l_gsa_sts_text_tbl QP_PREQ_GRP.VARCHAR_TYPE;
2970 I PLS_INTEGER := 0;
2971 BEGIN
2972 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
2973 l_gsa_line_index_tbl.DELETE;
2974 l_gsa_sts_text_tbl.DELETE;
2975
2976 IF l_debug = FND_API.G_TRUE THEN
2977 QP_PREQ_GRP.engine_debug('Begin Pub GSA check');
2978
2979 END IF;
2980 -- Call GSA Check only for non-gsa customers(GSA_QUALIFIER_FLAG IS NULL)
2981 IF G_GSA_CHECK_FLAG = G_YES
2982 AND G_GSA_ENABLED_FLAG = G_YES
2983 AND G_GSA_INDICATOR = G_NO
2984 THEN
2985 IF l_debug = FND_API.G_TRUE THEN
2986 QP_PREQ_GRP.engine_debug('IN GSA check attrmgr '|| G_ATTR_MGR_INSTALLED);
2987
2988 END IF;
2989 IF G_ATTR_MGR_INSTALLED = G_NO
2990 THEN
2991 FOR GSA IN l_gsa_check_cur
2992 LOOP
2993 -- I := I + 1; bug2426025 placed the counter in the if condition
2994 IF l_debug = FND_API.G_TRUE THEN
2995 QP_PREQ_GRP.engine_debug('GSA check: line_index '|| GSA.line_index);
2996 QP_PREQ_GRP.engine_debug('GSA check: gsa_price '|| GSA.operand);
2997 QP_PREQ_GRP.engine_debug('GSA check: adj_price '|| GSA.adjusted_unit_price);
2998 END IF;
2999 IF GSA.adjusted_unit_price <= GSA.operand
3000 THEN
3001 I := I + 1;
3002 l_gsa_line_index_tbl(I) := GSA.line_index;
3003 l_gsa_sts_text_tbl(I) := GSA.operand;
3004 IF l_debug = FND_API.G_TRUE THEN
3005 QP_PREQ_GRP.engine_debug('GSA violtn:lineindex '
3006 || l_gsa_line_index_tbl(I));
3007 QP_PREQ_GRP.engine_debug('GSA violtn:gsa price '
3008 || l_gsa_sts_text_tbl(I));
3009 END IF;
3010 END IF;
3011 END LOOP; --l_gsa_check_cur
3012 ELSE --G_ATTR_MGR_INSTALLED --not installed
3013 FOR GSA IN l_attrmgr_gsa_check_cur
3014 LOOP
3015 -- I := I + 1; bug2426025 placed the counter in the if condition
3016 IF l_debug = FND_API.G_TRUE THEN
3017 QP_PREQ_GRP.engine_debug('GSA check: line_index '|| GSA.line_index);
3018 QP_PREQ_GRP.engine_debug('GSA check: gsa_price '|| GSA.operand);
3019 QP_PREQ_GRP.engine_debug('GSA check: adj_price '|| GSA.adjusted_unit_price);
3020 END IF;
3021 IF GSA.adjusted_unit_price <= GSA.operand
3022 THEN
3023 I := I + 1;
3024 l_gsa_line_index_tbl(I) := GSA.line_index;
3025 l_gsa_sts_text_tbl(I) := GSA.operand;
3026 IF l_debug = FND_API.G_TRUE THEN
3027 QP_PREQ_GRP.engine_debug('GSA violtn:lineindex '
3028 || l_gsa_line_index_tbl(I));
3029 QP_PREQ_GRP.engine_debug('GSA violtn:gsa price '
3030 || l_gsa_sts_text_tbl(I));
3031 END IF;
3032 END IF;
3033 END LOOP; --l_attrmgr_gsa_check_cur
3034 END IF; --G_ATTR_MGR_INSTALLED --not installed
3035
3036 IF l_debug = FND_API.G_TRUE THEN
3037 QP_PREQ_GRP.engine_debug('AFTER GSA check');
3038 END IF;
3039 END IF;
3040
3041 IF l_gsa_line_index_tbl.COUNT > 0
3042 THEN
3043 IF l_debug = FND_API.G_TRUE THEN
3044 QP_PREQ_GRP.engine_debug('Before GSA update '|| l_gsa_line_index_tbl.COUNT);
3045 END IF;
3046 FORALL I IN l_gsa_line_index_tbl.FIRST..l_gsa_line_index_tbl.LAST
3047 UPDATE qp_npreq_lines_tmp
3048 SET pricing_status_code = G_STATUS_GSA_VIOLATION,
3049 pricing_status_text =
3050 'GSA VIOLATION - GSA PRICE '|| l_gsa_sts_text_tbl(I)
3051 WHERE line_index = l_gsa_line_index_tbl(I);
3052 END IF; --l_gsa_line_index_tbl.COUNT
3053
3054 IF l_debug = FND_API.G_TRUE THEN
3055 QP_PREQ_GRP.engine_debug('Pub GSA check completed');
3056
3057 END IF;
3058 --GSA VIOLATION CHECK
3059
3060
3061 EXCEPTION
3062 WHEN OTHERS THEN
3063 IF l_debug = FND_API.G_TRUE THEN
3064 QP_PREQ_GRP.ENGINE_DEBUG('exception QP_PREQ_PUB.check gsa_violation: '|| SQLERRM);
3065 END IF;
3066 x_return_status := FND_API.G_RET_STS_ERROR;
3067 x_return_status_text := 'QP_PREQ_PUB.check gsa_violation: '|| SQLERRM;
3068 END CHECK_GSA_VIOLATION;
3069
3070
3071 PROCEDURE BACK_CALCULATION(p_line_index IN VARCHAR2
3072 , p_amount_changed IN NUMBER
3073 , x_back_calc_rec OUT NOCOPY BACK_CALC_REC_TYPE
3074 , x_return_status OUT NOCOPY VARCHAR2
3075 , x_return_status_text OUT NOCOPY VARCHAR2) IS
3076
3077
3078 CURSOR l_back_calculate_cur IS
3079 SELECT ldet.created_from_list_line_id
3080 , ldet.line_index line_ind
3081 , ldet.line_detail_index
3082 , ldet.created_from_list_line_type
3083 , ldet.applied_flag
3084 , p_amount_changed amount_changed
3085 , line.priced_quantity
3086 , ldet.operand_calculation_code
3087 , ldet.operand_value
3088 , ldet.adjustment_amount
3089 , ldet.modifier_level_code
3090 , line.unit_price
3091 , ldet.pricing_status_code
3092 , ldet.pricing_status_text
3093 , line.rounding_factor
3094 , ldet.calculation_code
3095 , ldet.line_quantity
3096 , ldet.created_from_list_header_id
3097 , ldet.created_from_list_type_code
3098 , ldet.price_break_type_code
3099 , ldet.charge_type_code
3100 , ldet.charge_subtype_code
3101 , ldet.automatic_flag
3102 , ldet.pricing_phase_id
3103 , ldet.limit_code
3104 , ldet.limit_text
3105 , ldet.pricing_group_sequence
3106 , ldet.list_line_no
3107 , ldet.calculation_code
3108 --fix for bug 2833753
3109 , decode(G_BACK_CALCULATION_CODE, 'DIS',
3110 decode(ldet.calculation_code, 'BACK_CALCULATE', - 10000,
3111 decode(ldet.created_from_list_line_type, 'DIS',
3112 decode(ldet.applied_flag, G_YES, - 100, - 1000),
3113 decode(ldet.applied_flag, G_YES, 1000, 100))),
3114 decode(ldet.calculation_code, 'BACK_CALCULATE', 10000,
3115 decode(ldet.created_from_list_line_type, 'DIS',
3116 decode(ldet.applied_flag, G_YES, - 1000, - 100),
3117 decode(ldet.applied_flag, G_YES, 100, 1000)))) precedence
3118 FROM qp_npreq_ldets_tmp ldet, qp_npreq_lines_tmp line
3119 WHERE line.line_index = p_line_index
3120 AND line.line_type_code = G_LINE_LEVEL -- sql repos
3121 AND line.price_flag IN (G_YES, G_PHASE)
3122 AND ldet.line_index = line.line_index
3123 AND (ldet.pricing_status_code IN (G_STATUS_NEW, G_STATUS_UNCHANGED))
3124 --commented for OC issue of duplicate manual adj in temp table
3125 --as this cursor would pick up the engine returned manual adj
3126 -- or ldet.process_code = G_STATUS_NEW)
3127 AND ldet.created_from_list_line_type IN (G_DISCOUNT, G_SURCHARGE)
3128 AND ldet.automatic_flag = G_NO
3129 AND ldet.override_flag = G_YES
3130 AND ldet.pricing_group_sequence IS NULL --only return null bucket manual modifiers
3131 AND ldet.line_detail_index NOT IN
3132 (SELECT rltd.related_line_detail_index
3133 FROM qp_npreq_rltd_lines_tmp rltd
3134 WHERE rltd.relationship_type_code = G_PBH_LINE
3135 AND rltd.pricing_status_code = G_STATUS_NEW)
3136 --ORDER BY ldet.calculation_code,ldet.created_from_list_line_type,ldet.applied_flag desc;
3137 --ORDER BY ldet.created_from_list_line_type, precedence desc , ldet.applied_flag desc;
3138 --fix for bug 2833753
3139 ORDER BY precedence;
3140
3141 l_back_calc_rec back_calc_rec_type;
3142
3143 l_back_line_dtl_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
3144 l_back_line_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
3145 l_back_list_line_id_tbl QP_PREQ_GRP.NUMBER_TYPE;
3146 l_back_list_line_type_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3147 l_back_operand_value_tbl QP_PREQ_GRP.NUMBER_TYPE;
3148 l_back_priced_qty_tbl QP_PREQ_GRP.NUMBER_TYPE;
3149 l_back_unit_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
3150 l_back_adj_amt_tbl QP_PREQ_GRP.NUMBER_TYPE;
3151 l_back_amount_changed_tbl QP_PREQ_GRP.NUMBER_TYPE;
3152 l_back_applied_flag_tbl QP_PREQ_GRP.FLAG_TYPE;
3153 l_back_operand_calc_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3154 l_back_sts_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3155 l_back_sts_txt_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3156 l_back_rounding_fac_tbl QP_PREQ_GRP.NUMBER_TYPE;
3157 l_back_calc_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3158 l_back_line_qty_tbl QP_PREQ_GRP.NUMBER_TYPE;
3159 l_back_list_hdr_id_tbl QP_PREQ_GRP.NUMBER_TYPE;
3160 l_back_list_type_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3161 l_back_price_brk_type_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3162 l_back_chrg_type_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3163 l_back_chrg_subtype_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3164 l_back_auto_flag_tbl QP_PREQ_GRP.FLAG_TYPE;
3165 l_back_phase_id_tbl QP_PREQ_GRP.NUMBER_TYPE;
3166 l_back_limit_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3167 l_back_limit_text_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3168 l_back_bucket_tbl QP_PREQ_GRP.NUMBER_TYPE;
3169 l_back_list_line_no_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3170 l_back_calculation_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3171 l_back_calc_precedence_tbl QP_PREQ_GRP.NUMBER_TYPE;
3172 l_back_modifier_level_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3173
3174 BACK_CALCULATE_SUCC BOOLEAN := TRUE;
3175 l_return_status VARCHAR2(30);
3176 l_return_status_text VARCHAR2(240);
3177 l_adjustment_amount NUMBER := 0;
3178 l_operand_value NUMBER := 0;
3179
3180 i NUMBER;
3181
3182 BEGIN
3183
3184 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
3185 --**************************************************************
3186 --BACK CALCULATION ROUTINE
3187 --**************************************************************
3188 IF l_debug = FND_API.G_TRUE THEN
3189 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION ROUTINE '
3190 || G_BACK_CALCULATION_CODE);
3191
3192
3193 END IF;
3194 OPEN l_back_calculate_cur;
3195 --LOOP
3196 IF l_debug = FND_API.G_TRUE THEN
3197 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION ROUTINE1');
3198 END IF;
3199 l_back_list_line_id_tbl.DELETE;
3200 l_back_line_index_tbl.DELETE;
3201 l_back_line_dtl_index_tbl.DELETE;
3202 l_back_list_line_type_tbl.DELETE;
3203 l_back_applied_flag_tbl.DELETE;
3204 l_back_amount_changed_tbl.DELETE;
3205 l_back_priced_qty_tbl.DELETE;
3206 l_back_operand_calc_code_tbl.DELETE;
3207 l_back_operand_value_tbl.DELETE;
3208 l_back_adj_amt_tbl.DELETE;
3209 l_back_unit_price_tbl.DELETE;
3210 l_back_sts_code_tbl.DELETE;
3211 l_back_sts_txt_tbl.DELETE;
3212 l_back_rounding_fac_tbl.DELETE;
3213 l_back_calc_code_tbl.DELETE;
3214 l_back_line_qty_tbl.DELETE;
3215 l_back_list_hdr_id_tbl.DELETE;
3216 l_back_list_type_tbl.DELETE;
3217 l_back_price_brk_type_tbl.DELETE;
3218 l_back_chrg_type_tbl.DELETE;
3219 l_back_chrg_subtype_tbl.DELETE;
3220 l_back_auto_flag_tbl.DELETE;
3221 l_back_phase_id_tbl.DELETE;
3222 l_back_limit_code_tbl.DELETE;
3223 l_back_limit_text_tbl.DELETE;
3224 l_back_bucket_tbl.DELETE;
3225 l_back_list_line_no_tbl.DELETE;
3226 l_back_calculation_code_tbl.DELETE;
3227 l_back_calc_precedence_tbl.DELETE;
3228 l_back_modifier_level_code_tbl.DELETE;
3229
3230 FETCH l_back_calculate_cur BULK COLLECT INTO
3231 l_back_list_line_id_tbl,
3232 l_back_line_index_tbl,
3233 l_back_line_dtl_index_tbl,
3234 l_back_list_line_type_tbl,
3235 l_back_applied_flag_tbl,
3236 l_back_amount_changed_tbl,
3237 l_back_priced_qty_tbl,
3238 l_back_operand_calc_code_tbl,
3239 l_back_operand_value_tbl,
3240 l_back_adj_amt_tbl,
3241 l_back_modifier_level_code_tbl,
3242 l_back_unit_price_tbl,
3243 l_back_sts_code_tbl,
3244 l_back_sts_txt_tbl,
3245 l_back_rounding_fac_tbl,
3246 l_back_calc_code_tbl,
3247 l_back_line_qty_tbl,
3248 l_back_list_hdr_id_tbl,
3249 l_back_list_type_tbl,
3250 l_back_price_brk_type_tbl,
3251 l_back_chrg_type_tbl,
3252 l_back_chrg_subtype_tbl,
3253 l_back_auto_flag_tbl,
3254 l_back_phase_id_tbl,
3255 l_back_limit_code_tbl,
3256 l_back_limit_text_tbl,
3257 l_back_bucket_tbl,
3258 l_back_list_line_no_tbl,
3259 l_back_calculation_code_tbl,
3260 l_back_calc_precedence_tbl;
3261 IF l_debug = FND_API.G_TRUE THEN
3262 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION ROUTINE2');
3263 END IF;
3264 --EXIT WHEN l_back_list_line_id_tbl.COUNT = 0;
3265 CLOSE l_back_calculate_cur;
3266
3267 IF l_debug = FND_API.G_TRUE THEN
3268 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION ROUTINE2.5');
3269 END IF;
3270 --DEBUG
3271 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
3272 AND l_back_list_line_id_tbl.COUNT>0
3273 THEN
3274 IF l_debug = FND_API.G_TRUE THEN
3275 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION ROUTINE3'|| l_back_list_line_id_tbl.COUNT);
3276 END IF;
3277 FOR I IN 1..l_back_list_line_id_tbl.COUNT
3278 LOOP
3279 IF l_debug = FND_API.G_TRUE THEN
3280 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION ROUTINE4');
3281 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION ADJ '
3282 || l_back_list_line_id_tbl(i) ||' line index '
3283 || l_back_line_index_tbl(i) ||' detail index '
3284 || l_back_line_dtl_index_tbl(i) ||' adj type '
3285 || l_back_list_line_type_tbl(i) ||' applied flag '
3286 || l_back_applied_flag_tbl(i) ||' adj amt '
3287 || l_back_adj_amt_tbl(i) ||' amt changed '
3288 || l_back_amount_changed_tbl(i) ||' priced qty '
3289 || l_back_priced_qty_tbl(i) ||' operand code '
3290 || l_back_operand_calc_code_tbl(i) ||' operand '
3291 || l_back_operand_value_tbl(i) ||' unit price '
3292 || l_back_unit_price_tbl(i) ||' round fac '
3293 || l_back_rounding_fac_tbl(i) ||' line_qty '
3294 || l_back_line_qty_tbl(i) || ' calculation code '
3295 || l_back_calculation_code_tbl(i) || ' precedence '
3296 || l_back_calc_precedence_tbl(i) || ' modifier level '
3297 || l_back_modifier_level_code_tbl(i));
3298 END IF;
3299 END LOOP;
3300 END IF;
3301
3302 IF l_debug = FND_API.G_TRUE THEN
3303 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION ROUTINE4.5');
3304 END IF;
3305 IF l_back_line_index_tbl.COUNT > 0
3306 THEN
3307 IF p_amount_changed <= 0
3308 THEN
3309 FOR I IN
3310 l_back_line_dtl_index_tbl.FIRST..l_back_line_dtl_index_tbl.LAST
3311 LOOP
3312 IF l_debug = FND_API.G_TRUE THEN
3313 QP_PREQ_GRP.ENGINE_DEBUG('forward loop '|| i);
3314 END IF;
3315
3316 --fix for bug 2790460 to add the amount_changed to the
3317 --adjustment_amount if the adj
3318 --has been applied already and it is not back calculated
3319 IF (nvl(l_back_calculation_code_tbl(i), 'NULL')
3320 <> G_BACK_CALCULATE
3321 AND l_back_applied_flag_tbl(i) = G_YES) THEN
3322 l_back_amount_changed_tbl(i) :=
3323 nvl(l_back_adj_amt_tbl(i), 0) +
3324 l_back_amount_changed_tbl(i);
3325 END IF; --l_back_calculation_code_tbl(i)
3326
3327 BACK_CALCULATE_PRICE(
3328 l_back_operand_calc_code_tbl(i)
3329 , l_back_operand_value_tbl(i)
3330 , nvl(l_back_applied_flag_tbl(i), G_NO)
3331 , nvl(l_back_amount_changed_tbl(i), 0)
3332 , l_back_adj_amt_tbl(i)
3333 , nvl(l_back_priced_qty_tbl(i), 0)
3334 , nvl(l_back_unit_price_tbl(i), 0)
3335 , l_back_list_line_type_tbl(i)
3336 , l_adjustment_amount
3337 , l_operand_value
3338 , BACK_CALCULATE_SUCC
3339 , l_return_status
3340 , l_return_status_text);
3341
3342 IF BACK_CALCULATE_SUCC
3343 AND l_return_status = FND_API.G_RET_STS_SUCCESS
3344 THEN
3345 IF l_debug = FND_API.G_TRUE THEN
3346 QP_PREQ_GRP.ENGINE_DEBUG('back cal succ '
3347 || l_adjustment_amount ||' list_line_id '
3348 || l_back_list_line_id_tbl(i) ||' operand val '
3349 || l_operand_value);
3350
3351 END IF;
3352 l_back_calc_rec.line_detail_index :=
3353 l_back_line_dtl_index_tbl(i);
3354 l_back_calc_rec.line_index :=
3355 l_back_line_index_tbl(i);
3356 l_back_calc_rec.list_line_id :=
3357 l_back_list_line_id_tbl(i);
3358 l_back_calc_rec.list_line_type_code :=
3359 l_back_list_line_type_tbl(i);
3360 l_back_calc_rec.rounding_factor :=
3361 l_back_rounding_fac_tbl(i);
3362 l_back_calc_rec.line_quantity :=
3363 l_back_line_qty_tbl(i);
3364 l_back_calc_rec.list_header_id :=
3365 l_back_list_hdr_id_tbl(i);
3366 l_back_calc_rec.list_type_code :=
3367 l_back_list_type_tbl(i);
3368 l_back_calc_rec.price_break_type_code :=
3369 l_back_price_brk_type_tbl(i);
3370 l_back_calc_rec.charge_type_code :=
3371 l_back_chrg_type_tbl(i);
3372 l_back_calc_rec.charge_subtype_code :=
3373 l_back_chrg_subtype_tbl(i);
3374 l_back_calc_rec.automatic_flag :=
3375 l_back_auto_flag_tbl(i);
3376 l_back_calc_rec.pricing_phase_id :=
3377 l_back_phase_id_tbl(i);
3378 l_back_calc_rec.limit_code :=
3379 l_back_limit_code_tbl(i);
3380 l_back_calc_rec.limit_text :=
3381 l_back_limit_text_tbl(i);
3382 l_back_calc_rec.operand_calculation_code :=
3383 l_back_operand_calc_code_tbl(i);
3384 l_back_calc_rec.pricing_group_sequence :=
3385 l_back_bucket_tbl(i);
3386 l_back_calc_rec.list_line_no :=
3387 l_back_list_line_no_tbl(i);
3388 l_back_calc_rec.modifier_level_code :=
3389 l_back_modifier_level_code_tbl(i);
3390 --Fix for bug 2103325
3391 --if price is changed back to selling price
3392 --back calculated manual adj shd not be returned
3393 IF l_adjustment_amount = 0
3394 THEN
3395 l_back_calc_rec.applied_flag := G_NO;
3396 l_back_calc_rec.updated_flag := G_NO;
3397 ELSE
3398 l_back_calc_rec.applied_flag := G_YES;
3399 l_back_calc_rec.updated_flag := G_YES;
3400 END IF;
3401 l_back_calc_rec.updated_flag := G_YES;
3402 l_back_calc_rec.calculation_code :=
3403 G_BACK_CALCULATE;
3404 l_back_calc_rec.adjustment_amount :=
3405 l_adjustment_amount;
3406 l_back_calc_rec.operand_value :=
3407 l_operand_value;
3408 l_back_calc_rec.process_code :=
3409 G_STATUS_NEW;
3410 l_back_calc_rec.pricing_status_code :=
3411 G_STATUS_NEW;
3412 -- l_back_sts_code_tbl(i);
3413 l_back_calc_rec.pricing_status_text :=
3414 l_back_sts_txt_tbl(i);
3415 EXIT;
3416 ELSE
3417 NULL;
3418 END IF;
3419 END LOOP;
3420
3421 ELSE --p_amount_changed is positive, then its a surcharge
3422 FOR I IN REVERSE
3423 l_back_line_dtl_index_tbl.FIRST..l_back_line_dtl_index_tbl.LAST
3424 LOOP
3425 IF l_debug = FND_API.G_TRUE THEN
3426 QP_PREQ_GRP.ENGINE_DEBUG('reverse loop '|| i);
3427 END IF;
3428 --fix for bug 2790460 to add the amount_changed to the
3429 --adjustment_amount if the adj
3430 --has been applied already and it is not back calculated
3431 IF (nvl(l_back_calculation_code_tbl(i), 'NULL')
3432 <> G_BACK_CALCULATE
3433 AND l_back_applied_flag_tbl(i) = G_YES) THEN
3434 l_back_amount_changed_tbl(i) :=
3435 nvl(l_back_adj_amt_tbl(i), 0) +
3436 l_back_amount_changed_tbl(i);
3437 END IF; --l_back_calculation_code_tbl(i)
3438
3439 BACK_CALCULATE_PRICE(
3440 l_back_operand_calc_code_tbl(i)
3441 , l_back_operand_value_tbl(i)
3442 , nvl(l_back_applied_flag_tbl(i), G_NO)
3443 , nvl(l_back_amount_changed_tbl(i), 0)
3444 , l_back_adj_amt_tbl(i)
3445 , nvl(l_back_priced_qty_tbl(i), 0)
3446 , nvl(l_back_unit_price_tbl(i), 0)
3447 , l_back_list_line_type_tbl(i)
3448 , l_adjustment_amount
3449 , l_operand_value
3450 , BACK_CALCULATE_SUCC
3451 , l_return_status
3452 , l_return_status_text);
3453
3454 IF BACK_CALCULATE_SUCC
3455 AND l_return_status = FND_API.G_RET_STS_SUCCESS
3456 THEN
3457 IF l_debug = FND_API.G_TRUE THEN
3458 QP_PREQ_GRP.ENGINE_DEBUG('back cal succ '
3459 || l_adjustment_amount ||' list_line_id '
3460 || l_back_list_line_id_tbl(i) ||' operand val '
3461 || l_operand_value);
3462
3463 END IF;
3464 l_back_calc_rec.line_detail_index :=
3465 l_back_line_dtl_index_tbl(i);
3466 l_back_calc_rec.line_index :=
3467 l_back_line_index_tbl(i);
3468 l_back_calc_rec.list_line_id :=
3469 l_back_list_line_id_tbl(i);
3470 l_back_calc_rec.rounding_factor :=
3471 l_back_rounding_fac_tbl(i);
3472 l_back_calc_rec.line_quantity :=
3473 l_back_line_qty_tbl(i);
3474 l_back_calc_rec.list_header_id :=
3475 l_back_list_hdr_id_tbl(i);
3476 l_back_calc_rec.list_type_code :=
3477 l_back_list_type_tbl(i);
3478 l_back_calc_rec.price_break_type_code :=
3479 l_back_price_brk_type_tbl(i);
3480 l_back_calc_rec.charge_type_code :=
3481 l_back_chrg_type_tbl(i);
3482 l_back_calc_rec.charge_subtype_code :=
3483 l_back_chrg_subtype_tbl(i);
3484 l_back_calc_rec.automatic_flag :=
3485 l_back_auto_flag_tbl(i);
3486 l_back_calc_rec.pricing_phase_id :=
3487 l_back_phase_id_tbl(i);
3488 l_back_calc_rec.limit_code :=
3489 l_back_limit_code_tbl(i);
3490 l_back_calc_rec.limit_text :=
3491 l_back_limit_text_tbl(i);
3492 l_back_calc_rec.operand_calculation_code :=
3493 l_back_operand_calc_code_tbl(i);
3494 l_back_calc_rec.pricing_group_sequence :=
3495 l_back_bucket_tbl(i);
3496 l_back_calc_rec.list_line_no :=
3497 l_back_list_line_no_tbl(i);
3498 l_back_calc_rec.modifier_level_code :=
3499 l_back_modifier_level_code_tbl(i);
3500 --Fix for bug 2103325
3501 --if price is changed back to selling price
3502 --back calculated manual adj shd not be returned
3503 IF l_adjustment_amount = 0
3504 THEN
3505 l_back_calc_rec.applied_flag := G_NO;
3506 l_back_calc_rec.updated_flag := G_NO;
3507 ELSE
3508 l_back_calc_rec.applied_flag := G_YES;
3509 l_back_calc_rec.updated_flag := G_YES;
3510 END IF;
3511 l_back_calc_rec.adjustment_amount :=
3512 l_adjustment_amount;
3513 l_back_calc_rec.operand_value :=
3514 l_operand_value;
3515 l_back_calc_rec.process_code :=
3516 G_STATUS_NEW;
3517 l_back_calc_rec.pricing_status_code :=
3518 G_STATUS_NEW;
3519 -- l_back_sts_code_tbl(i);
3520 l_back_calc_rec.pricing_status_text :=
3521 l_back_sts_txt_tbl(i);
3522 l_back_calc_rec.calculation_code :=
3523 G_BACK_CALCULATE;
3524 EXIT;
3525 ELSE
3526 NULL;
3527 END IF;
3528 END LOOP;
3529
3530 END IF; --p_amount_changed
3531
3532 IF BACK_CALCULATE_SUCC
3533 THEN
3534 IF l_return_status = FND_API.G_RET_STS_SUCCESS
3535 THEN
3536 IF l_debug = FND_API.G_TRUE THEN
3537 QP_PREQ_GRP.ENGINE_DEBUG('back cal succ set status');
3538 END IF;
3539 x_return_status := l_return_status;
3540 x_return_status_text := l_return_status_text;
3541 x_back_calc_rec := l_back_calc_rec;
3542 END IF;
3543 ELSE
3544 IF l_return_status = FND_API.G_RET_STS_SUCCESS
3545 THEN
3546 IF l_debug = FND_API.G_TRUE THEN
3547 QP_PREQ_GRP.ENGINE_DEBUG('back cal fail set status');
3548 END IF;
3549 x_return_status := G_BACK_CALCULATION_STS;
3550 x_return_status_text := 'QP_PREQ_PUB: BACK CALCULATION FAILURE ';
3551 x_back_calc_rec := l_back_calc_rec;
3552 ELSE
3553 IF l_debug = FND_API.G_TRUE THEN
3554 QP_PREQ_GRP.ENGINE_DEBUG('back cal error set status');
3555 END IF;
3556 x_return_status := G_BACK_CALCULATION_STS;
3557 x_return_status_text := 'QP_PREQ_PUB: BACK CALCULATION ERROR '|| l_return_status_text;
3558 x_back_calc_rec := l_back_calc_rec;
3559 END IF;
3560 END IF;
3561
3562 ELSE
3563 IF l_debug = FND_API.G_TRUE THEN
3564 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION ROUTINE5');
3565 END IF;
3566 x_return_status := G_BACK_CALCULATION_STS;
3567 IF l_debug = FND_API.G_TRUE THEN
3568 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION ROUTINE6');
3569 END IF;
3570 x_return_status_text := 'QP_PREQ_PUB.BACK_CAL: NO MANUAL ADJ';
3571 IF l_debug = FND_API.G_TRUE THEN
3572 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION ROUTINE6.5');
3573 END IF;
3574 END IF;
3575 IF l_debug = FND_API.G_TRUE THEN
3576 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION ROUTINE7');
3577
3578 END IF;
3579 EXCEPTION
3580 WHEN OTHERS THEN
3581 IF l_debug = FND_API.G_TRUE THEN
3582 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION EXCEPTION '|| SQLERRM);
3583 END IF;
3584 x_return_status := FND_API.G_RET_STS_ERROR;
3585 x_return_status_text := 'Error QP_PREQ_PUB.BACK_CALCULATION '|| SQLERRM;
3586 END BACK_CALCULATION;
3587
3588 --procedure to update the line's adjusted_unit_price with unit_price
3589 --if the engine is called with calculate_only and there are no adjustments
3590 --fix for bug 2242736
3591 PROCEDURE UPDATE_UNIT_PRICE(x_return_status OUT NOCOPY VARCHAR2,
3592 x_return_status_text OUT NOCOPY VARCHAR2) IS
3593
3594 CURSOR l_check_adjustments_cur IS
3595 /*
3596 SELECT line.line_index, line.unit_price, line.adjusted_unit_price
3597 ,line.line_quantity, line.priced_quantity, line.catchweight_qty,line.actual_order_quantity
3598 , line.rounding_factor
3599 FROM qp_npreq_lines_tmp line
3600 WHERE line.price_flag in (G_YES, G_PHASE,G_CALCULATE_ONLY)
3601 and line.pricing_status_code in (G_STATUS_UPDATED, G_STATUS_UNCHANGED,
3602 G_STATUS_GSA_VIOLATION)
3603 and line.line_type_code = G_LINE_LEVEL
3604 and nvl(processed_code,'0')<> G_BY_ENGINE
3605 and (line.adjusted_unit_price <> line.unit_price
3606 --changed this for bug 2776800 to populate order_uom_selling_price
3607 --this means there are no adjustments and calculation has not taken place
3608 or line.order_uom_selling_price IS NULL )
3609 and not exists (select ldet.line_index
3610 from qp_npreq_ldets_tmp ldet
3611 where (ldet.line_index = line.line_index
3612 or ldet.modifier_level_code = G_ORDER_LEVEL)
3613 and nvl(ldet.created_from_list_type_code,'NULL') not in
3614 (G_PRICE_LIST_HEADER,G_AGR_LIST_HEADER)
3615 -- and ldet.pricing_status_code = G_STATUS_NEW)
3616 and ldet.pricing_status_code in (G_STATUS_NEW,G_STATUS_UPDATED)) --2729744
3617 --this is for not updating the unit_price on fg lines for prg cleanup
3618 --as they will not have any adjustments
3619 and line.process_status = G_STATUS_UNCHANGED
3620 --fix for bug 2691794
3621 and nvl(line.processed_flag,'N') <> G_FREEGOOD_LINE;
3622 and not exists (select 'Y' from qp_npreq_lines_tmp line2
3623 where line2.line_id = line.line_id
3624 and line2.line_index <> line.line_index);
3625 */
3626
3627 --fix for performance issue in bug 2928322
3628 --the column qualifiers_exists_flag will be populated to
3629 --G_CALCULATE_ONLY for all lines that went through calculation
3630 --we want to do this update only for those lines which
3631 --do not go through calculation
3632 SELECT line.line_index, line.unit_price, line.adjusted_unit_price
3633 , line.line_quantity, line.priced_quantity, line.catchweight_qty, line.actual_order_quantity
3634 , line.rounding_factor
3635 , line.updated_adjusted_unit_price
3636 , line.pricing_status_code
3637 , line.pricing_status_text
3638 , 0 amount_changed
3639 , line_unit_price
3640 FROM qp_npreq_lines_tmp line
3641 WHERE line.price_flag IN (G_YES, G_PHASE, G_CALCULATE_ONLY)
3642 AND line.pricing_status_code IN (G_STATUS_UPDATED, G_STATUS_UNCHANGED,
3643 G_STATUS_GSA_VIOLATION)
3644 AND line.line_type_code = G_LINE_LEVEL
3645 AND nvl(processed_code, '0') <> G_BY_ENGINE
3646 AND (line.adjusted_unit_price <> line.unit_price
3647 --changed this for bug 2776800 to populate order_uom_selling_price
3648 --this means there are no adjustments and calculation has not taken place
3649 OR line.updated_adjusted_unit_price IS NOT NULL
3650 OR line.order_uom_selling_price IS NULL )
3651 AND nvl(line.QUALIFIERS_EXIST_FLAG, G_NO) <> G_CALCULATE_ONLY
3652 AND nvl(line.processed_flag, 'N') <> G_FREEGOOD_LINE; -- added for bug 3116349 /*avallark*/
3653
3654 l_line_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
3655 l_unit_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
3656 l_adj_unit_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
3657 l_ord_uom_selling_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
3658 l_line_qty_tbl QP_PREQ_GRP.NUMBER_TYPE;
3659 l_priced_qty_tbl QP_PREQ_GRP.NUMBER_TYPE;
3660 l_catchwt_qty_tbl QP_PREQ_GRP.NUMBER_TYPE;
3661 l_actual_order_qty_tbl QP_PREQ_GRP.NUMBER_TYPE;
3662 l_rounding_factor_tbl QP_PREQ_GRP.NUMBER_TYPE;
3663 l_upd_adj_unit_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
3664 l_amount_changed_tbl QP_PREQ_GRP.NUMBER_TYPE;
3665 l_line_unit_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
3666 l_pricing_sts_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3667 l_pricing_sts_text_tbl QP_PREQ_GRP.VARCHAR_TYPE;
3668 l_routine VARCHAR2(100) := 'QP_PREQ_PUB.UPDATE_UNIT_PRICE';
3669
3670 l_return_status VARCHAR2(30);
3671 l_return_status_text VARCHAR2(240);
3672 l_ord_qty_operand NUMBER;
3673 l_ord_qty_adj_amt NUMBER;
3674 i NUMBER;
3675
3676 l_back_calc_ret_rec back_calc_rec_type;
3677
3678 l_ldet_dtl_index QP_PREQ_GRP.NUMBER_TYPE;
3679 l_ldet_line_index QP_PREQ_GRP.NUMBER_TYPE;
3680 l_ldet_operand_value QP_PREQ_GRP.NUMBER_TYPE;
3681 l_ldet_adjamt QP_PREQ_GRP.NUMBER_TYPE;
3682 l_ldet_applied_flag QP_PREQ_GRP.FLAG_TYPE;
3683 l_ldet_updated_flag QP_PREQ_GRP.FLAG_TYPE;
3684 l_ldet_process_code QP_PREQ_GRP.VARCHAR_TYPE;
3685 l_ldet_sts_code QP_PREQ_GRP.VARCHAR_TYPE;
3686 l_ldet_sts_text QP_PREQ_GRP.VARCHAR_TYPE;
3687 l_ldet_calc_code QP_PREQ_GRP.VARCHAR_TYPE;
3688 l_ldet_ord_qty_operand QP_PREQ_GRP.NUMBER_TYPE; --3057395
3689 l_ldet_ord_qty_adj_amt QP_PREQ_GRP.NUMBER_TYPE; --3057395
3690
3691 --[prarasto:Post Round] Start : new variables
3692 l_extended_selling_price_ur QP_PREQ_GRP.NUMBER_TYPE;
3693 l_adjusted_unit_price_ur QP_PREQ_GRP.NUMBER_TYPE;
3694 l_unit_selling_price_ur QP_PREQ_GRP.NUMBER_TYPE;
3695 l_extended_selling_price QP_PREQ_GRP.NUMBER_TYPE;
3696 l_adjusted_unit_price QP_PREQ_GRP.NUMBER_TYPE;
3697 l_unit_selling_price QP_PREQ_GRP.NUMBER_TYPE;
3698 --[prarasto:Post Round] End : new variables
3699
3700 BEGIN
3701 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
3702 IF l_debug = FND_API.G_TRUE THEN
3703 QP_PREQ_GRP.engine_debug('Begin update_unit_price');
3704
3705 END IF;
3706 OPEN l_check_adjustments_cur;
3707 l_line_index_tbl.DELETE;
3708 l_unit_price_tbl.DELETE;
3709 l_adj_unit_price_tbl.DELETE;
3710 l_ord_uom_selling_price_tbl.DELETE;
3711 l_line_qty_tbl.DELETE;
3712 l_priced_qty_tbl.DELETE;
3713 l_catchwt_qty_tbl.DELETE;
3714 l_actual_order_qty_tbl.DELETE;
3715 l_rounding_factor_tbl.DELETE;
3716 l_upd_adj_unit_price_tbl.DELETE;
3717 l_pricing_sts_code_tbl.DELETE;
3718 l_pricing_sts_text_tbl.DELETE;
3719 l_amount_changed_tbl.DELETE;
3720 l_line_unit_price_tbl.DELETE;
3721
3722 l_ldet_dtl_index.DELETE;
3723 l_ldet_line_index.DELETE;
3724 l_ldet_operand_value.DELETE;
3725 l_ldet_adjamt.DELETE;
3726 l_ldet_applied_flag.DELETE;
3727 l_ldet_updated_flag.DELETE;
3728 l_ldet_process_code.DELETE;
3729 l_ldet_sts_code.DELETE;
3730 l_ldet_sts_text.DELETE;
3731 l_ldet_calc_code.DELETE;
3732 l_ldet_ord_qty_operand.DELETE; --3057395
3733 l_ldet_ord_qty_adj_amt.DELETE; --3057395
3734
3735 FETCH l_check_adjustments_cur BULK COLLECT INTO
3736 l_line_index_tbl, l_unit_price_tbl, l_adj_unit_price_tbl,
3737 l_line_qty_tbl, l_priced_qty_tbl, l_catchwt_qty_tbl, l_actual_order_qty_tbl, l_rounding_factor_tbl,
3738 l_upd_adj_unit_price_tbl,
3739 l_pricing_sts_code_tbl,
3740 l_pricing_sts_text_tbl,
3741 l_amount_changed_tbl,
3742 l_line_unit_price_tbl;
3743 CLOSE l_check_adjustments_cur;
3744
3745 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
3746 AND l_line_index_tbl.COUNT > 0
3747 THEN
3748 FOR i IN l_line_index_tbl.FIRST..l_line_index_tbl.LAST
3749 LOOP
3750 IF l_debug = FND_API.G_TRUE THEN
3751 QP_PREQ_GRP.engine_debug('line_index '
3752 || l_line_index_tbl(i) ||' unit_price '
3753 || l_unit_price_tbl(i) ||' adj_unit_price '
3754 || l_adj_unit_price_tbl(i) ||' price_qty '
3755 || l_priced_qty_tbl(i) ||' ordqty '|| l_line_qty_tbl(i)
3756 ||' catchwt_qty '|| l_catchwt_qty_tbl(i)
3757 ||' upd_adj_unit_price '|| l_upd_adj_unit_price_tbl(i)
3758 ||' stscode '|| l_pricing_sts_code_tbl(i)
3759 ||' ststext '|| l_pricing_sts_text_tbl(i));
3760 END IF;
3761 END LOOP;
3762 END IF;
3763
3764 IF l_line_index_tbl.COUNT > 0 THEN
3765 FOR i IN l_line_index_tbl.FIRST..l_line_index_tbl.LAST
3766 LOOP
3767
3768 --for bug 2926554 back calculation needs to be done here
3769 --if the caller has overridden the selling price
3770 --and if the line did not go thru calculation
3771 IF l_upd_adj_unit_price_tbl(i) IS NOT NULL THEN
3772 IF l_debug = FND_API.G_TRUE THEN
3773 QP_PREQ_GRP.engine_debug('back calculation for line '
3774 || l_line_index_tbl(i));
3775 END IF; --l_debug
3776
3777 ---- 9537858/ 10315863 for ASO only when Line qty and Price qty are different Unit price is re calculated if occurs for other products please add in if
3778 IF G_REQUEST_TYPE_CODE = 'ASO' THEN
3779 l_upd_adj_unit_price_tbl(i) := l_upd_adj_unit_price_tbl(i)*(l_line_qty_tbl(i)/l_priced_qty_tbl(i));
3780 END IF;
3781 ---- 9537858/ 10315863
3782
3783 -- 9537858/ 10315863 No need to round at this stage.. rounding is done after Back_calculation
3784
3785 IF G_ROUND_INDIVIDUAL_ADJ not in (G_NO_ROUND, G_POST_ROUND) AND G_REQUEST_TYPE_CODE <> 'ASO'
3786 --[prarasto:Post Round] added check to skip rounding for Post Rounding
3787 AND l_rounding_factor_tbl(i) IS NOT NULL THEN
3788 l_upd_adj_unit_price_tbl(i) :=
3789 round(l_upd_adj_unit_price_tbl(i), - 1 * l_rounding_factor_tbl(i));
3790 END IF; --G_ROUND_INDIVIDUAL_ADJ
3791
3792
3793
3794 IF ((l_upd_adj_unit_price_tbl(i) -
3795 l_adj_unit_price_tbl(i)) <> 0) THEN
3796 --there are no applied adjustments as this line
3797 --did not go thru calculation
3798 l_amount_changed_tbl(i) :=
3799 (l_upd_adj_unit_price_tbl(i) - l_adj_unit_price_tbl(i));
3800
3801
3802 IF l_debug = FND_API.G_TRUE THEN
3803 QP_PREQ_GRP.engine_debug('amt chg '|| l_amount_changed_tbl(i));
3804 END IF; --l_debug
3805
3806 IF l_amount_changed_tbl(i) <= 0 THEN
3807 G_BACK_CALCULATION_CODE := 'DIS';
3808 ELSE
3809 G_BACK_CALCULATION_CODE := 'SUR';
3810 END IF; --l_amount_changed_tbl
3811
3812 BACK_CALCULATION(l_line_index_tbl(i)
3813 , l_amount_changed_tbl(i)
3814 , l_back_calc_ret_rec
3815 , l_return_status
3816 , l_return_status_text);
3817
3818 IF l_return_status = FND_API.G_RET_STS_SUCCESS THEN
3819 --need to do this check for bug 2833753
3820 IF l_debug = FND_API.G_TRUE THEN
3821 QP_PREQ_GRP.engine_debug('back cal succ insert rec ');
3822 END IF; --l_debug
3823
3824 l_adj_unit_price_tbl(i) := l_upd_adj_unit_price_tbl(i);
3825
3826 -- Ravi
3827 --this procedure is called to calculate the
3828 --selling_price,adjustment_amount and operand in ordered_qty
3829 --which is the line_quantity on lines_tmp
3830 -- Ravi bug# 2745337-divisor by zero
3831 IF (l_line_qty_tbl(i) <> 0
3832 OR l_back_calc_ret_rec.modifier_level_code = G_ORDER_LEVEL) THEN
3833 IF (l_debug = FND_API.G_TRUE) THEN
3834 QP_PREQ_GRP.engine_debug('Before GET_ORDERQTY_VALUES #6');
3835 END IF; --l_debug
3836 GET_ORDERQTY_VALUES(p_ordered_qty => l_line_qty_tbl(i),
3837 p_priced_qty => l_priced_qty_tbl(i),
3838 p_catchweight_qty => l_catchwt_qty_tbl(i),
3839 p_actual_order_qty => l_actual_order_qty_tbl(i),
3840 p_operand => l_back_calc_ret_rec.operand_value,
3841 p_adjustment_amt => l_back_calc_ret_rec.adjustment_amount,
3842 p_unit_price => l_unit_price_tbl(i),
3843 p_adjusted_unit_price => l_adj_unit_price_tbl(i),
3844 p_operand_calculation_code => l_back_calc_ret_rec.operand_calculation_code,
3845 p_input_type => 'OPERAND',
3846 x_ordqty_output1 => l_ord_qty_operand,
3847 x_ordqty_output2 => l_ord_qty_adj_amt,
3848 x_return_status => x_return_status,
3849 x_return_status_text => x_return_status_text);
3850 ELSE --l_line_qty_tbl(i)
3851 IF l_debug = FND_API.G_TRUE THEN
3852 QP_PREQ_GRP.engine_debug('Ordered Qty #3 : ' || l_line_qty_tbl(i));
3853 QP_PREQ_GRP.engine_debug('OPERAND Ordered Qty is 0 or modifier level code is not ORDER');
3854 END IF; --l_debug
3855 l_ord_qty_operand := 0;
3856 l_ord_qty_adj_amt := 0;
3857 END IF; --l_line_qty_tbl(i)
3858
3859 -- End Ravi
3860
3861 --fix for bug 2146050 to round adjustment amt
3862 IF G_ROUND_INDIVIDUAL_ADJ = G_ROUND_ADJ
3863 AND l_rounding_factor_tbl(i) IS NOT NULL THEN
3864 l_back_calc_ret_rec.adjustment_amount :=
3865 round(l_back_calc_ret_rec.adjustment_amount,
3866 - 1 * l_rounding_factor_tbl(i));
3867 l_ord_qty_adj_amt := round(l_ord_qty_adj_amt,
3868 - 1 * l_rounding_factor_tbl(i));
3869 END IF; --G_ROUND_INDIVIDUAL_ADJ
3870
3871 --load the l_back_calc_ret_rec to plsqltbl to do bulk update
3872 l_ldet_dtl_index(l_ldet_dtl_index.COUNT + 1) :=
3873 l_back_calc_ret_rec.line_detail_index;
3874 l_ldet_line_index(l_ldet_dtl_index.COUNT) :=
3875 l_back_calc_ret_rec.line_index;
3876 l_ldet_operand_value(l_ldet_dtl_index.COUNT) :=
3877 l_back_calc_ret_rec.operand_value;
3878 l_ldet_adjamt(l_ldet_dtl_index.COUNT) :=
3879 l_back_calc_ret_rec.adjustment_amount;
3880 l_ldet_applied_flag(l_ldet_dtl_index.COUNT) :=
3881 l_back_calc_ret_rec.applied_flag;
3882 l_ldet_updated_flag(l_ldet_dtl_index.COUNT) :=
3883 l_back_calc_ret_rec.updated_flag;
3884 l_ldet_process_code(l_ldet_dtl_index.COUNT) :=
3885 l_back_calc_ret_rec.process_code;
3886 l_ldet_sts_code(l_ldet_dtl_index.COUNT) :=
3887 l_back_calc_ret_rec.pricing_status_code;
3888 l_ldet_sts_text(l_ldet_dtl_index.COUNT) :=
3889 l_back_calc_ret_rec.pricing_status_text;
3890 l_ldet_calc_code(l_ldet_dtl_index.COUNT) :=
3891 l_back_calc_ret_rec.calculation_code;
3892 l_ldet_ord_qty_operand(l_ldet_dtl_index.COUNT) :=
3893 l_ord_qty_operand; --3057395
3894 l_ldet_ord_qty_adj_amt(l_ldet_dtl_index.COUNT) :=
3895 l_ord_qty_adj_amt; --3057395
3896
3897 ELSE --l_ret_status
3898 IF l_debug = FND_API.G_TRUE THEN
3899 QP_PREQ_GRP.engine_debug('back cal fail no insert rec');
3900 END IF; --l_debug
3901 l_pricing_sts_code_tbl(i) := l_return_status;
3902 l_pricing_sts_text_tbl(i) := l_return_status_text;
3903 END IF; --ret_status
3904 END IF; --l_upd_adj_unit_price_tbl - l_adj_unit
3905 ELSE
3906 --if not then the line has no adjustments and the
3907 --selling price needs to be replaced as the selling price
3908 l_adj_unit_price_tbl(i) := l_unit_price_tbl(i);
3909 END IF; --l_upd_adj_unit_price_tbl IS NOT NULL
3910
3911 IF l_debug = FND_API.G_TRUE THEN
3912 QP_PREQ_GRP.engine_debug('end back calc for line '
3913 ||' unit price '|| l_unit_price_tbl(i)
3914 ||' adj_unit_price '|| l_adj_unit_price_tbl(i)
3915 ||' upd_adj_unit_price '|| l_upd_adj_unit_price_tbl(i));
3916 END IF; --l_debug
3917
3918 --fix for bug 2812738
3919 --changes to calculate the order_uom_selling_price
3920 IF (l_line_qty_tbl(i) <> 0
3921 OR l_back_calc_ret_rec.modifier_level_code =
3922 G_ORDER_LEVEL) THEN
3923 IF (l_debug = FND_API.G_TRUE) THEN
3924 QP_PREQ_GRP.engine_debug('Before GET_ORDERQTY_VALUES #6.5');
3925 END IF; --l_debug
3926 GET_ORDERQTY_VALUES(p_ordered_qty => l_line_qty_tbl(i),
3927 p_priced_qty => l_priced_qty_tbl(i),
3928 p_catchweight_qty => l_catchwt_qty_tbl(i),
3929 p_actual_order_qty => l_actual_order_qty_tbl(i),
3930 p_unit_price => l_unit_price_tbl(i),
3931 p_adjusted_unit_price => l_adj_unit_price_tbl(i),
3932 p_line_unit_price => l_line_unit_price_tbl(i),
3933 p_input_type => 'SELLING_PRICE',
3934 x_ordqty_output1 => l_line_unit_price_tbl(i),
3935 x_ordqty_output2 => l_ord_uom_selling_price_tbl(i),
3936 x_return_status => x_return_status,
3937 x_return_status_text => x_return_status_text);
3938 ELSE --ordered_qty
3939 IF l_debug = FND_API.G_TRUE THEN
3940 QP_PREQ_GRP.engine_debug('Ordered Qty #2.5 : '
3941 || l_line_qty_tbl(i));
3942 QP_PREQ_GRP.engine_debug('SELLING PRICE Ordered Qty is '
3943 ||'0 or modifier level code is not ORDER');
3944 END IF; --l_debug
3945 l_line_unit_price_tbl(i) := 0;
3946 l_ord_uom_selling_price_tbl(i) := 0;
3947 END IF; --ordered_qty
3948
3949 --round the selling price if ROUND_INDIVIDUAL_ADJ
3950 --profile is N in this case the adjustment_amt will not be rounded
3951
3952 --===[prarasto:Post Round] Start : Calculate rounded values ==--
3953 l_adjusted_unit_price_ur(i) := l_adj_unit_price_tbl(i);
3954 l_unit_selling_price_ur(i) := l_ord_uom_selling_price_tbl(i);
3955
3956 IF (G_ROUND_INDIVIDUAL_ADJ not in ( G_NO_ROUND , G_POST_ROUND )) AND (l_rounding_factor_tbl(i) is not null)
3957 THEN
3958 IF (l_catchwt_qty_tbl(i) is null) and (l_actual_order_qty_tbl(i) is not null) THEN
3959 l_extended_selling_price_ur(i) := round(l_unit_selling_price_ur(i), - 1 * l_rounding_factor_tbl(i))
3960 * l_actual_order_qty_tbl(i);
3961 ELSE
3962 l_extended_selling_price_ur(i) := round(l_unit_selling_price_ur(i), - 1 * l_rounding_factor_tbl(i))
3963 * l_line_qty_tbl(i);
3964 END IF;
3965 ELSE
3966 IF (l_catchwt_qty_tbl(i) is null) and (l_actual_order_qty_tbl(i) is not null) THEN
3967 l_extended_selling_price_ur(i) := l_unit_selling_price_ur(i) * l_actual_order_qty_tbl(i);
3968 ELSE
3969 l_extended_selling_price_ur(i) := l_unit_selling_price_ur(i) * l_line_qty_tbl(i);
3970 END IF;
3971 END IF;
3972
3973
3974 IF l_debug = FND_API.G_TRUE THEN
3975 QP_PREQ_GRP.engine_debug('roundingfac to round sellingprice: '
3976 || l_rounding_factor_tbl(i));
3977 END IF; --l_debug
3978
3979 IF (G_ROUND_INDIVIDUAL_ADJ = G_NO_ROUND) or (l_rounding_factor_tbl(i) is null) THEN
3980 -- l_adj_unit_price_tbl(i) := l_adjusted_unit_price_ur(i);
3981 l_unit_selling_price(i) := l_unit_selling_price_ur(i);
3982 l_extended_selling_price(i) := l_extended_selling_price_ur(i);
3983 ELSE
3984 l_adj_unit_price_tbl(i) := round(l_adjusted_unit_price_ur(i), - 1 * l_rounding_factor_tbl(i));
3985 l_line_unit_price_tbl(i) := round(l_line_unit_price_tbl(i), - 1 * l_rounding_factor_tbl(i));
3986 l_unit_selling_price(i) := round(l_unit_selling_price_ur(i), - 1 * l_rounding_factor_tbl(i));
3987 l_extended_selling_price(i) := round(l_extended_selling_price_ur(i), - 1 * l_rounding_factor_tbl(i));
3988 END IF;
3989
3990 IF l_debug = FND_API.G_TRUE THEN
3991 QP_PREQ_GRP.engine_debug('Extended selling price unrounded : '||l_extended_selling_price_ur(i));
3992 QP_PREQ_GRP.engine_debug('Extended selling price : '||l_extended_selling_price(i));
3993 QP_PREQ_GRP.engine_debug('Unit selling price unrounded : '||l_unit_selling_price_ur(i));
3994 QP_PREQ_GRP.engine_debug('Unit selling price : '||l_unit_selling_price(i));
3995 QP_PREQ_GRP.engine_debug('Adjusted unit price unrounded : '||l_adjusted_unit_price_ur(i));
3996 QP_PREQ_GRP.engine_debug('Adjusted unit price : '||l_adj_unit_price_tbl(i));
3997 END IF; --l_debug
3998 --===[prarasto:Post Round] End : Calculate rounded values ==--
3999
4000 /*
4001 IF (l_catchwt_qty_tbl(i) IS NOT NULL) THEN
4002 l_ord_uom_selling_price_tbl(i) := (nvl(l_adj_unit_price_tbl(i),l_unit_price_tbl(i)) *
4003 (l_priced_qty_tbl(i)/ l_actual_order_qty_tbl(i))* (l_catchwt_qty_tbl(i)/l_line_qty_tbl(i)));
4004 ELSIF (l_actual_order_qty_tbl(i) IS NOT NULL) THEN
4005 l_ord_uom_selling_price_tbl(i) := (nvl(l_adj_unit_price_tbl(i),l_unit_price_tbl(i)) *
4006 (l_priced_qty_tbl(i)/ l_actual_order_qty_tbl(i)));
4007 ELSE
4008 l_ord_uom_selling_price_tbl(i) := (nvl(l_adj_unit_price_tbl(i),l_unit_price_tbl(i)) *
4009 (l_priced_qty_tbl(i)/ l_line_qty_tbl(i)));
4010 END IF;
4011
4012 IF l_rounding_factor_tbl(i) IS NOT NULL and G_ROUND_INDIVIDUAL_ADJ <> G_NO_ROUND THEN
4013 l_ord_uom_selling_price_tbl(i) := round(l_ord_uom_selling_price_tbl(i), (-1 * l_rounding_factor_tbl(i)));
4014 END IF;--l_rounding_factor_tbl
4015 */
4016
4017 IF l_debug = FND_API.G_TRUE THEN
4018 QP_PREQ_GRP.engine_debug('line_index '
4019 || l_line_index_tbl(i) ||' ord_uom_selling_price '
4020 || l_ord_uom_selling_price_tbl(i));
4021 END IF; --l_debug
4022
4023 END LOOP; --i
4024 END IF; --l_line_index_tbl.count
4025
4026 --added for bug 2926554
4027 IF l_ldet_dtl_index.COUNT > 0
4028 THEN
4029 FORALL i IN l_ldet_dtl_index.first..l_ldet_dtl_index.last
4030 UPDATE qp_npreq_ldets_tmp ldet
4031 SET ldet.operand_value = l_ldet_operand_value(i)
4032 , ldet.adjustment_amount = l_ldet_adjamt(i)
4033 , ldet.applied_flag = l_ldet_applied_flag(i)
4034 , ldet.updated_flag = l_ldet_updated_flag(i)
4035 , ldet.process_code = l_ldet_process_code(i)
4036 , ldet.pricing_status_code = l_ldet_sts_code(i)
4037 , ldet.pricing_status_text = l_ldet_sts_text(i)
4038 , ldet.calculation_code = l_ldet_calc_code(i)
4039 , ldet.order_qty_operand = l_ldet_ord_qty_operand(i) --3057395
4040 , ldet.order_qty_adj_amt = l_ldet_ord_qty_adj_amt(i) --3057395
4041 WHERE ldet.line_detail_index = l_ldet_dtl_index(i)
4042 AND ldet.line_index = l_ldet_line_index(i);
4043
4044 END IF; --l_ldet_dtl_index.COUNT
4045
4046
4047 IF l_line_index_tbl.COUNT > 0
4048 THEN
4049
4050 IF l_debug = FND_API.G_TRUE THEN
4051 QP_PREQ_GRP.engine_debug('unit price needs to be updated');
4052 END IF;
4053
4054 FORALL i IN l_line_index_tbl.FIRST..l_line_index_tbl.LAST
4055 UPDATE qp_npreq_lines_tmp
4056 SET adjusted_unit_price = l_adj_unit_price_tbl(i)
4057 --, adjusted_unit_price_ur = l_adjusted_unit_price_ur(i) --[prarasto:Post Round], [julin/postround] redesign
4058 , line_unit_price = l_line_unit_price_tbl(i)
4059 , pricing_status_code = nvl(l_pricing_sts_code_tbl(i), G_STATUS_UPDATED) /* bug 3248475 */
4060 , pricing_status_text = l_pricing_sts_text_tbl(i) /* bug 3248475 */
4061 , order_uom_selling_price = l_unit_selling_price(i) --[prarasto:Post Round]
4062 --, order_uom_selling_price_ur = l_unit_selling_price_ur(i) --[prarasto:Post Round], [julin/postround] redesign
4063 , extended_price = l_extended_selling_price(i) --[prarasto:Post Round]
4064 --, extended_selling_price_ur = l_extended_selling_price_ur(i) --[prarasto:Post Round], [julin/postround] redesign
4065 WHERE line_index = l_line_index_tbl(i)
4066 -- and (l_adj_unit_price_tbl(i) <> l_unit_price_tbl(i) --3524967
4067 AND (adjusted_unit_price <> unit_price --3524967
4068 --changes for bug 2776800 to populate order_uom_selling_price
4069 OR updated_adjusted_unit_price IS NOT NULL
4070 OR order_uom_selling_price IS NULL);
4071 END IF;
4072
4073 EXCEPTION
4074 WHEN OTHERS THEN
4075 x_return_status := FND_API.G_RET_STS_ERROR;
4076 x_return_status_text := l_routine ||' '|| SQLERRM;
4077 IF l_debug = FND_API.G_TRUE THEN
4078 QP_PREQ_GRP.ENGINE_DEBUG(x_return_status_text);
4079 END IF;
4080 END UPDATE_UNIT_PRICE;
4081
4082
4083
4084 --Procedure to update the line status to 'UPDATED' if there are
4085 --any lines with adjustments with process_code 'UPDATED'/'N'
4086
4087 PROCEDURE Update_Line_Status(x_return_status OUT NOCOPY VARCHAR2,
4088 x_return_status_text OUT NOCOPY VARCHAR2) IS
4089
4090 BEGIN
4091 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
4092 IF l_debug = FND_API.G_TRUE THEN
4093 QP_PREQ_GRP.engine_debug('Begin Update_Line_Status:calculate_flag '|| G_CALCULATE_FLAG);
4094
4095 END IF;
4096
4097 IF QP_JAVA_ENGINE_UTIL_PUB.Java_Engine_Running = 'N' THEN
4098 /* Modified where clause as per suggestion of spgopal for bug 3401941 */
4099 UPDATE qp_npreq_lines_tmp line
4100 SET pricing_status_code = G_STATUS_UPDATED
4101 --for bug 2812738 not to update if back_calc_error/gsa_violatn
4102 WHERE line.pricing_status_code = G_STATUS_UNCHANGED
4103 --fix for bug 3425569 where frozen lines were set to status updated
4104 --and processing constraints cause error in OM when they update frozen lines
4105 AND (line.price_flag IN (QP_PREQ_PUB.G_YES, QP_PREQ_PUB.G_PHASE, QP_PREQ_PUB.G_CALCULATE_ONLY)
4106 OR nvl(line.processed_code, '0') = QP_PREQ_PUB.G_BY_ENGINE)
4107 AND (G_CALCULATE_FLAG = G_CALCULATE_ONLY
4108
4109 OR EXISTS (SELECT 'Y' FROM qp_npreq_ldets_tmp ldet
4110 WHERE ldet.line_index = line.line_index
4111 AND ldet.pricing_status_code = G_STATUS_NEW
4112 AND ldet.applied_flag = G_YES -- bug 6111048/6328486
4113 AND ldet.process_code IN
4114 (G_STATUS_NEW, G_STATUS_UPDATED))
4115 --for bug#3224658
4116 OR EXISTS (SELECT 'Y' FROM qp_npreq_ldets_tmp
4117 WHERE modifier_level_code = 'ORDER'
4118 AND applied_flag = 'YES' -- bug 6628324
4119 AND pricing_status_code = G_STATUS_NEW
4120 AND process_code IN (G_STATUS_NEW, G_STATUS_UPDATED))
4121 OR EXISTS (SELECT 'Y' FROM oe_price_adjustments adj
4122 WHERE line.line_type_code = G_LINE_LEVEL
4123 AND line.line_id = adj.line_id
4124 AND adj.applied_flag = G_YES
4125 AND adj.list_line_id NOT IN (SELECT ldet.created_from_list_line_id FROM qp_npreq_ldets_tmp ldet
4126 WHERE ldet.line_index = line.line_index
4127 AND ldet.pricing_status_code = G_STATUS_NEW
4128 AND ldet.process_code IN (G_STATUS_NEW, G_STATUS_UPDATED)
4129 AND ldet.applied_flag = G_YES))
4130 OR EXISTS (SELECT 'Y' FROM oe_price_adjustments adj
4131 WHERE line.line_type_code = G_ORDER_LEVEL
4132 AND line.line_id = adj.header_id
4133 AND adj.applied_flag = G_YES
4134 AND adj.list_line_id NOT IN (SELECT ldet.created_from_list_line_id FROM qp_npreq_ldets_tmp ldet
4135 WHERE ldet.line_index = line.line_index
4136 AND ldet.pricing_status_code = G_STATUS_NEW
4137 AND ldet.process_code IN (G_STATUS_NEW, G_STATUS_UPDATED)
4138 AND ldet.applied_flag = G_YES))
4139 );
4140 ELSE
4141 UPDATE qp_int_lines line
4142 SET pricing_status_code = G_STATUS_UPDATED
4143 --for bug 2812738 not to update if back_calc_error/gsa_violatn
4144 WHERE line.pricing_status_code = G_STATUS_UNCHANGED
4145 --fix for bug 3425569 where frozen lines were set to status updated
4146 --and processing constraints cause error in OM when they update frozen lines
4147 AND (line.price_flag IN (QP_PREQ_PUB.G_YES, QP_PREQ_PUB.G_PHASE, QP_PREQ_PUB.G_CALCULATE_ONLY)
4148 OR nvl(line.processed_code, '0') = QP_PREQ_PUB.G_BY_ENGINE)
4149 AND (G_CALCULATE_FLAG = G_CALCULATE_ONLY
4150
4151 OR EXISTS (SELECT 'Y' FROM qp_int_ldets ldet
4152 WHERE ldet.line_index = line.line_index
4153 AND ldet.pricing_status_code = G_STATUS_NEW
4154 AND ldet.applied_flag = G_YES -- bug 6111048/6328486
4155 AND ldet.process_code IN
4156 (G_STATUS_NEW, G_STATUS_UPDATED))
4157 --for bug#3224658
4158 OR EXISTS (SELECT 'Y' FROM qp_int_ldets
4159 WHERE modifier_level_code = 'ORDER'
4160 AND applied_flag = 'YES' -- bug 6628324
4161 AND pricing_status_code = G_STATUS_NEW
4162 AND process_code IN (G_STATUS_NEW, G_STATUS_UPDATED))
4163 OR EXISTS (SELECT 'Y' FROM oe_price_adjustments adj
4164 WHERE line.line_type_code = G_LINE_LEVEL
4165 AND line.line_id = adj.line_id
4166 AND adj.applied_flag = G_YES
4167 AND adj.list_line_id NOT IN (SELECT ldet.created_from_list_line_id FROM qp_int_ldets ldet
4168 WHERE ldet.line_index = line.line_index
4169 AND ldet.pricing_status_code = G_STATUS_NEW
4170 AND ldet.process_code IN (G_STATUS_NEW, G_STATUS_UPDATED)
4171 AND ldet.applied_flag = G_YES))
4172 OR EXISTS (SELECT 'Y' FROM oe_price_adjustments adj
4173 WHERE line.line_type_code = G_ORDER_LEVEL
4174 AND line.line_id = adj.header_id
4175 AND adj.applied_flag = G_YES
4176 AND adj.list_line_id NOT IN (SELECT ldet.created_from_list_line_id FROM qp_int_ldets ldet
4177 WHERE ldet.line_index = line.line_index
4178 AND ldet.pricing_status_code = G_STATUS_NEW
4179 AND ldet.process_code IN (G_STATUS_NEW, G_STATUS_UPDATED)
4180 AND ldet.applied_flag = G_YES))
4181 );
4182
4183 END IF;
4184
4185 EXCEPTION
4186 WHEN OTHERS THEN
4187 x_return_status := FND_API.G_RET_STS_ERROR;
4188 x_return_status_text := 'Exception in QP_PREQ_PUB.Update_Line_Status: '|| SQLERRM;
4189 END Update_Line_Status;
4190
4191 --overloaded for QP.G reqts
4192 --this is used in performance code path called from QPXVCLNB.fetch_adjustments
4193
4194 PROCEDURE CALCULATE_PRICE(p_request_type_code IN VARCHAR2,
4195 p_rounding_flag IN VARCHAR2,
4196 p_view_name IN VARCHAR2,
4197 p_event_code IN VARCHAR2,
4198 p_adj_tbl IN QP_PREQ_PUB.ADJ_TBL_TYPE,
4199 x_return_status OUT NOCOPY VARCHAR2,
4200 x_return_status_text OUT NOCOPY VARCHAR2) IS
4201
4202 --fix for bug 2515762 to print in debug the rltd info
4203 CURSOR l_rltd_lines_cur IS
4204 SELECT line_index,
4205 related_line_index,
4206 line_detail_index,
4207 related_line_detail_index,
4208 relationship_type_code,
4209 list_line_id,
4210 related_list_line_id,
4211 related_list_line_type,
4212 operand_calculation_code,
4213 operand,
4214 pricing_group_sequence,
4215 setup_value_from,
4216 setup_value_to,
4217 qualifier_value
4218 FROM qp_npreq_rltd_lines_tmp
4219 WHERE pricing_status_code = G_STATUS_NEW;
4220
4221 CURSOR l_net_amount_flag_cur (p_list_line_id NUMBER) IS
4222 SELECT net_amount_flag
4223 FROM qp_list_lines
4224 WHERE list_line_id = p_list_line_id;
4225
4226
4227 Calculate_Exc EXCEPTION;
4228
4229
4230 --back_calculate BOOLEAN := FALSE;
4231 back_calculate_succ BOOLEAN := FALSE;
4232 line_change BOOLEAN := FALSE;
4233
4234 --l_amount_changed NUMBER :=0;
4235 l_adjustment_amount NUMBER := 0;
4236 l_operand_value NUMBER := 0;
4237 l_back_calculate_start_type VARCHAR2(30);
4238 --l_prev_line_index NUMBER :=0;
4239 l_prev_line_index NUMBER := - 9999; -- SL_latest 2892848
4240 l_1st_bucket VARCHAR2(1) := 'N'; -- SL_latest
4241 l_list_price NUMBER := 0;
4242 --l_adjusted_price NUMBER :=0; -- 2892848
4243 --l_prev_bucket NUMBER :=0; -- 2892848
4244 l_adjusted_price NUMBER := NULL; --2892848 so we can nvl(l_adjusted_price, unit_price) when assign l_sub_total_price
4245 l_prev_bucket NUMBER := - 9999; --2892848
4246 l_line_adjusted_price NUMBER := 0;
4247 l_sub_total_price NUMBER := NULL; -- SL_more
4248 l_return_adjustment NUMBER := 0;
4249 l_sign NUMBER := 1;
4250 l_return_status VARCHAR2(30);
4251 l_return_status_text VARCHAR2(240);
4252 l_routine VARCHAR2(50) := 'Routine :QP_PREQ_PUB.Calculate_price ';
4253 --l_processed_flag VARCHAR2(1);
4254 --l_pbh_request_qty NUMBER :=0;
4255
4256 --l_pbh_net_adj_amount NUMBER := 0; -- 2892848 no need
4257 --l_pbh_prev_net_adj_amount NUMBER := 0; -- 2892848 no need
4258
4259 i PLS_INTEGER;
4260 j PLS_INTEGER;
4261 x PLS_INTEGER := 0; -- 3126019
4262 y PLS_INTEGER;
4263 l_tbl_index PLS_INTEGER;
4264
4265 l_adj_tbl QP_PREQ_PUB.adj_tbl_type;
4266 l_frt_tbl FRT_CHARGE_TBL;
4267 l_back_calc_ret_rec back_calc_rec_type;
4268
4269 l_ldet_line_dtl_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
4270 l_ldet_line_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
4271 l_ldet_list_hdr_id_tbl QP_PREQ_GRP.NUMBER_TYPE;
4272 l_ldet_list_line_id_tbl QP_PREQ_GRP.NUMBER_TYPE;
4273 l_ldet_list_line_type_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4274 l_ldet_operand_value_tbl QP_PREQ_GRP.NUMBER_TYPE;
4275 l_ldet_adj_amt_tbl QP_PREQ_GRP.NUMBER_TYPE;
4276 l_ldet_applied_flag_tbl QP_PREQ_GRP.FLAG_TYPE;
4277 l_ldet_updated_flag_tbl QP_PREQ_GRP.FLAG_TYPE;
4278 l_ldet_pricing_sts_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4279 l_ldet_process_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4280 l_ldet_pricing_sts_txt_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4281 l_ldet_price_break_type_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4282 l_ldet_line_quantity_tbl QP_PREQ_GRP.NUMBER_TYPE;
4283 l_ldet_operand_calc_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4284 l_ldet_pricing_grp_seq_tbl QP_PREQ_GRP.NUMBER_TYPE;
4285 l_ldet_list_type_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4286 l_ldet_limit_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4287 l_ldet_limit_text_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4288 l_ldet_list_line_no_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4289 l_ldet_charge_type_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4290 l_ldet_charge_subtype_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4291 l_ldet_automatic_flag_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4292 l_ldet_pricing_phase_id_tbl QP_PREQ_GRP.NUMBER_TYPE;
4293 l_ldet_modifier_level_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4294 l_ldet_is_max_frt_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4295 l_ldet_calc_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4296 l_ldet_ordqty_operand_tbl QP_PREQ_GRP.NUMBER_TYPE;
4297 l_ldet_ordqty_adjamt_tbl QP_PREQ_GRP.NUMBER_TYPE;
4298 l_ldet_price_adjust_id_tbl QP_PREQ_GRP.NUMBER_TYPE; --bug 12731184
4299
4300
4301 l_line_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
4302 l_unit_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
4303 l_adj_unit_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
4304 l_amount_changed_tbl QP_PREQ_GRP.NUMBER_TYPE;
4305 l_ordered_qty_tbl QP_PREQ_GRP.NUMBER_TYPE;
4306 l_line_priced_qty_tbl QP_PREQ_GRP.NUMBER_TYPE;
4307 l_catchweight_qty_tbl QP_PREQ_GRP.NUMBER_TYPE;
4308 l_actual_order_qty_tbl QP_PREQ_GRP.NUMBER_TYPE;
4309 l_line_unit_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
4310 l_pricing_sts_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4311 l_pricing_sts_txt_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4312 l_process_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
4313 l_upd_adj_unit_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
4314 l_processed_flag_tbl QP_PREQ_GRP.FLAG_TYPE;
4315 l_rounding_factor_tbl QP_PREQ_GRP.NUMBER_TYPE;
4316 l_ordqty_selling_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
4317 l_ordqty_unit_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
4318 l_ntamt_adj_unit_price QP_PREQ_GRP.NUMBER_TYPE; -- 3126019
4319 l_calc_quantity NUMBER;
4320
4321 --[prarasto:Post Round] Start : new variables
4322 l_extended_selling_price_ur QP_PREQ_GRP.NUMBER_TYPE;
4323 l_adjusted_unit_price_ur QP_PREQ_GRP.NUMBER_TYPE;
4324 l_unit_selling_price_ur QP_PREQ_GRP.NUMBER_TYPE;
4325 l_extended_selling_price QP_PREQ_GRP.NUMBER_TYPE;
4326 l_adjusted_unit_price QP_PREQ_GRP.NUMBER_TYPE;
4327 l_unit_selling_price QP_PREQ_GRP.NUMBER_TYPE;
4328 --[prarasto:Post Round] End : new variables
4329
4330 l_back_calc_dtl_index QP_PREQ_GRP.NUMBER_TYPE;
4331 l_back_calc_adj_amt QP_PREQ_GRP.NUMBER_TYPE;
4332 l_back_calc_plsql_tbl_index QP_PREQ_GRP.NUMBER_TYPE;
4333
4334 l_back_calc_dtl_ind NUMBER;
4335 l_back_calc_adj_amount NUMBER;
4336 l_back_calc_plsql_index NUMBER;
4337 --begin 2388011
4338 l_req_value_per_unit NUMBER; --2388011 priya added this variable
4339 l_total_value NUMBER; --group_value --2388011 priya added this variable
4340 l_bucketed_adjustment NUMBER; --2388011 priya added this variable
4341 --end 2388011
4342
4343 l_pricing_attribute VARCHAR2(240);
4344
4345 --added to calculate order level adjustments' adj amt
4346 l_ord_dtl_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
4347 l_ord_adj_amt_tbl QP_PREQ_GRP.NUMBER_TYPE;
4348 l_ord_qty_adj_amt_tbl QP_PREQ_GRP.NUMBER_TYPE;
4349 l_ord_qty_operand_tbl QP_PREQ_GRP.NUMBER_TYPE;
4350 l_ord_qty_adj_amt NUMBER := 0;
4351 l_ord_qty_operand NUMBER := 0;
4352
4353 -- begin 2892848, net amount
4354 l_qualifier_value NUMBER := NULL; -- to qualify PBH
4355 s PLS_INTEGER := 0; -- counter for l_line_bucket_detail_tbl
4356 l_lg_adj_amt NUMBER := NULL; -- 2892848
4357 l_prev_lg_adj_amt NUMBER := 0;
4358
4359 /* SL_latest 2892848
4360 -- for linegroup
4361 TYPE bucket_adj_amt_tbl IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
4362 l_bucket_adj_amt_tbl bucket_adj_amt_tbl;
4363
4364 -- for line level
4365 TYPE bucket_index_adj_tbl IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
4366 l_bucket_index_adj_tbl bucket_index_adj_tbl;
4367
4368 TYPE prev_bucket_index_adj_tbl IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
4369 l_prev_bucket_index_adj_tbl prev_bucket_index_adj_tbl;
4370 -- end 2892848
4371 */
4372
4373 --begin SL_latest
4374 CURSOR l_net_mod_index_cur(p_list_line_id NUMBER) IS
4375 SELECT DISTINCT ldet.line_index
4376 FROM qp_npreq_ldets_tmp ldet
4377 WHERE ldet.created_from_list_line_id = p_list_line_id
4378 AND pricing_status_code IN (G_STATUS_NEW, G_STATUS_UPDATED, G_STATUS_UNCHANGED);
4379
4380 l_line_bucket_amt NUMBER := 0;
4381 l_lg_net_amt NUMBER := 0;
4382 l_prev_qty NUMBER := 0;
4383 l_applied_req_value_per_unit NUMBER := 0;
4384 l_prod_line_bucket_amt NUMBER := 0;
4385 l_lg_prod_net_amt NUMBER := 0;
4386
4387 -- record bucketed USP*qtyfor each line_index upon bucket change
4388 TYPE bucket_amt_tbl IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
4389 l_bucket_amt_tbl bucket_amt_tbl;
4390 l_prev_bucket_amt_tbl bucket_amt_tbl;
4391
4392 -- hash table of list_line_id and its corresponding lg_net_amt
4393 TYPE mod_lg_net_amt_tbl IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
4394 l_mod_lg_net_amt_tbl mod_lg_net_amt_tbl;
4395 l_mod_lg_prod_net_amt_tbl mod_lg_net_amt_tbl; -- [julin/4112395/4220399]
4396
4397 -- end SL_latest 2892848
4398
4399 l_adj_exists_in_tmp_tbl VARCHAR2(1) := 'N'; -- bug 3618464
4400 L_LINE_INDEX_STR VARCHAR2(2000); -- bug 3618464
4401 L_INSTR_POS NUMBER; -- bug 3618464
4402 L_INDEX NUMBER; -- bug 3618464
4403
4404 -- [julin/3265308] net amount calculation 'P', match product only.
4405 -- given a line line id, find the product attribute and context for
4406 -- the modifier and match all request lines with that context/attr
4407 -- pair. exclude logic included. price_flag clause included to
4408 -- ignore free goods.
4409 CURSOR l_prod_attr_info(p_list_line_id NUMBER) IS
4410 SELECT DISTINCT qla.line_index, ql.priced_quantity, ql.unit_price
4411 FROM qp_preq_line_attrs_tmp qla, qp_pricing_attributes qpa, qp_preq_lines_tmp ql
4412 WHERE qpa.list_line_id = p_list_line_id
4413 AND qla.context = qpa.product_attribute_context
4414 AND qla.attribute = qpa.product_attribute
4415 AND qla.value_from = qpa.product_attr_value
4416 AND qla.line_index = ql.line_index
4417 AND ql.price_flag <> G_PHASE
4418 AND ql.pricing_status_code IN (QP_PREQ_PUB.G_STATUS_UPDATED,
4419 QP_PREQ_PUB.G_STATUS_GSA_VIOLATION,
4420 QP_PREQ_PUB.G_STATUS_UNCHANGED)
4421 AND NOT EXISTS (SELECT qla2.line_index
4422 FROM qp_preq_line_attrs_tmp qla2, qp_pricing_attributes qpa2
4423 WHERE qpa2.list_line_id = p_list_line_id
4424 AND qpa2.excluder_flag = G_YES
4425 AND qla2.line_index = qla.line_index
4426 AND qla2.context = qpa2.product_attribute_context
4427 AND qla2.attribute = qpa2.product_attribute
4428 AND qla2.value_from = qpa2.product_attr_value);
4429
4430 l_netamt_flag VARCHAR2(1);
4431 l_bucketed_flag VARCHAR2(1);
4432
4433 -- [julin/5025231]
4434 l_line_ind_ind_lookup_tbl QP_PREQ_GRP.NUMBER_TYPE;
4435
4436 BEGIN
4437 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
4438 IF l_debug = FND_API.G_TRUE THEN
4439 QP_PREQ_GRP.engine_debug('begin calculate price 1');
4440
4441 QP_PREQ_GRP.engine_debug('Display related records ');
4442 END IF;
4443 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
4444 THEN
4445 --fix for bug 2515762 to print in debug the rltd info
4446 FOR cl IN l_rltd_lines_cur
4447 LOOP
4448 IF l_debug = FND_API.G_TRUE THEN
4449 QP_PREQ_GRP.engine_debug('related records with status N '
4450 ||' line_dtl_index '|| cl.line_detail_index
4451 ||' rltd_line_dtl_index '|| cl.related_line_detail_index
4452 ||' line_index '|| cl.line_index
4453 ||' rltd_line_index '|| cl.related_line_index
4454 ||' list_line_id '|| cl.list_line_id
4455 ||' rltd_list_line_id '|| cl.related_list_line_id
4456 ||' rltd_list_line_type '|| cl.related_list_line_type
4457 ||' operand '|| cl.operand
4458 ||' operator '|| cl.operand_calculation_code
4459 ||' bucket '|| cl.pricing_group_sequence
4460 ||' setval_from '|| cl.setup_value_from
4461 ||' setval_to '|| cl.setup_value_to
4462 ||' qual_value '|| cl.qualifier_value);
4463 END IF;
4464 END LOOP;
4465 END IF;
4466
4467 --reset order lvl adjustments' adj amt
4468 l_ord_dtl_index_tbl.DELETE;
4469 l_ord_adj_amt_tbl.DELETE;
4470 l_ord_qty_adj_amt_tbl.DELETE;
4471 l_ord_qty_operand_tbl.DELETE;
4472
4473 G_ldet_plsql_index_tbl.DELETE;
4474
4475 l_adj_tbl.DELETE;
4476 l_frt_tbl.DELETE;
4477 l_line_index_tbl.DELETE;
4478 l_unit_price_tbl.DELETE;
4479 l_adj_unit_price_tbl.DELETE;
4480 l_amount_changed_tbl.DELETE;
4481 l_ordered_qty_tbl.DELETE;
4482 l_line_unit_price_tbl.DELETE;
4483 l_line_priced_qty_tbl.DELETE;
4484 l_catchweight_qty_tbl.DELETE;
4485 l_actual_order_qty_tbl.DELETE;
4486 l_pricing_sts_code_tbl.DELETE;
4487 l_pricing_sts_txt_tbl.DELETE;
4488 l_process_code_tbl.DELETE;
4489 l_upd_adj_unit_price_tbl.DELETE;
4490 l_processed_flag_tbl.DELETE;
4491 l_rounding_factor_tbl.DELETE;
4492 l_ordqty_unit_price_tbl.DELETE;
4493 l_ordqty_selling_price_tbl.DELETE;
4494
4495 l_ldet_line_dtl_index_tbl.DELETE;
4496 l_ldet_price_adjust_id_tbl.delete; --bug 12731184
4497 l_ldet_line_index_tbl.DELETE;
4498 l_ldet_list_hdr_id_tbl.DELETE;
4499 l_ldet_list_line_id_tbl.DELETE;
4500 l_ldet_list_line_type_tbl.DELETE;
4501 l_ldet_operand_value_tbl.DELETE;
4502 l_ldet_adj_amt_tbl.DELETE;
4503 l_ldet_applied_flag_tbl.DELETE;
4504 l_ldet_updated_flag_tbl.DELETE;
4505 l_ldet_pricing_sts_code_tbl.DELETE;
4506 l_ldet_process_code_tbl.DELETE;
4507 l_ldet_pricing_sts_txt_tbl.DELETE;
4508 l_ldet_price_break_type_tbl.DELETE;
4509 l_ldet_line_quantity_tbl.DELETE;
4510 l_ldet_operand_calc_tbl.DELETE;
4511 l_ldet_pricing_grp_seq_tbl.DELETE;
4512 l_ldet_list_type_code_tbl.DELETE;
4513 l_ldet_limit_code_tbl.DELETE;
4514 l_ldet_limit_text_tbl.DELETE;
4515 l_ldet_list_line_no_tbl.DELETE;
4516 l_ldet_charge_type_tbl.DELETE;
4517 l_ldet_charge_subtype_tbl.DELETE;
4518 l_ldet_updated_flag_tbl.DELETE;
4519 l_ldet_automatic_flag_tbl.DELETE;
4520 l_ldet_pricing_phase_id_tbl.DELETE;
4521 l_ldet_modifier_level_tbl.DELETE;
4522 l_ldet_is_max_frt_tbl.DELETE;
4523 l_ldet_calc_code_tbl.DELETE;
4524 l_ldet_ordqty_operand_tbl.DELETE;
4525 l_ldet_ordqty_adjamt_tbl.DELETE;
4526
4527 l_back_calc_dtl_index.DELETE;
4528 l_back_calc_adj_amt.DELETE;
4529 l_back_calc_plsql_tbl_index.DELETE;
4530
4531 --l_bucket_adj_amt_tbl.delete; --2892848
4532 --l_bucket_index_adj_tbl.delete; --2892848
4533 --l_prev_bucket_index_adj_tbl.delete; --2892848
4534 l_bucket_amt_tbl.DELETE; -- 2892848 SL_latest
4535 l_prev_bucket_amt_tbl.DELETE;
4536 l_mod_lg_net_amt_tbl.DELETE; -- 2892848 SL_latest
4537 l_mod_lg_prod_net_amt_tbl.DELETE; -- -- [julin/4112395/4220399]
4538 l_ntamt_adj_unit_price.DELETE; --3126019
4539
4540 l_adj_tbl := p_adj_tbl;
4541
4542 IF l_debug = FND_API.G_TRUE THEN
4543 QP_PREQ_GRP.engine_debug('begin calculate price 2');
4544 QP_PREQ_GRP.engine_debug('SL, this direct insert path'); -- 2892848
4545
4546 END IF;
4547 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
4548 THEN
4549 IF l_debug = FND_API.G_TRUE THEN
4550 QP_PREQ_GRP.engine_debug('begin calculate price 3');
4551 END IF;
4552 FOR z IN 1..l_adj_tbl.COUNT
4553 LOOP
4554 IF l_debug = FND_API.G_TRUE THEN
4555 QP_PREQ_GRP.engine_debug('Processing Adjustments:
4556 line index '|| l_adj_tbl(z).line_ind ||' '||
4557 ' line dtl index '|| l_adj_tbl(z).line_detail_index ||
4558 ' pricing_status '|| l_adj_tbl(z).pricing_status_code ||
4559 ' ldet rec '|| l_adj_tbl(z).is_ldet_rec ||
4560 ' list line id '|| l_adj_tbl(z).created_from_list_line_id || -- 2892848
4561 ' bucket '|| l_adj_tbl(z).pricing_group_sequence ||
4562 ' adjustment id '|| l_adj_tbl(z).price_adjustment_id --bug 12731184
4563 ); --2892848
4564 END IF;
4565 --' bucket '||l_adj_tbl(z).pricing_group_sequence);
4566 END LOOP; --z l_adj_tbl
4567 END IF;
4568
4569 -- back_calculate := false;
4570 -- line_change := true;
4571 -- l_prev_line_index := fnd_api.g_miss_num;
4572 i := l_ldet_line_dtl_index_tbl.COUNT;
4573 j := l_adj_tbl.COUNT;
4574 x := l_line_index_tbl.COUNT;
4575 --l_pbh_net_adj_amount := 0; -- 2892848 no need
4576 --l_pbh_prev_net_adj_amount := 0; -- 2892848 no need
4577
4578 j := l_adj_tbl.FIRST;
4579 WHILE J IS NOT NULL
4580 LOOP
4581
4582 -- begin 2892848
4583 -- obtain net_adj_amount_flag from qp_list_lines table if null,
4584 -- since it may not be passed from calling application
4585 IF l_adj_tbl(j).net_amount_flag IS NULL THEN -- get it from setup just in case
4586 OPEN l_net_amount_flag_cur(l_adj_tbl(j).created_from_list_line_id);
4587 FETCH l_net_amount_flag_cur INTO l_adj_tbl(j).net_amount_flag;
4588 CLOSE l_net_amount_flag_cur;
4589 END IF;
4590 -- end 2892848
4591
4592 IF l_debug = FND_API.G_TRUE THEN
4593 QP_PREQ_GRP.engine_debug('Processing Line: Line Index '
4594 || l_adj_tbl(j).line_ind ||
4595 ' list price: '|| l_adj_tbl(j).unit_price ||
4596 ' l_adj_tbl(j).updated_adjusted_unit_price: '|| l_adj_tbl(j).updated_adjusted_unit_price ||
4597 ' previous l_adjusted_price: '|| l_adjusted_price || -- 2892848
4598 ' list line id: '|| l_adj_tbl(j).created_from_list_line_id ||
4599 ' bucket: '|| l_adj_tbl(j).pricing_group_sequence || -- 2892848
4600 ' net_amount_flag: '|| l_adj_tbl(j).net_amount_flag); -- 2892828
4601
4602 END IF; -- end debug
4603 l_return_adjustment := 0;
4604
4605
4606 ------------------NET AMT STUFF, SL_latest
4607 -- begin 2892848
4608 -- ldet lines are ordered by bucket, line index
4609 -- l_sub_total_price is bucketed unit price,
4610 -- l_adjusted_price is the current USP
4611 -- defaulting l_sub_total_price and l_adjusted_price
4612
4613 -- l_sub_total_price := nvl(l_adj_tbl(j).unit_price, 0); -- SL_more, do not reset, since we need USP from prev bucket sometimes
4614 IF (l_ntamt_adj_unit_price.EXISTS(l_adj_tbl(j).line_ind)) THEN
4615 IF l_debug = FND_API.G_TRUE THEN
4616 QP_PREQ_GRP.engine_debug('l_ntamt_adj_unit_price(cur_line_ind): '|| l_ntamt_adj_unit_price(l_adj_tbl(j).line_ind));
4617 END IF; -- Added For Bug No - 4033618
4618 l_adjusted_price := nvl(l_ntamt_adj_unit_price(l_adj_tbl(j).line_ind), l_adj_tbl(j).unit_price);
4619 ELSE
4620 l_adjusted_price := nvl(l_adj_tbl(j).unit_price, 0); -- SL_more
4621 END IF;
4622
4623 IF (l_adjusted_price IS NULL) THEN -- SL_more
4624 l_adjusted_price := 0; -- NULL cause nvl(l_ntamt_adj_unit_price(l_adj_tbl(j).line_ind),l_adj_tbl(j).unit_price) being null
4625 END IF; -- end debug
4626
4627 IF l_debug = FND_API.G_TRUE THEN -- SL_more
4628 QP_PREQ_GRP.engine_debug('l_adjusted_price default: '|| l_adjusted_price);
4629 END IF; -- end debug
4630
4631 IF (l_adj_tbl(j).pricing_group_sequence IS NULL OR
4632 l_adj_tbl(j).pricing_group_sequence = 0) THEN
4633 l_sub_total_price := nvl(l_adj_tbl(j).unit_price, 0);
4634 -- begin 3126019
4635 IF l_prev_line_index = l_adj_tbl(j).line_ind THEN -- will be at least 1
4636 line_change := FALSE;
4637 ELSE
4638 line_change := TRUE;
4639 l_prev_line_index := l_adj_tbl(j).line_ind;
4640 END IF;
4641 -- end 3126019
4642 --l_adjusted_price := l_sub_total_price; -- do not reset this
4643
4644 ELSE -- not null bucket modifiers or list line
4645 /*
4646 -- SL_more, we do not want this for same line same bucket case
4647 -- since we wnat l_bucket_amt_tbl(l_adj_tbl(j).line_ind) stays at end of prev bucket level
4648 -- default, in case there is no further lines to set this, SL_further fix
4649 l_bucket_amt_tbl(l_adj_tbl(j).line_ind) :=
4650 l_adjusted_price *l_adj_tbl(j).line_priced_quantity;
4651 */
4652
4653 IF l_debug = FND_API.G_TRUE THEN -- SL_more
4654 QP_PREQ_GRP.engine_debug('l_prev_line_index: '|| l_prev_line_index);
4655 END IF; -- end debug
4656
4657 -- same line
4658 IF l_prev_line_index = l_adj_tbl(j).line_ind THEN -- will be at least 1
4659 line_change := FALSE;
4660 -- same line, bucket change
4661 -- line at least from 1 to up, bucket atleast from 1 to up
4662 IF (l_prev_bucket <> l_adj_tbl(j).pricing_group_sequence) THEN -- same line, bucket change
4663 l_mod_lg_net_amt_tbl.DELETE; -- clear this table upon bucket change to keep it small
4664 l_mod_lg_prod_net_amt_tbl.DELETE; -- [julin/4112395/4220399]
4665 -- if they are the 1st bucketed modifiers
4666 -- later if is 1st bucket is linegroup net amt modifier, we use grp_amt as net_amt
4667 IF (l_prev_bucket = - 9999) THEN
4668 l_1st_bucket := 'Y';
4669 ELSE
4670 l_1st_bucket := 'N';
4671 END IF;
4672 l_prev_bucket := l_adj_tbl(j).pricing_group_sequence; -- preserve new bucket to be next prev_bucket
4673
4674 -- use USP as l_sub_total_price upon bucket change
4675 IF (l_ntamt_adj_unit_price.EXISTS(l_adj_tbl(j).line_ind)) THEN
4676 l_sub_total_price := nvl(l_ntamt_adj_unit_price(l_adj_tbl(j).line_ind), l_adj_tbl(j).unit_price);
4677 l_adjusted_price := l_sub_total_price;
4678 ELSE
4679 l_sub_total_price := nvl(l_adj_tbl(j).unit_price, 0);
4680 l_adjusted_price := l_sub_total_price;
4681 END IF;
4682
4683 -- l_bucket_amt_tbl(line_index) stores USP * ord_qty of the line upon bucket change
4684 -- we sum up amts of lines related to the net amt modifier to calculate l_lg_net_amt later
4685 l_bucket_amt_tbl(l_adj_tbl(j).line_ind) := l_adjusted_price * l_adj_tbl(j).line_priced_quantity;
4686
4687 -- [julin/4055310]
4688 l_prev_bucket_amt_tbl := l_bucket_amt_tbl;
4689
4690 IF l_debug = FND_API.G_TRUE THEN
4691 QP_PREQ_GRP.engine_debug('same line, different bucket.'
4692 ||' sub_total_price: '|| l_sub_total_price ||' adjusted_price: '|| l_adjusted_price );
4693 QP_PREQ_GRP.engine_debug('l_bucket_amt_tbl(' || l_adj_tbl(j).line_ind ||'): '
4694 || l_adjusted_price || '*' ||
4695 l_adj_tbl(j).line_priced_quantity || '=' || l_bucket_amt_tbl(l_adj_tbl(j).line_ind));
4696 END IF; -- end debug
4697
4698 ELSE -- SL_more, same line same bucket, ELSE IF (l_prev_bucket <> l_adj_tbl(j).pricing_group_sequence)
4699 IF l_debug = FND_API.G_TRUE THEN
4700 QP_PREQ_GRP.engine_debug('same line, same bucket.'
4701 ||' sub_total_price: '|| l_sub_total_price ||' adjusted_price: '|| l_adjusted_price );
4702 END IF; -- end debug
4703 END IF; -- END IF (l_prev_bucket <> l_adj_tbl(j).pricing_group_sequence)
4704
4705 ELSE -- line change (from -9999 to up, or from at least 1 to up)
4706
4707 line_change := TRUE;
4708 -- line change , bucket change
4709 -- bucket from -9999 to up,or from at least 1 to up
4710 IF l_prev_bucket <> l_adj_tbl(j).pricing_group_sequence THEN -- line change , bucket change
4711 -- l_mod_lg_net_amt_tbl(list_line_id) sotres l_lg_net_amt of the net amt modifier
4712 -- so no need to re-calculate l_lg_net_amt if same modifier is related to other line(s) in the same bucket
4713 -- clear this table upon bucket change to keep it small
4714 l_mod_lg_net_amt_tbl.DELETE;
4715 l_mod_lg_prod_net_amt_tbl.DELETE; -- [julin/4112395/4220399]
4716
4717 -- preserve l_prev_bucket
4718 -- if they are the 1st bucketed modifiers
4719 -- later if is 1st bucket is linegroup net amt modifier, we use grp_amt as net_amt
4720 IF (l_prev_bucket = - 9999) THEN
4721 l_1st_bucket := 'Y';
4722 ELSE
4723 l_1st_bucket := 'N';
4724 END IF;
4725 l_prev_bucket := l_adj_tbl(j).pricing_group_sequence; -- preserve new bucket to be next prev_bucket
4726
4727 -- use USP as l_sub_total_price upon bucket change
4728 IF (l_ntamt_adj_unit_price.EXISTS(l_adj_tbl(j).line_ind)) THEN
4729 l_sub_total_price := nvl(l_ntamt_adj_unit_price(l_adj_tbl(j).line_ind), l_adj_tbl(j).unit_price);
4730 l_adjusted_price := l_sub_total_price;
4731 ELSE
4732 l_sub_total_price := nvl(l_adj_tbl(j).unit_price, 0);
4733 l_adjusted_price := l_sub_total_price;
4734 END IF;
4735 IF l_debug = FND_API.G_TRUE THEN
4736 QP_PREQ_GRP.engine_debug('different line, different bucket. '
4737 ||' sub_total_price: '|| l_sub_total_price ||' adjusted_price: '|| l_adjusted_price );
4738 END IF; -- end debug
4739
4740 IF l_prev_line_index = - 9999 THEN -- 1st line as no USP in l_adj_unit_price_tbl
4741 l_bucket_amt_tbl(l_adj_tbl(j).line_ind) := nvl(l_adj_tbl(j).unit_price, 0) * l_adj_tbl(j).line_priced_quantity;
4742 IF l_debug = FND_API.G_TRUE THEN
4743 QP_PREQ_GRP.engine_debug('prev_line_index is -9999');
4744 QP_PREQ_GRP.engine_debug('l_bucket_amt_tbl(' || l_adj_tbl(j).line_ind ||'): '
4745 || nvl(l_adj_tbl(j).unit_price, 0) || '*' ||
4746 l_adj_tbl(j).line_priced_quantity || '=' || l_bucket_amt_tbl(l_adj_tbl(j).line_ind));
4747 END IF; -- end debug
4748
4749 -- bucket change, line change and not the 1st line
4750 ELSE -- l_prev_line_index <> -9999
4751
4752 IF l_debug = FND_API.G_TRUE THEN
4753 QP_PREQ_GRP.engine_debug('bucket change, line change and not the 1st line, sub_total_price: '|| l_sub_total_price ||' adjusted_price: '|| l_adjusted_price );
4754 END IF; -- END DEBUG
4755 IF (l_ntamt_adj_unit_price.EXISTS(l_prev_line_index)) THEN
4756 -- moment to capture current USP for prev line_index,
4757 -- so we have correct amts in l_bucket_amt_tbl when using it
4758 l_bucket_amt_tbl(l_prev_line_index) := nvl(l_ntamt_adj_unit_price(l_prev_line_index), l_adj_tbl(j).unit_price) * l_prev_qty;
4759
4760 IF l_debug = FND_API.G_TRUE THEN
4761 QP_PREQ_GRP.engine_debug('capture bucket amt of prev_line_index l_bucket_amt_tbl('|| l_prev_line_index ||'): '
4762 || nvl(l_ntamt_adj_unit_price(l_prev_line_index), l_adj_tbl(j).unit_price) || '*' ||
4763 l_prev_qty || '=' || l_bucket_amt_tbl(l_prev_line_index));
4764 END IF; -- end debug
4765
4766 ELSE -- ELSE IF (l_ntamt_adj_unit_price.EXISTS(l_prev_line_index))
4767 l_bucket_amt_tbl(l_prev_line_index) := nvl(l_adj_tbl(j).unit_price, 0) * l_prev_qty;
4768 IF l_debug = FND_API.G_TRUE THEN
4769
4770 QP_PREQ_GRP.engine_debug('l_bucket_amt_tbl(' || l_prev_line_index ||'): '
4771 || nvl(l_adj_tbl(j).unit_price, 0) || '*' ||
4772 l_prev_qty || '=' || l_bucket_amt_tbl(l_prev_line_index));
4773 END IF; -- end debug
4774 END IF; -- END (l_ntamt_adj_unit_price.EXISTS(l_prev_line_index))
4775 -- [julin/4055310]
4776 l_prev_bucket_amt_tbl := l_bucket_amt_tbl;
4777
4778 END IF; -- END l_prev_line_index=-9999
4779
4780 ELSE -- line change same bucket (bucket is at least from 1 to up, line is at least from 1 to up)
4781 IF (l_ntamt_adj_unit_price.EXISTS(l_adj_tbl(j).line_ind)) THEN
4782 l_sub_total_price := nvl(l_ntamt_adj_unit_price(l_adj_tbl(j).line_ind), l_adj_tbl(j).unit_price);
4783 l_adjusted_price := l_sub_total_price;
4784
4785 ELSE
4786 l_sub_total_price := nvl(l_adj_tbl(j).unit_price, 0);
4787 l_adjusted_price := l_sub_total_price;
4788
4789 END IF;
4790
4791 IF l_debug = FND_API.G_TRUE THEN
4792 QP_PREQ_GRP.engine_debug('different line, same bucket');
4793 QP_PREQ_GRP.engine_debug('sub_total_price: '|| l_sub_total_price ||' adjusted_price: '|| l_adjusted_price );
4794 END IF; -- end debug
4795
4796 -- moment to capture current USP for prev line_index,
4797 -- so we have correct amts in l_bucket_amt_tbl when using it
4798 IF l_ntamt_adj_unit_price.EXISTS(l_prev_line_index) THEN
4799 l_bucket_amt_tbl(l_prev_line_index) := nvl(l_ntamt_adj_unit_price(l_prev_line_index), 0) * l_prev_qty;
4800 IF l_debug = FND_API.G_TRUE THEN
4801 QP_PREQ_GRP.engine_debug('capture bucket_amt of prev line l_bucket_amt_tbl('|| l_prev_line_index ||'): '
4802 || nvl(l_ntamt_adj_unit_price(l_prev_line_index), 0) || '*' ||
4803 l_prev_qty || '=' || l_bucket_amt_tbl(l_prev_line_index));
4804 END IF; -- end debug
4805 /*
4806 ELSE
4807 l_bucket_amt_tbl(l_prev_line_index) := 0;
4808 */
4809 END IF; -- end if
4810
4811 -- SL_more, default, 1st bucket for this line has no prev buckets no prev adjs
4812 IF l_1st_bucket = 'Y' THEN -- 1st bucket for this line, bucket at lease 1 up
4813 l_bucket_amt_tbl(l_adj_tbl(j).line_ind) := nvl(l_adj_tbl(j).unit_price, 0) * l_adj_tbl(j).line_priced_quantity; -- for line level net amt we need this
4814 IF l_debug = FND_API.G_TRUE THEN
4815 QP_PREQ_GRP.engine_debug('1st bucket for this line l_bucket_amt_tbl('|| l_adj_tbl(j).line_ind ||'): '
4816 || nvl(l_adj_tbl(j).unit_price, 0) || '*' ||
4817 l_adj_tbl(j).line_priced_quantity || '=' || l_bucket_amt_tbl(l_adj_tbl(j).line_ind));
4818 END IF; -- end debug
4819 END IF; -- END IF l_1st_bucket ='Y'
4820
4821 END IF; -- end bucket change in the line change block
4822
4823 l_prev_line_index := l_adj_tbl(j).line_ind; -- preserve the new lind_ind to be l_prev_line_index
4824 l_prev_qty := l_adj_tbl(j).line_priced_quantity;
4825 END IF; --l_prev_line_index = line_index
4826 END IF; -- end if bucket is null or 0
4827
4828 IF l_debug = FND_API.G_TRUE THEN
4829
4830 QP_PREQ_GRP.engine_debug('after NET_AMT_STUFF block...');
4831 QP_PREQ_GRP.engine_debug('l_sub_total_price: '|| l_sub_total_price);
4832 QP_PREQ_GRP.engine_debug('l_adjusted_price: '|| l_adjusted_price);
4833
4834 END IF; -- Added For 4033618
4835 --SL_more
4836 IF l_sub_total_price IS NULL THEN -- default just in case
4837 l_sub_total_price := nvl(l_adj_tbl(j).unit_price, 0);
4838 END IF;
4839 -- end 2892848, SL_latest NET_AMT STUFF
4840
4841 /* 2892848 SL_latest
4842 -- begin 2892848
4843 -- ldet lines are ordered by bucket, line index
4844 -- when line_index changes, it means it is the point where bucket changes for that line index
4845 -- l_sub_total_price is bucketed unit price, l_adjusted_price is the current USP (diff data for diff line_index)
4846 ---Bucket calculations
4847 IF l_prev_line_index = l_adj_tbl(j).line_ind
4848 THEN
4849 IF l_debug = FND_API.G_TRUE THEN
4850 QP_PREQ_GRP.engine_debug('no line change'
4851 ||' prev_line_index '||l_prev_line_index
4852 ||' prev_bucket '||l_prev_bucket);
4853 END IF;
4854 line_change := false;
4855
4856
4857 IF l_debug = FND_API.G_TRUE THEN
4858 QP_PREQ_GRP.engine_debug('same line.');
4859 --||' sub_total_price '||l_sub_total_price ||' adjusted_price '||l_adjusted_price );
4860 END IF;
4861 ELSE
4862 line_change := true;
4863 l_prev_line_index := l_adj_tbl(j).line_ind; -- preserve the new lind_ind to be l_prev_line_index
4864
4865 IF l_adj_unit_price_tbl.EXISTS(l_adj_tbl(j).line_ind) THEN -- do so 'cos first line of that each line_ind will have no data
4866
4867 -- reset to last USP of prev bucket when bucket and line_ind changes
4868 IF l_adj_tbl(j).pricing_group_sequence is NULL THEN
4869 l_sub_total_price := l_adj_tbl(j).unit_price; -- use original unit price if null bucket
4870 ELSE
4871 l_sub_total_price :=l_adj_unit_price_tbl(l_adj_tbl(j).line_ind);
4872 END IF;
4873 l_adjusted_price :=l_adj_unit_price_tbl(l_adj_tbl(j).line_ind);
4874
4875 ELSE -- 1st line of each line index has no data in l_adj_unit_price_tbl, use original unit_price
4876
4877 l_sub_total_price := l_adj_tbl(j).unit_price;
4878 l_adjusted_price := l_adj_tbl(j).unit_price;
4879
4880 END IF; -- end index exists
4881
4882 IF l_debug = FND_API.G_TRUE THEN
4883 QP_PREQ_GRP.engine_debug('line change '
4884 ||' sub_total_price '||l_sub_total_price ||' adjusted_price '||l_adjusted_price );
4885 END IF;
4886
4887 END IF; --l_prev_line_index = line_index
4888 -- end 2892848
4889
4890 -- begin 2892848
4891 -- MOVE TO HERE
4892 IF l_adj_tbl(J).pricing_group_sequence <> 0 AND l_adj_tbl(J).pricing_group_sequence IS NOT NULL THEN -- bucket 0 is line event list price
4893 -- detect bucket change, need to CAPTURE unit_adjs (LINE) and adj_amts(LINEGROUP) up to the prev bucket
4894 IF l_prev_bucket <> l_adj_tbl(j).pricing_group_sequence THEN
4895 IF l_debug = FND_API.G_TRUE THEN
4896 QP_PREQ_GRP.engine_debug ('------BUCKET CHANGE----, place to debug adj_amts or unit_adjs up to prev bucket.');
4897 END IF; -- END debug
4898
4899 -- for LINE GROUP
4900 -- need capture the l_prev_lg_adj_amt
4901 -- l_bucket_adj_amt_tbl(bucket) stores adj_amts of all lines for each bucket
4902 -- prev_lg_adj_amt is the sum of adj_amts for all lines up to prev buckets
4903
4904 IF l_bucket_adj_amt_tbl.EXISTS(l_prev_bucket) THEN
4905 l_prev_lg_adj_amt := nvl(l_prev_lg_adj_amt,0) + l_bucket_adj_amt_tbl(l_prev_bucket);
4906 IF l_debug = FND_API.G_TRUE THEN
4907 QP_PREQ_GRP.engine_debug ('debug LINEGROUP adj amts up to prev bucket - '||l_prev_bucket ||': '||l_prev_lg_adj_amt);
4908 END IF; -- END debug
4909
4910 END IF; -- END IF l_bucket_adj_amt_tbl.EXISTS(l_prev_bucket)
4911
4912 -- bucket change for LINE LEVEL
4913 -- l_bucket_index_adj_tbl(line_index) stores sum of unit_adjs for each line_index
4914 -- l_prev_bucket_index_adj_tbl(line_index) is the sum of unit_adjs for that line_index up to prev bucket
4915
4916 IF l_bucket_index_adj_tbl.EXISTS(l_adj_tbl(j).line_ind) THEN
4917 IF l_prev_bucket_index_adj_tbl.EXISTS(l_adj_tbl(j).line_ind) THEN
4918 l_prev_bucket_index_adj_tbl(l_adj_tbl(j).line_ind):= nvl(l_prev_bucket_index_adj_tbl(l_adj_tbl(j).line_ind),0)
4919 + l_bucket_index_adj_tbl(l_adj_tbl(j).line_ind);
4920 ELSE
4921 l_prev_bucket_index_adj_tbl(l_adj_tbl(j).line_ind):= l_bucket_index_adj_tbl(l_adj_tbl(j).line_ind);
4922 END IF; -- END IF l_bucket_index_adj_tbl.EXISTS(l_adj_tbl(j).line_ind)
4923
4924 IF l_debug = FND_API.G_TRUE THEN
4925 QP_PREQ_GRP.engine_debug ('debug LINE unit adjs up to prev bucket for line index'||l_adj_tbl(j).line_ind ||': '||l_prev_bucket_index_adj_tbl(l_adj_tbl(j).line_ind) );
4926 END IF; -- END debug
4927 END IF; -- END IF l_bucket_index_adj_tbl.EXISTS
4928
4929 -- begin shu fix bug for special case, bucket change within same line index
4930 IF line_change = false THEN
4931 l_sub_total_price :=l_adj_unit_price_tbl(l_adj_tbl(j).line_ind);
4932
4933 IF l_debug = FND_API.G_TRUE THEN
4934 QP_PREQ_GRP.engine_debug('bucket change within same line'
4935 ||' sub_total_price '||l_sub_total_price ||' adjusted_price '||l_adjusted_price );
4936 END IF;
4937 END IF; -- END IF line_change = flase
4938 -- end shu fix bug
4939
4940 l_prev_bucket := l_adj_tbl(j).pricing_group_sequence; -- preserve new bucket to be next prev_bucket
4941
4942 ELSE -- bucket did not change but line changes within bucket, we also need to capture line level unit adjs of prev bucket
4943 IF line_change = true THEN
4944 IF l_bucket_index_adj_tbl.EXISTS(l_adj_tbl(j).line_ind) THEN
4945 IF l_prev_bucket_index_adj_tbl.EXISTS(l_adj_tbl(j).line_ind) THEN
4946 l_prev_bucket_index_adj_tbl(l_adj_tbl(j).line_ind):= nvl(l_prev_bucket_index_adj_tbl(l_adj_tbl(j).line_ind),0)
4947 + l_bucket_index_adj_tbl(l_adj_tbl(j).line_ind);
4948 ELSE
4949 l_prev_bucket_index_adj_tbl(l_adj_tbl(j).line_ind):= l_bucket_index_adj_tbl(l_adj_tbl(j).line_ind);
4950 END IF; -- END IF l_bucket_index_adj_tbl.EXISTS(l_adj_tbl(j).line_ind)
4951
4952 IF l_debug = FND_API.G_TRUE THEN
4953 QP_PREQ_GRP.engine_debug ('line change, debug LINE unit adjs up to prev bucket for line index'||l_adj_tbl(j).line_ind ||': '||l_prev_bucket_index_adj_tbl(l_adj_tbl(j).line_ind) );
4954 END IF; -- END debug
4955 END IF; -- END IF l_bucket_index_adj_tbl.EXISTS
4956 END IF; -- END IF line_change true
4957
4958 END IF; -- end if l_prev_bucket <> l_adj_tbl(j).pricing_group_sequence
4959
4960 ELSE -- bucket is 0 or null -- begin shu fix bug
4961 l_sub_total_price := nvl(l_adj_tbl(j).unit_price, 0);
4962 l_adjusted_price :=nvl (l_adj_unit_price_tbl(l_adj_tbl(j).line_ind),0);
4963 IF l_debug = FND_API.G_TRUE THEN
4964 QP_PREQ_GRP.engine_debug('bucket is 0 or null'
4965 ||' sub_total_price '||l_sub_total_price ||' adjusted_price '||l_adjusted_price );
4966 END IF;
4967 -- end shu fix bug
4968
4969 END IF; -- END IF l_adj_tbl(J).pricing_group_sequence <> 0 AND ...
4970 -- end 2892848
4971 out SL_latest*/
4972
4973 --This fix is for bug 1915355
4974 --To calculate lumpsum use group_qty/amt for linegrp
4975 --This is only for engine inserted records
4976 --for user passed adjustments, we will use only line_qty
4977 --to break the link from other lines that have this line
4978 --group adjustment
4979 l_calc_quantity := 0;
4980 --bug 4900095
4981 IF (QP_PREQ_GRP.G_service_line_qty_tbl.exists(l_adj_tbl(j).line_ind)
4982 or QP_PREQ_GRP.G_service_ldet_qty_tbl.exists(l_adj_tbl(j).line_detail_index))
4983 and l_adj_tbl(j).operand_calculation_code = G_LUMPSUM_DISCOUNT THEN
4984 --only for service items
4985 --when uom_quantity is passed as null,
4986 -- and contract_start/end_dates are passed
4987 --and for a line/linegroup lumpsum DIS/PBH/SUR/FREIGHT
4988 IF l_adj_tbl(j).modifier_level_code = G_LINE_GROUP THEN
4989 IF G_Service_pbh_lg_amt_qty.exists(l_adj_tbl(j).line_detail_index)
4990 and QP_PREQ_GRP.G_service_ldet_qty_tbl.exists(l_adj_tbl(j).line_detail_index) THEN
4991 l_calc_quantity := nvl(G_Service_pbh_lg_amt_qty(l_adj_tbl(j).line_detail_index),
4992 QP_PREQ_GRP.G_service_ldet_qty_tbl(l_adj_tbl(j).line_detail_index));
4993 ELSIF G_Service_pbh_lg_amt_qty.exists(l_adj_tbl(j).line_detail_index) THEN
4994 l_calc_quantity := G_Service_pbh_lg_amt_qty(l_adj_tbl(j).line_detail_index);
4995 ELSIF QP_PREQ_GRP.G_service_ldet_qty_tbl.exists(l_adj_tbl(j).line_detail_index) THEN
4996 l_calc_quantity := QP_PREQ_GRP.G_service_ldet_qty_tbl(l_adj_tbl(j).line_detail_index);
4997 ELSIF QP_PREQ_GRP.G_service_line_qty_tbl.exists(l_adj_tbl(j).line_ind) THEN
4998 l_calc_quantity := QP_PREQ_GRP.G_service_line_qty_tbl(l_adj_tbl(j).line_ind);
4999 ELSE
5000 l_calc_quantity :=
5001 nvl(nvl(l_adj_tbl(j).group_quantity
5002 , l_adj_tbl(j).group_amount) -- this is group_amount_per_unit
5003 , nvl(l_adj_tbl(j).priced_quantity
5004 , l_adj_tbl(j).line_priced_quantity));
5005 END IF;--G_Service_pbh_lg_amt_qty.exists
5006 ELSIF l_adj_tbl(j).modifier_level_code = G_LINE_LEVEL THEN
5007 IF QP_PREQ_GRP.G_service_line_qty_tbl.exists(l_adj_tbl(j).line_ind) THEN
5008 l_calc_quantity := QP_PREQ_GRP.G_service_line_qty_tbl(l_adj_tbl(j).line_ind);
5009 ELSE
5010 l_calc_quantity := nvl(l_adj_tbl(j).line_priced_quantity
5011 , l_adj_tbl(j).priced_quantity) ; -- request line qty, shu fix recurring 2702384
5012 END IF;--QP_PREQ_GRP.G_service_line_qty_tbl.exists
5013 END IF;--l_adj_tbl(j).modifier_level_code
5014 ELSE
5015 IF l_adj_tbl(j).modifier_level_code = G_LINE_GROUP
5016 -- and nvl(l_adj_tbl(j).is_ldet_rec,G_YES) = G_YES
5017 THEN
5018 l_calc_quantity :=
5019 nvl(nvl(l_adj_tbl(j).group_quantity
5020 , l_adj_tbl(j).group_amount) -- this is group_amount_per_unit
5021 , nvl(l_adj_tbl(j).priced_quantity
5022 , l_adj_tbl(j).line_priced_quantity));
5023 ELSE
5024 l_calc_quantity := nvl(l_adj_tbl(j).line_priced_quantity
5025 , l_adj_tbl(j).priced_quantity) ; -- request line qty, shu fix recurring 2702384
5026 END IF;
5027 END IF;--QP_PREQ_GRP.G_service_line_qty_tbl.exists(
5028
5029 l_calc_quantity := nvl(l_calc_quantity, 1);
5030
5031 -- SHU
5032 -- priced_quantity is 4000, group_amount i.e. 20*100 + 10* 200
5033 -- group_amount is 40, group_amount_per_unit
5034 -- line_priced_quantity is 20, order qty for line 1
5035
5036 IF l_debug = FND_API.G_TRUE THEN -- SHU
5037 QP_PREQ_GRP.engine_debug(
5038 'figuring out qty level '|| l_adj_tbl(j).modifier_level_code
5039 ||' priced_quantity '|| l_adj_tbl(j).priced_quantity -- from ldets.line_quantity
5040 ||' group_quantity '|| l_adj_tbl(j).group_quantity
5041 ||' group_amount '|| l_adj_tbl(j).group_amount
5042 ||' line_priced_quantity '|| l_adj_tbl(j).line_priced_quantity -- order_qty
5043 ||' calc '|| l_calc_quantity);
5044 END IF;
5045 --end fix for bug 1915355
5046 IF l_adj_tbl(j).created_from_list_line_type = G_PRICE_BREAK_TYPE
5047 AND l_adj_tbl(j).pricing_status_code
5048 IN (G_STATUS_NEW, G_STATUS_UPDATED, G_STATUS_UNCHANGED)
5049 THEN
5050 IF l_debug = FND_API.G_TRUE THEN
5051 QP_PREQ_GRP.engine_debug('Processing Price Break. call Price_Break_Calculation');
5052
5053 END IF;
5054
5055 --changes for PBH line group LUMPSUM bug 2388011 commented out
5056 --call to old signature of Price_Break_Calculation
5057 /*
5058 --fix for bug 2515762 to pass line_dtl_index instead of list_line_id
5059 QP_Calculate_Price_PUB.Price_Break_Calculation(
5060 l_adj_tbl(j).line_detail_index
5061 ,l_adj_tbl(j).price_break_type_code
5062 ,l_adj_tbl(j).line_ind
5063 ,nvl(l_calc_quantity,1)
5064 ,l_sub_total_price
5065 ,l_return_adjustment
5066 ,l_return_status
5067 ,l_return_status_text);
5068 */
5069 --changes for PBH line group LUMPSUM bug 2388011 commented out
5070 --call to old signature of Price_Break_Calculation
5071 --changes for PBH line group LUMPSUM bug 2388011 calling new
5072 --overloaded procedure Price_Break_Calculation
5073 --for bug 2908174 for copied orders breaks from
5074 --oe_price_adj must not be re-evaluated for price_flag 'P'
5075 IF l_adj_tbl(j).price_flag = G_PHASE
5076 AND l_adj_tbl(j).is_ldet_rec IN
5077 (G_ADJ_LINE_TYPE, G_ADJ_ORDER_TYPE) THEN
5078 l_return_adjustment := nvl(l_adj_tbl(j).adjustment_amount, 0);
5079 ELSE --l_adj_tbl(j).price_flag
5080 -- [nirmkuma/4222552] since passed line group manual discounts are
5081 -- treated only as line level, using following line level path, which
5082 -- looks at updated line_priced_quantity.
5083 IF (l_adj_tbl(j).modifier_level_code IN (G_LINE_LEVEL, G_ORDER_LEVEL)
5084 or (l_adj_tbl(j).modifier_level_code = G_LINE_GROUP and l_adj_tbl(j).automatic_flag = G_NO)) THEN
5085 IF G_pbhvolattr_attribute.EXISTS(l_adj_tbl(j).created_from_list_line_id) THEN
5086 IF G_pbhvolattr_attribute(l_adj_tbl(j).created_from_list_line_id)
5087 = G_QUANTITY_ATTRIBUTE THEN
5088 l_total_value := 0;
5089 l_req_value_per_unit := l_adj_tbl(j).line_priced_quantity;
5090 ELSE --same for item amount or others(treat as item_amt)
5091 -- bug 4086952 BREAKS ARE NOT ADJUSTING ON CHANGING THE ORDERED QTY WITH ITM AMOUNT
5092 IF G_pbhvolattr_attribute(l_adj_tbl(j).created_from_list_line_id) = G_LINE_AMT_ATTRIBUTE THEN
5093 l_total_value := l_adj_tbl(j).unit_price * l_adj_tbl(j).line_priced_quantity;
5094 l_req_value_per_unit := l_adj_tbl(j).line_priced_quantity;
5095 l_qualifier_value := l_adj_tbl(j).unit_price * l_adj_tbl(j).line_priced_quantity;
5096 ELSE --others volume attribute
5097 l_total_value := l_adj_tbl(j).priced_quantity; --4000
5098 l_req_value_per_unit := l_adj_tbl(j).line_priced_quantity; --20
5099 l_qualifier_value := l_adj_tbl(j).priced_quantity; --2892848 SL_latest move to here as default
5100 END IF;
5101 IF l_debug = FND_API.G_TRUE THEN
5102 QP_PREQ_GRP.engine_debug('l_qualifier_value default: '|| l_adj_tbl(j).priced_quantity);
5103 QP_PREQ_GRP.engine_debug('l_qualifier_value : '|| l_qualifier_value);
5104 END IF; -- end debug
5105 -- begin 2892848
5106 -- net_amount line level (not group of line) modifier
5107 IF l_adj_tbl(j).net_amount_flag IN (G_YES, 'P') THEN
5108 IF l_debug = FND_API.G_TRUE THEN
5109 QP_PREQ_GRP.engine_debug('net amount line level modifier: '|| l_adj_tbl(J).created_from_list_line_id);
5110 END IF; -- end debug
5111
5112 /* SL_latest 2892848
5113 IF l_prev_bucket_index_adj_tbl.EXISTS(l_adj_tbl(j).line_ind) THEN
5114 -- priced_quantity is line amount, line_priced_quantity is order qty
5115 l_qualifier_value:= l_adj_tbl(j).priced_quantity + nvl(l_prev_bucket_index_adj_tbl(l_adj_tbl(j).line_ind),0)* l_adj_tbl(j).line_priced_quantity;
5116 IF l_debug = FND_API.G_TRUE THEN
5117 QP_PREQ_GRP.engine_debug('line amount: '||l_adj_tbl(j).priced_quantity);
5118 QP_PREQ_GRP.engine_debug('order qty : '||l_adj_tbl(j).line_priced_quantity);
5119 QP_PREQ_GRP.engine_debug('unit adjs up to prev buckets: '|| nvl(l_prev_bucket_index_adj_tbl(l_adj_tbl(j).line_ind),0) );
5120 END IF; -- end debug
5121 ELSE
5122 l_qualifier_value:= l_adj_tbl(j).priced_quantity;
5123 END IF; -- END IF l_prev_bucket_index_adj_tbl.EXISTS(l_adj_tbl(j))
5124
5125 IF l_debug = FND_API.G_TRUE THEN
5126 QP_PREQ_GRP.engine_debug('line level net amount: '||l_qualifier_value);
5127 END IF; -- end debug
5128 ELSE -- not net_amount modifier
5129 l_qualifier_value := l_adj_tbl(j).priced_quantity; --2892848
5130
5131 IF l_debug = FND_API.G_TRUE THEN
5132 QP_PREQ_GRP.engine_debug('not net amount pbh qualifier value: '||l_qualifier_value);
5133 END IF; -- end debug
5134 */
5135 IF l_bucket_amt_tbl.EXISTS(l_adj_tbl(j).line_ind)THEN
5136 l_qualifier_value := l_bucket_amt_tbl(l_adj_tbl(j).line_ind);
5137 IF l_debug = FND_API.G_TRUE THEN
5138 QP_PREQ_GRP.engine_debug('line level net amount: '|| l_qualifier_value);
5139 END IF; -- end debug
5140 END IF; -- END IF l_bucket_amt_tbl.EXISTs
5141 END IF; -- END IF net_amount modifier
5142 -- end 2892848
5143
5144 END IF; --G_pbhvolattr_attribute
5145
5146 IF l_debug = FND_API.G_TRUE THEN
5147 QP_PREQ_GRP.engine_debug('PBH calc dtls attribute '
5148 || G_pbhvolattr_attribute(l_adj_tbl(j).created_from_list_line_id)
5149 ||' l_total_value '|| l_total_value ||' l_req_value_per_unit '
5150 || l_req_value_per_unit);
5151 END IF; --l_debug
5152 ELSE --no attribute
5153 --this is a setup bug where no attribute for PBH
5154 l_total_value := NULL;
5155 l_req_value_per_unit := NULL;
5156 END IF; --G_pbhvolattr_attribute.exists
5157
5158 ELSE --linegroup level
5159 IF G_pbhvolattr_attribute.EXISTS(l_adj_tbl(j).created_from_list_line_id) THEN
5160 IF G_pbhvolattr_attribute(l_adj_tbl(j).created_from_list_line_id)
5161 = G_QUANTITY_ATTRIBUTE THEN
5162 l_total_value := 0;
5163 l_req_value_per_unit := l_adj_tbl(j).group_quantity;
5164 ELSE --same for item amount or others(treat as item_amt)
5165 l_total_value := l_adj_tbl(j).priced_quantity; --4000
5166 IF l_adj_tbl(j).is_ldet_rec IN (G_LDET_ORDER_TYPE,
5167 G_LDET_LINE_TYPE) THEN
5168 l_req_value_per_unit := l_adj_tbl(j).group_amount; --40
5169 ELSE
5170 --for linegrp itemamt lumpsum, the adj_amt =
5171 --operand/group_amount. When calculation is done after
5172 --search, engine calculates group_amount as ldet.line_qty/
5173 --unit_price. But when calling application passes or we
5174 --fetch adj from OM, group_amt is range_break_qty which
5175 --is the line_qty returned by the pricing engine and the
5176 --the group_amt passed back by engine is not stored by OM
5177 --so we need to do this for adj not searched by engine
5178 -- [julin/4571612/4671446] explicitly set FND_API.G_NULL_NUM means infinity
5179 IF (l_adj_tbl(j).unit_price = 0) THEN
5180 l_req_value_per_unit := FND_API.G_NULL_NUM;
5181 ELSE
5182 l_req_value_per_unit := l_adj_tbl(j).group_amount / l_adj_tbl(j).unit_price;
5183 END IF;
5184 END IF;
5185
5186 -- begin 2892848
5187 -- IF net amount linegroup modifier
5188 IF l_adj_tbl(j).net_amount_flag IN (G_YES, 'P') THEN
5189
5190 IF l_debug = FND_API.G_TRUE THEN
5191 QP_PREQ_GRP.engine_debug('net amount linegroup modifier list_line_id: '|| l_adj_tbl(J).created_from_list_line_id);
5192 END IF; -- end debug
5193
5194 -- begin SL_latest 2892848
5195 l_lg_net_amt := 0; --SL_latest
5196 l_line_bucket_amt := 0; -- note 0+null is null, so we need to default this to 0
5197 -- [julin/4112395/4220399]
5198 l_lg_prod_net_amt := 0;
5199 l_prod_line_bucket_amt := 0;
5200
5201 -- fix of latest requirement, only add up net amounts within the group
5202 -- l_mod_lg_net_amt_tbl is hastable of modifier and its lg_net_amt for that bucket
5203 -- so we do not need to re-calculate l_lg_net_amt if the same modifier is related to other line index within the same bucket
5204 -- lg_net_amt is the sum of (USP at end of prev bucket *Qty) for the lines related to this modifier
5205 -- l_net_mod_index_cur has line_indexes from ldets tmp related to this net amount modifier
5206
5207 -- SL_further_fix
5208 -- if there are no prev buckets for this modifier,we use group amount as l_lg_net_amt
5209 -- since we do not have the adjs of other lines yet, so l_bucket_amt_tbl does not have complete data
5210
5211 -- [julin/3265308] net amount calculation 'P', match product only.
5212 -- For category net amount, 1st_bucket means that this is the
5213 -- first bucket of the line, so no adjustments have been ap-
5214 -- plied. However, other lines of the same category might
5215 -- have had modifiers in previous buckets applied, so we look
5216 -- at the bucket_amt_tbl to see if those have been calculated
5217 -- else we can assume no modifiers applied yet, and can hence
5218 -- calculate the list price * qty for those lines.
5219 IF nvl(l_adj_tbl(j).net_amount_flag, 'N') = 'P' THEN
5220 IF l_mod_lg_prod_net_amt_tbl.EXISTS(l_adj_tbl(j).created_from_list_line_id) THEN
5221 l_lg_prod_net_amt := l_mod_lg_prod_net_amt_tbl(l_adj_tbl(j).created_from_list_line_id);
5222 IF l_debug = FND_API.G_TRUE THEN
5223 QP_PREQ_GRP.engine_debug('recycle l_lg_prod_net_amt from l_mod_lg_net_amt_tbl: '|| l_lg_prod_net_amt);
5224 END IF; --end debug
5225 ELSE -- need to calculate l_lg_net_amt
5226 IF l_debug = FND_API.G_TRUE THEN
5227 QP_PREQ_GRP.engine_debug('1st bucket = '|| l_1st_bucket ||', net amount flag = P');
5228 END IF;
5229 -- calculate amount using product attribute net amount grouping
5230 FOR t IN l_prod_attr_info(l_adj_tbl(j).created_from_list_line_id) LOOP
5231 IF l_prev_bucket_amt_tbl.EXISTS(t.line_index) THEN
5232 l_prod_line_bucket_amt := nvl(l_prev_bucket_amt_tbl(t.line_index), 0);
5233 IF l_debug = FND_API.G_TRUE THEN
5234 QP_PREQ_GRP.engine_debug(t.line_index || ':' || l_prev_bucket_amt_tbl(t.line_index));
5235 END IF; --end debug
5236 ELSE
5237 -- have to compute list price * qty for the line (query from qp_npreq_lines_tmp)
5238 l_prod_line_bucket_amt := nvl(t.priced_quantity, 0) * nvl(t.unit_price, 0);
5239 IF l_debug = FND_API.G_TRUE THEN
5240 QP_PREQ_GRP.engine_debug('* line index '|| t.line_index ||' not in l_prev_bucket_amt_tbl');
5241 QP_PREQ_GRP.engine_debug(' got value '|| l_prod_line_bucket_amt ||' from lines_tmp instead');
5242 END IF;
5243 END IF;
5244 l_lg_prod_net_amt := l_lg_prod_net_amt + l_prod_line_bucket_amt;
5245
5246 IF l_debug = FND_API.G_TRUE THEN
5247 QP_PREQ_GRP.engine_debug('(catnetamt) l_prod_line_bucket_amt: ' || l_prod_line_bucket_amt);
5248 QP_PREQ_GRP.engine_debug('(catnetamt) up-tp-date l_lg_prod_net_amt: ' || l_lg_prod_net_amt); -- grp amt
5249 END IF;
5250 END LOOP;
5251
5252 l_mod_lg_prod_net_amt_tbl(l_adj_tbl(j).created_from_list_line_id) := l_lg_prod_net_amt; -- preserve this for recycle
5253 END IF;
5254 END IF; -- end l_adj_tbl(j).net_amount_flag = 'P' -- [julin/3265308]
5255
5256 IF (l_1st_bucket = 'Y') THEN
5257
5258 IF l_debug = FND_API.G_TRUE THEN
5259 QP_PREQ_GRP.engine_debug(' l_1st_bucket is Y, use group amount as l_lg_net_amt'); -- grp amt
5260 END IF; -- end debug
5261 l_lg_net_amt := l_adj_tbl(j).priced_quantity;
5262
5263 ELSE -- l_1st_bucket='N'
5264
5265 IF l_debug = FND_API.G_TRUE THEN
5266 QP_PREQ_GRP.engine_debug(' - not first bucket');
5267 END IF; --Added For Bug No - 4033618
5268 IF l_mod_lg_net_amt_tbl.EXISTS(l_adj_tbl(j).created_from_list_line_id) THEN
5269 l_lg_net_amt := l_mod_lg_net_amt_tbl(l_adj_tbl(j).created_from_list_line_id); -- 5346093
5270 IF l_debug = FND_API.G_TRUE THEN
5271 QP_PREQ_GRP.engine_debug('recycle lg_net_amt from l_mod_lg_net_amt_tbl: '|| l_lg_net_amt);
5272 END IF; --end debug
5273 ELSE -- need to calculate l_lg_net_amt
5274 IF l_debug = FND_API.G_TRUE THEN
5275 QP_PREQ_GRP.engine_debug('lg_net_amt for list line '|| l_adj_tbl(j).created_from_list_line_id ||' not cached');
5276 END IF;
5277 -- regular net amount processing
5278 l_adj_exists_in_tmp_tbl := 'N'; -- reset bug 3618464
5279 FOR t IN l_net_mod_index_cur(l_adj_tbl(j).created_from_list_line_id) LOOP
5280 l_adj_exists_in_tmp_tbl := 'Y'; -- bug 3618464
5281 IF l_bucket_amt_tbl.EXISTS(t.line_index) THEN
5282 l_line_bucket_amt := nvl(l_bucket_amt_tbl(t.line_index), 0);
5283 IF l_debug = FND_API.G_TRUE THEN
5284 QP_PREQ_GRP.engine_debug(t.line_index || ':' || l_bucket_amt_tbl(t.line_index));
5285 END IF; --end debug
5286 ELSE
5287 l_line_bucket_amt := 0;
5288 END IF;
5289 l_lg_net_amt := l_lg_net_amt + l_line_bucket_amt;
5290
5291 IF l_debug = FND_API.G_TRUE THEN
5292 QP_PREQ_GRP.engine_debug('l_line_bucket_amt: ' || l_line_bucket_amt);
5293 QP_PREQ_GRP.engine_debug('up-tp-date l_lg_net_amt: ' || l_lg_net_amt); -- grp amt
5294 END IF; --end debug
5295 END LOOP; -- end l_net_mod_index_cur
5296
5297 -- Bug 3618464 - GROUP OF LINES, NET AMOUNT, OVERRIDE MODIFIER
5298 -- get the line indexes from G_LINE_INDEXES_FOR_LINE_ID for the given list_line_id
5299 IF l_adj_exists_in_tmp_tbl = 'N' THEN
5300 IF G_LINE_INDEXES_FOR_LINE_ID.EXISTS(l_adj_tbl(j).created_from_list_line_id) THEN
5301 l_line_index_str := G_LINE_INDEXES_FOR_LINE_ID(l_adj_tbl(j).created_from_list_line_id);
5302 END IF;
5303 IF l_debug = FND_API.G_TRUE THEN
5304 QP_PREQ_GRP.engine_debug('l_line_index_str = ' || l_line_index_str);
5305 END IF;
5306 IF l_line_index_str IS NOT NULL THEN
5307 LOOP
5308 l_instr_pos := instr(l_line_index_str, ',');
5309 EXIT WHEN (nvl(l_instr_pos, 0) = 0);
5310
5311 l_index := ltrim(rtrim(substr(l_line_index_str, 1, l_instr_pos - 1)));
5312 l_line_index_str := substr(l_line_index_str, l_instr_pos + 1);
5313
5314 IF l_bucket_amt_tbl.EXISTS(l_index) THEN
5315 l_line_bucket_amt := nvl(l_bucket_amt_tbl(l_index), 0);
5316 IF l_debug = FND_API.G_TRUE THEN
5317 QP_PREQ_GRP.engine_debug('Net Amount Override PBH LINEGROUP ' || l_index || ':' || l_bucket_amt_tbl(l_index));
5318 END IF; --end debug
5319 ELSE
5320 l_line_bucket_amt := 0;
5321 END IF;
5322 l_lg_net_amt := l_lg_net_amt + l_line_bucket_amt;
5323
5324 IF l_debug = FND_API.G_TRUE THEN
5325 QP_PREQ_GRP.engine_debug('l_bucket_amt_tbl(' || l_index ||'): '|| l_line_bucket_amt);
5326 END IF; --end debug
5327 END LOOP;
5328 END IF; --if l_line_index_str is not null
5329 END IF; --if l_adj_exists_in_tmp_tbl = 'N'
5330
5331 l_mod_lg_net_amt_tbl(l_adj_tbl(j).created_from_list_line_id) := l_lg_net_amt; -- preserve this for recycle
5332
5333 END IF; --l_mod_lg_net_amt_tbl.EXIST
5334
5335 END IF; -- END IF l_prev_bucket = -9999
5336
5337 IF l_debug = FND_API.G_TRUE THEN
5338 QP_PREQ_GRP.engine_debug('final l_lg_net_amt: '|| l_lg_net_amt);
5339 END IF; --end debug
5340 -- end SL_latest
5341
5342 -- [julin/4112395/4220399]
5343 IF (nvl(l_adj_tbl(j).net_amount_flag, 'N') = 'P') THEN
5344 l_qualifier_value := l_lg_prod_net_amt;
5345 -- [julin/4571612/4671446] explicitly set FND_API.G_NULL_NUM means infinity
5346 IF (l_sub_total_price = 0) THEN
5347 l_req_value_per_unit := FND_API.G_NULL_NUM;
5348 l_applied_req_value_per_unit := FND_API.G_NULL_NUM;
5349 ELSE
5350 l_req_value_per_unit := l_lg_prod_net_amt / l_sub_total_price; --bug 3404493
5351 l_applied_req_value_per_unit := l_lg_net_amt / l_sub_total_price;
5352 END IF;
5353 ELSE
5354 l_qualifier_value := l_lg_net_amt;
5355 -- [julin/4571612/4671446] explicitly set FND_API.G_NULL_NUM means infinity
5356 IF (l_sub_total_price = 0) THEN
5357 l_req_value_per_unit := FND_API.G_NULL_NUM;
5358 ELSE
5359 l_req_value_per_unit := l_lg_net_amt / l_sub_total_price; --bug 3404493
5360 END IF;
5361 END IF;
5362
5363 IF l_debug = FND_API.G_TRUE THEN
5364 QP_PREQ_GRP.engine_debug('group amount: ' || l_adj_tbl(j).priced_quantity); -- grp amt
5365 QP_PREQ_GRP.engine_debug('group of lines net amt: '|| l_qualifier_value);
5366 END IF; --end debug
5367
5368 ELSE -- not net amount modifier
5369 l_qualifier_value := l_adj_tbl(j).priced_quantity; -- not net amount grouop of line modifier
5370 END IF; -- END IF net_amount_flag = 'Y' for line group modifiers
5371 -- end 2892848
5372
5373 END IF; --G_pbhvolattr_attribute
5374
5375 IF l_debug = FND_API.G_TRUE THEN
5376 QP_PREQ_GRP.engine_debug('PBH calc dtls attribute '
5377 || G_pbhvolattr_attribute(l_adj_tbl(j).created_from_list_line_id)
5378 ||' l_total_value '|| l_total_value --4000
5379 ||' l_req_value_per_unit '|| l_req_value_per_unit); --40
5380 END IF; --l_debug
5381 ELSE --no attribute
5382 --this is a setup bug where no attribute for PBH
5383 l_total_value := NULL;
5384 l_req_value_per_unit := NULL;
5385 END IF; --G_pbhvolattr_attribute.exists
5386 END IF; --modifier level code
5387
5388 /* out 2892848
5389 -- obtain net_adj_amount_flag from qp_list_lines table if null,
5390 -- since it may not be passed from calling application
5391 -- net_amount_new 2720717
5392 IF l_adj_tbl(j).net_amount_flag IS NULL THEN
5393 OPEN l_net_amount_flag_cur(l_adj_tbl(j).created_from_list_line_id);
5394 FETCH l_net_amount_flag_cur into l_adj_tbl(j).net_amount_flag;
5395 CLOSE l_net_amount_flag_cur;
5396 END IF;
5397 */ -- out 2892848
5398
5399 -- [julin/3265308] Price_Break_Calculation should have same
5400 -- behavior for both net_amount_flag = G_YES and 'P'.
5401 IF (l_adj_tbl(j).net_amount_flag IN (G_YES, 'P')) THEN
5402 l_bucketed_flag := G_YES;
5403 ELSE
5404 l_bucketed_flag := G_NO;
5405 END IF;
5406
5407 --4900095 used in price_break_calculation
5408 G_PBH_MOD_LEVEL_CODE(l_adj_tbl(j).line_detail_index) :=
5409 l_adj_tbl(j).modifier_level_code;
5410
5411 QP_Calculate_Price_PUB.Price_Break_Calculation(
5412 l_adj_tbl(j).line_detail_index, -- line_detail_index
5413 l_adj_tbl(j).price_break_type_code,
5414 l_adj_tbl(j).line_ind,
5415 l_req_value_per_unit, -- Group Value per unit,group quantity,item qty 40
5416 l_applied_req_value_per_unit, -- [julin/4112395/4220399]
5417 l_total_value, -- Total value (Group amount or item amount) 4000
5418 l_sub_total_price,
5419 l_adj_tbl(j).line_priced_quantity, -- 2388011, SHU FIX diff PRIYA, 20
5420 --l_pbh_prev_net_adj_amount, -- net_amount, 2720717 -- 2892848
5421 l_qualifier_value, -- p_bucketed_adj, 2892848
5422 l_bucketed_flag, -- net_amount_new, 2720717, [julin/3265308]
5423 l_adj_tbl(j).automatic_flag, -- 5413797
5424 l_return_adjustment,
5425 l_return_status,
5426 l_return_status_text);
5427
5428 --end changes for bug 2388011
5429
5430 l_return_adjustment := - 1 * nvl(l_return_adjustment, 0);
5431
5432 -- 2892848
5433 IF l_debug = FND_API.G_TRUE THEN
5434 QP_PREQ_GRP.engine_debug('PBH return adjustment '|| l_return_adjustment); --40
5435 END IF; --l_debug
5436 -- end 2892848
5437
5438 END IF; --l_adj_tbl(j).price_flag
5439
5440
5441 ELSE --created_from_list_line_type not PBH, 2892848 change comment only
5442 IF l_debug = FND_API.G_TRUE THEN
5443 QP_PREQ_GRP.engine_debug('Processing DIS/SUR/FRT: '|| l_adj_tbl(j).created_from_list_line_id); -- 2892848, change debug msg
5444 END IF; -- end debug
5445
5446 IF l_adj_tbl(j).created_from_list_line_type = G_DISCOUNT
5447 AND l_adj_tbl(j).operand_calculation_code <> G_NEWPRICE_DISCOUNT
5448 --included this newprice check for negative newprice bug 2065609
5449 THEN
5450 l_sign := - 1;
5451 ELSE
5452 l_sign := 1;
5453 END IF; --l_adj_tbl(j).created_from_list_line_type=g_discount
5454
5455 IF l_debug = FND_API.G_TRUE THEN
5456 QP_PREQ_GRP.engine_debug('this check '
5457 || l_adj_tbl(j).line_type_code ||' '
5458 || l_calc_quantity ||' '|| l_adj_tbl(j).operand_calculation_code);
5459
5460 END IF;
5461 IF l_adj_tbl(j).modifier_level_code = G_ORDER_LEVEL
5462 AND l_calc_quantity = 0
5463 AND l_adj_tbl(j).operand_calculation_code = G_LUMPSUM_DISCOUNT
5464 THEN
5465 l_calc_quantity := 1;
5466 IF l_debug = FND_API.G_TRUE THEN
5467 QP_PREQ_GRP.engine_debug('Order lvl qty '||
5468 l_calc_quantity);
5469 END IF;
5470 END IF;
5471
5472 IF l_debug = FND_API.G_TRUE THEN
5473 QP_PREQ_GRP.engine_debug('this sign '|| l_sign);
5474 END IF;
5475
5476 IF l_adj_tbl(j).PRICING_STATUS_CODE IN
5477 (G_STATUS_NEW, G_STATUS_UPDATED, G_STATUS_UNCHANGED)
5478 THEN
5479 /*
5480 IF l_adj_tbl(j).updated_flag = G_YES
5481 and nvl(l_adj_tbl(j).automatic_flag,G_NO) = G_NO
5482 and (l_adj_tbl(j).adjustment_amount IS NOT NULL
5483 and l_adj_tbl(j).adjustment_amount <> g_miss_num) --FND_API.G_MISS_NUM)
5484 THEN
5485 --to avoid rounding issues in rev calculations
5486 --for user-overridden adjustments
5487 IF l_debug = FND_API.G_TRUE THEN
5488 qp_preq_grp.engine_debug(' adj amt manual adj '||
5489 l_adj_tbl(j).adjustment_amount);
5490 END IF;
5491 l_return_adjustment := l_adj_tbl(j).adjustment_amount;
5492 ELSE
5493 */--commented to avoid overriding errors
5494 IF l_debug = FND_API.G_TRUE THEN
5495 qp_preq_grp.engine_debug(' adj amt manual adj '||
5496 l_adj_tbl(j).adjustment_amount);
5497
5498 END IF;
5499 --bug 2691794
5500 IF
5501 -- l_adj_tbl(j).created_from_list_line_type <> G_FREIGHT_CHARGE and ** Commented for bug#3596827 **
5502 l_adj_tbl(j).price_flag = G_PHASE
5503 AND l_adj_tbl(j).line_category = 'RETURN'
5504 AND l_adj_tbl(j).operand_calculation_code = G_LUMPSUM_DISCOUNT
5505 and l_adj_tbl(j).is_ldet_rec not in
5506 (G_LDET_ORDER_TYPE, G_LDET_LINE_TYPE) -- 4534961/4492066
5507 THEN
5508 l_return_adjustment := l_adj_tbl(j).adjustment_amount;
5509 -- begin 12670913 smbalara
5510 IF l_debug = FND_API.G_TRUE THEN
5511 QP_PREQ_GRP.engine_debug('-- Debug for LUMPSUM, RETURN --');
5512 QP_PREQ_GRP.engine_debug('-- round(operand/qty, factor) => '||
5513 'round('||l_adj_tbl(j).operand_value||'/'||
5514 l_adj_tbl(j).line_priced_quantity||', '||
5515 l_adj_tbl(j).rounding_factor||') = '||
5516 round(
5517 l_adj_tbl(j).operand_value/l_adj_tbl(j).line_priced_quantity,
5518 -1*l_adj_tbl(j).rounding_factor)
5519 );
5520 QP_PREQ_GRP.engine_debug('-- compare to adjustment amount '||
5521 l_adj_tbl(j).adjustment_amount);
5522 END IF;
5523 IF round(
5524 l_adj_tbl(j).operand_value/l_adj_tbl(j).line_priced_quantity,
5525 -1*l_adj_tbl(j).rounding_factor) * l_sign <>
5526 l_adj_tbl(j).adjustment_amount
5527 THEN
5528 IF l_debug = FND_API.G_TRUE THEN
5529 QP_PREQ_GRP.engine_debug('-- recalculating frtchg operand ='||
5530 'qty*adj amt');
5531 END IF;
5532 --end 12670913 smbalara
5533 l_adj_tbl(j).operand_value :=
5534 l_adj_tbl(j).line_priced_quantity *
5535 l_adj_tbl(j).adjustment_amount *
5536 l_sign;
5537 --begin 12670913 smbalara
5538 ELSE
5539 IF l_debug = FND_API.G_TRUE THEN
5540 QP_PREQ_GRP.engine_debug('-- keeping frtchg operand.');
5541 END IF;
5542 END IF;
5543 -- end 12670913 smbalara
5544 IF l_debug = FND_API.G_TRUE THEN
5545 QP_PREQ_GRP.engine_debug('return line frtchg operand '
5546 || l_adj_tbl(j).operand_value ||' adj amt '
5547 || l_return_adjustment);
5548 END IF; --l_debug
5549 ELSE --l_adj_tbl(j).created_from_list_line_type = frt
5550 IF l_adj_tbl(j).operand_calculation_code =
5551 G_LUMPSUM_DISCOUNT
5552 AND l_adj_tbl(j).modifier_level_code = G_LINE_GROUP
5553 AND l_adj_tbl(j).is_ldet_rec NOT IN
5554 (G_LDET_ORDER_TYPE, G_LDET_LINE_TYPE) THEN
5555 BEGIN
5556 SELECT pricing_attribute INTO l_pricing_attribute
5557 FROM qp_pricing_attributes
5558 WHERE list_line_id =
5559 l_adj_tbl(j).created_from_list_line_id
5560 AND pricing_attribute_context =
5561 G_PRIC_VOLUME_CONTEXT;
5562 EXCEPTION
5563 WHEN OTHERS THEN
5564 l_pricing_attribute := NULL;
5565 END;
5566
5567 IF l_pricing_attribute IS NOT NULL
5568 AND l_pricing_attribute = G_PRIC_ATTRIBUTE12
5569 AND l_adj_tbl(j).modifier_level_code = G_LINE_GROUP
5570 AND l_adj_tbl(j).is_ldet_rec NOT IN
5571 (G_LDET_ORDER_TYPE, G_LDET_LINE_TYPE) THEN
5572 --for linegrp itemamt lumpsum, the adj_amt =
5573 --operand/group_amount. When calculation is done after
5574 --search, engine calculates group_amount as ldet.line_qty/
5575 --unit_price. But when calling application passes or we
5576 --fetch adj from OM, group_amt is range_break_qty which
5577 --is the line_qty returned by the pricing engine and the
5578 --the group_amt passed back by engine is not stored by OM
5579 --so we need to do this for adj not searched by engine
5580 -- [julin/4571612/4671446] explicitly set FND_API.G_NULL_NUM means infinity
5581 IF (l_adj_tbl(j).unit_price = 0) THEN
5582 l_calc_quantity := FND_API.G_NULL_NUM;
5583 ELSE
5584 l_calc_quantity := l_calc_quantity / l_adj_tbl(j).unit_price;
5585 END IF;
5586 END IF; --l_pricing_attribute
5587 IF l_debug = FND_API.G_TRUE THEN
5588 QP_PREQ_GRP.engine_debug('l_calc_qty for lumpsum '
5589 || l_calc_quantity);
5590 END IF; --l_debug
5591 END IF; --l_adj_tbl(j).operand_calculation_code
5592
5593 Calculate_bucket_price(
5594 l_adj_tbl(j).created_from_list_line_type
5595 , l_sub_total_price
5596 , nvl(l_calc_quantity, 1)
5597 , l_adj_tbl(j).operand_calculation_code
5598 , nvl(l_adj_tbl(j).operand_value, 0) * l_sign
5599 , l_return_adjustment
5600 , l_return_status
5601 , l_return_status_text);
5602 END IF; --l_adj_tbl(j).created_from_list_line_type = frt
5603
5604 IF l_return_status = FND_API.G_RET_STS_ERROR
5605 THEN
5606 x_return_status := l_return_status;
5607 x_return_status_text := l_return_status_text;
5608 END IF;
5609 -- END IF;--manual adj updated and applied
5610 END IF;
5611 END IF;
5612
5613 --This code is to avoid the order level adjustments being
5614 --returned with each line and to return only one order level
5615 --adjustment with the summary line
5616
5617 IF (l_debug = FND_API.G_TRUE) THEN
5618 QP_PREQ_GRP.engine_debug('Is Ldet Rec : ' || l_adj_tbl(j).is_ldet_rec);
5619 END IF;
5620
5621 IF ((l_adj_tbl(j).is_ldet_rec IN
5622 (G_LDET_LINE_TYPE, G_ADJ_LINE_TYPE, G_ASO_LINE_TYPE)
5623 AND l_adj_tbl(j).line_type_code = G_LINE_LEVEL)
5624 OR (l_adj_tbl(j).is_ldet_rec IN
5625 (G_LDET_ORDER_TYPE, G_ADJ_ORDER_TYPE, G_ASO_ORDER_TYPE)
5626 AND l_adj_tbl(j).line_type_code = G_ORDER_LEVEL))
5627 THEN
5628 i := i + 1;
5629 l_ldet_line_dtl_index_tbl(i) := l_adj_tbl(j).line_detail_index;
5630
5631 -- bug 12731184 start
5632 IF l_adj_tbl(j).is_ldet_rec = G_ADJ_LINE_TYPE THEN
5633 l_ldet_price_adjust_id_tbl(i) := l_adj_tbl(j).price_adjustment_id;
5634 ELSE
5635 l_ldet_price_adjust_id_tbl(i) := null;
5636 END IF;
5637 -- bug 12731184 end
5638
5639 --need to store this for bug 2833753
5640 G_ldet_plsql_index_tbl(l_ldet_line_dtl_index_tbl(i)) := i;
5641 IF (l_debug = FND_API.G_TRUE) THEN
5642 QP_PREQ_GRP.engine_debug('Adding line details : '
5643 || l_ldet_line_dtl_index_tbl(i) ||' plsqlind '
5644 || G_ldet_plsql_index_tbl(l_ldet_line_dtl_index_tbl(i)));
5645 END IF;
5646 l_ldet_line_index_tbl(i) := l_adj_tbl(j).curr_line_index;
5647 l_ldet_list_hdr_id_tbl(i) :=
5648 l_adj_tbl(j).created_from_list_header_id;
5649 l_ldet_list_line_id_tbl(i) :=
5650 l_adj_tbl(j).created_from_list_line_id;
5651 IF l_debug = FND_API.G_TRUE THEN
5652 QP_PREQ_GRP.engine_debug('adjusted amt 1 ');
5653 END IF;
5654 l_ldet_list_line_type_tbl(i) :=
5655 l_adj_tbl(j).created_from_list_line_type;
5656 IF l_debug = FND_API.G_TRUE THEN
5657 QP_PREQ_GRP.engine_debug('adjusted amt 2 ');
5658 END IF;
5659 l_ldet_adj_amt_tbl(i) := nvl(l_return_adjustment, 0);
5660 IF l_debug = FND_API.G_TRUE THEN
5661 QP_PREQ_GRP.engine_debug('adjusted amt 3 ');
5662 END IF;
5663
5664 -- begin 2892848
5665 IF l_debug = FND_API.G_TRUE THEN
5666 QP_PREQ_GRP.engine_debug(' unrounded adj_amt l_ldet_adj_amt_tbl('|| i ||'): '|| l_ldet_adj_amt_tbl(i)); -- 2892848
5667 END IF; --END IF l_debug
5668 /* SL_latest 2892848
5669 -- CONTINUE building l_bucket_adj_amt_tbl and l_bucket_index_adj_tbl regardless of bucket
5670 -- only for bucket modifiers, 0 is price list line, null is reg modifier
5671 IF l_adj_tbl(j).pricing_group_sequence IS NOT NULL AND l_adj_tbl(j).pricing_group_sequence <> 0 THEN
5672 IF l_bucket_adj_amt_tbl.EXISTS(l_adj_tbl(j).pricing_group_sequence) THEN -- avoid no data found or table index not exists for 1st rec
5673 IF l_debug = FND_API.G_TRUE THEN
5674 QP_PREQ_GRP.engine_debug (' accumulated adj amts by bucket BEFORE: ' || l_bucket_adj_amt_tbl(l_adj_tbl(j).pricing_group_sequence));
5675 END IF; -- end debug
5676 l_bucket_adj_amt_tbl(l_adj_tbl(j).pricing_group_sequence):= nvl(l_bucket_adj_amt_tbl(l_adj_tbl(j).pricing_group_sequence),0) +
5677 nvl(l_ldet_adj_amt_tbl(i),0)* l_adj_tbl(j).line_priced_quantity;
5678
5679 ELSE -- avoid no data found err
5680 l_bucket_adj_amt_tbl(l_adj_tbl(j).pricing_group_sequence):= nvl(l_ldet_adj_amt_tbl(i),0) * l_adj_tbl(j).line_priced_quantity;
5681 END IF; -- END IF l_bucket_adj_amt_tbl.EXISTS
5682 IF l_debug = FND_API.G_TRUE THEN
5683 QP_PREQ_GRP.engine_debug (' (LINEGROUP) building l_bucket_adj_amt_tbl by bucket: '||l_adj_tbl(j).pricing_group_sequence);
5684 QP_PREQ_GRP.engine_debug (' nvl of current unit adj: '||nvl(l_ldet_adj_amt_tbl(i), 0));
5685 QP_PREQ_GRP.engine_debug (' order qty: '||l_adj_tbl(j).line_priced_quantity);
5686 QP_PREQ_GRP.engine_debug (' accumulated adj amts for this bucket: ' || l_bucket_adj_amt_tbl(l_adj_tbl(j).pricing_group_sequence));
5687 END IF; -- END debug
5688
5689 -- for LINE LEVEL
5690 IF l_bucket_index_adj_tbl.EXISTS(l_adj_tbl(j).line_ind) THEN
5691 IF l_debug = FND_API.G_TRUE THEN
5692 QP_PREQ_GRP.engine_debug (' accumulated unit adj by line BEFORE: ' || nvl(l_bucket_index_adj_tbl(l_adj_tbl(j).line_ind), 0));
5693 END IF; -- end debug
5694 l_bucket_index_adj_tbl(l_adj_tbl(j).line_ind) := nvl(l_bucket_index_adj_tbl(l_adj_tbl(j).line_ind), 0) + nvl(l_ldet_adj_amt_tbl(i), 0);
5695 ELSE -- avoid no datat found err
5696 l_bucket_index_adj_tbl(l_adj_tbl(j).line_ind) := nvl(l_ldet_adj_amt_tbl(i), 0);
5697 END IF; -- END IF l_bucket_index_adj_tbl.EXISTS
5698 IF l_debug = FND_API.G_TRUE THEN
5699 QP_PREQ_GRP.engine_debug (' (LINE) building l_bucket_index_adj_tbl for line_index: '||l_adj_tbl(j).line_ind);
5700 QP_PREQ_GRP.engine_debug (' accumulated unit adjs by line index: '||l_bucket_index_adj_tbl(l_adj_tbl(j).line_ind));
5701 END IF; -- END debug
5702 END IF; -- END IF bucket is not null and 0
5703
5704 -- end 2892848
5705 */
5706 /* out 2892848
5707 --begin net_amount, 2720717
5708 l_pbh_net_adj_amount := l_pbh_net_adj_amount + l_ldet_adj_amt_tbl(i);
5709 IF l_debug = FND_API.G_TRUE THEN
5710 QP_PREQ_GRP.engine_debug('------ ');
5711 QP_PREQ_GRP.engine_debug('i: '||i);
5712 QP_PREQ_GRP.engine_debug('l_ldet_adj_amt_tbl(i): '||l_ldet_adj_amt_tbl(i));
5713 QP_PREQ_GRP.engine_debug('l_pbh_net_adj_amount: '||l_pbh_net_adj_amount);
5714 END IF; --END IF l_debug
5715 --end net_amount, 2720717
5716 */
5717
5718 IF l_adj_tbl(j).calculation_code = G_BACK_CALCULATE THEN
5719 l_back_calc_dtl_index(l_adj_tbl(j).line_ind)
5720 := l_adj_tbl(j).line_detail_index;
5721 l_back_calc_adj_amt(l_adj_tbl(j).line_ind)
5722 := nvl(l_return_adjustment, 0);
5723 l_back_calc_plsql_tbl_index(l_adj_tbl(j).line_ind)
5724 := i;
5725 IF l_debug = FND_API.G_TRUE THEN
5726 QP_PREQ_GRP.engine_debug('Back calc line index '
5727 || l_back_calc_dtl_index(l_adj_tbl(j).line_ind)
5728 ||' adjamt '|| l_back_calc_adj_amt(l_adj_tbl(j).line_ind)
5729 ||' plsql ind '
5730 || l_back_calc_plsql_tbl_index(l_adj_tbl(j).line_ind));
5731 END IF; --l_debug
5732 END IF; --l_adj_tbl(j).calculation_code
5733
5734 --this procedure is called to calculate the
5735 --selling_price,adjustment_amount and operand in ordered_qty
5736 --which is the line_quantity on lines_tmp
5737 -- Ravi bug# 2745337-divisor by zero
5738 IF (l_adj_tbl(j).ordered_qty <> 0 OR l_adj_tbl(j).modifier_level_code = 'ORDER') THEN
5739 IF (l_debug = FND_API.G_TRUE) THEN
5740 QP_PREQ_GRP.engine_debug('Before Going into GET_ORDERQTY_VALUES #1');
5741 END IF;
5742 GET_ORDERQTY_VALUES(p_ordered_qty => l_adj_tbl(j).ordered_qty,
5743 p_priced_qty => l_adj_tbl(j).line_priced_quantity,
5744 p_catchweight_qty => l_adj_tbl(j).catchweight_qty,
5745 p_actual_order_qty => l_adj_tbl(j).actual_order_qty,
5746 p_operand => l_adj_tbl(j).operand_value,
5747 p_adjustment_amt => l_ldet_adj_amt_tbl(i),
5748 p_unit_price => l_adj_tbl(j).unit_price,
5749 p_adjusted_unit_price => l_sub_total_price,
5750 p_operand_calculation_code => l_adj_tbl(j).operand_calculation_code,
5751 p_input_type => 'OPERAND',
5752 x_ordqty_output1 => l_ldet_ordqty_operand_tbl(i),
5753 x_ordqty_output2 => l_ldet_ordqty_adjamt_tbl(i),
5754 x_return_status => x_return_status,
5755 x_return_status_text => x_return_status_text);
5756 ELSE
5757 IF l_debug = FND_API.G_TRUE THEN
5758 QP_PREQ_GRP.engine_debug('Ordered Qty #1: ' || l_adj_tbl(j).ordered_qty);
5759 QP_PREQ_GRP.engine_debug('OPERAND Ordered Qty is 0 or modifier level code is not ORDER');
5760 END IF;
5761 l_ldet_ordqty_operand_tbl(i) := 0;
5762 l_ldet_ordqty_adjamt_tbl(i) := 0;
5763 END IF;
5764
5765 IF l_debug = FND_API.G_TRUE THEN
5766 QP_PREQ_GRP.engine_debug('Printing ordqty_operand '
5767 || l_ldet_ordqty_operand_tbl(i) ||' ordqty_adjamt '
5768 || l_ldet_ordqty_adjamt_tbl(i));
5769 END IF; --l_debug
5770
5771 --round the adjustment_amount with factor on the line
5772 --engine updates the factor on the line
5773 --w/nvl(user_passed,price_list rounding_factor)
5774 IF G_ROUND_INDIVIDUAL_ADJ = G_ROUND_ADJ
5775 AND l_adj_tbl(j).rounding_factor IS NOT NULL
5776 THEN
5777 l_ldet_adj_amt_tbl(i) :=
5778 round(l_ldet_adj_amt_tbl(i),
5779 ( - 1 * l_adj_tbl(j).rounding_factor));
5780 l_ldet_ordqty_adjamt_tbl(i) :=
5781 round(l_ldet_ordqty_adjamt_tbl(i),
5782 ( - 1 * l_adj_tbl(j).rounding_factor));
5783 END IF;
5784
5785 IF l_debug = FND_API.G_TRUE THEN
5786 QP_PREQ_GRP.engine_debug('rounded adj: '|| l_ldet_adj_amt_tbl(i) ||
5787 ' rounding fac '|| l_adj_tbl(j).rounding_factor ||
5788 ' ordqty_adjamt '|| l_ldet_ordqty_adjamt_tbl(i) ||
5789 ' '|| l_adj_tbl(j).curr_line_index ||' '|| l_adj_tbl(j).line_ind ||
5790 ' is_ldet_rec '|| l_adj_tbl(j).is_ldet_rec ||
5791 ' linetypecode '|| l_adj_tbl(j).line_type_code);
5792
5793 END IF;
5794
5795 l_ldet_process_code_tbl(i) := l_adj_tbl(j).process_code;
5796 l_ldet_calc_code_tbl(i) := l_adj_tbl(j).calculation_code;
5797 l_ldet_updated_flag_tbl(i) := l_adj_tbl(j).updated_flag;
5798 l_ldet_operand_value_tbl(i) := l_adj_tbl(j).operand_value;
5799 l_ldet_price_break_type_tbl(i) := l_adj_tbl(j).price_break_type_code;
5800 l_ldet_operand_calc_tbl(i) := l_adj_tbl(j).operand_calculation_code;
5801 l_ldet_pricing_grp_seq_tbl(i) := l_adj_tbl(j).pricing_group_sequence;
5802 l_ldet_list_type_code_tbl(i) := l_adj_tbl(j).created_from_list_type_code;
5803 l_ldet_limit_code_tbl(i) := l_adj_tbl(j).limit_code;
5804 l_ldet_limit_text_tbl(i) := l_adj_tbl(j).limit_text;
5805 l_ldet_list_line_no_tbl(i) := l_adj_tbl(j).list_line_no;
5806 l_ldet_charge_type_tbl(i) := l_adj_tbl(j).charge_type_code;
5807 l_ldet_charge_subtype_tbl(i) := l_adj_tbl(j).charge_subtype_code;
5808 l_ldet_pricing_phase_id_tbl(i) := l_adj_tbl(j).pricing_phase_id;
5809 l_ldet_automatic_flag_tbl(i) := l_adj_tbl(j).automatic_flag;
5810 l_ldet_modifier_level_tbl(i) := l_adj_tbl(j).modifier_level_code;
5811 --to store gro/line qty in line qty based on mod level
5812 --l_ldet_line_quantity_tbl(i) := nvl(l_calc_quantity,1); -- 40,SHU, this is inconsistent with PL/SQL path
5813 l_ldet_line_quantity_tbl(i) := l_adj_tbl(j).priced_quantity; -- -- 2388011, SHU FIX diff PRIYA,to be the same as PL/SQL path
5814 l_ldet_is_max_frt_tbl(i) := G_NO;
5815 IF l_debug = FND_API.G_TRUE THEN
5816 QP_PREQ_GRP.engine_debug('adjusted amt 4 ');
5817
5818 QP_PREQ_GRP.engine_debug('Returned adj : '|| i
5819 ||' line detail index '|| l_ldet_line_dtl_index_tbl(i)
5820 ||' adj amt '|| l_ldet_adj_amt_tbl(i));
5821
5822
5823 END IF;
5824 IF l_return_status = FND_API.G_RET_STS_ERROR
5825 THEN
5826 IF l_debug = FND_API.G_TRUE THEN
5827 QP_PREQ_GRP.engine_debug('Calc Error');
5828 END IF;
5829 l_ldet_pricing_sts_code_tbl(i) := G_STATUS_CALC_ERROR;
5830 l_ldet_pricing_sts_txt_tbl(i) := l_return_status_text;
5831 l_ldet_applied_flag_tbl(i) := G_NO;
5832 ELSE
5833 IF l_debug = FND_API.G_TRUE THEN
5834 QP_PREQ_GRP.engine_debug('Calc Succ');
5835 END IF;
5836 l_ldet_pricing_sts_code_tbl(i) :=
5837 l_adj_tbl(j).pricing_status_code;
5838 IF l_adj_tbl(j).pricing_status_code = G_STATUS_UNCHANGED
5839 AND l_adj_tbl(j).is_ldet_rec IN (G_ASO_ORDER_TYPE,
5840 G_ASO_LINE_TYPE)
5841 THEN
5842 l_ldet_pricing_sts_code_tbl(i) := G_STATUS_NEW;
5843 END IF;
5844 --manual frt charges should not have appl flag YES
5845 --and manual adj which are updated and applied shdbe app
5846 --should retain applied flag as when auto overr adj
5847 --are deleted OM Int makes applied 'N' and updated
5848 --'Y' and does not physically delete records
5849 l_ldet_applied_flag_tbl(i) :=
5850 l_adj_tbl(j).applied_flag;
5851 /*
5852 IF nvl(l_adj_tbl(j).automatic_flag,G_NO) = G_YES
5853 or (nvl(l_adj_tbl(j).applied_flag,G_NO) = G_YES
5854 and nvl(l_adj_tbl(j).updated_flag,G_NO) = G_YES)
5855 THEN
5856 l_ldet_applied_flag_tbl(i) := G_YES;
5857 ELSE
5858 l_ldet_applied_flag_tbl(i) := G_NO;
5859 END IF;
5860 */
5861 l_ldet_pricing_sts_txt_tbl(i) :=
5862 l_adj_tbl(j).pricing_status_text;
5863 END IF; --l_return_status = FND_API.G_RET_STS_ERROR
5864
5865 IF l_adj_tbl(j).created_from_list_line_type = G_FREIGHT_CHARGE
5866 AND nvl(l_adj_tbl(j).automatic_flag, G_NO) = G_YES
5867 AND l_adj_tbl(j).pricing_status_code IN
5868 (G_STATUS_NEW, G_STATUS_UPDATED, G_STATUS_UNCHANGED)
5869 THEN
5870 IF l_debug = FND_API.G_TRUE THEN
5871 QP_PREQ_GRP.engine_debug('looping thru FRT for list_line id '
5872 || l_adj_tbl(j).created_from_list_line_id ||' adj amt '
5873 || l_ldet_adj_amt_tbl(i) ||' upd '
5874 || l_adj_tbl(j).updated_flag
5875 ||' level '|| l_adj_tbl(j).modifier_level_code);
5876 END IF;
5877 l_ldet_pricing_sts_code_tbl(i) := G_STATUS_DELETED;
5878 l_ldet_pricing_sts_txt_tbl(i) := G_NOT_MAX_FRT_CHARGE;
5879
5880 IF l_frt_tbl.COUNT = 0
5881 THEN
5882 --no record for charge type subtype combn
5883 --so insert into l_frt_tbl
5884 IF l_debug = FND_API.G_TRUE THEN
5885 QP_PREQ_GRP.engine_debug('No frtcharge in tbl: insert rec');
5886 END IF;
5887 l_frt_tbl(1).line_index := l_adj_tbl(j).line_ind;
5888 l_frt_tbl(1).line_detail_index :=
5889 l_adj_tbl(j).line_detail_index;
5890 l_frt_tbl(1).created_from_list_line_id :=
5891 l_adj_tbl(j).created_from_list_line_id;
5892 l_frt_tbl(1).adjustment_amount :=
5893 l_ldet_adj_amt_tbl(i);
5894 l_frt_tbl(1).charge_type_code :=
5895 l_adj_tbl(j).charge_type_code;
5896 l_frt_tbl(1).charge_subtype_code :=
5897 l_adj_tbl(j).charge_subtype_code;
5898 l_frt_tbl(1).updated_flag :=
5899 nvl(l_adj_tbl(j).updated_flag, G_NO);
5900 --this is to show if a frt rec is max or not
5901 l_ldet_is_max_frt_tbl(i) := G_YES;
5902 IF l_adj_tbl(j).modifier_level_code IN
5903 (G_LINE_LEVEL, G_LINE_GROUP)
5904 THEN
5905 l_frt_tbl(1).LEVEL := G_LINE_LEVEL;
5906 ELSIF l_adj_tbl(j).modifier_level_code = G_ORDER_LEVEL
5907 THEN
5908 l_frt_tbl(1).LEVEL := G_ORDER_LEVEL;
5909 END IF;
5910 ELSIF l_frt_tbl.COUNT > 0
5911 THEN
5912 IF l_debug = FND_API.G_TRUE THEN
5913 QP_PREQ_GRP.engine_debug('frtchrg records exist');
5914
5915 END IF;
5916 FOR N IN l_frt_tbl.FIRST..l_frt_tbl.LAST
5917 LOOP
5918 IF l_debug = FND_API.G_TRUE THEN
5919 QP_PREQ_GRP.engine_debug('existing frt record id '
5920 || l_frt_tbl(N).created_from_list_line_id
5921 ||' level '|| l_frt_tbl(N).LEVEL);
5922
5923 END IF;
5924 IF l_adj_tbl(j).line_ind = l_frt_tbl(N).line_index AND
5925 nvl(l_adj_tbl(j).charge_type_code, 'NULL') =
5926 nvl(l_frt_tbl(N).charge_type_code, 'NULL') AND
5927 nvl(l_adj_tbl(j).charge_subtype_code, 'NULL') =
5928 nvl(l_frt_tbl(N).charge_subtype_code, 'NULL') AND
5929 (l_frt_tbl(N).LEVEL = l_adj_tbl(j).modifier_level_code
5930 OR (l_frt_tbl(N).LEVEL = G_LINE_LEVEL AND
5931 l_adj_tbl(j).modifier_level_code = G_LINE_GROUP))
5932 THEN
5933 --record exists for charge type subtype combn
5934 IF l_debug = FND_API.G_TRUE THEN
5935 QP_PREQ_GRP.engine_debug('charge combn match');
5936
5937 END IF;
5938 IF nvl(l_frt_tbl(N).updated_flag, G_NO) = G_NO
5939 THEN
5940 IF l_debug = FND_API.G_TRUE THEN
5941 QP_PREQ_GRP.engine_debug('Rec is NOT overriden');
5942 END IF;
5943 --only if user has not overridden
5944 --replace the record with the ct adj
5945
5946 IF nvl(l_adj_tbl(j).updated_flag, G_NO) = G_YES
5947 THEN
5948 IF l_debug = FND_API.G_TRUE THEN
5949 QP_PREQ_GRP.engine_debug('Repl overridden rec');
5950 END IF;
5951 --if ct adj is overridden
5952 l_frt_tbl(N).line_detail_index
5953 := l_adj_tbl(j).line_detail_index;
5954 l_frt_tbl(N).created_from_list_line_id :=
5955 l_adj_tbl(j).created_from_list_line_id;
5956 l_frt_tbl(N).line_index
5957 := l_adj_tbl(j).line_ind;
5958 l_frt_tbl(N).adjustment_amount
5959 := l_ldet_adj_amt_tbl(i);
5960 l_frt_tbl(N).updated_flag
5961 := l_adj_tbl(j).updated_flag;
5962 --this is to show if a frt rec is max or not
5963 l_ldet_is_max_frt_tbl(i) := G_YES;
5964 ELSIF nvl(l_adj_tbl(j).updated_flag, G_NO) = G_NO
5965 AND l_ldet_adj_amt_tbl(i)
5966 > l_frt_tbl(N).adjustment_amount
5967 THEN
5968 --if ct adj's adj amt is greater
5969 IF l_debug = FND_API.G_TRUE THEN
5970 QP_PREQ_GRP.engine_debug('replace high adjamt');
5971 END IF;
5972 l_frt_tbl(N).line_detail_index
5973 := l_adj_tbl(j).line_detail_index;
5974 l_frt_tbl(N).created_from_list_line_id
5975 := l_adj_tbl(j).created_from_list_line_id;
5976 l_frt_tbl(N).line_index
5977 := l_adj_tbl(j).line_ind;
5978 l_frt_tbl(N).adjustment_amount
5979 := l_ldet_adj_amt_tbl(i);
5980 l_frt_tbl(N).updated_flag
5981 := l_adj_tbl(j).updated_flag;
5982 --this is to show if a frt rec is max or not
5983 l_ldet_is_max_frt_tbl(i) := G_YES;
5984 END IF; --l_adj_tbl(j).updated_flag
5985
5986 END IF; --frt_tbl.updated_flag
5987 EXIT;
5988 ELSE
5989 --no match for charge type subtype combn
5990 --so insert into l_frt_tbl
5991 IF l_debug = FND_API.G_TRUE THEN
5992 QP_PREQ_GRP.engine_debug('charge combn no match');
5993
5994 END IF;
5995 IF N = l_frt_tbl.LAST
5996 THEN
5997 --this is the last record and the
5998 --charge type subtype combn not match
5999 IF l_debug = FND_API.G_TRUE THEN
6000 QP_PREQ_GRP.engine_debug('lastrec:insert new record');
6001 END IF;
6002 l_frt_tbl(N + 1).line_index :=
6003 l_adj_tbl(j).line_ind;
6004 l_frt_tbl(N + 1).line_detail_index :=
6005 l_adj_tbl(j).line_detail_index;
6006 l_frt_tbl(N + 1).created_from_list_line_id :=
6007 l_adj_tbl(j).created_from_list_line_id;
6008 l_frt_tbl(N + 1).adjustment_amount :=
6009 l_ldet_adj_amt_tbl(i);
6010 l_frt_tbl(N + 1).charge_type_code :=
6011 l_adj_tbl(j).charge_type_code;
6012 l_frt_tbl(N + 1).charge_subtype_code :=
6013 l_adj_tbl(j).charge_subtype_code;
6014 l_frt_tbl(N + 1).updated_flag :=
6015 nvl(l_adj_tbl(j).updated_flag, G_NO);
6016 IF l_adj_tbl(j).modifier_level_code IN
6017 (G_LINE_LEVEL, G_LINE_GROUP)
6018 THEN
6019 l_frt_tbl(N + 1).LEVEL := G_LINE_LEVEL;
6020 ELSIF l_adj_tbl(j).modifier_level_code =
6021 G_ORDER_LEVEL
6022 THEN
6023 l_frt_tbl(N + 1).LEVEL := G_ORDER_LEVEL;
6024 END IF;
6025 --this is to show if a frt rec is max or not
6026 l_ldet_is_max_frt_tbl(i) := G_YES;
6027 END IF; --last rec of frt_tbl
6028 END IF; --matching charge_type/subtype
6029
6030 END LOOP; --loop thru the frt tbl
6031 END IF; --frt charge tbl count
6032
6033 END IF; --created_from_list_line_type
6034
6035
6036 END IF; --is_ldet_rec
6037
6038 -------------------------------------------------------------------------------
6039 --code added to calculate adj amt on order lvl adj
6040 --fix for bug 1767249
6041 IF l_adj_tbl(j).modifier_level_code =
6042 G_ORDER_LEVEL
6043 AND l_adj_tbl(j).created_from_list_line_type
6044 <> G_FREIGHT_CHARGE
6045 THEN
6046 IF l_debug = FND_API.G_TRUE THEN
6047 QP_PREQ_GRP.engine_debug('ord lvl adj processing '
6048 || l_adj_tbl(j).modifier_level_code ||' listlineid '
6049 || l_adj_tbl(j).created_from_list_line_id ||' adj '
6050 || l_return_adjustment ||'qty '
6051 || l_adj_tbl(j).line_priced_quantity);
6052 END IF;
6053 IF l_ord_dtl_index_tbl.COUNT = 0
6054 THEN
6055 IF l_debug = FND_API.G_TRUE THEN
6056 QP_PREQ_GRP.engine_debug('ord lvl firstrec');
6057 END IF;
6058 l_ord_dtl_index_tbl(1) :=
6059 l_adj_tbl(j).line_detail_index;
6060 --fix for bug2424931 multiply by priced_qty
6061 l_ord_adj_amt_tbl(1) :=
6062 nvl(l_return_adjustment, 0) *
6063 nvl(l_adj_tbl(j).line_priced_quantity, 0);
6064
6065 IF l_debug = FND_API.G_TRUE THEN
6066 QP_PREQ_GRP.engine_debug('ord lvl1');
6067 QP_PREQ_GRP.engine_debug('ord lvl2'
6068 || l_adj_tbl(j).line_priced_quantity);
6069 QP_PREQ_GRP.engine_debug('ord lvl3'
6070 || l_adj_tbl(j).ordered_qty);
6071 QP_PREQ_GRP.engine_debug('ord lvl4'
6072 || l_adj_tbl(j).catchweight_qty);
6073 QP_PREQ_GRP.engine_debug('ord lvl5'
6074 || l_adj_tbl(j).actual_order_qty);
6075 QP_PREQ_GRP.engine_debug('ord lvl6'
6076 || l_adj_tbl(j).operand_value);
6077 QP_PREQ_GRP.engine_debug('ord lvl7'
6078 || l_adj_tbl(j).unit_price);
6079 QP_PREQ_GRP.engine_debug('ord lvl8'
6080 || l_adj_tbl(j).operand_calculation_code);
6081 QP_PREQ_GRP.engine_debug('ord lvl9'
6082 || l_return_adjustment);
6083 QP_PREQ_GRP.engine_debug('ord lvl10'
6084 || l_sub_total_price);
6085 END IF; --l_debug
6086
6087 --l_ord_qty_adj_amt_tbl
6088 l_ord_qty_adj_amt := 0;
6089 l_ord_qty_operand := 0;
6090 GET_ORDERQTY_VALUES(
6091 p_ordered_qty => l_adj_tbl(j).ordered_qty,
6092 p_priced_qty =>
6093 l_adj_tbl(j).line_priced_quantity,
6094 p_catchweight_qty =>
6095 l_adj_tbl(j).catchweight_qty,
6096 p_actual_order_qty =>
6097 l_adj_tbl(j).actual_order_qty,
6098 p_operand => l_adj_tbl(j).operand_value,
6099 p_adjustment_amt => nvl(l_return_adjustment, 0),
6100 p_unit_price => l_adj_tbl(j).unit_price,
6101 p_adjusted_unit_price => l_sub_total_price,
6102 p_operand_calculation_code =>
6103 l_adj_tbl(j).operand_calculation_code,
6104 p_input_type => 'OPERAND',
6105 x_ordqty_output1 => l_ord_qty_operand,
6106 x_ordqty_output2 => l_ord_qty_adj_amt,
6107 x_return_status => x_return_status,
6108 x_return_status_text => x_return_status_text);
6109
6110 l_ord_qty_operand_tbl(1) := l_ord_qty_operand;
6111 l_ord_qty_adj_amt_tbl(1) := l_ord_qty_adj_amt;
6112
6113 IF l_debug = FND_API.G_TRUE THEN
6114 QP_PREQ_GRP.engine_debug('ord lvl firstrec'
6115 ||' adjamt '|| l_ord_adj_amt_tbl(1)
6116 ||' ordqtyadjamt '|| l_ord_qty_adj_amt_tbl(1)
6117 ||' ordqtyoperand '|| l_ord_qty_operand_tbl(1));
6118 END IF;
6119 ELSE ---l_ord_dtl_index_tbl.COUNT
6120 FOR n IN
6121 l_ord_dtl_index_tbl.FIRST..l_ord_dtl_index_tbl.LAST
6122 LOOP
6123 IF l_debug = FND_API.G_TRUE THEN
6124 QP_PREQ_GRP.engine_debug('ord lvl adj index '||
6125 l_ord_dtl_index_tbl(n) ||' current rec index '
6126 || l_adj_tbl(j).line_detail_index
6127 ||' count '|| l_ord_dtl_index_tbl.COUNT
6128 ||' lastrec dtl index '
6129 || l_ord_dtl_index_tbl(l_ord_dtl_index_tbl.LAST))
6130 ;
6131 END IF;
6132 IF l_ord_dtl_index_tbl(n) =
6133 l_adj_tbl(j).line_detail_index
6134 THEN
6135 IF l_debug = FND_API.G_TRUE THEN
6136 QP_PREQ_GRP.engine_debug('found match '
6137 ||' ct adjamt '|| l_ord_adj_amt_tbl(n));
6138 END IF;
6139 --fix for bug2424931 multiply by priced_qty
6140 l_ord_adj_amt_tbl(n) := l_ord_adj_amt_tbl(n) +
6141 nvl(l_return_adjustment, 0) *
6142 nvl(l_adj_tbl(j).line_priced_quantity, 0);
6143
6144 l_ord_qty_adj_amt := 0;
6145 l_ord_qty_operand := 0;
6146
6147 --l_ord_qty_adj_amt_tbl
6148 GET_ORDERQTY_VALUES(
6149 p_ordered_qty => l_adj_tbl(j).ordered_qty,
6150 p_priced_qty =>
6151 l_adj_tbl(j).line_priced_quantity,
6152 p_catchweight_qty =>
6153 l_adj_tbl(j).catchweight_qty,
6154 p_actual_order_qty =>
6155 l_adj_tbl(j).actual_order_qty,
6156 p_operand => l_adj_tbl(j).operand_value,
6157 p_adjustment_amt => nvl(l_return_adjustment, 0),
6158 p_unit_price => l_adj_tbl(j).unit_price,
6159 p_adjusted_unit_price => l_sub_total_price,
6160 p_operand_calculation_code =>
6161 l_adj_tbl(j).operand_calculation_code,
6162 p_input_type => 'OPERAND',
6163 x_ordqty_output1 => l_ord_qty_operand,
6164 x_ordqty_output2 => l_ord_qty_adj_amt,
6165 x_return_status => x_return_status,
6166 x_return_status_text => x_return_status_text);
6167
6168 l_ord_qty_adj_amt_tbl(n) :=
6169 l_ord_qty_adj_amt_tbl(n) + l_ord_qty_adj_amt;
6170 l_ord_qty_operand_tbl(n) := l_ord_qty_operand;
6171
6172 IF l_debug = FND_API.G_TRUE THEN
6173 QP_PREQ_GRP.engine_debug('ord lvl adj amt '||
6174 l_ord_adj_amt_tbl(n)
6175 ||' ordqtyadjamt '|| l_ord_qty_adj_amt_tbl(n)
6176 ||' ordqtyoperand '|| l_ord_qty_operand_tbl(n));
6177 END IF;
6178 EXIT; --exit the loop once matches
6179 ELSIF l_ord_dtl_index_tbl(n) =
6180 l_ord_dtl_index_tbl(l_ord_dtl_index_tbl.LAST)
6181 AND l_ord_dtl_index_tbl(n) <>
6182 l_adj_tbl(j).line_detail_index
6183 THEN
6184 IF l_debug = FND_API.G_TRUE THEN
6185 QP_PREQ_GRP.engine_debug('ord lvl lastrec '||
6186 l_adj_tbl(j).line_detail_index ||' adjamt '
6187 || l_return_adjustment
6188 ||' qty '|| l_adj_tbl(j).line_priced_quantity);
6189 END IF;
6190 l_ord_dtl_index_tbl(l_ord_dtl_index_tbl.COUNT + 1)
6191 := l_adj_tbl(j).line_detail_index;
6192 --fix for bug2424931 multiply by priced_qty
6193 l_ord_adj_amt_tbl(l_ord_dtl_index_tbl.COUNT)
6194 := nvl(l_return_adjustment, 0) *
6195 nvl(l_adj_tbl(j).line_priced_quantity, 0);
6196
6197 --l_ord_qty_adj_amt_tbl
6198 l_ord_qty_adj_amt := 0;
6199 l_ord_qty_operand := 0;
6200
6201 GET_ORDERQTY_VALUES(
6202 p_ordered_qty => l_adj_tbl(j).ordered_qty,
6203 p_priced_qty =>
6204 l_adj_tbl(j).line_priced_quantity,
6205 p_catchweight_qty =>
6206 l_adj_tbl(j).catchweight_qty,
6207 p_actual_order_qty =>
6208 l_adj_tbl(j).actual_order_qty,
6209 p_operand => l_adj_tbl(j).operand_value,
6210 p_adjustment_amt => nvl(l_return_adjustment, 0),
6211 p_unit_price => l_adj_tbl(j).unit_price,
6212 p_adjusted_unit_price => l_sub_total_price,
6213 p_operand_calculation_code =>
6214 l_adj_tbl(j).operand_calculation_code,
6215 p_input_type => 'OPERAND',
6216 x_ordqty_output1 => l_ord_qty_operand,
6217 x_ordqty_output2 => l_ord_qty_adj_amt,
6218 x_return_status => x_return_status,
6219 x_return_status_text => x_return_status_text);
6220
6221 l_ord_qty_operand_tbl(l_ord_dtl_index_tbl.COUNT)
6222 := l_ord_qty_operand;
6223 l_ord_qty_adj_amt_tbl(l_ord_dtl_index_tbl.COUNT)
6224 := l_ord_qty_adj_amt;
6225
6226 IF l_debug = FND_API.G_TRUE THEN
6227 QP_PREQ_GRP.engine_debug('ord lvl lastadjamt '||
6228 l_ord_adj_amt_tbl(l_ord_dtl_index_tbl.COUNT));
6229 END IF;
6230 END IF; -----l_ord_dtl_index_tbl(n)
6231 IF l_debug = FND_API.G_TRUE THEN
6232 QP_PREQ_GRP.engine_debug('ord lvl adj:dtlindex '
6233 || l_ord_dtl_index_tbl(n) ||' adj amt '
6234 || l_ord_adj_amt_tbl(n)
6235 ||' ordqtyadjamt '|| l_ord_qty_adj_amt_tbl(n)
6236 ||' ordqtyoperand '|| l_ord_qty_operand_tbl(n));
6237 END IF;
6238 END LOOP; --l_ord_dtl_index_tbl
6239 END IF; --l_ord_dtl_index_tbl.COUNT
6240 END IF; --order level
6241 -------------------------------------------------------------------------------
6242
6243 IF l_adj_tbl(j).created_from_list_line_type IN
6244 (G_DISCOUNT, G_SURCHARGE, G_PRICE_BREAK_TYPE)
6245 AND l_adj_tbl(j).pricing_status_code IN
6246 (G_STATUS_NEW, G_STATUS_UPDATED, G_STATUS_UNCHANGED)
6247 --added for auto overr deleted adj
6248 AND l_adj_tbl(j).applied_flag = G_YES
6249 AND nvl(l_adj_tbl(j).accrual_flag, G_NO) = G_NO
6250 THEN
6251 --Update the adjustment amount for each adjustment
6252 -- 2892848_latest
6253 -- so we have correct current USP, considered each adj shall be rounded
6254 IF G_ROUND_INDIVIDUAL_ADJ = G_ROUND_ADJ
6255 AND l_adj_tbl(j).rounding_factor IS NOT NULL
6256 THEN
6257 l_return_adjustment := round (l_return_adjustment, - 1 * l_adj_tbl(j).rounding_factor);
6258 END IF; -- end rounding
6259 -- end 2892848_latest
6260 IF l_debug = FND_API.G_TRUE THEN
6261 QP_PREQ_GRP.engine_debug('prev USP: '|| l_adjusted_price);
6262 QP_PREQ_GRP.engine_debug('current adjustment: '|| l_return_adjustment);
6263 END IF;
6264
6265 l_adjusted_price := l_adjusted_price + nvl(l_return_adjustment, 0);
6266 IF l_debug = FND_API.G_TRUE THEN
6267 QP_PREQ_GRP.engine_debug('adjusted price, i.e. current USP : '|| l_adjusted_price); -- 2892848, good place to debug current USP
6268 END IF;
6269 END IF; --created_from_list_line_type
6270
6271 IF l_debug = FND_API.G_TRUE THEN
6272
6273 QP_PREQ_GRP.engine_debug('Processed lines: line index'
6274 || l_adj_tbl(j).line_ind ||' adjusted price '
6275 --||l_adj_tbl(j).updated_adjusted_unit_price -- 2892848
6276 || l_adjusted_price -- 2892848
6277 ||' adjustment count '|| l_ldet_line_dtl_index_tbl.COUNT);
6278
6279 END IF;
6280
6281 -- begin 3126019 , this x loop cannot have gap for bulk insert later
6282 -- therefore we cannot do x:=l_adj_tbl(j).line_ind;
6283 /* out 2892848*/
6284
6285 IF line_change = TRUE
6286 THEN
6287 IF l_debug = FND_API.G_TRUE THEN
6288 QP_PREQ_GRP.engine_debug('line change ');
6289 END IF;
6290
6291 --[julin/5025231]
6292 --x := x + 1;
6293 IF l_line_ind_ind_lookup_tbl.exists(l_adj_tbl(j).line_ind) THEN
6294 x := l_line_ind_ind_lookup_tbl(l_adj_tbl(j).line_ind);
6295 ELSE
6296 x := l_line_ind_ind_lookup_tbl.count + 1;
6297 l_line_ind_ind_lookup_tbl(l_adj_tbl(j).line_ind) := x;
6298 END IF;
6299 END IF;
6300
6301
6302
6303 --x:=l_adj_tbl(j).line_ind; -- 2892848, 3126019
6304
6305 IF l_debug = FND_API.G_TRUE THEN
6306 QP_PREQ_GRP.engine_debug('Update the adjustment amount for each adjustment...');
6307 QP_PREQ_GRP.engine_debug('line_ind: '|| l_adj_tbl(j).line_ind);
6308 QP_PREQ_GRP.engine_debug('changing price in line_tbl('|| x || ')');
6309
6310 END IF;
6311 --Update the adjustment amount for each adjustment
6312 l_line_index_tbl(x) := l_adj_tbl(j).line_ind;
6313 l_adj_unit_price_tbl(x) := l_adjusted_price;
6314 l_unit_price_tbl(x) := l_adj_tbl(j).unit_price;
6315 l_amount_changed_tbl(x) := l_adj_tbl(j).amount_changed;
6316 l_upd_adj_unit_price_tbl(x) :=
6317 l_adj_tbl(j).updated_adjusted_unit_price;
6318
6319 --netamt tbls, 3126019
6320 l_ntamt_adj_unit_price(l_line_index_tbl(x)) := l_adj_unit_price_tbl(x); -- 3126019
6321
6322
6323 -- Ravi
6324 l_ordered_qty_tbl(x) := l_adj_tbl(j).ordered_qty;
6325 l_line_unit_price_tbl(x) := l_adj_tbl(j).line_unit_price;
6326 l_line_priced_qty_tbl(x) := l_adj_tbl(j).line_priced_quantity;
6327 l_catchweight_qty_tbl(x) := l_adj_tbl(j).catchweight_qty;
6328 l_actual_order_qty_tbl(x) := l_adj_tbl(j).actual_order_qty;
6329 -- End Ravi
6330
6331 -- Ravi bug# 2745337-divisor by zero
6332 IF (l_adj_tbl(j).ordered_qty <> 0 OR l_adj_tbl(j).modifier_level_code = 'ORDER') THEN
6333 IF (l_debug = FND_API.G_TRUE) THEN
6334 QP_PREQ_GRP.engine_debug('Before Going into GET_ORDERQTY_VALUES #2');
6335 END IF;
6336 GET_ORDERQTY_VALUES(p_ordered_qty => l_adj_tbl(j).ordered_qty,
6337 p_priced_qty => l_adj_tbl(j).line_priced_quantity,
6338 p_catchweight_qty => l_adj_tbl(j).catchweight_qty,
6339 p_actual_order_qty => l_adj_tbl(j).actual_order_qty,
6340 p_unit_price => l_adj_tbl(j).unit_price,
6341 p_adjusted_unit_price => l_adj_unit_price_tbl(x),
6342 p_line_unit_price => l_adj_tbl(j).line_unit_price,
6343 p_input_type => 'SELLING_PRICE',
6344 x_ordqty_output1 => l_ordqty_unit_price_tbl(x),
6345 x_ordqty_output2 => l_ordqty_selling_price_tbl(x),
6346 x_return_status => x_return_status,
6347 x_return_status_text => x_return_status_text);
6348 ELSE
6349 IF l_debug = FND_API.G_TRUE THEN
6350 QP_PREQ_GRP.engine_debug('Ordered Qty #2 : ' || l_adj_tbl(j).ordered_qty);
6351 QP_PREQ_GRP.engine_debug('SELLING PRICE Ordered Qty is 0 or modifier level code is not ORDER');
6352 END IF;
6353 l_ordqty_unit_price_tbl(x) := 0;
6354 l_ordqty_selling_price_tbl(x) := 0;
6355 END IF;
6356
6357 IF l_debug = FND_API.G_TRUE THEN
6358 QP_PREQ_GRP.engine_debug('Printing ordqty_selling_price '
6359 || l_ordqty_selling_price_tbl(x) ||' unit_price '
6360 || l_ordqty_unit_price_tbl(x));
6361 END IF; --l_debug
6362
6363 --If PUB API fetches any out of phase or manual adjustments
6364 --pricing sts code on the line must be UPDATED
6365 --and should remain same otherwise
6366 --This change done because when manual adj are applied,
6367 --GRP puts pricing sts as UNCHANGED and OM Integration
6368 --will not change the new selling price
6369 IF l_adj_tbl(j).line_pricing_status_code <> G_STATUS_UPDATED
6370 AND l_adj_tbl(j).PROCESS_CODE = G_STATUS_UPDATED
6371 THEN
6372 l_pricing_sts_code_tbl(x) := G_STATUS_UPDATED;
6373 ELSE
6374 l_pricing_sts_code_tbl(x) :=
6375 l_adj_tbl(j).line_pricing_status_code;
6376 END IF;
6377 l_pricing_sts_txt_tbl(x) := l_adj_tbl(j).pricing_status_text;
6378 l_rounding_factor_tbl(x) := l_adj_tbl(j).rounding_factor;
6379
6380 --round the selling price if ROUND_INDIVIDUAL_ADJ profile is N
6381 --in this case the adjustment_amt will not be rounded
6382 --IF G_ROUND_INDIVIDUAL_ADJ = G_NO_ROUND_ADJ
6383
6384 /* 2892848_latest
6385 -- we should round adjs, move rounding ahead
6386 IF G_ROUND_INDIVIDUAL_ADJ <> G_NO_ROUND -- shu fix bug 2239061
6387 -- this is not the final USP since now we order by bucket
6388
6389 and l_rounding_factor_tbl(x) IS NOT NULL
6390 THEN
6391 IF l_debug = FND_API.G_TRUE THEN
6392 QP_PREQ_GRP.engine_debug('need to round selling price, rounding factor: '
6393 ||l_rounding_factor_tbl(x));
6394 END IF;
6395 l_adj_unit_price_tbl(x) :=
6396 round(l_adj_unit_price_tbl(x),-1*l_rounding_factor_tbl(x));
6397 l_ordqty_selling_price_tbl(x) :=
6398 round(l_ordqty_selling_price_tbl(x),-1*l_rounding_factor_tbl(x));
6399 l_ordqty_unit_price_tbl(x) :=
6400 round(l_ordqty_unit_price_tbl(x),-1*l_rounding_factor_tbl(x));
6401 END IF;
6402 */
6403
6404 --This is for prg to get the oldfgline's selling price
6405
6406 IF G_PRG_UNCH_LINE_IND_TBL.EXISTS(l_line_index_tbl(x)) THEN
6407 --fix for bug 2831270
6408 G_PRG_UNCH_CALC_PRICE_TBL(G_PRG_UNCH_LINE_IND_TBL(l_line_index_tbl(x))) :=
6409 l_adj_unit_price_tbl(x);
6410
6411 IF l_debug = FND_API.G_TRUE THEN
6412 QP_PREQ_GRP.engine_debug('oldfgline line ind '
6413 || l_line_index_tbl(x) ||' adjprice '
6414 || G_PRG_UNCH_CALC_PRICE_TBL(G_PRG_UNCH_LINE_IND_TBL(l_line_index_tbl(x))));
6415 END IF; --l_debug
6416 END IF; --G_PRG_UNCH_LINE_IND_TBL
6417
6418 IF l_debug = FND_API.G_TRUE THEN
6419 QP_PREQ_GRP.engine_debug('price in line_tbl'
6420 ||' table index '|| x
6421 ||' line index '|| l_line_index_tbl(x)
6422 ||' adjusted price '|| l_adj_unit_price_tbl(x)
6423 ||' orduomsellingprice '|| l_ordqty_selling_price_tbl(x)
6424 ||' lineunitprice '|| l_ordqty_unit_price_tbl(x)
6425 ||' amt changed '|| l_amount_changed_tbl(x));
6426
6427
6428
6429 QP_PREQ_GRP.engine_debug('going to next line --------------'
6430 || i ||' x '|| x);
6431 END IF;
6432 J := l_adj_tbl.NEXT(j);
6433 END LOOP;
6434 IF l_debug = FND_API.G_TRUE THEN
6435 QP_PREQ_GRP.engine_debug('----------------------------------');
6436
6437 END IF;
6438 IF l_frt_tbl.COUNT > 0
6439 OR l_ldet_line_dtl_index_tbl.COUNT > 0
6440 THEN
6441 x := l_ldet_line_dtl_index_tbl.FIRST;
6442 WHILE x IS NOT NULL
6443 LOOP
6444 IF l_debug = FND_API.G_TRUE THEN
6445 QP_PREQ_GRP.engine_debug('frt charge processing listlineid1 ');
6446 QP_PREQ_GRP.engine_debug('frt charge processing listlineid '
6447 || l_ldet_line_dtl_index_tbl(x) ||' type '
6448 || l_ldet_list_line_type_tbl(x) ||' is max frt ');
6449 END IF;
6450 -- ||l_ldet_is_max_frt_tbl(x));
6451
6452 --fix for bug2424931 update order lvl adj amt
6453 IF (l_debug = FND_API.G_TRUE) THEN
6454 QP_PREQ_GRP.engine_debug('Modifier Level : ' || l_ldet_modifier_level_tbl(x));
6455 END IF;
6456
6457 IF l_ldet_modifier_level_tbl(x) = G_ORDER_LEVEL
6458 THEN
6459 IF l_debug = FND_API.G_TRUE THEN
6460 QP_PREQ_GRP.engine_debug('update ord lvl adj amt '
6461 ||'looping thru dtlind '|| l_ldet_line_dtl_index_tbl(x));
6462 END IF;
6463 i := l_ord_dtl_index_tbl.FIRST;
6464 WHILE i IS NOT NULL
6465 LOOP
6466 IF l_ord_dtl_index_tbl(i) =
6467 l_ldet_line_dtl_index_tbl(x)
6468 THEN
6469 IF l_debug = FND_API.G_TRUE THEN
6470 QP_PREQ_GRP.engine_debug('update ord lvl '
6471 ||' line_dtl_index '|| l_ord_dtl_index_tbl(i)
6472 ||'adj amt '|| l_ord_adj_amt_tbl(i));
6473 END IF;
6474 l_ldet_adj_amt_tbl(x) :=
6475 l_ord_adj_amt_tbl(i);
6476 l_ldet_ordqty_adjamt_tbl(x) :=
6477 l_ord_qty_adj_amt_tbl(i);
6478 l_ldet_ordqty_operand_tbl(x) :=
6479 l_ord_qty_operand_tbl(i);
6480 l_ord_dtl_index_tbl.DELETE(i);
6481 l_ord_adj_amt_tbl.DELETE(i);
6482 END IF; --l_ord_dtl_index_tbl
6483 i := l_ord_dtl_index_tbl.NEXT(i);
6484 END LOOP;
6485 END IF; --l_ldet_modifier_level_tbl
6486
6487 IF l_ldet_list_line_type_tbl(x) = G_FREIGHT_CHARGE
6488 THEN
6489 IF l_debug = FND_API.G_TRUE THEN
6490 QP_PREQ_GRP.engine_debug('frt charge processing listlineid2 ');
6491 END IF;
6492 y := l_frt_tbl.FIRST;
6493 WHILE y IS NOT NULL
6494 LOOP
6495 IF l_debug = FND_API.G_TRUE THEN
6496 QP_PREQ_GRP.engine_debug('frt charge processing listlineid3 ');
6497 QP_PREQ_GRP.engine_debug('l_ldet_line_index_tbl(x): '|| l_ldet_line_index_tbl(x));
6498 END IF;
6499 IF l_frt_tbl(y).line_detail_index =
6500 l_ldet_line_dtl_index_tbl(x)
6501 AND l_ldet_line_index_tbl(x) = -- 2892848 fix bug,
6502 l_frt_tbl(y).line_index -- 2892848 fix bug
6503 THEN
6504 IF l_debug = FND_API.G_TRUE THEN
6505 QP_PREQ_GRP.engine_debug('frt charge processing listlineid4 ');
6506 END IF;
6507 l_ldet_pricing_sts_code_tbl(x) := G_STATUS_NEW;
6508 l_ldet_pricing_sts_txt_tbl(x) := 'MAX FRT CHARGE';
6509 l_frt_tbl.DELETE(y);
6510 IF l_debug = FND_API.G_TRUE THEN
6511 QP_PREQ_GRP.engine_debug('frt charge retaind '
6512 || l_ldet_list_line_id_tbl(x) ||' '
6513 || l_ldet_pricing_sts_code_tbl(x));
6514 END IF;
6515 END IF;
6516 y := l_frt_tbl.NEXT(y);
6517 END LOOP; --frt_tbl
6518 END IF; --frt_charge
6519 x := l_ldet_line_dtl_index_tbl.NEXT(x);
6520 END LOOP; --ldet_line_dtl_index_tbl
6521 IF l_debug = FND_API.G_TRUE THEN
6522 QP_PREQ_GRP.engine_debug('----------------------------------');
6523 END IF;
6524 END IF; --frt_tbl.count
6525
6526 IF l_debug = FND_API.G_TRUE THEN
6527 QP_PREQ_GRP.engine_debug('----------------------------------');
6528
6529 END IF;
6530 --**************************************************************
6531 --BACK CALCULATION ROUTINE
6532 --**************************************************************
6533 --xxxxxxxxxxxxxx
6534
6535 IF l_debug = FND_API.G_TRUE THEN
6536 QP_PREQ_GRP.engine_debug('back calculation for line ');
6537 END IF;
6538 IF l_line_index_tbl.COUNT > 0
6539 THEN
6540 IF l_debug = FND_API.G_TRUE THEN
6541 QP_PREQ_GRP.engine_debug('back calculation1 for line ');
6542 END IF;
6543 i := l_line_index_tbl.FIRST;
6544 WHILE i IS NOT NULL
6545 LOOP
6546 IF l_debug = FND_API.G_TRUE THEN
6547 QP_PREQ_GRP.engine_debug('back calculation2 for line '
6548 || l_amount_changed_tbl(i));
6549 END IF; --l_debug
6550
6551 IF l_back_calc_dtl_index.EXISTS(l_line_index_tbl(i)) THEN
6552 l_back_calc_adj_amount := nvl(l_back_calc_adj_amt(l_line_index_tbl(i)), 0);
6553 l_back_calc_dtl_ind := nvl(l_back_calc_dtl_index(l_line_index_tbl(i)), 0);
6554 l_back_calc_plsql_index := l_back_calc_plsql_tbl_index(l_line_index_tbl(i));
6555 ELSE
6556 l_back_calc_adj_amount := 0;
6557 l_back_calc_dtl_ind := 0;
6558 l_back_calc_plsql_index := 0;
6559 END IF;
6560 IF l_debug = FND_API.G_TRUE THEN
6561 QP_PREQ_GRP.engine_debug('prev back calculation rec '
6562 || l_back_calc_dtl_ind
6563 ||' plsql '|| l_back_calc_plsql_index
6564 ||' adj amt '|| l_back_calc_adj_amount);
6565 END IF; --l_debug
6566
6567 --l_back_calc_adj_amt has to be subtracted from amount changed
6568 --as we want to back calculate the amount overridden now
6569 --as the adjustment l_back_calc_dtl_index has been applied
6570 --already during calculation
6571 IF l_upd_adj_unit_price_tbl(i) IS NOT NULL
6572 AND ((l_upd_adj_unit_price_tbl(i) -
6573 l_adj_unit_price_tbl(i)) <> 0)
6574 THEN
6575 IF l_debug = FND_API.G_TRUE THEN
6576 QP_PREQ_GRP.engine_debug('back calculation for line '
6577 || l_line_index_tbl(i));
6578
6579 END IF;
6580
6581 ---- 9537858 / 10315863 for ASO only when Line qty and Price qty are different Unit price is re calculated if occurs for other products please add in if
6582 IF G_REQUEST_TYPE_CODE = 'ASO' THEN
6583 l_upd_adj_unit_price_tbl(i) := l_upd_adj_unit_price_tbl(i)*(l_ordered_qty_tbl(i)/l_line_priced_qty_tbl(i));
6584 END IF;
6585 ---- 9537858 / 10315863
6586 /* 9537858 / 10315863 No need to round at this stage.. rounding is done after Back_calculation */
6587
6588 --fix for bug 2146050
6589 IF G_ROUND_INDIVIDUAL_ADJ not in (G_NO_ROUND, G_POST_ROUND) AND G_REQUEST_TYPE_CODE <> 'ASO'
6590 --[prarasto:Post Round] added check to skip rounding for Post Rounding
6591 AND l_rounding_factor_tbl(i) IS NOT NULL
6592 THEN
6593 l_upd_adj_unit_price_tbl(i) :=
6594 round(l_upd_adj_unit_price_tbl(i),
6595 - 1 * l_rounding_factor_tbl(i));
6596
6597 -- 2892848
6598 l_adj_unit_price_tbl(i) :=
6599 round(l_adj_unit_price_tbl(i),
6600 - 1 * l_rounding_factor_tbl(i));
6601 END IF;
6602
6603 --l_back_calc_adj_amt is added to remove the
6604 --adjustment applied earlier
6605 l_amount_changed_tbl(i) :=
6606 (l_upd_adj_unit_price_tbl(i) +
6607 l_back_calc_adj_amount)
6608 - l_adj_unit_price_tbl(i);
6609
6610 IF l_debug = FND_API.G_TRUE THEN
6611 QP_PREQ_GRP.engine_debug('amt changed '
6612 || l_amount_changed_tbl(i));
6613 END IF; --l_debug
6614
6615 IF l_amount_changed_tbl(i) <= 0 THEN
6616 G_BACK_CALCULATION_CODE := 'DIS';
6617 ELSE
6618 G_BACK_CALCULATION_CODE := 'SUR';
6619 END IF; --l_amount_changed_tbl
6620
6621 BACK_CALCULATION(l_line_index_tbl(i)
6622 , l_amount_changed_tbl(i)
6623 , l_back_calc_ret_rec
6624 , l_return_status
6625 , l_return_status_text);
6626
6627 IF l_return_status = FND_API.G_RET_STS_SUCCESS
6628 THEN
6629
6630 --need to do this check for bug 2833753
6631 IF G_ldet_plsql_index_tbl.EXISTS(l_back_calc_ret_rec.line_detail_index) THEN
6632 --if this is an existing adjustment, need to update
6633 l_tbl_index := G_ldet_plsql_index_tbl(l_back_calc_ret_rec.line_detail_index);
6634 ELSE
6635 l_tbl_index := l_ldet_line_dtl_index_tbl.COUNT + 1;
6636 END IF; --G_ldet_plsql_index_tbl
6637
6638 IF l_debug = FND_API.G_TRUE THEN
6639 QP_PREQ_GRP.engine_debug('back cal succ insert rec '
6640 || l_tbl_index);
6641 END IF;
6642 l_ldet_line_dtl_index_tbl(l_tbl_index) :=
6643 l_back_calc_ret_rec.line_detail_index;
6644
6645 --bug 13696379
6646 l_ldet_price_adjust_id_tbl(l_tbl_index) := null;
6647
6648 l_ldet_line_index_tbl(l_tbl_index) :=
6649 l_back_calc_ret_rec.line_index;
6650 l_ldet_list_line_id_tbl(l_tbl_index) :=
6651 l_back_calc_ret_rec.list_line_id;
6652 l_ldet_applied_flag_tbl(l_tbl_index) :=
6653 l_back_calc_ret_rec.applied_flag;
6654 l_ldet_updated_flag_tbl(l_tbl_index) :=
6655 l_back_calc_ret_rec.updated_flag;
6656 l_ldet_adj_amt_tbl(l_tbl_index) :=
6657 l_back_calc_ret_rec.adjustment_amount;
6658 l_ldet_operand_value_tbl(l_tbl_index) :=
6659 l_back_calc_ret_rec.operand_value;
6660 l_ldet_process_code_tbl(l_tbl_index) :=
6661 l_back_calc_ret_rec.process_code;
6662 l_ldet_pricing_sts_code_tbl(l_tbl_index) :=
6663 l_back_calc_ret_rec.pricing_status_code;
6664 l_ldet_pricing_sts_txt_tbl(l_tbl_index) :=
6665 l_back_calc_ret_rec.pricing_status_text;
6666 l_ldet_list_hdr_id_tbl(l_tbl_index) := NULL;
6667 l_ldet_list_line_type_tbl(l_tbl_index) :=
6668 l_back_calc_ret_rec.list_line_type_code;
6669 l_ldet_line_quantity_tbl(l_tbl_index) :=
6670 l_back_calc_ret_rec.line_quantity;
6671 l_ldet_process_code_tbl(l_tbl_index) :=
6672 G_STATUS_NEW;
6673 l_ldet_list_hdr_id_tbl(l_tbl_index) :=
6674 l_back_calc_ret_rec.list_header_id;
6675 l_ldet_list_type_code_tbl(l_tbl_index) :=
6676 l_back_calc_ret_rec.list_type_code;
6677 l_ldet_price_break_type_tbl(l_tbl_index) :=
6678 l_back_calc_ret_rec.price_break_type_code;
6679 l_ldet_charge_type_tbl(l_tbl_index) :=
6680 l_back_calc_ret_rec.charge_type_code;
6681 l_ldet_charge_subtype_tbl(l_tbl_index) :=
6682 l_back_calc_ret_rec.charge_subtype_code;
6683 l_ldet_automatic_flag_tbl(l_tbl_index) :=
6684 l_back_calc_ret_rec.automatic_flag;
6685 l_ldet_pricing_phase_id_tbl(l_tbl_index) :=
6686 l_back_calc_ret_rec.pricing_phase_id;
6687 l_ldet_limit_code_tbl(l_tbl_index) :=
6688 l_back_calc_ret_rec.limit_code;
6689 l_ldet_limit_text_tbl(l_tbl_index) :=
6690 l_back_calc_ret_rec.limit_text;
6691 l_ldet_operand_calc_tbl(l_tbl_index) :=
6692 l_back_calc_ret_rec.operand_calculation_code;
6693 l_ldet_pricing_grp_seq_tbl(l_tbl_index) :=
6694 l_back_calc_ret_rec.pricing_group_sequence;
6695 l_ldet_list_line_no_tbl(l_tbl_index) :=
6696 l_back_calc_ret_rec.list_line_no;
6697 l_ldet_calc_code_tbl(l_tbl_index) :=
6698 l_back_calc_ret_rec.calculation_code;
6699 l_ldet_modifier_level_tbl(l_tbl_index) :=
6700 l_back_calc_ret_rec.modifier_level_code;
6701
6702 --if a different adj is selected this time
6703 --need to mark the old one as deleted
6704 IF l_back_calc_ret_rec.line_detail_index <>
6705 l_back_calc_dtl_ind
6706 AND l_back_calc_plsql_index <> 0 THEN
6707 l_ldet_applied_flag_tbl(l_back_calc_plsql_index)
6708 := G_NO;
6709 l_ldet_calc_code_tbl(l_back_calc_plsql_index)
6710 := NULL;
6711 l_ldet_pricing_sts_code_tbl(l_back_calc_plsql_index)
6712 := G_STATUS_DELETED;
6713 l_ldet_pricing_sts_txt_tbl(l_back_calc_plsql_index)
6714 := 'DELETED IN BACK CALC';
6715 END IF; --l_back_calc_ret_rec.line_detail_index
6716
6717
6718 l_adj_unit_price_tbl(i) := l_upd_adj_unit_price_tbl(i);
6719
6720 --fix for bug 2812738
6721 --changes to calculate the order_uom_selling_price
6722 IF (l_ordered_qty_tbl(i) <> 0
6723 OR l_ldet_modifier_level_tbl(l_tbl_index) =
6724 G_ORDER_LEVEL) THEN
6725 IF (l_debug = FND_API.G_TRUE) THEN
6726 QP_PREQ_GRP.engine_debug('Before Going into '
6727 ||'GET_ORDERQTY_VALUES #2.5');
6728 END IF; --l_debug
6729 GET_ORDERQTY_VALUES(p_ordered_qty =>
6730 l_ordered_qty_tbl(i),
6731 p_priced_qty => l_line_priced_qty_tbl(i),
6732 p_catchweight_qty => l_catchweight_qty_tbl(i),
6733 p_actual_order_qty => l_actual_order_qty_tbl(i),
6734 p_unit_price => l_unit_price_tbl(i),
6735 p_adjusted_unit_price => l_adj_unit_price_tbl(i),
6736 p_line_unit_price => l_line_unit_price_tbl(i),
6737 p_input_type => 'SELLING_PRICE',
6738 x_ordqty_output1 => l_ordqty_unit_price_tbl(i),
6739 x_ordqty_output2 => l_ordqty_selling_price_tbl(i),
6740 x_return_status => x_return_status,
6741 x_return_status_text => x_return_status_text);
6742 ELSE --ordered_qty
6743 IF l_debug = FND_API.G_TRUE THEN
6744 QP_PREQ_GRP.engine_debug('Ordered Qty #2.5 : '
6745 || l_ordered_qty_tbl(i));
6746 QP_PREQ_GRP.engine_debug('SELLING PRICE Ordered Qty is '
6747 ||'0 or modifier level code is not ORDER');
6748 END IF; --l_debug
6749 l_ordqty_unit_price_tbl(i) := 0;
6750 l_ordqty_selling_price_tbl(i) := 0;
6751 END IF; --ordered_qty
6752
6753 -- Ravi
6754 --this procedure is called to calculate the
6755 --selling_price,adjustment_amount and operand in ordered_qty
6756 --which is the line_quantity on lines_tmp
6757 -- This needs to be called for back calculated adj record,otherwise
6758 -- l_ldet_ordqty_operand_tbl and l_ldet_ordqty_adjamt_tbl data is not there
6759 -- and is failing with error element at index[5] does not exist error when
6760 -- trying to override the selling price
6761
6762 -- Ravi bug# 2745337-divisor by zero
6763 IF (l_ordered_qty_tbl(i) <> 0
6764 OR l_ldet_modifier_level_tbl(l_tbl_index) =
6765 G_ORDER_LEVEL) THEN
6766 IF (l_debug = FND_API.G_TRUE) THEN
6767 QP_PREQ_GRP.engine_debug('Before Going into GET_ORDERQTY_VALUES #3');
6768 END IF;
6769 GET_ORDERQTY_VALUES(p_ordered_qty => l_ordered_qty_tbl(i),
6770 p_priced_qty => l_line_priced_qty_tbl(i),
6771 p_catchweight_qty => l_catchweight_qty_tbl(i),
6772 p_actual_order_qty => l_actual_order_qty_tbl(i),
6773 p_operand => l_ldet_operand_value_tbl(l_tbl_index),
6774 p_adjustment_amt => l_ldet_adj_amt_tbl(l_tbl_index),
6775 p_unit_price => l_unit_price_tbl(i),
6776 p_adjusted_unit_price => l_adj_unit_price_tbl(i),
6777 p_operand_calculation_code => l_ldet_operand_calc_tbl(l_tbl_index),
6778 p_input_type => 'OPERAND',
6779 x_ordqty_output1 => l_ldet_ordqty_operand_tbl(l_tbl_index),
6780 x_ordqty_output2 => l_ldet_ordqty_adjamt_tbl(l_tbl_index),
6781 x_return_status => x_return_status,
6782 x_return_status_text => x_return_status_text);
6783 ELSE
6784 IF l_debug = FND_API.G_TRUE THEN
6785 QP_PREQ_GRP.engine_debug('Ordered Qty #3 : ' || l_ordered_qty_tbl(i));
6786 QP_PREQ_GRP.engine_debug('OPERAND Ordered Qty is 0 or modifier level code is not ORDER');
6787 END IF;
6788 l_ldet_ordqty_operand_tbl(l_tbl_index) := 0;
6789 l_ldet_ordqty_adjamt_tbl(l_tbl_index) := 0;
6790 END IF;
6791
6792 -- End Ravi
6793
6794 --fix for bug 2146050 to round adjustment amt
6795 IF G_ROUND_INDIVIDUAL_ADJ = G_ROUND_ADJ
6796 AND l_rounding_factor_tbl(i) IS NOT NULL
6797 THEN
6798 l_ldet_adj_amt_tbl(l_tbl_index) :=
6799 round(l_ldet_adj_amt_tbl(l_tbl_index),
6800 - 1 * l_rounding_factor_tbl(i));
6801 l_ldet_ordqty_adjamt_tbl(l_tbl_index) :=
6802 round(l_ldet_ordqty_adjamt_tbl(l_tbl_index),
6803 - 1 * l_rounding_factor_tbl(i));
6804 END IF;
6805
6806 --round the selling price if ROUND_INDIVIDUAL_ADJ
6807 --profile is N in this case the adjustment_amt
6808 --will not be rounded
6809 IF G_ROUND_INDIVIDUAL_ADJ = G_NO_ROUND_ADJ -- 2892848_latest, not to round current USP for G_ROUND_ADJ case since it is not final USP yet
6810 --IF G_ROUND_INDIVIDUAL_ADJ <> G_NO_ROUND -- shu fix 2239061
6811 AND l_rounding_factor_tbl(i) IS NOT NULL
6812 THEN
6813 IF l_debug = FND_API.G_TRUE THEN
6814 QP_PREQ_GRP.engine_debug('need to round selling price, rounding factor: '
6815 || l_rounding_factor_tbl(i));
6816 END IF;
6817 l_adj_unit_price_tbl(i) :=
6818 round(l_adj_unit_price_tbl(i)
6819 , - 1 * l_rounding_factor_tbl(i));
6820 l_ordqty_unit_price_tbl(i) :=
6821 round(l_ordqty_unit_price_tbl(i)
6822 , - 1 * l_rounding_factor_tbl(i));
6823 l_ordqty_selling_price_tbl(i) :=
6824 round(l_ordqty_selling_price_tbl(i)
6825 , - 1 * l_rounding_factor_tbl(i));
6826 END IF;
6827
6828 ELSE --ret_status
6829 IF l_debug = FND_API.G_TRUE THEN
6830 QP_PREQ_GRP.engine_debug('back cal fail no insert rec');
6831 END IF;
6832 l_pricing_sts_code_tbl(i) := l_return_status;
6833 l_pricing_sts_txt_tbl(i) :=
6834 l_return_status_text;
6835 END IF; --ret_status
6836 END IF;
6837 i := l_line_index_tbl.NEXT(i);
6838 END LOOP;
6839 END IF; --count > 0
6840 IF l_debug = FND_API.G_TRUE THEN
6841 QP_PREQ_GRP.engine_debug('end back calc for line ');
6842
6843 END IF;
6844 ---------------------------------------------------------------------
6845 --Debug Info
6846 ---------------------------------------------------------------------
6847 IF QP_PREQ_GRP.g_debug_engine = fnd_api.g_true
6848 THEN
6849 IF l_debug = FND_API.G_TRUE THEN
6850 QP_PREQ_GRP.engine_debug('in debug --------------');
6851 END IF;
6852 j := l_line_index_tbl.FIRST;
6853 WHILE j IS NOT NULL
6854 LOOP
6855 -- begin 2892848_latest
6856 /* commented out for bug 3663518
6857 IF G_ROUND_INDIVIDUAL_ADJ <> G_NO_ROUND -- 2892848_latest, round finalUSP
6858 AND l_rounding_factor_tbl(j) IS NOT NULL THEN
6859
6860 l_adj_unit_price_tbl(j) := round(l_adj_unit_price_tbl(j)
6861 ,-1*l_rounding_factor_tbl(j));
6862
6863 l_ordqty_unit_price_tbl(j) := round(l_ordqty_unit_price_tbl(j)
6864 ,-1*l_rounding_factor_tbl(j));
6865
6866 l_ordqty_selling_price_tbl(j) := round(l_ordqty_selling_price_tbl(j)
6867 ,-1*l_rounding_factor_tbl(j));
6868 END IF; -- end rounding 2892848
6869 */
6870
6871 IF l_debug = FND_API.G_TRUE THEN
6872 QP_PREQ_GRP.engine_debug('(No final rounding) Line Info '|| j
6873 ||' line index '|| l_line_index_tbl(j)
6874 ||' unit price '|| l_unit_price_tbl(j)
6875 ||' final adjusted_unit_price '|| l_adj_unit_price_tbl(j)
6876 ||' pricing_status_code '|| l_pricing_sts_code_tbl(j)
6877 ||' pricing_status_text '|| l_pricing_sts_txt_tbl(j));
6878 END IF;
6879 -- ||' processed_flag '||l_processed_flag_tbl(j));
6880 -- ||' processed_code '||l_processed_code_tbl(j));
6881 IF l_debug = FND_API.G_TRUE THEN
6882 QP_PREQ_GRP.engine_debug('----------------------------------');
6883 END IF;
6884 i := l_ldet_line_dtl_index_tbl.FIRST;
6885 WHILE i IS NOT NULL
6886 LOOP
6887 IF l_line_index_tbl(j) = l_ldet_line_index_tbl(i)
6888 THEN
6889 IF l_debug = FND_API.G_TRUE THEN
6890 QP_PREQ_GRP.engine_debug('Line detail Info '|| i
6891 ||' line detail index '|| l_ldet_line_dtl_index_tbl(i)
6892 ||' list_line_id '|| l_ldet_list_line_id_tbl(i)
6893 ||' operand '|| l_ldet_operand_value_tbl(i)
6894 ||' adjustment amount '|| l_ldet_adj_amt_tbl(i)
6895 ||' applied flag '|| l_ldet_applied_flag_tbl(i)
6896 ||' updated flag '|| l_ldet_updated_flag_tbl(i)
6897 ||' pricingstatus code '|| l_ldet_pricing_sts_code_tbl(i)
6898 ||' process code '|| l_ldet_process_code_tbl(i));
6899 END IF;
6900 END IF;
6901 i := l_ldet_line_dtl_index_tbl.NEXT(i);
6902 END LOOP;
6903 IF l_debug = FND_API.G_TRUE THEN
6904 QP_PREQ_GRP.engine_debug('----------------------------------');
6905 END IF;
6906 j := l_line_index_tbl.NEXT(j);
6907 END LOOP;
6908 IF l_debug = FND_API.G_TRUE THEN
6909 QP_PREQ_GRP.engine_debug('-------------------------------------------');
6910
6911 END IF;
6912 END IF;
6913
6914 IF l_debug = FND_API.G_TRUE THEN
6915 QP_PREQ_GRP.engine_debug('Updating the line details ------------------------');
6916
6917 END IF;
6918 ---------------------------------------------------------------------
6919 --Update Adjustments
6920 ---------------------------------------------------------------------
6921 IF l_ldet_line_dtl_index_tbl.COUNT > 0
6922 THEN
6923 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
6924 THEN
6925 i := l_ldet_line_dtl_index_tbl.FIRST;
6926 WHILE i IS NOT NULL
6927 LOOP
6928 IF l_debug = FND_API.G_TRUE THEN
6929 QP_PREQ_GRP.engine_debug('line details: line index '
6930 || l_ldet_line_index_tbl(i) ||' detail index '
6931 || l_ldet_line_dtl_index_tbl(i) ||' operand '
6932 || l_ldet_operand_value_tbl(i) ||' adjamt '
6933 || l_ldet_adj_amt_tbl(i) ||' applied flag '
6934 || l_ldet_applied_flag_tbl(i) ||' pricing_status '
6935 || l_ldet_pricing_sts_code_tbl(i) ||' text '
6936 || l_ldet_pricing_sts_txt_tbl(i) ||' process code '
6937 || l_ldet_process_code_tbl(i) ||' list hdr id '
6938 || l_ldet_list_hdr_id_tbl(i) ||' adj type '
6939 || l_ldet_list_line_type_tbl(i) ||' adj id '
6940 || l_ldet_list_line_id_tbl(i) || ' list line id '
6941 || l_ldet_ordqty_operand_tbl(i) || ' Ord Qty Operand '
6942 || l_ldet_ordqty_adjamt_tbl(i) || 'Ord Qty Adj Amt');
6943 QP_PREQ_GRP.engine_debug('------------------------');
6944 END IF;
6945 i := l_ldet_line_dtl_index_tbl.NEXT(i);
6946 END LOOP;
6947 END IF;
6948
6949 IF l_debug = FND_API.G_TRUE THEN
6950 QP_PREQ_GRP.engine_debug('line details: before update ');
6951 END IF;
6952 IF l_ldet_line_dtl_index_tbl.COUNT > 0
6953 THEN
6954 FORALL i IN l_ldet_line_dtl_index_tbl.FIRST..l_ldet_line_dtl_index_tbl.LAST
6955 UPDATE qp_npreq_ldets_tmp
6956 SET adjustment_amount = l_ldet_adj_amt_tbl(i),
6957 operand_value = l_ldet_operand_value_tbl(i),
6958 line_quantity = l_ldet_line_quantity_tbl(i),
6959 applied_flag = l_ldet_applied_flag_tbl(i),
6960 updated_flag = l_ldet_updated_flag_tbl(i),
6961 pricing_status_code = l_ldet_pricing_sts_code_tbl(i),
6962 pricing_status_text = l_ldet_pricing_sts_txt_tbl(i),
6963 process_code = l_ldet_process_code_tbl(i),
6964 calculation_code = l_ldet_calc_code_tbl(i),
6965 order_qty_operand = l_ldet_ordqty_operand_tbl(i),
6966 order_qty_adj_amt = nvl(l_ldet_ordqty_adjamt_tbl(i), l_ldet_adj_amt_tbl(i))
6967 WHERE line_detail_index = l_ldet_line_dtl_index_tbl(i)
6968 -- AND line_index = l_ldet_line_index_tbl(i)
6969 AND pricing_status_code <> G_STATUS_DELETED --[julin/4671446]
6970 AND l_ldet_process_code_tbl(i) IN (G_STATUS_NEW,
6971 G_STATUS_DELETED);
6972 IF l_debug = FND_API.G_TRUE THEN
6973 QP_PREQ_GRP.engine_debug('line details: before insert ');
6974 END IF;
6975 END IF; --l_ldet_line_dtl_index_tbl.count > 0
6976
6977 FORALL i IN l_ldet_line_dtl_index_tbl.FIRST..l_ldet_line_dtl_index_tbl.LAST
6978 INSERT INTO qp_npreq_ldets_tmp
6979 (
6980 line_detail_index
6981 , line_index
6982 , line_detail_type_code
6983 , pricing_status_code
6984 , pricing_status_text
6985 , process_code
6986 , created_from_list_header_id
6987 , created_from_list_line_id
6988 , created_from_list_line_type
6989 , adjustment_amount
6990 , operand_value
6991 , modifier_level_code
6992 , price_break_type_code
6993 , line_quantity
6994 , operand_calculation_code
6995 , pricing_group_sequence
6996 , created_from_list_type_code
6997 , applied_flag
6998 , limit_code
6999 , limit_text
7000 , list_line_no
7001 , charge_type_code
7002 , charge_subtype_code
7003 , updated_flag
7004 , automatic_flag
7005 , pricing_phase_id
7006 , calculation_code
7007 , order_qty_operand
7008 , order_qty_adj_amt
7009 , price_adjustment_id --bug 12731184
7010 )
7011 -- VALUES
7012 SELECT
7013 l_ldet_line_dtl_index_tbl(i)
7014 , l_ldet_line_index_tbl(i)
7015 , 'NULL'
7016 , l_ldet_pricing_sts_code_tbl(i)
7017 , l_ldet_pricing_sts_txt_tbl(i)
7018 , l_ldet_process_code_tbl(i)
7019 , l_ldet_list_hdr_id_tbl(i)
7020 , l_ldet_list_line_id_tbl(i)
7021 , l_ldet_list_line_type_tbl(i)
7022 , l_ldet_adj_amt_tbl(i)
7023 , l_ldet_operand_value_tbl(i)
7024 , l_ldet_modifier_level_tbl(i)
7025 , l_ldet_price_break_type_tbl(i)
7026 , l_ldet_line_quantity_tbl(i)
7027 , l_ldet_operand_calc_tbl(i)
7028 , l_ldet_pricing_grp_seq_tbl(i)
7029 , l_ldet_list_type_code_tbl(i)
7030 , l_ldet_applied_flag_tbl(i)
7031 , l_ldet_limit_code_tbl(i)
7032 , l_ldet_limit_text_tbl(i)
7033 , l_ldet_list_line_no_tbl(i)
7034 , l_ldet_charge_type_tbl(i)
7035 , l_ldet_charge_subtype_tbl(i)
7036 , l_ldet_updated_flag_tbl(i)
7037 , l_ldet_automatic_flag_tbl(i)
7038 , l_ldet_pricing_phase_id_tbl(i)
7039 , l_ldet_calc_code_tbl(i)
7040 , l_ldet_ordqty_operand_tbl(i)
7041 , nvl(l_ldet_ordqty_adjamt_tbl(i), l_ldet_adj_amt_tbl(i))
7042 , l_ldet_price_adjust_id_tbl(i) --bug 12731184
7043 FROM dual
7044 WHERE l_ldet_process_code_tbl(i) = G_STATUS_UPDATED;
7045 END IF;
7046
7047 ---------------------------------------------------------------------
7048 IF l_debug = FND_API.G_TRUE THEN
7049 QP_PREQ_GRP.engine_debug('Updating the line info ------------------------');
7050 END IF;
7051 ---------------------------------------------------------------------
7052 --Update Order Lines
7053 ---------------------------------------------------------------------
7054
7055
7056 IF l_line_index_tbl.COUNT > 0
7057 THEN
7058 FOR i IN l_line_index_tbl.FIRST..l_line_index_tbl.LAST
7059 LOOP
7060 IF l_debug = FND_API.G_TRUE THEN
7061 QP_PREQ_GRP.engine_debug('line info '|| l_line_index_tbl(i)
7062 ||' unit price '|| l_unit_price_tbl(i)
7063 ||' adj unit price '|| l_adj_unit_price_tbl(i));
7064 END IF;
7065 END LOOP;
7066 FOR i IN l_line_index_tbl.FIRST..l_line_index_tbl.LAST
7067 LOOP
7068
7069 --===[prarasto:Post Round] Start : Calculate rounded values ==--
7070 l_adjusted_unit_price_ur(i) := l_adj_unit_price_tbl(i);
7071 l_unit_selling_price_ur(i) := l_ordqty_selling_price_tbl(i);
7072
7073 IF (G_ROUND_INDIVIDUAL_ADJ not in ( G_NO_ROUND , G_POST_ROUND )) AND (l_rounding_factor_tbl(i) is not null)
7074 THEN
7075 IF (l_catchweight_qty_tbl(i) is null) and (l_actual_order_qty_tbl(i) is not null) THEN
7076 l_extended_selling_price_ur(i) := round(l_unit_selling_price_ur(i), - 1 * l_rounding_factor_tbl(i))
7077 * l_actual_order_qty_tbl(i);
7078 ELSE
7079 l_extended_selling_price_ur(i) := round(l_unit_selling_price_ur(i), - 1 * l_rounding_factor_tbl(i))
7080 * l_ordered_qty_tbl(i);
7081 END IF;
7082 ELSE
7083 IF (l_catchweight_qty_tbl(i) is null) and (l_actual_order_qty_tbl(i) is not null) THEN
7084 l_extended_selling_price_ur(i) := l_unit_selling_price_ur(i) * l_actual_order_qty_tbl(i);
7085 ELSE
7086 l_extended_selling_price_ur(i) := l_unit_selling_price_ur(i) * l_ordered_qty_tbl(i);
7087 END IF;
7088 END IF;
7089
7090 IF (G_ROUND_INDIVIDUAL_ADJ = G_NO_ROUND) or (l_rounding_factor_tbl(i) is null) THEN
7091 -- l_adj_unit_price_tbl(i) := l_adjusted_unit_price_ur(i);
7092 l_unit_selling_price(i) := l_unit_selling_price_ur(i);
7093 l_extended_selling_price(i) := l_extended_selling_price_ur(i);
7094 ELSE
7095 l_adj_unit_price_tbl(i) := round(l_adjusted_unit_price_ur(i), - 1 * l_rounding_factor_tbl(i));
7096 l_ordqty_unit_price_tbl(i) := round(l_ordqty_unit_price_tbl(i), - 1 * l_rounding_factor_tbl(i));
7097 l_unit_selling_price(i) := round(l_unit_selling_price_ur(i), - 1 * l_rounding_factor_tbl(i));
7098 l_extended_selling_price(i) := round(l_extended_selling_price_ur(i), - 1 * l_rounding_factor_tbl(i));
7099 END IF;
7100
7101 IF l_debug = FND_API.G_TRUE THEN
7102 QP_PREQ_GRP.engine_debug('Extended selling price unrounded : '||l_extended_selling_price_ur(i));
7103 QP_PREQ_GRP.engine_debug('Extended selling price : '||l_extended_selling_price(i));
7104 QP_PREQ_GRP.engine_debug('Unit selling price unrounded : '||l_unit_selling_price_ur(i));
7105 QP_PREQ_GRP.engine_debug('Unit selling price : '||l_unit_selling_price(i));
7106 QP_PREQ_GRP.engine_debug('Adjusted unit price unrounded : '||l_adjusted_unit_price_ur(i));
7107 QP_PREQ_GRP.engine_debug('Adjusted unit price : '||l_adj_unit_price_tbl(i));
7108 QP_PREQ_GRP.engine_debug('Line unit price : '||l_ordqty_unit_price_tbl(i));
7109 END IF; --l_debug
7110 --===[prarasto:Post Round] End : Calculate rounded values ==--
7111
7112
7113 UPDATE qp_npreq_lines_tmp
7114 SET unit_price = l_unit_price_tbl(i),
7115 adjusted_unit_price = l_adj_unit_price_tbl(i), --[prarasto:Post Round]
7116 --adjusted_unit_price_ur = l_adjusted_unit_price_ur(i), --[prarasto:Post Round], [julin/postround] redesign
7117 /* decode(G_ROUND_INDIVIDUAL_ADJ,
7118 G_NO_ROUND, l_adj_unit_price_tbl(i),
7119 decode(l_rounding_factor_tbl(i),
7120 NULL, l_adj_unit_price_tbl(i),
7121 round(l_adj_unit_price_tbl(i), - 1 * l_rounding_factor_tbl(i)))),
7122 */
7123 -- updated_adjusted_unit_price = l_upd_adj_unit_price_tbl(i)
7124 pricing_status_code = l_pricing_sts_code_tbl(i),
7125 pricing_status_text = l_pricing_sts_txt_tbl(i),
7126 processed_flag = G_PROCESSED,
7127 line_unit_price = l_ordqty_unit_price_tbl(i), --[prarasto:Post Round]
7128 /* decode(G_ROUND_INDIVIDUAL_ADJ,
7129 G_NO_ROUND, l_ordqty_unit_price_tbl(i),
7130 decode(l_rounding_factor_tbl(i),
7131 NULL, l_ordqty_unit_price_tbl(i),
7132 round(l_ordqty_unit_price_tbl(i), - 1 * l_rounding_factor_tbl(i)))),
7133 */
7134 order_uom_selling_price = l_unit_selling_price(i), --[prarasto:Post Round]
7135 /* decode(G_ROUND_INDIVIDUAL_ADJ,
7136 G_NO_ROUND, l_ordqty_selling_price_tbl(i),
7137 decode(l_rounding_factor_tbl(i),
7138 NULL, l_ordqty_selling_price_tbl(i),
7139 round(l_ordqty_selling_price_tbl(i), - 1 * l_rounding_factor_tbl(i)))),
7140 */
7141 --order_uom_selling_price_ur = l_unit_selling_price_ur(i), --[prarasto:Post Round], [julin/postround] redesign
7142 extended_price = l_extended_selling_price(i), --[prarasto:Post Round]
7143 --extended_selling_price_ur = l_extended_selling_price_ur(i), --[prarasto:Post Round], [julin/postround] redesign
7144 QUALIFIERS_EXIST_FLAG = G_CALCULATE_ONLY
7145 WHERE line_index = l_line_index_tbl(i);
7146 -- AND l_processed_code_tbl(i) = G_STATUS_NEW;
7147
7148 END LOOP; --[prarasto:Post Round]
7149 END IF;
7150 ---------------------------------------------------------------------
7151
7152 -- QP_CLEANUP_ADJUSTMENTS_PVT.cleanup_adjustments('ONTVIEW',G_YES);
7153
7154
7155 --X_RETURN_STATUS:= FND_API.G_RET_STS_SUCCESS;
7156 --X_RETURN_STATUS_TEXT:= l_routine||' SUCCESS ';
7157
7158 IF l_debug = FND_API.G_TRUE THEN
7159 QP_PREQ_GRP.engine_debug('end calculate price');
7160 END IF;
7161 EXCEPTION
7162 WHEN Calculate_exc THEN
7163 IF l_debug = FND_API.G_TRUE THEN
7164 QP_PREQ_GRP.engine_debug('Error in calculate_price'|| X_RETURN_STATUS_TEXT);
7165 END IF;
7166 X_RETURN_STATUS := FND_API.G_RET_STS_ERROR;
7167 WHEN OTHERS THEN
7168 IF l_debug = FND_API.G_TRUE THEN
7169 QP_PREQ_GRP.engine_debug('Error in calculate_price'|| SQLERRM);
7170 END IF;
7171 X_RETURN_STATUS := FND_API.G_RET_STS_ERROR;
7172 X_RETURN_STATUS_TEXT := l_routine || SQLERRM;
7173
7174 END CALCULATE_PRICE;
7175
7176 --this is used in pl/sql code path for OKC/OKS/ASO
7177 --this is called from QP_PREQ_PUB.price_request
7178
7179 PROCEDURE CALCULATE_PRICE(p_rounding_flag IN VARCHAR2,
7180 x_return_status OUT NOCOPY VARCHAR2,
7181 x_return_status_text OUT NOCOPY VARCHAR2) IS
7182
7183 /*
7184 INDX,QP_PREQ_PUB.calculate_price.l_line_cur,qp_npreq_lines_tmp_N2,LINE_TYPE_CODE,1
7185 */
7186 -- for bug 3820859, to start with adjusted_unit_price should be same as unit_price
7187 -- if not, then the same discount is getting applied twice if limit profile is set, because discounts calculations happens twice -
7188 -- once from QP_PREQ_GRP and then from QP_PREQ_PUB
7189 CURSOR l_line_cur IS SELECT
7190 line.line_index
7191 , line.unit_price adjusted_unit_price -- bug 3820859
7192 , line.unit_price
7193 , line.processed_flag
7194 , line.processed_code
7195 , line.updated_adjusted_unit_price
7196 , line.rounding_factor
7197 , line.pricing_status_code, line.pricing_status_text
7198 FROM qp_npreq_lines_tmp line
7199 WHERE
7200 line.price_flag IN (G_YES, G_PHASE, G_CALCULATE_ONLY)
7201 AND line.line_type_code IN (G_LINE_LEVEL, G_ORDER_LEVEL)
7202 AND line.pricing_status_code IN (G_STATUS_UPDATED
7203 , G_STATUS_GSA_VIOLATION
7204 , G_STATUS_UNCHANGED)
7205 AND nvl(processed_code, '0') <> G_BY_ENGINE
7206 AND line.usage_pricing_type IN
7207 (QP_PREQ_GRP.G_BILLING_TYPE, QP_PREQ_GRP.G_REGULAR_USAGE_TYPE);
7208
7209 /*
7210 INDX,QP_PREQ_PUB.calculate_price.l_bucket_price_cur,qp_npreq_lines_tmp_N1,LINE_INDEX,1
7211 INDX,QP_PREQ_PUB.calculate_price.l_bucket_price_cur,qp_npreq_lines_tmp_N1,LINE_TYPE_CODE,2
7212 INDX,QP_PREQ_PUB.calculate_price.l_bucket_price_cur,qp_npreq_lines_tmp_N2,LINE_TYPE_CODE,1
7213 INDX,QP_PREQ_PUB.calculate_price.l_bucket_price_cur,qp_npreq_ldets_tmp_N3,LINE_INDEX,1
7214 INDX,QP_PREQ_PUB.calculate_price.l_bucket_price_cur,qp_npreq_ldets_tmp_N3,CREATED_FROM_LIST_LINE_TYPE,2
7215 */
7216 CURSOR l_bucket_price_cur(p_line_index NUMBER) IS -- 2892848
7217 SELECT ldet.created_from_list_line_id
7218 , line.line_index line_ind
7219 , ldet.line_detail_index
7220 , ldet.created_from_list_line_type
7221 , ldet.modifier_level_code
7222 , ldet.applied_flag
7223 , 1.0 amount_changed
7224 , line.adjusted_unit_price
7225 --changed to make sure lumpsum on order level frt charge divide by 1 quantity
7226 , ldet.line_quantity priced_quantity
7227 , line.priced_quantity priced_qty
7228 , ldet.group_quantity
7229 , ldet.group_amount
7230 , line.updated_adjusted_unit_price
7231 , ldet.automatic_flag
7232 , ldet.override_flag
7233 , ldet.pricing_group_sequence
7234 , ldet.operand_calculation_code
7235 , ldet.operand_value
7236 , ldet.adjustment_amount
7237 , line.unit_price
7238 , ldet.accrual_flag
7239 , ldet.updated_flag
7240 , ldet.process_code
7241 , ldet.pricing_status_code
7242 , ldet.pricing_status_text
7243 , ldet.price_break_type_code
7244 , ldet.charge_type_code
7245 , ldet.charge_subtype_code
7246 , line.rounding_factor
7247 , G_LINE_LEVEL line_type
7248 , 'N' is_max_frt
7249 , ldet.net_amount_flag
7250 FROM qp_npreq_ldets_tmp ldet, qp_npreq_lines_tmp line
7251 --where line.line_index = p_line_index -- 2892848
7252 WHERE ldet.line_index = line.line_index -- 2892848
7253 --and ldet.line_index = line.line_index --2892848
7254 AND line.price_flag IN (G_YES, G_PHASE, G_CALCULATE_ONLY)
7255 AND ldet.process_code = G_STATUS_NEW
7256 AND (ldet.applied_flag = G_YES
7257 OR ldet.created_from_list_line_type = G_FREIGHT_CHARGE)
7258 AND ldet.created_from_list_line_type IN (G_DISCOUNT
7259 , G_SURCHARGE, G_PRICE_BREAK_TYPE, G_FREIGHT_CHARGE)
7260 AND nvl(ldet.created_from_list_type_code, 'NULL') NOT IN
7261 (G_PRICE_LIST_HEADER, G_AGR_LIST_HEADER)
7262 AND ldet.line_detail_index NOT IN
7263 (SELECT rltd.related_line_detail_index
7264 FROM qp_npreq_rltd_lines_tmp rltd
7265 WHERE rltd.pricing_status_code = G_STATUS_NEW
7266 AND rltd.relationship_type_code = G_PBH_LINE)
7267 -- next 4 conditions added for 3435240
7268 AND line.line_type_code = G_LINE_LEVEL
7269 AND line.pricing_status_code IN (G_STATUS_UPDATED
7270 , G_STATUS_GSA_VIOLATION
7271 , G_STATUS_UNCHANGED)
7272 AND nvl(line.processed_code, '0') <> G_BY_ENGINE
7273 AND line.usage_pricing_type IN
7274 (QP_PREQ_GRP.G_BILLING_TYPE, QP_PREQ_GRP.G_REGULAR_USAGE_TYPE)
7275 UNION
7276 SELECT ldet.created_from_list_line_id
7277 , line.line_index line_ind
7278 , ldet.line_detail_index
7279 , ldet.created_from_list_line_type
7280 , ldet.modifier_level_code
7281 , ldet.applied_flag
7282 , 1.0 amount_changed
7283 , line.adjusted_unit_price
7284 --changed to make sure lumpsum on order level frt charge divide by 1 quantity
7285 , ldet.line_quantity priced_quantity
7286 , line.priced_quantity priced_qty
7287 , ldet.group_quantity
7288 , ldet.group_amount
7289 , line.updated_adjusted_unit_price
7290 , ldet.automatic_flag
7291 , ldet.override_flag
7292 , ldet.pricing_group_sequence
7293 , ldet.operand_calculation_code
7294 , ldet.operand_value
7295 , ldet.adjustment_amount
7296 , line.unit_price
7297 , ldet.accrual_flag
7298 , ldet.updated_flag
7299 , ldet.process_code
7300 , ldet.pricing_status_code
7301 , ldet.pricing_status_text
7302 , ldet.price_break_type_code
7303 , ldet.charge_type_code
7304 , ldet.charge_subtype_code
7305 , line.rounding_factor
7306 , G_ORDER_LEVEL line_type
7307 , 'N' is_max_frt
7308 , ldet.net_amount_flag
7309 FROM qp_npreq_ldets_tmp ldet, qp_npreq_lines_tmp line
7310 , qp_npreq_lines_tmp line1
7311 --where line.line_index = p_line_index -- 2892848
7312 --and ldet.line_index = line1.line_index -- 2892848
7313 WHERE ldet.line_index = line1.line_index -- 2892848
7314 AND line1.line_type_code = G_ORDER_LEVEL
7315 AND line1.price_flag IN (G_YES, G_PHASE, G_CALCULATE_ONLY)
7316 AND line.line_type_code = G_LINE_LEVEL
7317 AND ldet.process_code = G_STATUS_NEW
7318 AND (ldet.applied_flag = G_YES
7319 OR ldet.created_from_list_line_type = G_FREIGHT_CHARGE)
7320 AND ldet.created_from_list_line_type IN (G_DISCOUNT,
7321 G_SURCHARGE, G_PRICE_BREAK_TYPE, G_FREIGHT_CHARGE)
7322 AND nvl(ldet.created_from_list_type_code, 'NULL') NOT IN
7323 (G_PRICE_LIST_HEADER, G_AGR_LIST_HEADER)
7324 AND ldet.line_detail_index NOT IN
7325 (SELECT rltd.related_line_detail_index
7326 FROM qp_npreq_rltd_lines_tmp rltd
7327 WHERE rltd.pricing_status_code = G_STATUS_NEW
7328 AND rltd.relationship_type_code = G_PBH_LINE)
7329 -- next 4 conditions added for 3435240
7330 AND line.price_flag IN (G_YES, G_PHASE, G_CALCULATE_ONLY)
7331 AND line.pricing_status_code IN (G_STATUS_UPDATED
7332 , G_STATUS_GSA_VIOLATION
7333 , G_STATUS_UNCHANGED)
7334 AND nvl(line.processed_code, '0') <> G_BY_ENGINE
7335 AND line.usage_pricing_type IN
7336 (QP_PREQ_GRP.G_BILLING_TYPE, QP_PREQ_GRP.G_REGULAR_USAGE_TYPE)
7337 --order by line_ind,pricing_group_sequence; -- 2892848
7338 ORDER BY pricing_group_sequence, line_ind; -- 2829848
7339
7340 CURSOR l_chk_backcal_adj_exist_cur(p_line_index NUMBER) IS
7341 SELECT ldet.line_detail_index
7342 , ldet.adjustment_amount
7343 FROM qp_npreq_ldets_tmp ldet
7344 WHERE line_index = p_line_index
7345 AND calculation_code = G_BACK_CALCULATE
7346 AND applied_flag = G_YES
7347 AND updated_flag = G_YES;
7348
7349 -- net_amount 2720717
7350 CURSOR l_net_amount_flag_cur (p_list_line_id NUMBER) IS
7351 SELECT net_amount_flag
7352 FROM qp_list_lines
7353 WHERE list_line_id = p_list_line_id;
7354
7355 l_bucket_price_rec l_bucket_price_cur%ROWTYPE;
7356 l_line_rec l_line_cur%ROWTYPE;
7357 l_return_adjustment NUMBER := g_miss_num; --FND_API.G_MISS_NUM;
7358 l_sub_total_price NUMBER := g_miss_num; --FND_API.G_MISS_NUM;
7359 l_list_price NUMBER := g_miss_num; --FND_API.G_MISS_NUM;
7360 --l_adjusted_price NUMBER := g_miss_num;--FND_API.G_MISS_NUM; -- 2892848
7361
7362
7363
7364 TYPE LINES_TBL_TYPE IS TABLE OF l_line_rec%TYPE INDEX BY BINARY_INTEGER;
7365 l_lines_tbl LINES_TBL_TYPE;
7366
7367 TYPE LBUCKET_TBL_TYPE IS TABLE OF l_bucket_price_rec%TYPE INDEX BY BINARY_INTEGER;
7368 l_ldet_tbl LBUCKET_TBL_TYPE;
7369 l_frt_charge_tbl FRT_CHARGE_TBL;
7370 l_back_calc_ret_rec back_calc_rec_type;
7371
7372 BACK_CALCULATE BOOLEAN := TRUE;
7373
7374 --l_prev_line_index NUMBER := g_miss_num;--FND_API.G_MISS_NUM;
7375 l_prev_line_index NUMBER := - 9999; -- 2892848, SL_latest
7376 l_1st_bucket VARCHAR2(1) := 'N';
7377 l_prev_adj NUMBER := g_miss_num; --FND_API.G_MISS_NUM;
7378 l_sign NUMBER := g_miss_num; --FND_API.G_MISS_NUM;
7379 l_amount_changed NUMBER := g_miss_num; --FND_API.G_MISS_NUM;
7380 l_adjustment_amount NUMBER := g_miss_num; --FND_API.G_MISS_NUM;
7381 l_operand_value NUMBER := g_miss_num; --FND_API.G_MISS_NUM;
7382 l_BACK_CALCULATE_START_TYPE VARCHAR2(30) := G_BACK_CALCULATION_STS_NONE; -- 2892848
7383 --l_prev_bucket qp_npreq_ldets_tmp.PRICING_GROUP_SEQUENCE%TYPE := g_miss_num;--FND_API.G_MISS_NUM;
7384 l_back_calc_dtl_index NUMBER := 0;
7385 l_back_calc_adj_amt NUMBER := 0;
7386
7387 l_ldet_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
7388 l_line_index NUMBER := g_miss_num; --FND_API.G_MISS_NUM;
7389 l_calc_quantity NUMBER := 0;
7390
7391 --added to calculate order level adjustments' adj amt
7392 l_ord_dtl_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
7393 l_ord_adj_amt_tbl QP_PREQ_GRP.NUMBER_TYPE;
7394
7395 l_updated_adj_unit_price_ur QP_PREQ_GRP.NUMBER_TYPE; --[prarasto:Post Round]
7396 l_adjusted_unit_price_ur QP_PREQ_GRP.NUMBER_TYPE; --[prarasto:Post Round]
7397
7398 i NUMBER := 0;
7399 j NUMBER := 0;
7400 k NUMBER := 0;
7401 x NUMBER := 0;
7402 m NUMBER := 0;
7403
7404 Calculate_Exc EXCEPTION;
7405
7406 --begin 2388011
7407 l_req_value_per_unit NUMBER; --2388011 priya added this variable
7408 l_total_value NUMBER; --group_value --2388011 priya added this variable
7409 l_bucketed_adjustment NUMBER; --2388011 priya added this variable
7410 --end 2388011
7411
7412 --net_amount 2720717
7413 --l_pbh_net_adj_amount NUMBER := 0; -- sum up adj amts -- 2892848 SL_latest
7414 --l_pbh_prev_net_adj_amount NUMBER := 0; -- whenever bucket change - 2892848 SL_latest
7415
7416 l_pbh_pricing_attr VARCHAR2(240);
7417
7418 l_adjusted_price NUMBER := NULL; --2892848 so we can nvl(l_adjusted_price, unit_price) when assign l_sub_total_price
7419 l_prev_bucket NUMBER := - 9999; --2892848
7420 -- begin 2892848, net amount
7421 l_qualifier_value NUMBER := NULL; -- to qualify PBH
7422 s PLS_INTEGER := 0; -- counter for l_line_bucket_detail_tbl
7423 l_lg_adj_amt NUMBER := NULL; -- 2892848
7424 --l_prev_lg_adj_amt NUMBER:=0; -- 2892848 SL_latest
7425 line_change BOOLEAN := NULL;
7426
7427 /* SL latest
7428 -- for linegroup
7429 TYPE bucket_adj_amt_tbl IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
7430 l_bucket_adj_amt_tbl bucket_adj_amt_tbl;
7431
7432 -- for line level
7433 TYPE bucket_index_adj_tbl IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
7434 l_bucket_index_adj_tbl bucket_index_adj_tbl;
7435
7436 TYPE prev_bucket_index_adj_tbl IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
7437 l_prev_bucket_index_adj_tbl prev_bucket_index_adj_tbl;
7438 */
7439 --begin SL_latest
7440 CURSOR l_net_mod_index_cur(p_list_line_id NUMBER) IS
7441 SELECT DISTINCT ldet.line_index
7442 FROM qp_npreq_ldets_tmp ldet
7443 WHERE ldet.created_from_list_line_id = p_list_line_id
7444 AND pricing_status_code IN (G_STATUS_NEW, G_STATUS_UPDATED, G_STATUS_UNCHANGED);
7445
7446 l_line_bucket_amt NUMBER := NULL;
7447 l_lg_net_amt NUMBER := NULL;
7448 l_prev_qty NUMBER := 0;
7449
7450 -- [julin/4112395/4220399]
7451 l_applied_req_value_per_unit NUMBER := 0;
7452 l_prod_line_bucket_amt NUMBER := 0;
7453 l_lg_prod_net_amt NUMBER := 0;
7454
7455 -- record bucketed USP*qtyfor each line_index upon bucket change
7456 TYPE bucket_amt_tbl IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
7457 l_bucket_amt_tbl bucket_amt_tbl;
7458 l_prev_bucket_amt_tbl bucket_amt_tbl;
7459
7460 -- hash table of list_line_id and its corresponding lg_net_amt
7461 TYPE mod_lg_net_amt_tbl IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
7462 l_mod_lg_net_amt_tbl mod_lg_net_amt_tbl;
7463 l_mod_lg_prod_net_amt_tbl mod_lg_net_amt_tbl; -- [julin/4112395/4220399]
7464
7465
7466 -- end SL_latest
7467 -- end 2892848
7468
7469 l_return_status VARCHAR2(30);
7470 l_return_status_text VARCHAR2(240);
7471 l_routine VARCHAR2(50) := 'Routine :QP_PREQ_PUB.Calculate_price ';
7472
7473 -- [julin/3265308] net amount calculation 'P', match product only.
7474 -- given a line line id, find the product attribute and context for
7475 -- the modifier and match all request lines with that context/attr
7476 -- pair. exclude logic included. price_flag clause included to
7477 -- ignore free goods.
7478 CURSOR l_prod_attr_info(p_list_line_id NUMBER) IS
7479 SELECT DISTINCT qla.line_index, ql.priced_quantity, ql.unit_price
7480 FROM qp_preq_line_attrs_tmp qla, qp_pricing_attributes qpa, qp_preq_lines_tmp ql
7481 WHERE qpa.list_line_id = p_list_line_id
7482 AND qla.context = qpa.product_attribute_context
7483 AND qla.attribute = qpa.product_attribute
7484 AND qla.value_from = qpa.product_attr_value
7485 AND qla.line_index = ql.line_index
7486 AND ql.price_flag <> G_PHASE
7487 AND ql.pricing_status_code IN (QP_PREQ_PUB.G_STATUS_UPDATED,
7488 QP_PREQ_PUB.G_STATUS_GSA_VIOLATION,
7489 QP_PREQ_PUB.G_STATUS_UNCHANGED)
7490 AND NOT EXISTS (SELECT qla2.line_index
7491 FROM qp_preq_line_attrs_tmp qla2, qp_pricing_attributes qpa2
7492 WHERE qpa2.list_line_id = p_list_line_id
7493 AND qpa2.excluder_flag = G_YES
7494 AND qla2.line_index = qla.line_index
7495 AND qla2.context = qpa2.product_attribute_context
7496 AND qla2.attribute = qpa2.product_attribute
7497 AND qla2.value_from = qpa2.product_attr_value);
7498
7499 l_netamt_flag VARCHAR2(1);
7500 l_bucketed_flag VARCHAR2(1);
7501
7502 BEGIN
7503
7504 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
7505 IF l_debug = FND_API.G_TRUE THEN
7506 QP_PREQ_GRP.ENGINE_DEBUG('begin calculate price');
7507 QP_PREQ_GRP.ENGINE_DEBUG('SL, this is Oracle IT path'); -- 2892848
7508
7509 END IF;
7510
7511 --4900095 call Determine_svc_item_quantity
7512 IF QP_PREQ_GRP.G_Service_line_qty_tbl.COUNT = 0 THEN
7513 Determine_svc_item_quantity;
7514 END IF;
7515
7516
7517
7518 --reset order lvl adjustments' adj amt
7519 l_ord_dtl_index_tbl.DELETE;
7520 l_ord_adj_amt_tbl.DELETE;
7521 --l_bucket_adj_amt_tbl.delete; --SL_latest 2892848
7522 --l_bucket_index_adj_tbl.delete; --2892848
7523 --l_prev_bucket_index_adj_tbl.delete; --2892848
7524 l_bucket_amt_tbl.DELETE; -- 2892848 SL_latest
7525 l_prev_bucket_amt_tbl.DELETE;
7526 l_mod_lg_net_amt_tbl.DELETE; -- 2892848 SL_latest
7527 l_mod_lg_prod_net_amt_tbl.DELETE; -- [julin/4112395/4220399]
7528
7529 l_lines_tbl.DELETE;
7530 l_ldet_tbl.DELETE;
7531 FOR l_line_rec IN l_line_cur
7532 LOOP
7533 --The freight_charge functionality to return worst freight charge
7534 --has been coded with an assumption that only one line is dealt
7535 --with in the l_bucket_price_cur below
7536 l_lines_tbl(l_line_rec.line_index) := l_line_rec; -- bug 3306349
7537
7538 IF l_debug = FND_API.G_TRUE THEN
7539 QP_PREQ_GRP.ENGINE_DEBUG('Gather lines passed: Line_Index '|| l_line_rec.line_index ||
7540 ' list price '|| l_line_rec.unit_price ||
7541 ' adjusted unit price '|| l_line_rec.adjusted_unit_price ||
7542 ' updated adjusted unit price '|| l_line_rec.updated_adjusted_unit_price);
7543
7544 END IF;
7545 END LOOP;
7546
7547 /* shu 2892848 , move this loop head to be after l_bucket_price_cur loop end
7548 j:=0;
7549
7550 j:= l_lines_tbl.FIRST;
7551 While j IS NOT NULL LOOP
7552 */
7553
7554 -- net_amount_new, 2720717
7555 -- reset for every request line
7556 --l_pbh_net_adj_amount:= 0; -- 2892848
7557 --l_pbh_prev_net_adj_amount:=0; -- 2892848
7558
7559 BACK_CALCULATE := FALSE;
7560 --l_list_price := l_lines_tbl(j).unit_price; -- 2892848
7561 --l_sub_total_price := l_list_price; -- 2892848
7562 --l_adjusted_price := l_list_price; -- 2892848
7563 --l_prev_bucket := g_miss_num;--FND_API.G_MISS_NUM; -- 2892848
7564 l_amount_changed := 0;
7565 l_BACK_CALCULATE_START_TYPE := G_BACK_CALCULATION_STS_NONE;
7566 l_return_status := '';
7567 l_return_status_text := '';
7568
7569 IF l_debug = FND_API.G_TRUE THEN
7570 /* 2892848
7571 QP_PREQ_GRP.ENGINE_DEBUG('************************ looping through request lines');
7572 QP_PREQ_GRP.ENGINE_DEBUG('Processing
7573 Line Index'||l_lines_tbl(j).line_index||
7574 ' list price '||l_lines_tbl(j).unit_price||
7575 ' updated adjusted price '||l_lines_tbl(j).updated_adjusted_unit_price);
7576 */
7577 QP_PREQ_GRP.ENGINE_DEBUG('Display price: price '
7578 || l_list_price ||' sub-t '|| l_sub_total_price
7579 ||' adj price '|| l_adjusted_price);
7580
7581 END IF; -- END IF l_debug
7582
7583 l_frt_charge_tbl.DELETE;
7584 l_ldet_tbl.DELETE;
7585
7586 i := 0; -- modifier lines in ldets
7587 --OPEN l_bucket_price_cur(l_lines_tbl(j).line_index);
7588 OPEN l_bucket_price_cur(1); -- 2892848
7589 LOOP -- process adjustments for each request line
7590 FETCH l_bucket_price_cur INTO l_bucket_price_rec;
7591
7592 i := i + 1;
7593
7594 EXIT WHEN l_bucket_price_cur%NOTFOUND;
7595
7596 -- begin 2892848
7597 -- ASK PRIYA see if there is a way to tell if line is from calling application???
7598 -- obtain net_adj_amount_flag from qp_list_lines table if null,
7599 -- since it may not be passed from calling application
7600 IF l_bucket_price_rec.net_amount_flag IS NULL THEN -- get it from setup just in case
7601 OPEN l_net_amount_flag_cur(l_bucket_price_rec.created_from_list_line_id);
7602 FETCH l_net_amount_flag_cur INTO l_bucket_price_rec.net_amount_flag;
7603 CLOSE l_net_amount_flag_cur;
7604 END IF;
7605 l_return_adjustment := 0; -- diff other path ???
7606 -- end 2892848
7607
7608 IF l_debug = FND_API.G_TRUE THEN
7609 QP_PREQ_GRP.ENGINE_DEBUG('------------------- looping through ldet lines');
7610 QP_PREQ_GRP.ENGINE_DEBUG('Processing Adjustments:
7611 line index '|| l_bucket_price_rec.line_ind ||
7612 ' list line id '|| l_bucket_price_rec.created_from_list_line_id ||
7613 ' bucket '|| l_bucket_price_rec.pricing_group_sequence ||
7614 ' net amount flag '|| l_bucket_price_rec.net_amount_flag || -- 2892848
7615 ' override_flag '|| l_bucket_price_rec.override_flag ||
7616 ' automatic '|| l_bucket_price_rec.automatic_flag ||
7617 ' line_type '|| l_bucket_price_rec.line_type);
7618
7619 END IF;
7620
7621
7622 IF l_bucket_price_rec.created_from_list_line_type = G_DISCOUNT
7623 AND l_bucket_price_rec.operand_calculation_code <> G_NEWPRICE_DISCOUNT THEN
7624 l_sign := - 1;
7625 ELSE
7626 l_sign := 1;
7627 END IF;
7628
7629 ------------------NET AMT STUFF, SL_latest
7630 -- begin 2892848
7631 -- ldet lines are ordered by bucket, line index
7632 -- l_sub_total_price is bucketed unit price, l_adjusted_unit_price is current USP
7633
7634 -- defaults
7635 IF l_lines_tbl.EXISTS(l_bucket_price_rec.line_ind) THEN
7636 l_adjusted_price := nvl(l_lines_tbl(l_bucket_price_rec.line_ind).adjusted_unit_price, l_lines_tbl(l_bucket_price_rec.line_ind).unit_price);
7637 --l_sub_total_price := nvl(l_lines_tbl(l_bucket_price_rec.line_ind).unit_price, 0); --Bug No: 7323594
7638 ELSE
7639 l_adjusted_price := 0;
7640 l_sub_total_price := 0;
7641 END IF;
7642
7643 -- use original list_price for null bucket modifiers or
7644 -- use USP as l_sub_total_price for bucket modifiers
7645 IF (l_bucket_price_rec.pricing_group_sequence IS NULL OR
7646 l_bucket_price_rec.pricing_group_sequence = 0) THEN
7647
7648 IF l_lines_tbl.EXISTS(l_bucket_price_rec.line_ind) THEN
7649 l_adjusted_price := nvl(l_lines_tbl(l_bucket_price_rec.line_ind).adjusted_unit_price, l_lines_tbl(l_bucket_price_rec.line_ind).unit_price);
7650 l_sub_total_price := nvl(l_lines_tbl(l_bucket_price_rec.line_ind).unit_price, 0);
7651 ELSE
7652 l_adjusted_price := 0;
7653 l_sub_total_price := 0;
7654 END IF;
7655
7656 ELSE -- bucket not null and not 0
7657
7658 /* SL_more do no want this for same line same bucket case
7659 -- default, in case there is no further lines to set this, SL_further fix
7660
7661 l_bucket_amt_tbl(l_bucket_price_rec.line_ind) :=
7662 l_adjusted_price *l_bucket_price_rec.priced_qty;
7663 */
7664 IF l_prev_line_index = l_bucket_price_rec.line_ind THEN -- will be at least 1
7665 line_change := FALSE;
7666
7667 -- line at least from 1 to up, bucket atleast from 1 to up
7668 IF (l_prev_bucket <> l_bucket_price_rec.pricing_group_sequence) THEN -- same line, bucket change
7669 l_mod_lg_net_amt_tbl.DELETE; -- clear this table upon bucket change to keep it small
7670 l_mod_lg_prod_net_amt_tbl.DELETE; -- [julin/4112395/4220399]
7671 -- so we can use it latest, use grp_amt as l_lg_net_amt for this case
7672 IF l_prev_bucket = - 9999 THEN
7673 l_1st_bucket := 'Y';
7674 ELSE
7675 l_1st_bucket := 'N';
7676 END IF;
7677 l_prev_bucket := l_bucket_price_rec.pricing_group_sequence; -- preserve new bucket to be next prev_bucket
7678
7679 IF (l_lines_tbl.EXISTS(l_bucket_price_rec.line_ind)) THEN
7680 l_sub_total_price := nvl(l_lines_tbl(l_bucket_price_rec.line_ind).adjusted_unit_price, l_lines_tbl(l_bucket_price_rec.line_ind).unit_price);
7681 l_adjusted_price := l_sub_total_price;
7682 l_bucket_amt_tbl(l_bucket_price_rec.line_ind) := nvl(l_lines_tbl(l_bucket_price_rec.line_ind).adjusted_unit_price, 0) * l_bucket_price_rec.priced_qty;
7683 IF l_debug = FND_API.G_TRUE THEN
7684 QP_PREQ_GRP.engine_debug('bucket change within same line.'
7685 ||' sub_total_price: '|| l_sub_total_price ||' adjusted_price: '|| l_adjusted_price );
7686 QP_PREQ_GRP.engine_debug('l_bucket_amt_tbl(' || l_bucket_price_rec.line_ind ||'): '
7687 || nvl(l_lines_tbl(l_bucket_price_rec.line_ind).adjusted_unit_price, 0) || '*' ||
7688 l_bucket_price_rec.priced_qty || '=' || l_bucket_amt_tbl(l_bucket_price_rec.line_ind));
7689 END IF; -- end debug
7690 END IF; -- END IF l_lines_tbl.EXISTS(l_bucket_price_rec.line_ind)
7691
7692 -- [julin/4055310]
7693 l_prev_bucket_amt_tbl := l_bucket_amt_tbl;
7694
7695 END IF; -- end bucket change, (l_prev_bucket <> l_bucket_price_rec.pricing_group_sequence)
7696
7697 ELSE -- line change (from -9999 to up, or from at least 1 to up)
7698
7699 line_change := TRUE;
7700
7701 -- bucket from -9999 to up,or from at least 1 to up
7702 IF l_prev_bucket <> l_bucket_price_rec.pricing_group_sequence THEN -- line change , bucket change
7703
7704 l_mod_lg_net_amt_tbl.DELETE; -- clear this table upon bucket change to keep it small
7705 l_mod_lg_prod_net_amt_tbl.DELETE; -- [julin/4112395/4220399]
7706
7707 -- preserve l_prev_bucket to be -9999 if this is 1st bucket
7708 -- so we can use it latest, use grp_amt as l_lg_net_amt for this case
7709 IF l_prev_bucket = - 9999 THEN
7710 l_1st_bucket := 'Y';
7711 ELSE
7712 l_1st_bucket := 'N';
7713 END IF;
7714 l_prev_bucket := l_bucket_price_rec.pricing_group_sequence; -- preserve new bucket to be next prev_bucket
7715 IF (l_lines_tbl.EXISTS(l_bucket_price_rec.line_ind)) THEN
7716 l_sub_total_price := nvl(l_lines_tbl(l_bucket_price_rec.line_ind).adjusted_unit_price, l_lines_tbl(l_bucket_price_rec.line_ind).unit_price);
7717 ELSE
7718 l_sub_total_price := 0;
7719 END IF; -- END IF l_lines_tbl.EXISTS(l_bucket_price_rec.line_ind)
7720 l_adjusted_price := l_sub_total_price;
7721 IF l_debug = FND_API.G_TRUE THEN
7722 QP_PREQ_GRP.engine_debug('bucket change, line change. '
7723 ||' sub_total_price: '|| l_sub_total_price ||' adjusted_price: '|| l_adjusted_price );
7724 END IF; -- end debug
7725
7726 IF l_prev_line_index = - 9999 THEN
7727 IF l_lines_tbl.EXISTS(l_bucket_price_rec.line_ind) THEN
7728 l_bucket_amt_tbl(l_bucket_price_rec.line_ind) := nvl(l_lines_tbl(l_bucket_price_rec.line_ind).unit_price, 0) * l_bucket_price_rec.priced_qty;
7729 IF l_debug = FND_API.G_TRUE THEN
7730 QP_PREQ_GRP.engine_debug('prev_line_index is -9999');
7731 QP_PREQ_GRP.engine_debug('l_bucket_amt_tbl(' || l_bucket_price_rec.line_ind ||'): '
7732 || nvl(l_lines_tbl(l_bucket_price_rec.line_ind).unit_price, 0) || '*' ||
7733 l_bucket_price_rec.priced_qty || '=' || l_bucket_amt_tbl(l_bucket_price_rec.line_ind));
7734 END IF; -- end debug
7735 END IF; -- END IF l_lines_tbl.EXISTS(l_bucket_price_rec.line_ind)
7736
7737 ELSE -- l_prev_line_index <> -9999
7738 IF (l_lines_tbl.EXISTS(l_prev_line_index)) THEN
7739 l_bucket_amt_tbl(l_prev_line_index) := nvl(l_lines_tbl(l_prev_line_index).adjusted_unit_price, 0) * l_prev_qty;
7740 IF l_debug = FND_API.G_TRUE THEN
7741 QP_PREQ_GRP.engine_debug('capture bucket_amt of prev line l_bucket_amt_tbl('|| l_prev_line_index ||'): '
7742 || nvl(l_lines_tbl(l_prev_line_index).adjusted_unit_price, 0) || '*' ||
7743 l_prev_qty || '=' || l_bucket_amt_tbl(l_prev_line_index));
7744 END IF; -- end debug
7745 END IF; -- END IF l_lines_tbl.EXISTS(l_prev_line_index)
7746
7747 -- [julin/4055310]
7748 l_prev_bucket_amt_tbl := l_bucket_amt_tbl;
7749
7750 END IF; -- END l_prev_line_index=-9999
7751
7752 ELSE -- line change same bucket (bucket is at least from 1 to up, line is at least from 1 to up)
7753 IF l_lines_tbl.EXISTS(l_bucket_price_rec.line_ind) THEN
7754 l_sub_total_price := nvl(l_lines_tbl(l_bucket_price_rec.line_ind).adjusted_unit_price, l_lines_tbl(l_bucket_price_rec.line_ind).unit_price);
7755 ELSE
7756 l_sub_total_price := 0;
7757 END IF; -- END IF l_lines_tbl.EXISTS(l_bucket_price_rec.line_ind)
7758 l_adjusted_price := l_sub_total_price;
7759
7760 IF l_debug = FND_API.G_TRUE THEN
7761 QP_PREQ_GRP.engine_debug('line change, same bucket');
7762 QP_PREQ_GRP.engine_debug('l_sub_total_price: '|| l_sub_total_price);
7763 END IF; -- end debug
7764
7765 IF l_lines_tbl.EXISTS(l_prev_line_index) THEN
7766 l_bucket_amt_tbl(l_prev_line_index) := nvl(l_lines_tbl(l_prev_line_index).adjusted_unit_price, 0) * l_prev_qty;
7767 IF l_debug = FND_API.G_TRUE THEN
7768 QP_PREQ_GRP.engine_debug('l_bucket_amt_tbl(' || l_prev_line_index ||'): '
7769 || nvl(l_lines_tbl(l_prev_line_index).adjusted_unit_price, 0) || '*' ||
7770 l_prev_qty || '=' || l_bucket_amt_tbl(l_prev_line_index));
7771 END IF; -- end debug
7772 END IF; -- END IF l_lines_tbl.EXISTS(l_prev_line_index)
7773
7774 -- SL_more, to default and for line level net amt, in case no further line to set this
7775 IF l_1st_bucket = 'Y' THEN
7776 IF l_lines_tbl.EXISTS(l_bucket_price_rec.line_ind) THEN
7777 l_bucket_amt_tbl(l_bucket_price_rec.line_ind) := nvl(l_lines_tbl(l_bucket_price_rec.line_ind).unit_price, 0) * l_bucket_price_rec.priced_qty; -- for line level net amt we need this
7778 IF l_debug = FND_API.G_TRUE THEN
7779 QP_PREQ_GRP.engine_debug('1st bucket for this line l_bucket_amt_tbl('|| l_bucket_price_rec.line_ind ||'): '
7780 || nvl(l_lines_tbl(l_bucket_price_rec.line_ind).unit_price, 0) || '*' ||
7781 l_bucket_price_rec.priced_qty || '=' || l_bucket_amt_tbl(l_bucket_price_rec.line_ind));
7782 END IF; -- end debug
7783 END IF; -- END IF l_lines_tbl.EXISTS(l_bucket_price_rec.line_ind)
7784 END IF; -- END IF l_1st_bucket ='Y'
7785
7786 END IF; -- end bucket change in the line change block
7787
7788 l_prev_line_index := l_bucket_price_rec.line_ind; -- preserve the new lind_ind to be l_prev_line_index
7789 l_prev_qty := l_bucket_price_rec.priced_qty;
7790 END IF; --l_prev_line_index = line_index
7791 END IF; -- end if bucket is null or 0
7792 -- end 2892848, SL_latest
7793
7794 /* SL_latest
7795 -- begin 2892848
7796 -- MOVE TO HERE
7797 IF l_bucket_price_rec.pricing_group_sequence <> 0 AND l_bucket_price_rec.pricing_group_sequence IS NOT NULL THEN -- bucket 0 is line event list price
7798 -- detect bucket change, need to CAPTURE unit_adjs (LINE) and adj_amts(LINEGROUP) up to the prev bucket
7799 IF l_prev_bucket <> l_bucket_price_rec.pricing_group_sequence THEN
7800 IF l_debug = FND_API.G_TRUE THEN
7801 QP_PREQ_GRP.engine_debug ('------BUCKET CHANGE----, place to record bucket USP for each line_index');
7802 END IF; -- END debug
7803
7804 -- for LINE GROUP
7805 -- need capture the l_prev_lg_adj_amt
7806 -- l_bucket_adj_amt_tbl(bucket) stores adj_amts of all lines for each bucket
7807 -- prev_lg_adj_amt is the sum of adj_amts for all lines up to prev buckets
7808
7809 IF l_bucket_adj_amt_tbl.EXISTS(l_prev_bucket) THEN
7810 l_prev_lg_adj_amt := nvl(l_prev_lg_adj_amt,0) + l_bucket_adj_amt_tbl(l_prev_bucket);
7811 IF l_debug = FND_API.G_TRUE THEN
7812 QP_PREQ_GRP.engine_debug ('debug LINEGROUP adj amts up to prev bucket - '||l_prev_bucket ||': '||l_prev_lg_adj_amt);
7813 END IF; -- END debug
7814
7815 END IF; -- END IF l_bucket_adj_amt_tbl.EXISTS(l_prev_bucket)
7816
7817 -- bucket change for LINE LEVEL
7818 -- l_bucket_index_adj_tbl(line_index) stores sum of unit_adjs for each line_index
7819 -- l_prev_bucket_index_adj_tbl(line_index) is the sum of unit_adjs for that line_index up to prev bucket
7820
7821 IF l_bucket_index_adj_tbl.EXISTS(l_bucket_price_rec.line_ind) THEN
7822 IF l_prev_bucket_index_adj_tbl.EXISTS(l_bucket_price_rec.line_ind) THEN
7823 l_prev_bucket_index_adj_tbl(l_bucket_price_rec.line_ind):= nvl(l_prev_bucket_index_adj_tbl(l_bucket_price_rec.line_ind),0)
7824 + l_bucket_index_adj_tbl(l_bucket_price_rec.line_ind);
7825 ELSE
7826 l_prev_bucket_index_adj_tbl(l_bucket_price_rec.line_ind):= l_bucket_index_adj_tbl(l_bucket_price_rec.line_ind);
7827 END IF; -- END IF l_bucket_index_adj_tbl.EXISTS(l_bucket_price_rec.line_ind)
7828
7829 IF l_debug = FND_API.G_TRUE THEN
7830 QP_PREQ_GRP.engine_debug ('debug LINE unit adjs up to prev bucket for line index'||l_bucket_price_rec.line_ind ||': '||l_prev_bucket_index_adj_tbl(l_bucket_price_rec.line_ind) );
7831 END IF; -- END debug
7832 END IF; -- END IF l_bucket_index_adj_tbl.EXISTS
7833
7834
7835 -- begin shu fix bug for special case, bucket change within same line index
7836 IF line_change = false THEN
7837 l_sub_total_price := nvl(l_adjusted_price, l_lines_tbl(l_bucket_price_rec.line_ind).unit_price);
7838 IF l_debug = FND_API.G_TRUE THEN
7839 QP_PREQ_GRP.engine_debug('bucket change within same line'
7840 ||' sub_total_price '||l_sub_total_price ||' adjusted_price '||l_adjusted_price );
7841 END IF;
7842 END IF; -- END IF line_change = flase
7843 -- end shu fix bug
7844
7845 l_prev_bucket := l_bucket_price_rec.pricing_group_sequence; -- preserve new bucket to be next prev_bucket
7846
7847 ELSE -- bucket did not change but line changes within bucket, we also need to capture line level unit adjs of prev bucket
7848
7849
7850 IF line_change = true THEN
7851 IF l_bucket_index_adj_tbl.EXISTS(l_bucket_price_rec.line_ind) THEN
7852 IF l_prev_bucket_index_adj_tbl.EXISTS(l_bucket_price_rec.line_ind) THEN
7853 l_prev_bucket_index_adj_tbl(l_bucket_price_rec.line_ind):= nvl(l_prev_bucket_index_adj_tbl(l_bucket_price_rec.line_ind),0)
7854 + l_bucket_index_adj_tbl(l_bucket_price_rec.line_ind);
7855 ELSE
7856 l_prev_bucket_index_adj_tbl(l_bucket_price_rec.line_ind):= l_bucket_index_adj_tbl(l_bucket_price_rec.line_ind);
7857 END IF; -- END IF l_bucket_index_adj_tbl.EXISTS(l_bucket_price_rec.line_ind)
7858
7859 IF l_debug = FND_API.G_TRUE THEN
7860 QP_PREQ_GRP.engine_debug ('line change, debug LINE unit adjs up to prev bucket for line index'||l_bucket_price_rec.line_ind ||': '||l_prev_bucket_index_adj_tbl(l_bucket_price_rec.line_ind) );
7861 END IF; -- END debug
7862 END IF; -- END IF l_bucket_index_adj_tbl.EXISTS
7863 END IF; -- END IF line_change true
7864
7865 END IF; -- end if l_prev_bucket <> l_bucket_price_rec.pricing_group_sequence
7866
7867 ELSE -- bucket is 0 or null -- begin shu fix bug
7868 l_sub_total_price := nvl(l_lines_tbl(l_bucket_price_rec.line_ind).unit_price, 0);
7869 l_adjusted_price := nvl(l_lines_tbl(l_bucket_price_rec.line_ind).adjusted_unit_price,l_lines_tbl(l_bucket_price_rec.line_ind).unit_price);
7870 IF l_debug = FND_API.G_TRUE THEN
7871 QP_PREQ_GRP.engine_debug('bucket is 0 or null'
7872 ||' sub_total_price '||l_sub_total_price ||' adjusted_price '||l_adjusted_price );
7873 END IF;
7874 -- end shu fix bug
7875 END IF; -- END IF l_bucket_price_rec(J).pricing_group_sequence <> 0 AND ...
7876 -- end 2892848
7877 ------------------END NET AMT STUFF
7878 */
7879
7880 --This code is for bug 1915355
7881 --To calculate lumpsum use group_qty/amt for linegrp
7882 --This is only for engine inserted records
7883 --for user passed adjustments, we will use only line_qty
7884 --to break the link from other lines that have this line
7885 --group adjustment
7886 --for bug2897524 retain line_quantity for zerounitprice
7887 IF l_bucket_price_rec.priced_quantity = 0
7888 AND l_bucket_price_rec.unit_price <> 0
7889 THEN
7890 IF l_debug = FND_API.G_TRUE THEN
7891 QP_PREQ_GRP.engine_debug('line_qty zero changed to null');
7892 END IF;
7893 l_bucket_price_rec.priced_quantity := NULL;
7894 END IF;
7895
7896 --bug 4900095
7897 IF (QP_PREQ_GRP.G_service_line_qty_tbl.exists(l_bucket_price_rec.line_ind)
7898 or QP_PREQ_GRP.G_service_ldet_qty_tbl.exists(l_bucket_price_rec.line_detail_index))
7899 and l_bucket_price_rec.operand_calculation_code = G_LUMPSUM_DISCOUNT THEN
7900 --only for service items
7901 --when uom_quantity is passed as null,
7902 -- and contract_start/end_dates are passed
7903 --and for a line/linegroup lumpsum DIS/PBH/SUR/FREIGHT
7904 IF l_bucket_price_rec.modifier_level_code = G_LINE_GROUP THEN
7905 IF G_Service_pbh_lg_amt_qty.exists(l_bucket_price_rec.line_detail_index)
7906 and QP_PREQ_GRP.G_service_ldet_qty_tbl.exists(l_bucket_price_rec.line_detail_index) THEN
7907 l_calc_quantity := nvl(G_Service_pbh_lg_amt_qty(l_bucket_price_rec.line_detail_index),
7908 QP_PREQ_GRP.G_service_ldet_qty_tbl(l_bucket_price_rec.line_detail_index));
7909 ELSIF G_Service_pbh_lg_amt_qty.exists(l_bucket_price_rec.line_detail_index) THEN
7910 l_calc_quantity := G_Service_pbh_lg_amt_qty(l_bucket_price_rec.line_detail_index);
7911 ELSIF QP_PREQ_GRP.G_service_ldet_qty_tbl.exists(l_bucket_price_rec.line_detail_index) THEN
7912 l_calc_quantity := QP_PREQ_GRP.G_service_ldet_qty_tbl(l_bucket_price_rec.line_detail_index);
7913 ELSIF QP_PREQ_GRP.G_service_line_qty_tbl.exists(l_bucket_price_rec.line_ind) THEN
7914 l_calc_quantity := QP_PREQ_GRP.G_service_line_qty_tbl(l_bucket_price_rec.line_ind);
7915 ELSE
7916 l_calc_quantity :=
7917 nvl(nvl(l_bucket_price_rec.group_quantity
7918 , l_bucket_price_rec.group_amount)
7919 , nvl(l_bucket_price_rec.priced_quantity
7920 , l_bucket_price_rec.priced_qty));
7921 END IF;--G_Service_pbh_lg_amt_qty.exists
7922 ELSIF l_bucket_price_rec.modifier_level_code = G_LINE_LEVEL THEN
7923 IF QP_PREQ_GRP.G_service_line_qty_tbl.exists(l_bucket_price_rec.line_ind) THEN
7924 l_calc_quantity := QP_PREQ_GRP.G_service_line_qty_tbl(l_bucket_price_rec.line_ind);
7925 ELSE
7926 l_calc_quantity :=
7927 nvl(nvl(l_bucket_price_rec.group_quantity
7928 , l_bucket_price_rec.group_amount)
7929 , nvl(l_bucket_price_rec.priced_quantity
7930 , l_bucket_price_rec.priced_qty));
7931 END IF;--G_Service_pbh_lg_amt_qty.exists
7932 END IF;--l_bucket_price_rec.modifier_level_code
7933 ELSE
7934 IF l_bucket_price_rec.modifier_level_code =
7935 G_LINE_GROUP
7936 AND l_bucket_price_rec.pricing_status_code =
7937 G_STATUS_NEW
7938 THEN
7939 l_calc_quantity :=
7940 nvl(nvl(l_bucket_price_rec.group_quantity
7941 , l_bucket_price_rec.group_amount)
7942 , nvl(l_bucket_price_rec.priced_quantity
7943 , l_bucket_price_rec.priced_qty));
7944 ELSE
7945 l_calc_quantity :=
7946 nvl(l_bucket_price_rec.priced_qty, l_bucket_price_rec.priced_quantity);
7947 END IF; --_bucket_price_rec.modifier_level_code
7948 END IF;--QP_PREQ_GRP.G_service_line_qty_tbl.exists
7949
7950 --fix for bug2424931
7951 l_calc_quantity := nvl(l_calc_quantity, 1);
7952
7953 IF l_debug = FND_API.G_TRUE THEN
7954 QP_PREQ_GRP.engine_debug('figuring out qty level '
7955 || l_bucket_price_rec.modifier_level_code
7956 ||' pricedqty '|| l_bucket_price_rec.priced_quantity
7957 ||' grpqty '|| l_bucket_price_rec.group_quantity
7958 ||' grpamt '|| l_bucket_price_rec.group_amount
7959 ||' lqty '|| l_bucket_price_rec.priced_qty -- order_qty of the line
7960 ||' calc '|| l_calc_quantity);
7961 END IF;
7962 --End fix for bug 1915355
7963 IF l_bucket_price_rec.created_from_list_line_type
7964 = G_PRICE_BREAK_TYPE
7965 THEN
7966
7967 BEGIN
7968 SELECT pricing_attribute
7969 INTO l_pbh_pricing_attr
7970 FROM qp_pricing_attributes
7971 WHERE list_line_id =
7972 l_bucket_price_rec.created_from_list_line_id;
7973 EXCEPTION
7974 WHEN OTHERS THEN
7975 l_pbh_pricing_attr := NULL;
7976 END;
7977
7978 --changes for PBH line group LUMPSUM bug 2388011 commented out
7979 --call to old signature of Price_Break_Calculation
7980 /*
7981 --fix for bug 2515762 to pass line_dtl_index instead of list_line_id
7982 QP_Calculate_Price_PUB.Price_Break_Calculation(
7983 l_bucket_price_rec.line_detail_index
7984 ,l_bucket_price_rec.price_break_type_code
7985 ,l_bucket_price_rec.line_ind
7986 ,nvl(l_calc_quantity,1)
7987 ,l_sub_total_price
7988 ,l_return_adjustment
7989 ,l_return_status
7990 ,l_return_status_text);
7991 */
7992 --changes for PBH line group LUMPSUM bug 2388011 calling new
7993 --overloaded procedure Price_Break_Calculation
7994
7995 -- [nirmkuma 4222552 ] since passed line group manual discounts are
7996 -- treated only as line level, using following line level path, which
7997 -- looks at updated line_priced_quantity.
7998
7999 IF (l_bucket_price_rec.modifier_level_code IN (G_LINE_LEVEL, G_ORDER_LEVEL)
8000 or (l_bucket_price_rec.modifier_level_code = G_LINE_GROUP
8001 and l_bucket_price_rec.automatic_flag = G_NO)) THEN
8002 IF nvl(l_pbh_pricing_attr, 'NULL') = G_QUANTITY_ATTRIBUTE THEN
8003 l_total_value := 0;
8004 l_req_value_per_unit := l_bucket_price_rec.priced_qty;
8005 ELSE --same for item amount or others(treat as item_amt)
8006 l_total_value := l_bucket_price_rec.priced_quantity;
8007 l_req_value_per_unit := l_bucket_price_rec.priced_qty;
8008 l_qualifier_value := l_bucket_price_rec.priced_quantity; --2892848 move to here
8009
8010 -- begin 2892848
8011 -- net_amount line level (not group of line) modifier
8012 IF l_bucket_price_rec.net_amount_flag IN (G_YES, 'P') THEN
8013 IF l_debug = FND_API.G_TRUE THEN
8014 QP_PREQ_GRP.engine_debug('net amount line level modifier: '|| l_bucket_price_rec.created_from_list_line_id);
8015 END IF; -- end debug
8016 /* SL_latest
8017 IF l_prev_bucket_index_adj_tbl.EXISTS(l_bucket_price_rec.line_ind) THEN
8018 l_qualifier_value:= l_bucket_price_rec.priced_quantity
8019 + nvl(l_prev_bucket_index_adj_tbl(l_bucket_price_rec.line_ind),0)* l_bucket_price_rec.priced_qty;
8020 IF l_debug = FND_API.G_TRUE THEN
8021 QP_PREQ_GRP.engine_debug('line amount: '||l_bucket_price_rec.priced_quantity);
8022 QP_PREQ_GRP.engine_debug('order qty : '||l_bucket_price_rec.priced_qty);
8023 QP_PREQ_GRP.engine_debug('unit adjs up to prev buckets: '|| nvl(l_prev_bucket_index_adj_tbl(l_bucket_price_rec.line_ind),0) );
8024 END IF; -- end debug
8025 ELSE
8026 l_qualifier_value:= l_bucket_price_rec.priced_quantity;
8027 END IF; -- END IF l_prev_bucket_index_adj_tbl.EXISTS(l_bucket_price_rec)
8028 */
8029 IF l_bucket_amt_tbl.EXISTS(l_bucket_price_rec.line_ind)THEN
8030 l_qualifier_value := l_bucket_amt_tbl(l_bucket_price_rec.line_ind);
8031 IF l_debug = FND_API.G_TRUE THEN
8032 QP_PREQ_GRP.engine_debug('line level net amount, SL_latest ?: '|| l_bucket_amt_tbl(l_bucket_price_rec.line_ind));
8033 END IF; -- end debug
8034 END IF; -- END IF l_bucket_amt_tbl.EXISTs
8035 END IF; -- END IF net_amount modifier
8036 -- end 2892848
8037
8038 END IF; --l_pbh_pricing_attr
8039 ELSE --linegroup level
8040 IF nvl(l_pbh_pricing_attr, 'NULL') = G_QUANTITY_ATTRIBUTE THEN
8041 l_total_value := 0;
8042 l_req_value_per_unit := l_bucket_price_rec.group_quantity;
8043 ELSE --same for item amount or others(treat as item_amt)
8044 l_total_value := l_bucket_price_rec.priced_quantity;
8045 l_req_value_per_unit := l_bucket_price_rec.group_amount;
8046
8047 -- begin 2892848
8048 -- IF net amount linegroup modifier
8049 IF l_bucket_price_rec.net_amount_flag IN (G_YES, 'P') THEN
8050
8051 IF l_debug = FND_API.G_TRUE THEN
8052 QP_PREQ_GRP.engine_debug('net amount linegroup modifier id: '|| l_bucket_price_rec.created_from_list_line_id);
8053 END IF; -- end debug
8054
8055 l_lg_net_amt := 0;
8056 l_line_bucket_amt := 0; -- note 0+null is null
8057 -- [julin/4112395/4220399]
8058 l_lg_prod_net_amt := 0;
8059 l_prod_line_bucket_amt := 0;
8060
8061 -- net amount is grp_amt - (adj_amts of all lines from prev bucket)
8062 --l_qualifier_value := l_bucket_price_rec.priced_quantity + l_prev_lg_adj_amt; -- 2892848 old way
8063
8064 -- begin SL_latest
8065 -- SL_further_fix
8066 -- if there are no prev buckets(l_prev_bucket=-9999) for this modifier, then use group amount
8067 -- since we do not have the adjs of other lines yet, l_bucket_amt_tbl does not have complete data
8068
8069 -- [julin/3265308] net amount calculation 'P', match product only.
8070 -- For category net amount, 1st_bucket means that this is the
8071 -- first bucket of the line, so no adjustments have been ap-
8072 -- plied. However, other lines of the same category might
8073 -- have had modifiers in previous buckets applied, so we look
8074 -- at the bucket_amt_tbl to see if those have been calculated
8075 -- else we can assume no modifiers applied yet, and can hence
8076 -- calculate the list price * qty for those lines.
8077 IF nvl(l_bucket_price_rec.net_amount_flag, 'N') = 'P' THEN
8078 IF l_mod_lg_prod_net_amt_tbl.EXISTS(l_bucket_price_rec.created_from_list_line_id) THEN
8079 l_lg_prod_net_amt := l_mod_lg_prod_net_amt_tbl(l_bucket_price_rec.created_from_list_line_id);
8080 IF l_debug = FND_API.G_TRUE THEN
8081 QP_PREQ_GRP.engine_debug('recycle l_lg_prod_net_amt from l_mod_lg_net_amt_tbl: '|| l_lg_prod_net_amt);
8082 END IF; --end debug
8083 ELSE -- need to calculate l_lg_net_amt
8084 IF l_debug = FND_API.G_TRUE THEN
8085 QP_PREQ_GRP.engine_debug('1st bucket = '|| l_1st_bucket ||', net amount flag = P');
8086 END IF;
8087 -- calculate amount using product attribute net amount grouping
8088 FOR t IN l_prod_attr_info(l_bucket_price_rec.created_from_list_line_id) LOOP
8089 IF l_prev_bucket_amt_tbl.EXISTS(t.line_index) THEN
8090 l_prod_line_bucket_amt := nvl(l_prev_bucket_amt_tbl(t.line_index), 0);
8091 IF l_debug = FND_API.G_TRUE THEN
8092 QP_PREQ_GRP.engine_debug(t.line_index || ':' || l_prev_bucket_amt_tbl(t.line_index));
8093 END IF; --end debug
8094 ELSE
8095 -- have to compute list price * qty for the line (query from qp_npreq_lines_tmp)
8096 l_prod_line_bucket_amt := nvl(t.priced_quantity, 0) * nvl(t.unit_price, 0);
8097 IF l_debug = FND_API.G_TRUE THEN
8098 QP_PREQ_GRP.engine_debug('* line index '|| t.line_index ||' not in l_prev_bucket_amt_tbl');
8099 QP_PREQ_GRP.engine_debug(' got value '|| l_prod_line_bucket_amt ||' from lines_tmp instead');
8100 END IF;
8101 END IF;
8102 l_lg_prod_net_amt := l_lg_prod_net_amt + l_prod_line_bucket_amt;
8103
8104 IF l_debug = FND_API.G_TRUE THEN
8105 QP_PREQ_GRP.engine_debug('(catnetamt) l_prod_line_bucket_amt: ' || l_prod_line_bucket_amt);
8106 QP_PREQ_GRP.engine_debug('(catnetamt) up-tp-date l_lg_prod_net_amt: ' || l_lg_prod_net_amt); -- grp amt
8107 END IF;
8108 END LOOP;
8109
8110 l_mod_lg_prod_net_amt_tbl(l_bucket_price_rec.created_from_list_line_id) := l_lg_prod_net_amt; -- preserve this for recycle
8111 END IF;
8112 END IF; -- end l_bucket_price_rec.net_amount_flag = 'P' -- [julin/3265308]
8113
8114 IF l_1st_bucket = 'Y' THEN
8115
8116 IF l_debug = FND_API.G_TRUE THEN
8117 QP_PREQ_GRP.engine_debug(' l_1st_bucket is Y, use group amount as l_lg_net_amt'); -- grp amt
8118 END IF; -- end debug
8119 l_lg_net_amt := l_bucket_price_rec.priced_quantity;
8120
8121 ELSE -- l_1st_bucket <>'Y'
8122
8123 IF l_debug = FND_API.G_TRUE THEN
8124 QP_PREQ_GRP.engine_debug(' - not first bucket');
8125 END IF;
8126 IF l_mod_lg_net_amt_tbl.EXISTS(l_bucket_price_rec.created_from_list_line_id) THEN
8127 l_qualifier_value := l_mod_lg_net_amt_tbl(l_bucket_price_rec.created_from_list_line_id);
8128 IF l_debug = FND_API.G_TRUE THEN
8129 QP_PREQ_GRP.engine_debug('recycle lg_net_amt from l_mod_lg_net_amt_tbl('|| l_bucket_price_rec.line_ind ||'): '|| l_qualifier_value);
8130 END IF; --end debug
8131
8132 ELSE -- ELSE IF l_mod_lg_net_amt_tbl.EXISTS
8133
8134 -- regular net amount processing
8135 -- fix of latest requirement, only add up net amounts with in the group
8136 -- lg_net_amt_tbl is hastable of modifier and its lg_net_amt for that bucket, to_do
8137 -- lg_net_amt is the sum of (USP at end of last bucket *Qty) for the lines related to this modifier
8138 -- l_net_mod_index_cur has line_indexes related to this net amount modifier
8139
8140 -- regular net amount processing
8141 -- fix of latest requirement, only add up net amounts with in the group
8142 -- lg_net_amt_tbl is hastable of modifier and its lg_net_amt for that bucket, to_do
8143 -- lg_net_amt is the sum of (USP at end of last bucket *Qty) for the lines related to this modifier
8144 -- l_net_mod_index_cur has line_indexes related to this net amount modifier
8145
8146 FOR t IN l_net_mod_index_cur(l_bucket_price_rec.created_from_list_line_id) LOOP
8147 IF l_bucket_amt_tbl.EXISTS(t.line_index) THEN
8148 l_line_bucket_amt := nvl(l_bucket_amt_tbl(t.line_index), 0);
8149 IF l_debug = FND_API.G_TRUE THEN
8150 QP_PREQ_GRP.engine_debug(t.line_index || ':' || l_bucket_amt_tbl(t.line_index));
8151 END IF; --end debug
8152 ELSE
8153 l_line_bucket_amt := 0;
8154 END IF;
8155 l_lg_net_amt := l_lg_net_amt + l_line_bucket_amt;
8156
8157 IF l_debug = FND_API.G_TRUE THEN
8158 QP_PREQ_GRP.engine_debug('net amount l_bucket_amt_tbl('|| t.line_index ||'): '|| l_line_bucket_amt);
8159 END IF; --end debug
8160
8161 END LOOP; -- end l_net_mod_index_cur
8162
8163 l_mod_lg_net_amt_tbl(l_bucket_price_rec.created_from_list_line_id) := l_lg_net_amt;
8164
8165 END IF; --l_mod_lg_net_amt_tbl.EXIST
8166 END IF; -- END IF l_prev_bucket = -9999
8167
8168 -- end SL_latest
8169
8170 -- [julin/4112395/4220399]
8171 IF (nvl(l_bucket_price_rec.net_amount_flag, 'N') = 'P') THEN
8172 l_qualifier_value := l_lg_prod_net_amt;
8173 -- [julin/4571612/4671446] explicitly set FND_API.G_NULL_NUM means infinity
8174 IF (l_sub_total_price = 0) THEN
8175 l_req_value_per_unit := FND_API.G_NULL_NUM;
8176 l_applied_req_value_per_unit := FND_API.G_NULL_NUM;
8177 ELSE
8178 l_req_value_per_unit := l_lg_prod_net_amt / l_sub_total_price; --bug 3404493
8179 l_applied_req_value_per_unit := l_lg_net_amt / l_sub_total_price;
8180 END IF;
8181 ELSE
8182 l_qualifier_value := l_lg_net_amt;
8183 -- [julin/4571612/4671446] explicitly set FND_API.G_NULL_NUM means infinity
8184 IF (l_sub_total_price = 0) THEN
8185 l_req_value_per_unit := FND_API.G_NULL_NUM;
8186 ELSE
8187 l_req_value_per_unit := l_lg_net_amt / l_sub_total_price; --bug 3404493
8188 END IF;
8189 END IF;
8190
8191 IF l_debug = FND_API.G_TRUE THEN
8192 QP_PREQ_GRP.engine_debug('group amount: ' || l_bucket_price_rec.priced_quantity); -- grp amt
8193 QP_PREQ_GRP.engine_debug('group of lines net amt: '|| l_qualifier_value);
8194
8195 END IF; --end debug
8196
8197 ELSE -- not net amount modifier
8198 l_qualifier_value := l_bucket_price_rec.priced_quantity; -- not net amount grouop of line modifier
8199
8200 END IF; -- END IF net_amount_flag = 'Y' for line group modifiers
8201 -- end 2892848
8202
8203 END IF; --l_pbh_pricing_attr
8204 END IF; --modifier level code
8205
8206 IF l_debug = FND_API.G_TRUE THEN
8207 QP_PREQ_GRP.engine_debug('PBH break dtls attribute '
8208 || l_pbh_pricing_attr ||' l_total_value '|| l_total_value
8209 ||' l_req_value_per_unit '|| l_req_value_per_unit);
8210 END IF; --l_debug
8211
8212 -- obtain net_adj_amount_flag from qp_list_lines table if null,
8213 -- since it may not be passed from calling application
8214 -- net_amount_new 2720717
8215 IF l_bucket_price_rec.net_amount_flag IS NULL THEN
8216 OPEN l_net_amount_flag_cur(l_bucket_price_rec.created_from_list_line_id);
8217 FETCH l_net_amount_flag_cur INTO l_bucket_price_rec.net_amount_flag;
8218 CLOSE l_net_amount_flag_cur;
8219 END IF;
8220
8221 -- [julin/3265308] Price_Break_Calculation should have same
8222 -- behavior for both net_amount_flag = G_YES and 'P'.
8223 IF (l_bucket_price_rec.net_amount_flag IN (G_YES, 'P')) THEN
8224 l_bucketed_flag := G_YES;
8225 ELSE
8226 l_bucketed_flag := G_NO;
8227 END IF;
8228
8229 --4900095 used in price_break_calculation
8230 G_PBH_MOD_LEVEL_CODE(l_bucket_price_rec.line_detail_index) :=
8231 l_bucket_price_rec.modifier_level_code;
8232
8233 QP_Calculate_Price_PUB.Price_Break_Calculation(
8234 l_bucket_price_rec.line_detail_index, -- line_detail_index
8235 l_bucket_price_rec.price_break_type_code,
8236 l_bucket_price_rec.line_ind,
8237 l_req_value_per_unit, -- Group Value per unit,group quantity,item qty 40
8238 l_applied_req_value_per_unit, -- [julin/4112395/4220399]
8239 l_total_value, -- Total value (Group amount or item amount) 4000
8240 l_sub_total_price,
8241 --l_bucket_price_rec.priced_quantity, -- 2388011
8242 l_bucket_price_rec.priced_qty, -- FIX BUG 2880314, should be order qty of the line
8243 --l_pbh_prev_net_adj_amount, -- net_amt_new 2720717--2892848
8244 l_qualifier_value, -- p_bucketed_adj, 2892848
8245 l_bucketed_flag, -- net_amt_new 2720717, [julin/3265308]
8246 l_bucket_price_rec.automatic_flag, -- 5413797
8247 l_return_adjustment,
8248 l_return_status,
8249 l_return_status_text);
8250 --end changes for bug 2388011
8251
8252 l_return_adjustment :=
8253 - 1 * nvl(l_return_adjustment, 0);
8254
8255 -- 2892848
8256 IF l_debug = FND_API.G_TRUE THEN
8257 QP_PREQ_GRP.engine_debug('PBH return adjustment '|| l_return_adjustment); --40
8258 END IF; --l_debug
8259 -- end 2892848
8260
8261 ELSE --created_from_list_line_type not PBH 2892848 comment change
8262 /*
8263 IF l_bucket_price_rec.updated_flag = G_YES
8264 and nvl(l_bucket_price_rec.automatic_flag,G_NO) = G_NO
8265 and (l_bucket_price_rec.adjustment_amount IS NOT NULL
8266 and l_bucket_price_rec.adjustment_amount <>
8267 G_MISS_NUM) --FND_API.G_MISS_NUM)
8268 THEN
8269 --to avoid rounding issues in rev calculations
8270 --for user-overridden adjustments
8271 l_return_adjustment :=
8272 l_bucket_price_rec.adjustment_amount;
8273 ELSE
8274 */--commented to avoid overriding errors
8275
8276 Calculate_bucket_price(
8277 l_bucket_price_rec.created_from_list_line_type
8278 , l_sub_total_price
8279 , nvl(l_calc_quantity, 1)
8280 , l_bucket_price_rec.operand_calculation_code
8281 , nvl(l_bucket_price_rec.operand_value, 0) * l_sign
8282 , l_return_adjustment
8283 , l_return_status
8284 , l_return_status_text);
8285 -- END IF;
8286 END IF;
8287
8288 IF l_return_status = FND_API.G_RET_STS_ERROR
8289 THEN
8290 x_return_status := l_return_status;
8291 x_return_status_text := l_return_status_text;
8292 RAISE Calculate_Exc;
8293 END IF;
8294
8295 -- 2892848
8296 IF l_debug = FND_API.G_TRUE THEN
8297 QP_PREQ_GRP.engine_debug(' unrounded adj_amt l_return_adjustment '|| l_return_adjustment); -- 2892848, will be rounded later, ok
8298 END IF; --END IF l_debug
8299 /* SL_latest
8300 -- CONTINUE building l_bucket_adj_amt_tbl and l_bucket_index_adj_tbl regardless of bucket
8301 IF l_bucket_price_rec.pricing_group_sequence IS NOT NULL THEN
8302 IF l_bucket_adj_amt_tbl.EXISTS(l_bucket_price_rec.pricing_group_sequence) THEN -- avoid no data found or table index not exists for 1st rec
8303 IF l_debug = FND_API.G_TRUE THEN
8304 QP_PREQ_GRP.engine_debug (' accumulated adj amts by bucket BEFORE: ' || l_bucket_adj_amt_tbl(l_bucket_price_rec.pricing_group_sequence));
8305 END IF; -- end debug
8306 l_bucket_adj_amt_tbl(l_bucket_price_rec.pricing_group_sequence):= nvl(l_bucket_adj_amt_tbl(l_bucket_price_rec.pricing_group_sequence),0) +
8307 nvl(l_return_adjustment,0)* l_bucket_price_rec.priced_qty;
8308
8309 ELSE -- avoid no data found err
8310 l_bucket_adj_amt_tbl(l_bucket_price_rec.pricing_group_sequence):= nvl(l_return_adjustment,0) * l_bucket_price_rec.priced_qty;
8311 END IF; -- END IF l_bucket_adj_amt_tbl.EXISTS
8312
8313 IF l_debug = FND_API.G_TRUE THEN
8314 QP_PREQ_GRP.engine_debug (' (LINEGROUP) building l_bucket_adj_amt_tbl by bucket: '||l_bucket_price_rec.pricing_group_sequence);
8315 QP_PREQ_GRP.engine_debug (' nvl of current unit adj: '||nvl(l_return_adjustment, 0));
8316 QP_PREQ_GRP.engine_debug (' order qty: '||l_bucket_price_rec.priced_qty);
8317 QP_PREQ_GRP.engine_debug (' accumulated adj amts for this bucket: ' || l_bucket_adj_amt_tbl(l_bucket_price_rec.pricing_group_sequence));
8318 END IF; -- END debug
8319
8320 -- for LINE LEVEL
8321 IF l_bucket_index_adj_tbl.EXISTS(l_bucket_price_rec.line_ind) THEN
8322 IF l_debug = FND_API.G_TRUE THEN
8323 QP_PREQ_GRP.engine_debug (' accumulated unit adj by line BEFORE: ' || nvl(l_bucket_index_adj_tbl(l_bucket_price_rec.line_ind), 0));
8324 END IF; -- end debug
8325 l_bucket_index_adj_tbl(l_bucket_price_rec.line_ind) := nvl(l_bucket_index_adj_tbl(l_bucket_price_rec.line_ind), 0) + nvl(l_return_adjustment, 0);
8326 ELSE -- avoid no datat found err
8327 l_bucket_index_adj_tbl(l_bucket_price_rec.line_ind) := nvl(l_return_adjustment, 0);
8328 END IF; -- END IF l_bucket_index_adj_tbl.EXISTS
8329
8330 IF l_debug = FND_API.G_TRUE THEN
8331 QP_PREQ_GRP.engine_debug (' (LINE) building l_bucket_index_adj_tbl for line_index: '||l_bucket_price_rec.line_ind);
8332 QP_PREQ_GRP.engine_debug (' accumulated unit adjs by line index: '||l_bucket_index_adj_tbl(l_bucket_price_rec.line_ind));
8333 END IF; -- END debug
8334 END IF; -- END IF l_bucket_price_rec.pricing_group_sequence IS NOT NULL
8335 -- end 2892848
8336 */
8337 --round the adjustment_amount with factor on the line
8338 --engine updates the factor on the line
8339 --w/nvl(user_passed,price_list rounding_factor)
8340 IF G_ROUND_INDIVIDUAL_ADJ = G_ROUND_ADJ -- 2892848_latest
8341 AND l_bucket_price_rec.rounding_factor IS NOT NULL
8342 THEN
8343 l_return_adjustment :=
8344 round(l_return_adjustment,
8345 ( - 1 * l_bucket_price_rec.rounding_factor));
8346 END IF;
8347
8348 IF l_debug = FND_API.G_TRUE THEN
8349 QP_PREQ_GRP.engine_debug('rounded adj: '||
8350 l_return_adjustment
8351 ||' roundingfac: '|| l_bucket_price_rec.rounding_factor);
8352
8353 END IF;
8354 l_bucket_price_rec.adjustment_amount :=
8355 nvl(l_return_adjustment, 0);
8356
8357 /* SL_latest 2892848
8358 l_pbh_net_adj_amount := l_pbh_net_adj_amount + l_bucket_price_rec.adjustment_amount; -- 2892848 SL_latest
8359
8360 IF l_debug = FND_API.G_TRUE THEN
8361 QP_PREQ_GRP.engine_debug('adjustment_amount: '||l_bucket_price_rec.adjustment_amount);
8362 QP_PREQ_GRP.engine_debug('l_pbh_net_adj_amount: '||l_pbh_net_adj_amount);
8363 END IF; -- END IF l_debug
8364 */
8365 --code added to calculate adj amt on order lvl adj
8366 --fix for bug 1767249
8367 IF l_bucket_price_rec.line_type =
8368 G_ORDER_LEVEL
8369 AND l_bucket_price_rec.created_from_list_line_type
8370 <> G_FREIGHT_CHARGE
8371 THEN
8372 IF l_debug = FND_API.G_TRUE THEN
8373 QP_PREQ_GRP.engine_debug('ord lvl adj processing '
8374 || l_bucket_price_rec.line_type ||' listlineid '
8375 || l_bucket_price_rec.created_from_list_line_id);
8376 END IF;
8377 IF l_ord_dtl_index_tbl.COUNT = 0
8378 THEN
8379 IF l_debug = FND_API.G_TRUE THEN
8380 QP_PREQ_GRP.engine_debug('ord lvl firstrec');
8381 END IF;
8382 l_ord_dtl_index_tbl(1) :=
8383 l_bucket_price_rec.line_detail_index;
8384 --fix for bug2424931 multiply by priced_qty
8385 l_ord_adj_amt_tbl(1) :=
8386 nvl(l_bucket_price_rec.adjustment_amount, 0) *
8387 nvl(l_bucket_price_rec.priced_qty, 0);
8388 IF l_debug = FND_API.G_TRUE THEN
8389 QP_PREQ_GRP.engine_debug('ordlvl firstrec adj '
8390 || l_ord_adj_amt_tbl(1));
8391 END IF;
8392 ELSE
8393 FOR n IN
8394 l_ord_dtl_index_tbl.FIRST..l_ord_dtl_index_tbl.LAST
8395 LOOP
8396 IF l_debug = FND_API.G_TRUE THEN
8397 QP_PREQ_GRP.engine_debug('ord lvl adj index '||
8398 l_ord_dtl_index_tbl(n) ||' current rec index '
8399 || l_bucket_price_rec.line_detail_index
8400 ||' count '|| l_ord_dtl_index_tbl.COUNT
8401 ||' lastrec dtl index '
8402 || l_ord_dtl_index_tbl(l_ord_dtl_index_tbl.LAST));
8403 END IF;
8404 IF l_ord_dtl_index_tbl(n) =
8405 l_bucket_price_rec.line_detail_index
8406 THEN
8407 --fix for bug2424931 multiply by priced_qty
8408 l_ord_adj_amt_tbl(n) := l_ord_adj_amt_tbl(n) +
8409 nvl(l_bucket_price_rec.adjustment_amount, 0) *
8410 nvl(l_bucket_price_rec.priced_qty, 0);
8411 IF l_debug = FND_API.G_TRUE THEN
8412 QP_PREQ_GRP.engine_debug('ord lvl adj amt '||
8413 l_ord_adj_amt_tbl(n));
8414 END IF;
8415 EXIT; --exit the loop once matches
8416 ELSIF l_ord_dtl_index_tbl(n) =
8417 l_ord_dtl_index_tbl(l_ord_dtl_index_tbl.LAST)
8418 AND l_ord_dtl_index_tbl(n) <>
8419 l_bucket_price_rec.line_detail_index
8420 THEN
8421 IF l_debug = FND_API.G_TRUE THEN
8422 QP_PREQ_GRP.engine_debug('ord lvl lastrec '||
8423 l_bucket_price_rec.line_detail_index ||' adjamt '
8424 || l_bucket_price_rec.adjustment_amount
8425 ||' qty '|| l_bucket_price_rec.priced_qty);
8426 END IF;
8427 l_ord_dtl_index_tbl(l_ord_dtl_index_tbl.COUNT + 1)
8428 := l_bucket_price_rec.line_detail_index;
8429 --fix for bug2424931 multiply by priced_qty
8430 l_ord_adj_amt_tbl(l_ord_dtl_index_tbl.COUNT)
8431 := nvl(l_bucket_price_rec.adjustment_amount, 0) *
8432 nvl(l_bucket_price_rec.priced_qty, 0);
8433 IF l_debug = FND_API.G_TRUE THEN
8434 QP_PREQ_GRP.engine_debug('ord lvl adj amt '||
8435 l_ord_adj_amt_tbl(l_ord_dtl_index_tbl.COUNT));
8436 END IF;
8437 END IF;
8438 IF l_debug = FND_API.G_TRUE THEN
8439 QP_PREQ_GRP.engine_debug('ord lvl adj:dtlindex '
8440 || l_ord_dtl_index_tbl(n) ||' adj amt '
8441 || l_ord_adj_amt_tbl(n));
8442 END IF;
8443 END LOOP; --l_ord_dtl_index_tbl
8444 END IF; --l_ord_dtl_index_tbl.COUNT
8445 END IF; --order level
8446
8447
8448 --end code added to calculate adj amt on order lvl adj
8449 --manual frt charges shd not be returned as applied
8450 IF nvl(l_bucket_price_rec.automatic_flag, G_NO) = G_YES
8451 OR (nvl(l_bucket_price_rec.applied_flag, G_NO) = G_YES
8452 AND nvl(l_bucket_price_rec.updated_flag, G_NO) = G_YES)
8453 THEN
8454 l_bucket_price_rec.applied_flag := G_YES;
8455 ELSE
8456 l_bucket_price_rec.applied_flag := G_NO;
8457 END IF;
8458
8459 IF l_return_status = FND_API.G_RET_STS_ERROR THEN
8460
8461 l_bucket_price_rec.process_code :=
8462 FND_API.G_RET_STS_ERROR;
8463 l_bucket_price_rec.pricing_status_text :=
8464 l_return_status_text;
8465 END IF;
8466
8467
8468 --populate grp/line qty into line qty
8469 l_bucket_price_rec.priced_quantity :=
8470 l_bucket_price_rec.priced_quantity;
8471 l_ldet_tbl(i) := l_bucket_price_rec;
8472
8473 IF l_debug = FND_API.G_TRUE THEN
8474 QP_PREQ_GRP.ENGINE_DEBUG('Passed to table:
8475 line index '|| l_ldet_tbl(i).line_ind ||
8476 ' list_line_id '|| l_ldet_tbl(i).created_from_list_line_id ||
8477 ' adjustment amount '|| l_ldet_tbl(i).adjustment_amount ||
8478 ' applied flag '|| l_ldet_tbl(i).applied_flag);
8479
8480
8481
8482
8483 END IF;
8484 IF l_bucket_price_rec.created_from_list_line_type IN
8485 (G_DISCOUNT, G_SURCHARGE, G_PRICE_BREAK_TYPE)
8486 AND nvl(l_bucket_price_rec.accrual_flag, G_NO) = G_NO
8487 THEN
8488
8489 l_adjusted_price := (l_adjusted_price + nvl(l_return_adjustment, 0));
8490 IF l_debug = FND_API.G_TRUE THEN
8491 QP_PREQ_GRP.ENGINE_DEBUG('Display price: price '
8492 --||l_list_price||' sub-t '||l_sub_total_price -- 2892848
8493 ||' adj price (USP) '|| l_adjusted_price
8494 ||' ret adj '|| l_return_adjustment);
8495 END IF; -- end debug
8496
8497 j := l_bucket_price_rec.line_ind; -- 2892848
8498
8499 --Update the adjustment amount for each adjustment
8500 l_lines_tbl(j).line_index := l_bucket_price_rec.line_ind;
8501 l_lines_tbl(j).adjusted_unit_price := l_adjusted_price;
8502
8503 -- 2892848_latest, do not round here since it is not final USP
8504 --round the selling price if G_ROUND_INDIVIDUAL_ADJ=Y
8505 -- need to re-evaluate how this should work now
8506 /*
8507 IF G_ROUND_INDIVIDUAL_ADJ <> G_NO_ROUND -- shu, fix bug 2239061
8508 and l_lines_tbl(j).rounding_factor IS NOT NULL
8509 THEN
8510 IF l_debug = FND_API.G_TRUE THEN
8511 QP_PREQ_GRP.engine_debug('round current USP, rounding_factor: '
8512 ||l_lines_tbl(j).rounding_factor);
8513 END IF;
8514 l_lines_tbl(j).adjusted_unit_price :=
8515 round(l_lines_tbl(j).adjusted_unit_price,
8516 -1*l_lines_tbl(j).rounding_factor);
8517 END IF; -- END IF G_ROUND_INDIVIDUAL_ADJ = G_ROUND_ADJ
8518 */
8519
8520 IF l_debug = FND_API.G_TRUE THEN
8521 QP_PREQ_GRP.ENGINE_DEBUG('adjusted_price'
8522 || l_lines_tbl(j).adjusted_unit_price ||
8523 ' bucket '|| l_bucket_price_rec.pricing_group_sequence ||
8524 ' list_line_id '|| l_bucket_price_rec.created_from_list_line_id);
8525 END IF;
8526 END IF;
8527
8528
8529 --Freight Charge functionality
8530 IF l_bucket_price_rec.created_from_list_line_type =
8531 G_FREIGHT_CHARGE
8532 AND nvl(l_bucket_price_rec.automatic_flag, G_NO) = G_YES
8533 THEN
8534 IF l_debug = FND_API.G_TRUE THEN
8535 QP_PREQ_GRP.engine_debug('frt chrge func '
8536 ||'looping thru freight charge for list_line id '
8537 || l_bucket_price_rec.created_from_list_line_id
8538 ||' adj amt '
8539 || l_bucket_price_rec.adjustment_amount ||' upd '
8540 || l_bucket_price_rec.updated_flag);
8541
8542 END IF;
8543 --deleting all the frt charges to start with
8544 l_ldet_tbl(i).pricing_status_code := G_STATUS_DELETED;
8545 l_ldet_tbl(i).pricing_status_text :=
8546 G_NOT_MAX_FRT_CHARGE;
8547
8548 IF l_frt_charge_tbl.COUNT = 0
8549 THEN
8550 --no record for charge type subtype combn
8551 --so insert into l_frt_charge_tbl
8552 IF l_debug = FND_API.G_TRUE THEN
8553 QP_PREQ_GRP.engine_debug('No frt charge so far'
8554 ||' insert new frt record ');
8555 END IF;
8556 l_frt_charge_tbl(1).line_index :=
8557 l_bucket_price_rec.line_ind;
8558 l_frt_charge_tbl(1).line_detail_index :=
8559 l_bucket_price_rec.line_detail_index;
8560 l_frt_charge_tbl(1).created_from_list_line_id :=
8561 l_bucket_price_rec.created_from_list_line_id;
8562 l_frt_charge_tbl(1).adjustment_amount :=
8563 l_bucket_price_rec.adjustment_amount;
8564 l_frt_charge_tbl(1).charge_type_code :=
8565 l_bucket_price_rec.charge_type_code;
8566 l_frt_charge_tbl(1).charge_subtype_code :=
8567 l_bucket_price_rec.charge_subtype_code;
8568 l_frt_charge_tbl(1).updated_flag :=
8569 nvl(l_bucket_price_rec.updated_flag, G_NO);
8570 --this is to show if a frt rec is max or not
8571 l_ldet_tbl(i).is_max_frt := G_YES;
8572 IF l_bucket_price_rec.modifier_level_code IN
8573 (G_LINE_LEVEL, G_LINE_GROUP)
8574 THEN
8575 l_frt_charge_tbl(1).LEVEL := G_LINE_LEVEL;
8576 ELSIF l_bucket_price_rec.modifier_level_code =
8577 G_ORDER_LEVEL
8578 THEN
8579 l_frt_charge_tbl(1).LEVEL := G_ORDER_LEVEL;
8580 END IF;
8581 ELSIF l_frt_charge_tbl.COUNT > 0
8582 THEN
8583 IF l_debug = FND_API.G_TRUE THEN
8584 QP_PREQ_GRP.engine_debug('frtchrg records exist');
8585
8586 END IF;
8587 FOR N IN l_frt_charge_tbl.FIRST..l_frt_charge_tbl.LAST
8588 LOOP
8589 IF l_debug = FND_API.G_TRUE THEN
8590 QP_PREQ_GRP.engine_debug('existing frt record id '
8591 || l_frt_charge_tbl(N).created_from_list_line_id);
8592 -- begin 2892848
8593 QP_PREQ_GRP.engine_debug('begin shu debug, line_ind: '-- 2892848
8594 || l_bucket_price_rec.line_ind ||' line_index: '|| l_frt_charge_tbl(N).line_index );
8595 QP_PREQ_GRP.engine_debug('charge_type_code, rec: '-- 2892848
8596 || l_bucket_price_rec.charge_type_code ||' frt tbl: '|| l_frt_charge_tbl(N).charge_type_code );
8597 QP_PREQ_GRP.engine_debug('charge_subtype_code, rec: '-- 2892848
8598 || l_bucket_price_rec.charge_subtype_code ||' frt tbl: '|| l_frt_charge_tbl(N).charge_subtype_code );
8599 QP_PREQ_GRP.engine_debug('level, rec: '-- 2892848
8600 || l_bucket_price_rec.modifier_level_code ||' frt tbl: '|| l_frt_charge_tbl(N).LEVEL );
8601 -- end 2892848
8602
8603 END IF; -- end debug
8604 IF l_bucket_price_rec.line_ind = l_frt_charge_tbl(N).line_index -- 2892848, bug fix
8605 AND nvl(l_bucket_price_rec.charge_type_code, 'NULL') = -- 2892848, bug fix
8606 nvl(l_frt_charge_tbl(N).charge_type_code, 'NULL')
8607 AND nvl(l_bucket_price_rec.charge_subtype_code, 'NULL') =
8608 nvl(l_frt_charge_tbl(N).charge_subtype_code, 'NULL')
8609 AND (l_frt_charge_tbl(N).LEVEL =
8610 l_bucket_price_rec.modifier_level_code
8611 OR (l_frt_charge_tbl(N).LEVEL = G_LINE_LEVEL AND
8612 l_bucket_price_rec.modifier_level_code =
8613 G_LINE_GROUP))
8614 THEN
8615 --record exists for charge type subtype combn
8616 IF l_debug = FND_API.G_TRUE THEN
8617 QP_PREQ_GRP.engine_debug('charge combn match'
8618 || l_frt_charge_tbl(N).updated_flag);
8619 END IF;
8620 IF nvl(l_frt_charge_tbl(N).updated_flag, G_NO) = G_NO
8621 THEN
8622 IF l_debug = FND_API.G_TRUE THEN
8623 QP_PREQ_GRP.engine_debug('Rec is NOT overriden');
8624 END IF;
8625 --only if user has not overridden
8626 --replace the record with the ct adj
8627 IF nvl(l_bucket_price_rec.updated_flag, G_NO) =
8628 G_YES
8629 THEN
8630 IF l_debug = FND_API.G_TRUE THEN
8631 QP_PREQ_GRP.engine_debug('Repl overridden rec');
8632 END IF;
8633 --if ct adj is overridden
8634 l_frt_charge_tbl(N).line_detail_index
8635 := l_bucket_price_rec.line_detail_index;
8636 l_frt_charge_tbl(N).created_from_list_line_id :=
8637 l_bucket_price_rec.created_from_list_line_id;
8638 l_frt_charge_tbl(N).line_index
8639 := l_bucket_price_rec.line_ind;
8640 l_frt_charge_tbl(N).adjustment_amount
8641 := l_bucket_price_rec.adjustment_amount;
8642 l_frt_charge_tbl(N).updated_flag
8643 := l_bucket_price_rec.updated_flag;
8644 ELSIF nvl(l_bucket_price_rec.updated_flag, G_NO) =
8645 G_NO
8646 AND l_bucket_price_rec.adjustment_amount
8647 > l_frt_charge_tbl(N).adjustment_amount
8648 THEN
8649 --if ct adj's adj amt is greater
8650 IF l_debug = FND_API.G_TRUE THEN
8651 QP_PREQ_GRP.engine_debug('replace high adjamt');
8652 END IF;
8653 l_frt_charge_tbl(N).line_detail_index
8654 := l_bucket_price_rec.line_detail_index;
8655 l_frt_charge_tbl(N).created_from_list_line_id
8656 := l_bucket_price_rec.created_from_list_line_id;
8657 l_frt_charge_tbl(N).line_index
8658 := l_bucket_price_rec.line_ind;
8659 l_frt_charge_tbl(N).adjustment_amount
8660 := l_bucket_price_rec.adjustment_amount;
8661 l_frt_charge_tbl(N).updated_flag
8662 := l_bucket_price_rec.updated_flag;
8663 END IF; --bucket_price_rec.updated_flag
8664 END IF; --frt_charge_tbl.updated_flag
8665 EXIT;
8666 ELSE
8667 --no match for charge type subtype combn
8668 --so insert into l_frt_charge_tbl
8669 IF l_debug = FND_API.G_TRUE THEN
8670 QP_PREQ_GRP.engine_debug('charge combn no match');
8671 END IF;
8672 IF N = l_frt_charge_tbl.LAST
8673 THEN
8674 --this is the last record and the
8675 --charge type subtype combn not match
8676 IF l_debug = FND_API.G_TRUE THEN
8677 QP_PREQ_GRP.engine_debug('hit last rec in tbl'
8678 ||' insert new record ');
8679 QP_PREQ_GRP.engine_debug('shu debug, l_bucket_price_rec.adjustment_amount: '-- shu, 2892848
8680 || l_bucket_price_rec.adjustment_amount); -- 2892848
8681 END IF;
8682 l_frt_charge_tbl(N + 1).line_index :=
8683 l_bucket_price_rec.line_ind;
8684 l_frt_charge_tbl(N + 1).line_detail_index :=
8685 l_bucket_price_rec.line_detail_index;
8686 l_frt_charge_tbl(N + 1).created_from_list_line_id :=
8687 l_bucket_price_rec.created_from_list_line_id;
8688 l_frt_charge_tbl(N + 1).adjustment_amount :=
8689 l_bucket_price_rec.adjustment_amount;
8690 l_frt_charge_tbl(N + 1).charge_type_code :=
8691 l_bucket_price_rec.charge_type_code;
8692 l_frt_charge_tbl(N + 1).charge_subtype_code :=
8693 l_bucket_price_rec.charge_subtype_code;
8694 l_frt_charge_tbl(N + 1).updated_flag :=
8695 nvl(l_bucket_price_rec.updated_flag, G_NO);
8696 --this is to show if a frt rec is max or not
8697 l_ldet_tbl(i).is_max_frt := G_YES;
8698 IF l_bucket_price_rec.modifier_level_code IN
8699 (G_LINE_LEVEL, G_LINE_GROUP)
8700 THEN
8701 l_frt_charge_tbl(N + 1).LEVEL :=
8702 G_LINE_LEVEL;
8703 ELSIF l_bucket_price_rec.modifier_level_code =
8704 G_ORDER_LEVEL
8705 THEN
8706 l_frt_charge_tbl(N + 1).LEVEL :=
8707 G_ORDER_LEVEL;
8708 END IF;
8709 END IF; --last rec of frt_charge_tbl
8710 END IF; --matching charge_type/subtype
8711 END LOOP; --loop thru the frt charge tbl
8712 END IF; --frt charge tbl count
8713
8714 END IF; --created_from_list_line_type is frt charge
8715
8716 END LOOP;
8717 CLOSE l_bucket_price_cur;
8718
8719 --Freight Charge Functionality update status of frt charge adj
8720 IF l_frt_charge_tbl.COUNT > 0
8721 THEN
8722 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
8723 THEN
8724 FOR S IN l_frt_charge_tbl.FIRST..l_frt_charge_tbl.LAST
8725 LOOP
8726 IF l_debug = FND_API.G_TRUE THEN
8727 QP_PREQ_GRP.engine_debug('shu debug, line_index: '-- shu, 2892848
8728 || l_frt_charge_tbl(s).line_index); -- 2892848
8729 QP_PREQ_GRP.engine_debug('shu debug, l_frt_charge_tbl.line_detail_index: '-- shu, 2892848
8730 || l_frt_charge_tbl(s).line_detail_index); -- 2892848
8731 QP_PREQ_GRP.engine_debug('display frt dlts '
8732 ||' list line id '
8733 || l_frt_charge_tbl(s).created_from_list_line_id);
8734 END IF;
8735 END LOOP;
8736 END IF;
8737 FOR N IN l_ldet_tbl.FIRST..l_ldet_tbl.LAST
8738 LOOP
8739 IF l_debug = FND_API.G_TRUE THEN
8740 QP_PREQ_GRP.engine_debug('in frt charge loop (SL, l_ldet_tbl loop) '-- 2892848
8741 || l_ldet_tbl(N).created_from_list_line_id
8742 ||' '|| l_ldet_tbl(N).created_from_list_line_type
8743 ||' sts '|| l_ldet_tbl(N).pricing_status_code
8744 ||' is max frt '|| l_ldet_tbl(N).is_max_frt);
8745 END IF;
8746 IF l_ldet_tbl(N).created_from_list_line_type =
8747 G_FREIGHT_CHARGE
8748 THEN
8749 M := l_frt_charge_tbl.FIRST;
8750 WHILE M IS NOT NULL
8751 LOOP
8752 IF l_ldet_tbl(N).line_detail_index =
8753 l_frt_charge_tbl(M).line_detail_index
8754 AND l_ldet_tbl(N).line_ind = -- 2892848 fix bug
8755 l_frt_charge_tbl(M).line_index -- 2892848 fix bug
8756 THEN
8757 l_ldet_tbl(N).pricing_status_code :=
8758 G_STATUS_NEW;
8759 l_ldet_tbl(N).pricing_status_text :=
8760 'MAX FRT CHARGE';
8761 l_frt_charge_tbl.DELETE(M);
8762 IF l_debug = FND_API.G_TRUE THEN
8763 QP_PREQ_GRP.engine_debug('applied frt charge '
8764 || l_ldet_tbl(N).created_from_list_line_id);
8765 END IF;
8766 END IF;
8767 M := l_frt_charge_tbl.NEXT(M);
8768 END LOOP; --frt_charge_tbl
8769 END IF;
8770 END LOOP;
8771 END IF; --frt_charge_tbl.count
8772
8773 -- begin 2892848 shu test, move outer j loop head to here
8774 j := 0;
8775
8776 j := l_lines_tbl.FIRST;
8777 WHILE j IS NOT NULL LOOP -- end 2892848
8778
8779 IF l_debug = FND_API.G_TRUE THEN
8780 QP_PREQ_GRP.ENGINE_DEBUG('Processed lines:
8781 line index'|| l_lines_tbl(j).line_index
8782 ||' updated adjusted price '
8783 || l_lines_tbl(j).updated_adjusted_unit_price
8784 ||' adjustment count '|| l_ldet_tbl.COUNT);
8785
8786 END IF;
8787 x := l_ldet_tbl.FIRST;
8788 WHILE x IS NOT NULL LOOP
8789 IF l_debug = FND_API.G_TRUE THEN
8790 QP_PREQ_GRP.ENGINE_DEBUG('line_detail_index '
8791 || l_ldet_tbl(x).line_detail_index
8792 ||'up adj price1 '
8793 || l_ldet_tbl(x).created_from_list_line_id
8794 ||' status '
8795 || l_ldet_tbl(x).pricing_status_code
8796 ||' count '|| l_ldet_tbl.COUNT);
8797 END IF;
8798
8799 /*
8800 INDX,QP_PREQ_PUB.calculate_price.upd1,qp_npreq_ldets_tmp_U1,LINE_DETAIL_INDEX,1
8801 */
8802 UPDATE qp_npreq_ldets_tmp SET
8803 adjustment_amount = l_ldet_tbl(x).adjustment_amount,
8804 applied_flag = l_ldet_tbl(x).applied_flag,
8805 line_quantity = l_ldet_tbl(x).priced_quantity,
8806 --included for freight charge functionality
8807 pricing_status_code = l_ldet_tbl(x).pricing_status_code,
8808 pricing_status_text = l_ldet_tbl(x).pricing_status_text
8809 WHERE line_detail_index = l_ldet_tbl(x).line_detail_index;
8810
8811 x := l_ldet_tbl.NEXT(x);
8812 END LOOP;
8813
8814
8815 /*****************************************************************
8816 BACK CALCULATION ROUTINE
8817 ******************************************************************/
8818
8819 IF l_debug = FND_API.G_TRUE THEN
8820 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION ROUTINE ');
8821
8822 END IF;
8823 l_ldet_tbl.DELETE;
8824
8825 --changes for bug 1963391
8826 --if a manual adj is applied and user overrides selling price back to original
8827 --price there is no point to check for back_calculate at the beginning
8828 --as l_amount_changed will be zero whereas at this point
8829 --l_amount_changed will not be zero
8830
8831 IF l_debug = FND_API.G_TRUE THEN
8832 QP_PREQ_GRP.ENGINE_DEBUG('BACK CALCULATION check: upd adj price '
8833 || l_lines_tbl(j).updated_adjusted_unit_price
8834 ||' adj price '|| l_lines_tbl(j).adjusted_unit_price);
8835
8836 END IF;
8837 --fix for rounding issue for bug 2146050
8838 --round the overridden selling price
8839
8840 l_adjusted_unit_price_ur(j) := l_lines_tbl(j).adjusted_unit_price; --[prarasto:Post Round]
8841 l_updated_adj_unit_price_ur(j) := l_lines_tbl(j).updated_adjusted_unit_price; --[prarasto:Post Round]
8842
8843 IF l_lines_tbl(j).rounding_factor IS NOT NULL
8844 AND G_ROUND_INDIVIDUAL_ADJ not in ( G_NO_ROUND, G_POST_ROUND ) --[prarasto:Post Round] added check to
8845 --skip rounding for Post Round option
8846 THEN
8847 --first round the overridden selling price--2146050
8848 l_lines_tbl(j).updated_adjusted_unit_price :=
8849 round(l_lines_tbl(j).updated_adjusted_unit_price,
8850 - 1 * l_lines_tbl(j).rounding_factor);
8851
8852 --also need to round final USP for the line here -2892848_latest
8853 l_lines_tbl(j).adjusted_unit_price :=
8854 round(l_lines_tbl(j).adjusted_unit_price,
8855 - 1 * l_lines_tbl(j).rounding_factor);
8856 END IF;
8857
8858 -- 2892848
8859 IF l_debug = FND_API.G_TRUE THEN
8860 QP_PREQ_GRP.ENGINE_DEBUG('AFTER ROUNDING, adjusted_unit_price:'
8861 || l_lines_tbl(j).adjusted_unit_price
8862 ||' updated_adjusted_unit_price: '|| l_lines_tbl(j).adjusted_unit_price);
8863
8864 END IF;
8865
8866 --this amount changed is also rounded --2146050
8867 l_amount_changed := l_lines_tbl(j).updated_adjusted_unit_price
8868 - l_lines_tbl(j).adjusted_unit_price;
8869
8870 l_back_calc_dtl_index := 0;
8871 l_back_calc_adj_amt := 0;
8872
8873 --Back calculation
8874 IF (l_lines_tbl(j).updated_adjusted_unit_price IS NULL
8875 OR l_amount_changed = 0) --no back cal if no amt change
8876 THEN
8877 IF l_debug = FND_API.G_TRUE THEN
8878 QP_PREQ_GRP.ENGINE_DEBUG('no back calculation');
8879 END IF;
8880 BACK_CALCULATE := FALSE;
8881 ELSE
8882 IF l_debug = FND_API.G_TRUE THEN
8883 QP_PREQ_GRP.ENGINE_DEBUG('back calculation set');
8884 END IF;
8885 BACK_CALCULATE := TRUE;
8886
8887 OPEN l_chk_backcal_adj_exist_cur(l_lines_tbl(j).line_index);
8888 FETCH l_chk_backcal_adj_exist_cur INTO
8889 l_back_calc_dtl_index, l_back_calc_adj_amt;
8890 CLOSE l_chk_backcal_adj_exist_cur;
8891
8892 l_back_calc_dtl_index :=
8893 nvl(l_back_calc_dtl_index, 0);
8894 l_back_calc_adj_amt :=
8895 nvl(l_back_calc_adj_amt, 0);
8896 IF l_debug = FND_API.G_TRUE THEN
8897 QP_PREQ_GRP.engine_debug('back cal dtl '||
8898 l_back_calc_dtl_index ||' adjamt '|| l_back_calc_adj_amt);
8899 END IF;
8900
8901 --changes for bug 2043442
8902 --calculate effective change in amount change which
8903 --includes the manual adjustment that may be applied
8904 --already irrespective of whether applied_flag is Y or N
8905 --This will recalculate adjustment amount rather
8906 --than calculating effective change when SP is overridden
8907 --second time or thereafter
8908 l_amount_changed := l_amount_changed +
8909 l_back_calc_adj_amt;
8910
8911 IF l_debug = FND_API.G_TRUE THEN
8912 QP_PREQ_GRP.engine_debug('back cal dtl '||
8913 ' amt changed '|| l_amount_changed);
8914
8915 END IF;
8916 IF l_amount_changed <= 0 THEN
8917 l_BACK_CALCULATE_START_TYPE := G_DISCOUNT;
8918 ELSIF l_amount_changed > 0 THEN
8919 l_BACK_CALCULATE_START_TYPE := G_SURCHARGE;
8920 END IF;
8921 IF l_debug = FND_API.G_TRUE THEN
8922 QP_PREQ_GRP.ENGINE_DEBUG('back calculation start type'
8923 || l_BACK_CALCULATE_START_TYPE
8924 ||' amount changed '|| l_amount_changed);
8925
8926 END IF;
8927 l_return_status := '';
8928 l_return_status_text := '';
8929
8930 IF l_debug = FND_API.G_TRUE THEN
8931 QP_PREQ_GRP.ENGINE_DEBUG('before back calculation '
8932 || l_lines_tbl(j).line_index
8933 ||' amt changed '|| l_amount_changed);
8934 END IF;
8935 IF l_amount_changed <= 0 THEN
8936 G_BACK_CALCULATION_CODE := 'DIS';
8937 ELSE
8938 G_BACK_CALCULATION_CODE := 'SUR';
8939 END IF; --l_amount_changed_tbl
8940 BACK_CALCULATION(l_lines_tbl(j).line_index
8941 , l_amount_changed
8942 , l_back_calc_ret_rec
8943 , l_return_status
8944 , l_return_status_text);
8945 IF l_debug = FND_API.G_TRUE THEN
8946 QP_PREQ_GRP.ENGINE_DEBUG('after back calculation ');
8947
8948 END IF;
8949
8950 IF l_lines_tbl(j).rounding_factor IS NOT NULL
8951 AND G_ROUND_INDIVIDUAL_ADJ = G_ROUND_ADJ
8952 THEN
8953 --round the adjustment amount --2146050
8954 --it must have been rounded already
8955 l_back_calc_ret_rec.adjustment_amount :=
8956 round(l_back_calc_ret_rec.adjustment_amount,
8957 - 1 * l_back_calc_ret_rec.rounding_factor);
8958 IF l_debug = FND_API.G_TRUE THEN
8959 QP_PREQ_GRP.ENGINE_DEBUG('back calc rounded '
8960 || l_back_calc_ret_rec.adjustment_amount
8961 ||' roundingfac '
8962 || l_back_calc_ret_rec.rounding_factor);
8963 END IF;
8964 END IF;
8965
8966 END IF;
8967 --end changes for bug 1963391
8968
8969
8970
8971 IF BACK_CALCULATE
8972 THEN
8973 IF l_debug = FND_API.G_TRUE THEN
8974 QP_PREQ_GRP.ENGINE_DEBUG('Back calculate');
8975 END IF;
8976 IF l_back_calc_ret_rec.calculation_code
8977 = G_BACK_CALCULATE
8978 THEN
8979
8980 IF l_debug = FND_API.G_TRUE THEN
8981 QP_PREQ_GRP.ENGINE_DEBUG('Back Calculate: '
8982 ||'before update ldets: line_detail_index '
8983 || l_back_calc_ret_rec.line_detail_index
8984 ||' list line id '
8985 || l_back_calc_ret_rec.list_line_id
8986 ||' adjustment amount '
8987 || l_back_calc_ret_rec.adjustment_amount
8988 ||' operand '|| l_back_calc_ret_rec.operand_value
8989 ||' calculation_code '
8990 || l_back_calc_ret_rec.calculation_code);
8991
8992 QP_PREQ_GRP.engine_debug('chk back cal dtl '||
8993 l_back_calc_dtl_index);
8994
8995 END IF;
8996 IF l_back_calc_dtl_index <> 0
8997 AND l_back_calc_dtl_index <>
8998 l_back_calc_ret_rec.line_detail_index
8999 THEN
9000 --delete the existing back calculated adj
9001 UPDATE qp_npreq_ldets_tmp
9002 SET applied_flag = G_NO,
9003 calculation_code = NULL,
9004 pricing_status_code = G_STATUS_DELETED,
9005 pricing_status_text =
9006 'DELETED IN BACK CALC DUE TO CHANGE IN ADJ AMT'
9007 WHERE line_detail_index = l_back_calc_dtl_index;
9008
9009 END IF;
9010
9011 /*
9012 INDX,QP_PREQ_PUB.calculate_price.upd2,qp_npreq_ldets_tmp_U1,LINE_DETAIL_INDEX,1
9013 */
9014 UPDATE qp_npreq_ldets_tmp ldet
9015 SET ldet.operand_value =
9016 l_back_calc_ret_rec.operand_value
9017 , ldet.adjustment_amount =
9018 l_back_calc_ret_rec.adjustment_amount
9019 , ldet.applied_flag =
9020 l_back_calc_ret_rec.applied_flag
9021 , ldet.updated_flag =
9022 l_back_calc_ret_rec.updated_flag
9023 , ldet.process_code =
9024 l_back_calc_ret_rec.process_code
9025 , ldet.pricing_status_text =
9026 l_back_calc_ret_rec.pricing_status_text
9027 , ldet.calculation_code =
9028 l_back_calc_ret_rec.calculation_code
9029 WHERE ldet.line_detail_index =
9030 l_back_calc_ret_rec.line_detail_index
9031 AND ldet.line_index =
9032 l_back_calc_ret_rec.line_index
9033 AND ldet.created_from_list_line_id =
9034 l_back_calc_ret_rec.list_line_id;
9035 END IF;
9036 END IF; --back_calculate
9037
9038 IF l_debug = FND_API.G_TRUE THEN
9039 QP_PREQ_GRP.engine_debug('return sts '|| l_return_status);
9040 QP_PREQ_GRP.engine_debug('return txt '|| l_return_status_text);
9041 END IF;
9042 IF BACK_CALCULATE
9043 THEN
9044 IF l_debug = FND_API.G_TRUE THEN
9045 QP_PREQ_GRP.ENGINE_DEBUG('Back calculate');
9046
9047 END IF;
9048 IF l_return_status = FND_API.G_RET_STS_SUCCESS
9049 THEN
9050 IF l_debug = FND_API.G_TRUE THEN
9051 QP_PREQ_GRP.ENGINE_DEBUG('Back calculate Success');
9052 END IF;
9053 l_lines_tbl(j).processed_flag := G_PROCESSED;
9054 --change for bug 2146050
9055 --recalculate the selling price again after back calc
9056 l_lines_tbl(j).adjusted_unit_price :=
9057 l_lines_tbl(j).adjusted_unit_price +
9058 nvl(l_back_calc_ret_rec.adjustment_amount, 0);
9059
9060 --[prarasto:Post Round] added to calculate unrounded adjusted unit price after calculating adjustment amount
9061 l_adjusted_unit_price_ur(j) := l_adjusted_unit_price_ur(j) +
9062 nvl(l_back_calc_ret_rec.adjustment_amount, 0);
9063
9064 --round the SP if G_ROUND_INDIVIDUAL_ADJ=G_NO_ROUND_ADJ
9065 --IF G_ROUND_INDIVIDUAL_ADJ = G_NO_ROUND_ADJ
9066
9067 -- IF G_ROUND_INDIVIDUAL_ADJ <> G_NO_ROUND -- shu fix 2239061,
9068 IF G_ROUND_INDIVIDUAL_ADJ not in ( G_NO_ROUND, G_POST_ROUND ) --[prarasto:Post Round] added check to
9069 --skip rounding for Post Round option
9070 AND l_lines_tbl(j).rounding_factor IS NOT NULL
9071 THEN
9072 IF l_debug = FND_API.G_TRUE THEN
9073 QP_PREQ_GRP.engine_debug('need to round selling price, rounding_factor: '
9074 || l_lines_tbl(j).rounding_factor);
9075 END IF;
9076 l_lines_tbl(j).adjusted_unit_price :=
9077 round(l_lines_tbl(j).adjusted_unit_price,
9078 - 1 * l_lines_tbl(j).rounding_factor);
9079 END IF;
9080 ELSE
9081 IF l_debug = FND_API.G_TRUE THEN
9082 QP_PREQ_GRP.ENGINE_DEBUG('Back calculate Failure');
9083 END IF;
9084 l_lines_tbl(j).processed_flag := G_NOT_PROCESSED;
9085 l_lines_tbl(j).processed_code :=
9086 QP_PREQ_PUB.G_BACK_CALCULATION_STS;
9087 l_lines_tbl(j).pricing_status_code :=
9088 QP_PREQ_PUB.G_BACK_CALCULATION_STS;
9089 l_lines_tbl(j).pricing_status_text := l_return_status_text;
9090 END IF; --l_return_status
9091 ELSE
9092 IF l_debug = FND_API.G_TRUE THEN
9093 QP_PREQ_GRP.ENGINE_DEBUG('NO Back calculate');
9094 END IF;
9095 l_lines_tbl(j).processed_flag := G_PROCESSED;
9096 END IF; --back_calculate
9097
9098
9099 IF l_lines_tbl(j).processed_flag = G_PROCESSED THEN
9100 /*
9101 INDX,QP_PREQ_PUB.calculate_price.upd3,qp_npreq_lines_tmp_N1,LINE_INDEX,1
9102 */
9103 UPDATE qp_npreq_lines_tmp SET adjusted_unit_price
9104 = nvl(l_lines_tbl(j).updated_adjusted_unit_price,
9105 l_lines_tbl(j).adjusted_unit_price)
9106 --, adjusted_unit_price_ur = nvl(l_updated_adj_unit_price_ur(j), --[prarasto:Post Round] added unrounded adjusted unit price, [julin/postround] redesign
9107 -- l_adjusted_unit_price_ur(j))
9108 , processed_flag = l_lines_tbl(j).processed_flag
9109 , processed_code = l_lines_tbl(j).processed_code
9110 , pricing_status_code =
9111 l_lines_tbl(j).pricing_status_code
9112 , pricing_status_text =
9113 l_lines_tbl(j).pricing_status_text
9114 , QUALIFIERS_EXIST_FLAG = G_CALCULATE_ONLY
9115 WHERE line_index = l_lines_tbl(j).line_index;
9116
9117
9118 IF l_debug = FND_API.G_TRUE THEN
9119 QP_PREQ_GRP.ENGINE_DEBUG('Processed Price:
9120 line index'|| l_lines_tbl(j).line_index ||
9121 ' adjusted price '|| l_lines_tbl(j).adjusted_unit_price ||
9122 'processed_code' || l_lines_tbl(j).processed_code);
9123 END IF;
9124 ELSE
9125 /*
9126 INDX,QP_PREQ_PUB.calculate_price.upd4,qp_npreq_lines_tmp_N1,LINE_INDEX,1
9127 */
9128 UPDATE qp_npreq_lines_tmp SET adjusted_unit_price
9129 = l_lines_tbl(j).adjusted_unit_price
9130 --, adjusted_unit_price_ur = l_adjusted_unit_price_ur(j) --[prarasto:Post Round] added unrounded adjusted unit price, [julin/postround] redesign
9131 , processed_flag = l_lines_tbl(j).processed_flag
9132 , processed_code = l_lines_tbl(j).processed_code
9133 , pricing_status_code =
9134 l_lines_tbl(j).pricing_status_code
9135 , pricing_status_text =
9136 l_lines_tbl(j).pricing_status_text
9137 , QUALIFIERS_EXIST_FLAG = G_CALCULATE_ONLY
9138 WHERE line_index = l_lines_tbl(j).line_index;
9139
9140
9141 IF l_debug = FND_API.G_TRUE THEN
9142 QP_PREQ_GRP.ENGINE_DEBUG('Failed Process price:
9143 line index '|| l_lines_tbl(j).line_index ||
9144 ' adjusted price '|| l_lines_tbl(j).adjusted_unit_price ||
9145 'processed_code' || l_lines_tbl(j).processed_code);
9146 END IF;
9147 END IF;
9148
9149
9150
9151
9152
9153
9154
9155 j := l_lines_tbl.NEXT(j);
9156 IF l_debug = FND_API.G_TRUE THEN
9157 QP_PREQ_GRP.ENGINE_DEBUG('-----------------------------------');
9158 END IF;
9159 END LOOP;
9160
9161 --to update adj amt on order level adjustments
9162 IF l_ord_dtl_index_tbl.COUNT > 0
9163 THEN
9164 IF l_debug = FND_API.G_TRUE THEN
9165 QP_PREQ_GRP.engine_debug('updating order lvl adj amt: '||
9166 l_ord_dtl_index_tbl.COUNT);
9167 END IF;
9168 FORALL i IN l_ord_dtl_index_tbl.FIRST..l_ord_dtl_index_tbl.LAST
9169 UPDATE qp_npreq_ldets_tmp
9170 SET adjustment_amount = l_ord_adj_amt_tbl(i)
9171 WHERE line_detail_index = l_ord_dtl_index_tbl(i);
9172 END IF;
9173
9174
9175
9176 --GSA VIOLATION CHECK
9177
9178 -- Call GSA Check only for non-gsa customers(GSA_QUALIFIER_FLAG IS NULL)
9179 IF G_GSA_CHECK_FLAG = G_YES
9180 AND G_GSA_ENABLED_FLAG = G_YES
9181 THEN
9182 IF l_debug = FND_API.G_TRUE THEN
9183 QP_PREQ_GRP.engine_debug('Begin Pub GSA check');
9184
9185 END IF;
9186 /*
9187 INDX,QP_PREQ_PUB.calculate_price.upd5,qp_npreq_lines_tmp_N2,LINE_TYPE_CODE,1
9188 INDX,QP_PREQ_PUB.calculate_price.upd5,qp_npreq_line_attrs_tmp_N2,LINE_TYPE_CODE,1
9189 INDX,QP_PREQ_PUB.calculate_price.upd5,qp_npreq_line_attrs_tmp_N1,LINE_INDEX,1
9190 INDX,QP_PREQ_PUB.calculate_price.upd5,qp_npreq_line_attrs_tmp_N1,ATTRIBUTE_TYPE,2
9191 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_PRICING_ATTRIBUTES_N5,PRICING_PHASE_ID,1
9192 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_PRICING_ATTRIBUTES_N5,QUALIFICATION_IND,2
9193 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_PRICING_ATTRIBUTES_N5,PRODUCT_ATTRIBUTE_CONTEXT,3
9194 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_PRICING_ATTRIBUTES_N5,PRODUCT_ATTRIBUTE,4
9195 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_PRICING_ATTRIBUTES_N5,PRODUCT_ATTRIBUTE_VALUE,5
9196 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_PRICING_ATTRIBUTES_N5,EXCLUDER_FLAG,6
9197 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_PRICING_ATTRIBUTES_N5,LIST_HEADER_ID,7
9198 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_PRICING_ATTRIBUTES_N5,LIST_LINE_ID,8
9199 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_PRICE_REQ_SOURCES_PK,REQUEST_TYPE_CODE,1
9200 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_LIST_HEADERS_B_N1,ACTIVE_FLAG,1
9201 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_LIST_HEADERS_B_N1,CURRENCY_CODE,2
9202 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_LIST_HEADERS_B_N1,LIST_TYPE_CODE,3
9203 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_LIST_HEADERS_B_N1,SOURCE_SYSTEM_CODE,4
9204 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_LIST_HEADERS_B_N1,LIST_HEADER_ID,5
9205 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_LIST_HEADERS_B_N1,GSA_INDICATOR,6
9206 INDX,QP_PREQ_PUB.calculate_price.upd5,QP_LIST_LINES_PK,LIST_LINE_ID,1
9207 */
9208 IF l_debug = FND_API.G_TRUE THEN
9209 QP_PREQ_GRP.engine_debug('Pub GSA attr_mgr_installed '
9210 || G_ATTR_MGR_INSTALLED);
9211 END IF;
9212 IF G_ATTR_MGR_INSTALLED = G_NO
9213 THEN
9214 UPDATE qp_npreq_lines_tmp line
9215 SET line.pricing_status_code = G_STATUS_GSA_VIOLATION
9216 , line.pricing_status_text = 'QP_PREQ_PUB: GSA VIOLATION'
9217 WHERE line.line_type_code = G_LINE_LEVEL
9218 --made this change look at only successful lines
9219 AND line.pricing_status_code IN
9220 (G_STATUS_UPDATED, G_STATUS_UNCHANGED)
9221 AND NOT EXISTS (SELECT 'X'
9222 FROM qp_npreq_line_attrs_tmp gsa_attr
9223 WHERE gsa_attr.line_index = line.line_index
9224 --fix for bug 2080187
9225 AND gsa_attr.pricing_status_code = G_STATUS_UNCHANGED
9226 AND gsa_attr.attribute_type = G_QUALIFIER_TYPE
9227 AND gsa_attr.context = G_CUSTOMER_CONTEXT
9228 AND gsa_attr.attribute = G_GSA_ATTRIBUTE
9229 AND gsa_attr.value_from = G_YES)
9230 AND line.adjusted_unit_price <=
9231 --(SELECT /*+ ORDERED USE_NL(qpa ql req lhdr) */ MIN(ql.operand) -- 7323912
9232 (SELECT /*+ ORDERED USE_NL(qpa ql req lhdr) INDEX(LHDR QP_LIST_HEADERS_B_N9) */ MIN(ql.operand) -- 7323912
9233 FROM qp_npreq_line_attrs_tmp lattr,
9234 qp_pricing_attributes qpa,
9235 qp_list_headers_b lhdr, --7323912
9236 qp_price_req_sources req, --7323912
9237 qp_list_lines ql
9238 WHERE lattr.line_index = line.line_index
9239 AND lattr.attribute_type = G_PRODUCT_TYPE
9240 AND lattr.context = qpa.product_attribute_context
9241 AND lattr.attribute = qpa.product_attribute
9242 AND lattr.value_from = qpa.product_attr_value
9243 AND qpa.excluder_flag = G_NO
9244 AND qpa.pricing_phase_id = 2
9245 AND qpa.qualification_ind = 6
9246 AND lattr.line_index = line.line_index
9247 AND req.request_type_code = line.request_type_code
9248 AND lhdr.list_header_id = qpa.list_header_id
9249 AND lhdr.active_flag = G_YES
9250 AND ((lhdr.currency_code IS NOT NULL AND lhdr.currency_code = line.currency_code)
9251 OR
9252 lhdr.currency_code IS NULL) -- optional currency
9253 AND lhdr.list_type_code = G_DISCOUNT_LIST_HEADER
9254 AND lhdr.source_system_code = req.source_system_code
9255 AND lhdr.gsa_indicator = G_YES
9256 AND trunc(line.pricing_effective_date) BETWEEN
9257 trunc(nvl(lhdr.start_date_active
9258 , line.pricing_effective_date))
9259 AND trunc(nvl(lhdr.End_date_active
9260 , line.pricing_effective_date))
9261 AND qpa.list_line_id = ql.list_line_id
9262 AND trunc(line.pricing_effective_date) BETWEEN
9263 trunc(nvl(ql.start_date_active
9264 , line.pricing_effective_date))
9265 AND trunc(nvl(ql.End_date_active
9266 , line.pricing_effective_date)));
9267 ELSE --G_ATTR_MGR_INSTALLED
9268 UPDATE qp_npreq_lines_tmp line
9269 SET line.pricing_status_code = G_STATUS_GSA_VIOLATION
9270 , line.pricing_status_text = 'QP_PREQ_PUB: GSA VIOLATION'
9271 WHERE line.line_type_code = G_LINE_LEVEL
9272 --made this change look at only successful lines
9273 AND line.pricing_status_code IN
9274 (G_STATUS_UPDATED, G_STATUS_UNCHANGED)
9275 AND NOT EXISTS (SELECT 'X'
9276 FROM qp_npreq_line_attrs_tmp gsa_attr
9277 WHERE gsa_attr.line_index = line.line_index
9278 --fix for bug 2080187
9279 AND gsa_attr.pricing_status_code = G_STATUS_UNCHANGED
9280 AND gsa_attr.attribute_type = G_QUALIFIER_TYPE
9281 AND gsa_attr.context = G_CUSTOMER_CONTEXT
9282 AND gsa_attr.attribute = G_GSA_ATTRIBUTE
9283 AND gsa_attr.value_from = G_YES)
9284 AND line.adjusted_unit_price <=
9285 --(SELECT /*+ ORDERED USE_NL(qpa ql req lhdr) */ MIN(ql.operand) --7323912
9286 (SELECT /*+ ORDERED USE_NL(qpa ql req lhdr) INDEX(LHDR QP_LIST_HEADERS_B_N9) */ MIN(ql.operand) --7323912
9287 FROM qp_npreq_line_attrs_tmp lattr,
9288 qp_pricing_attributes qpa,
9289 qp_list_headers_b lhdr, --7323912
9290 qp_price_req_sources_v req, --7323912
9291 qp_list_lines ql
9292 WHERE lattr.line_index = line.line_index
9293 AND lattr.attribute_type = G_PRODUCT_TYPE
9294 AND lattr.context = qpa.product_attribute_context
9295 AND lattr.attribute = qpa.product_attribute
9296 AND lattr.value_from = qpa.product_attr_value
9297 AND qpa.excluder_flag = G_NO
9298 AND qpa.pricing_phase_id = 2
9299 AND qpa.qualification_ind = 6
9300 AND lattr.line_index = line.line_index
9301 AND req.request_type_code = line.request_type_code
9302 AND lhdr.list_header_id = qpa.list_header_id
9303 AND lhdr.active_flag = G_YES
9304 AND ((lhdr.currency_code IS NOT NULL AND lhdr.currency_code = line.currency_code)
9305 OR
9306 lhdr.currency_code IS NULL) -- optional currency
9307 AND lhdr.list_type_code = G_DISCOUNT_LIST_HEADER
9308 AND lhdr.source_system_code = req.source_system_code
9309 AND lhdr.gsa_indicator = G_YES
9310 AND trunc(line.pricing_effective_date) BETWEEN
9311 trunc(nvl(lhdr.start_date_active
9312 , line.pricing_effective_date))
9313 AND trunc(nvl(lhdr.End_date_active
9314 , line.pricing_effective_date))
9315 AND qpa.list_line_id = ql.list_line_id
9316 AND trunc(line.pricing_effective_date) BETWEEN
9317 trunc(nvl(ql.start_date_active
9318 , line.pricing_effective_date))
9319 AND trunc(nvl(ql.End_date_active
9320 , line.pricing_effective_date)));
9321 END IF;
9322 IF l_debug = FND_API.G_TRUE THEN
9323 QP_PREQ_GRP.engine_debug('End Pub GSA check');
9324 END IF;
9325 END IF;
9326
9327
9328
9329 --GSA VIOLATION CHECK
9330
9331
9332 X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;
9333 X_RETURN_STATUS_TEXT := l_routine ||' SUCCESS ';
9334
9335 IF l_debug = FND_API.G_TRUE THEN
9336 QP_PREQ_GRP.ENGINE_DEBUG('end calculate price');
9337 END IF;
9338 EXCEPTION
9339 WHEN Calculate_Exc THEN
9340 IF l_debug = FND_API.G_TRUE THEN
9341 QP_PREQ_GRP.ENGINE_DEBUG('Error in calculate_price'|| x_return_status_text);
9342 END IF;
9343 X_RETURN_STATUS := FND_API.G_RET_STS_ERROR;
9344 WHEN OTHERS THEN
9345 IF l_debug = FND_API.G_TRUE THEN
9346 QP_PREQ_GRP.ENGINE_DEBUG('Error in calculate_price'|| SQLERRM);
9347 END IF;
9348 X_RETURN_STATUS := FND_API.G_RET_STS_ERROR;
9349 X_RETURN_STATUS_TEXT := l_routine || SQLERRM;
9350 END CALCULATE_PRICE;
9351
9352
9353 --coded for bug 2264566
9354 --This is to delete/cleanup the related lines inserted by GRP
9355 --for manual PBH adjustment
9356 --when the calling application is passing the manual PBH to be applied
9357 PROCEDURE Cleanup_rltd_lines(x_return_status OUT NOCOPY VARCHAR2,
9358 x_return_status_text OUT NOCOPY VARCHAR2) IS
9359 CURSOR l_dbg_cleanup_cur IS
9360 SELECT rltd.line_detail_index,
9361 rltd.related_line_detail_index,
9362 rltd.list_line_id,
9363 rltd.related_list_line_id,
9364 rltd.pricing_status_code
9365 FROM qp_npreq_rltd_lines_tmp rltd
9366 WHERE rltd.relationship_type_code = G_PBH_LINE;
9367 BEGIN
9368 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
9369 IF l_debug = FND_API.G_TRUE
9370 THEN
9371 QP_PREQ_GRP.engine_debug('------------------------------');
9372 FOR cl IN l_dbg_cleanup_cur
9373 LOOP
9374 QP_PREQ_GRP.engine_debug('Rltd lines: line_dtl_index '
9375 || cl.line_detail_index ||' rltd_line_dtl_index '
9376 || cl.related_line_detail_index ||' list_line_id '
9377 || cl.list_line_id ||' rltd_list_line_id '|| cl.related_list_line_id
9378 ||' pricing_status_code '|| cl.pricing_status_code);
9379 END LOOP;
9380 END IF;
9381
9382 --mark the engine passed relationships of manual PBH as deleted
9383 --if the parent PBH line is deleted
9384 UPDATE qp_npreq_rltd_lines_tmp SET pricing_status_code = G_STATUS_DELETED
9385 WHERE line_detail_index IN (SELECT line_detail_index
9386 FROM qp_npreq_ldets_tmp ldet
9387 WHERE (ldet.process_code = G_STATUS_DELETED
9388 OR ldet.pricing_status_code = G_STATUS_DELETED))
9389 --fix for bug 2515762 automatic overrideable break
9390 -- and ldet.automatic_flag = G_NO)
9391 AND pricing_status_code = G_STATUS_NEW
9392 AND relationship_type_code = G_PBH_LINE;
9393
9394 --mark the engine returned manual child PBH lines as deleted
9395 UPDATE qp_npreq_ldets_tmp ldet SET pricing_status_code = G_STATUS_DELETED
9396 WHERE ldet.line_detail_index IN
9397 (SELECT rltd.related_line_detail_index
9398 FROM qp_npreq_rltd_lines_tmp rltd
9399 WHERE rltd.relationship_type_code = G_PBH_LINE
9400 AND rltd.pricing_status_code = G_STATUS_DELETED);
9401
9402 IF l_debug = FND_API.G_TRUE THEN
9403 QP_PREQ_GRP.engine_debug('------------------------------');
9404 FOR cl IN l_dbg_cleanup_cur
9405 LOOP
9406 QP_PREQ_GRP.engine_debug('Rltd lines: line_dtl_index '
9407 || cl.line_detail_index ||' rltd_line_dtl_index '
9408 || cl.related_line_detail_index ||' list_line_id '
9409 || cl.list_line_id ||' rltd_list_line_id '|| cl.related_list_line_id
9410 ||' pricing_status_code '|| cl.pricing_status_code);
9411 END LOOP;
9412 END IF;
9413 EXCEPTION
9414 WHEN OTHERS THEN
9415 x_return_status := FND_API.G_RET_STS_ERROR;
9416 x_return_status_text := 'Exception in QP_PREQ_PUB.Cleanup_rltd_lines '|| SQLERRM;
9417 END Cleanup_rltd_lines;
9418
9419
9420 --coded for bug 2264566
9421 --This is to update the related lines passed by calling application
9422 --along with a manual/auto-overridden PBH adjustments with the relevant
9423 --information needed to calculate adjustment amount for PBH from the setup
9424 PROCEDURE Update_Related_Line_Info(x_return_status OUT NOCOPY VARCHAR2,
9425 x_return_status_text OUT NOCOPY VARCHAR2) IS
9426
9427 CURSOR l_dbg_rltd_cur IS
9428 SELECT
9429 qpa.pricing_attr_value_from,
9430 qpa.pricing_attr_value_to,
9431 ldet_pbh.price_break_type_code,
9432 ldet_pbh.created_from_list_line_id list_line_id,
9433 ldet.created_from_list_line_id related_list_line_id,
9434 ldet.created_from_list_line_type related_list_line_type,
9435 ldet.operand_calculation_code operand_calculation_code,
9436 ldet.operand_value operand,
9437 ldet.pricing_group_sequence pricing_group_sequence,
9438 nvl(ldet.line_quantity,
9439 nvl(line.priced_quantity, line.line_quantity))
9440 qualifier_value
9441 FROM
9442 qp_npreq_rltd_lines_tmp rltd,
9443 qp_npreq_lines_tmp line,
9444 qp_npreq_ldets_tmp ldet,
9445 qp_npreq_ldets_tmp ldet_pbh,
9446 qp_pricing_attributes qpa
9447 WHERE
9448 rltd.pricing_status_code = G_STATUS_NEW
9449 AND ldet.line_detail_index =
9450 rltd.related_line_detail_index
9451 AND ldet_pbh.line_detail_index = rltd.line_detail_index
9452 AND line.line_index = ldet.line_index
9453 AND qpa.list_line_id = ldet.created_from_list_line_id
9454 AND qpa.pricing_attribute_context = G_PRIC_VOLUME_CONTEXT
9455 AND ldet.process_code = G_STATUS_NEW
9456 AND ldet.pricing_status_code = G_STATUS_UNCHANGED
9457 AND rltd.relationship_type_code = G_PBH_LINE;
9458
9459 CURSOR l_dbg_rltd_upd_cur IS
9460 SELECT setup_value_from,
9461 setup_value_to,
9462 relationship_type_detail,
9463 list_line_id,
9464 related_list_line_id,
9465 related_list_line_type,
9466 operand_calculation_code,
9467 operand,
9468 pricing_group_sequence,
9469 qualifier_value
9470 FROM qp_npreq_rltd_lines_tmp rltd
9471 WHERE rltd.pricing_status_code = G_STATUS_NEW
9472 AND rltd.relationship_type_code = G_PBH_LINE;
9473
9474 BEGIN
9475
9476 IF l_debug = FND_API.G_TRUE THEN
9477 QP_PREQ_GRP.engine_debug('-------------------------------------');
9478 FOR cl IN l_dbg_rltd_cur
9479 LOOP
9480 QP_PREQ_GRP.engine_debug('rltd info: value_from '
9481 || cl.pricing_attr_value_from
9482 ||' value to '|| cl.pricing_attr_value_to
9483 ||' price brktype '|| cl.price_break_type_code
9484 ||' list_line_id '|| cl.list_line_id
9485 ||' rltd_list_line_id '|| cl.related_list_line_id
9486 ||' rltd_list_line_type '|| cl.related_list_line_type
9487 ||' operand_calculation_code '|| cl.operand_calculation_code
9488 ||' operand '|| cl.operand
9489 ||' bucket '|| cl.pricing_group_sequence
9490 ||' qualifier_value '|| cl.qualifier_value);
9491 END LOOP;
9492 END IF;
9493
9494 --when any changes are made to this, the similar updated stmt
9495 --in update_passed_in_pbh procedure in this file also needs to be changed
9496 UPDATE qp_npreq_rltd_lines_tmp rltd
9497 SET (setup_value_from,
9498 setup_value_to,
9499 relationship_type_detail,
9500 list_line_id,
9501 related_list_line_id,
9502 related_list_line_type,
9503 operand_calculation_code,
9504 operand,
9505 pricing_group_sequence,
9506 qualifier_value)
9507 =
9508 (SELECT
9509 qpa.pricing_attr_value_from,
9510 qpa.pricing_attr_value_to,
9511 ldet_pbh.price_break_type_code,
9512 ldet_pbh.created_from_list_line_id,
9513 ldet.created_from_list_line_id,
9514 ldet.created_from_list_line_type,
9515 ldet.operand_calculation_code,
9516 ldet.operand_value,
9517 ldet.pricing_group_sequence,
9518 nvl(ldet.line_quantity,
9519 nvl(line.priced_quantity, line.line_quantity))
9520 FROM
9521 qp_npreq_lines_tmp line,
9522 qp_npreq_ldets_tmp ldet,
9523 qp_npreq_ldets_tmp ldet_pbh,
9524 qp_pricing_attributes qpa
9525 WHERE
9526 ldet.line_detail_index = rltd.related_line_detail_index
9527 AND ldet_pbh.line_detail_index = rltd.line_detail_index
9528 AND line.line_index = ldet.line_index
9529 AND qpa.list_line_id = ldet.created_from_list_line_id
9530 AND ldet.process_code = G_STATUS_NEW
9531 AND ldet.pricing_status_code = G_STATUS_UNCHANGED
9532 AND rltd.relationship_type_code = G_PBH_LINE
9533 AND rltd.pricing_status_code = G_STATUS_NEW)
9534 WHERE rltd.line_detail_index IN (SELECT ldet.line_detail_index
9535 FROM qp_npreq_ldets_tmp ldet
9536 WHERE ldet.process_code = G_STATUS_NEW
9537 AND ldet.pricing_status_code = G_STATUS_UNCHANGED
9538 AND ldet.created_from_list_line_type = G_PRICE_BREAK_TYPE)
9539 AND rltd.relationship_type_code = G_PBH_LINE
9540 AND rltd.pricing_status_code = G_STATUS_NEW;
9541
9542 IF l_debug = FND_API.G_TRUE
9543 THEN
9544 QP_PREQ_GRP.engine_debug('-------------------------------------');
9545 FOR cl IN l_dbg_rltd_upd_cur
9546 LOOP
9547 QP_PREQ_GRP.engine_debug('rltd info: value_from '
9548 || cl.setup_value_from
9549 ||' value to '|| cl.setup_value_to
9550 ||' price brktype '|| cl.relationship_type_detail
9551 ||' list_line_id '|| cl.list_line_id
9552 ||' rltd_list_line_id '|| cl.related_list_line_id
9553 ||' rltd_list_line_type '|| cl.related_list_line_type
9554 ||' operand_calculation_code '|| cl.operand_calculation_code
9555 ||' operand '|| cl.operand
9556 ||' bucket '|| cl.pricing_group_sequence
9557 ||' qualifier_value '|| cl.qualifier_value);
9558 END LOOP;
9559 END IF;
9560 EXCEPTION
9561 WHEN OTHERS THEN
9562 x_return_status := FND_API.G_RET_STS_ERROR;
9563 x_return_status_text := 'Exception in QP_PREQ_PUB.Update_Related_Line_Info '|| SQLERRM;
9564 END Update_Related_Line_Info;
9565
9566
9567 --This is to cleanup duplicate adjustments between user passed
9568 --and engine returned adjustments and to consider out of phase adj
9569 PROCEDURE PROCESS_ADJUSTMENTS(P_PRICING_EVENT VARCHAR2
9570 , X_RETURN_STATUS OUT NOCOPY VARCHAR2
9571 , X_RETURN_STATUS_TEXT OUT NOCOPY VARCHAR2) IS
9572
9573 /*
9574 INDX,QP_PREQ_PUB.process_adjustments.l_duplicate_cur,qp_npreq_ldets_tmp_N1,LINE_INDEX,1
9575 INDX,QP_PREQ_PUB.process_adjustments.l_duplicate_cur,qp_npreq_ldets_tmp_N1,CREATED_FROM_LIST_LINE_ID,5
9576 */
9577 CURSOR l_duplicate_cur IS
9578 SELECT /*+ index (ldeta qp_preq_ldets_tmp_n5) */ -- 9362867
9579 ldeta.line_detail_index
9580 , ldeta.line_index
9581 , ldeta.created_from_list_line_id
9582 , ldeta.pricing_status_code
9583 , ldeta.process_code
9584 , ldeta.pricing_status_text
9585 , ldeta.applied_flag
9586 , ldeta.updated_flag
9587 FROM qp_npreq_ldets_tmp ldeta
9588 WHERE --ldeta.pricing_status_code = 'X'
9589 ldeta.process_code = G_STATUS_NEW
9590 AND ldeta.created_from_list_line_id IN
9591 (SELECT /*+ index (ldetb qp_preq_ldets_tmp_n5) */ -- 9362867
9592 ldetb.created_from_list_line_id
9593 FROM qp_npreq_ldets_tmp ldetb
9594 WHERE ldetb.created_from_list_line_id =
9595 ldeta.created_from_list_line_id
9596 AND ldetb.line_index = ldeta.line_index
9597 AND ldetb.process_code = G_STATUS_NEW
9598 GROUP BY ldetb.created_from_list_line_id
9599 HAVING COUNT( * ) > 1)
9600 ORDER BY ldeta.line_index
9601 , ldeta.created_from_list_line_id
9602 , ldeta.pricing_status_code DESC;
9603 -- and ldetb.pricing_status_code = 'N'desc);
9604
9605 l_duplicate_rec l_duplicate_cur%ROWTYPE;
9606 l_duplicate_rec1 l_duplicate_cur%ROWTYPE;
9607
9608 TYPE DUP_ADJ_TBL_TYPE IS TABLE OF l_duplicate_rec%TYPE INDEX BY BINARY_INTEGER;
9609
9610 l_dup_adj_tbl DUP_ADJ_TBL_TYPE;
9611 l_routine VARCHAR2(100) := 'Routine:QP_PREQ_PUB.PROCESS_ADJUSTMENTS';
9612
9613 /*
9614 indxno index used
9615 */
9616 CURSOR lcur IS
9617 SELECT line_index
9618 , created_from_list_line_id
9619 , pricing_status_code, applied_flag
9620 , updated_flag, operand_value
9621 FROM qp_npreq_ldets_tmp
9622 WHERE PRICING_STATUS_CODE = G_STATUS_UNCHANGED;
9623
9624 lrec lcur%ROWTYPE;
9625
9626 /*
9627 INDX,QP_PREQ_PUB.process_adjustments.lcur1,qp_npreq_ldets_tmp_N3,LINE_INDEX,1
9628 INDX,QP_PREQ_PUB.process_adjustments.lcur1,qp_npreq_ldets_tmp_N3,PRICING_STATUS_CODE,4
9629 */
9630 CURSOR lcur1 IS
9631 SELECT created_from_list_line_id
9632 , line_detail_index
9633 , line_quantity
9634 , line_index
9635 , applied_flag
9636 , updated_flag
9637 , pricing_status_code
9638 , process_code
9639 FROM qp_npreq_ldets_tmp
9640 ORDER BY line_index;
9641
9642 lrec1 lcur1%ROWTYPE;
9643
9644 i PLS_INTEGER;
9645
9646 Process_Exc EXCEPTION;
9647
9648 BEGIN
9649
9650
9651
9652 /*
9653 open lcur;LOOP
9654 fetch lcur into lrec;
9655 EXIT when lcur%NOTFOUND;
9656 IF l_debug = FND_API.G_TRUE THEN
9657 QP_PREQ_GRP.ENGINE_DEBUG(lrec.line_index||
9658 ' user passed list_line_id '||lrec.created_from_list_line_id||
9659 ' pricing_status_code '||lrec.pricing_status_code||
9660 ' applied_flag '||lrec.applied_flag||
9661 ' updated_flag '||lrec.updated_flag||
9662 ' operand '||lrec.operand_value);
9663 END IF;
9664 END LOOP;
9665 IF l_debug = FND_API.G_TRUE THEN
9666 QP_PREQ_GRP.ENGINE_DEBUG('--------------------------------------------------');
9667 END IF;
9668 CLOSE lcur;
9669 */
9670
9671 ----------------------------------------------------------------------------
9672 --The following code will process the information returned by the
9673 --pricing engine in the temporary tables, compare the adjustments passes
9674 --by the calling application and mark the temporary table qp_npreq_ldets_tmp
9675 --field process_code with a value G_STATUS_NEW
9676 ----------------------------------------------------------------------------
9677 IF l_debug = FND_API.G_TRUE THEN
9678 QP_PREQ_GRP.ENGINE_DEBUG('START PROCESS ADJUSTMENTS '|| p_pricing_event);
9679
9680 END IF;
9681 --Step 0: Update all user passed adjustments to process_code 'DELETED'
9682 --to start with
9683
9684 UPDATE qp_npreq_ldets_tmp ldet SET ldet.process_code = G_STATUS_DELETED
9685 WHERE ldet.pricing_status_code = G_STATUS_UNCHANGED;
9686
9687 --First Step: Retain the adjustments input by user
9688 --which are in the phase which do not belong to the
9689 --event passed in the control record
9690
9691
9692 /*
9693 INDX,QP_PREQ_PUB.process_adjustments.upd1,QP_EVENT_PHASES_U1,PRICING_EVENT_CODE,1
9694 */
9695 UPDATE qp_npreq_ldets_tmp ldet SET ldet.process_code = G_STATUS_NEW
9696 WHERE ldet.pricing_status_code = G_STATUS_UNCHANGED AND
9697 ldet.applied_flag = G_YES AND
9698 ldet.pricing_phase_id NOT IN (SELECT ev.pricing_phase_id
9699 FROM qp_event_phases ev, qp_pricing_phases ph
9700 , qp_npreq_lines_tmp line
9701 WHERE instr(p_pricing_event, ev.pricing_event_code || ',') > 0
9702 AND ev.pricing_phase_id = ph.pricing_phase_id
9703 AND line.price_flag <> G_CALCULATE_ONLY
9704 AND ((G_GET_FREIGHT_FLAG = G_YES AND ph.freight_exists = G_YES)
9705 OR (G_GET_FREIGHT_FLAG = G_NO))
9706 AND line.line_index = ldet.line_index
9707 AND ((nvl(Get_buy_line_price_flag(ldet.created_from_list_line_id, ldet.line_index), line.price_flag) = G_YES)
9708 OR ((nvl(Get_buy_line_price_flag(ldet.created_from_list_line_id, ldet.line_index), line.price_flag) = G_PHASE)
9709 AND (nvl(ph.user_freeze_override_flag, ph.freeze_override_flag) = G_YES))));
9710
9711 IF l_debug = FND_API.G_TRUE THEN
9712 QP_PREQ_GRP.ENGINE_DEBUG('PROCESS ADJUSTMENTS: Step1');
9713
9714 END IF;
9715 --Second Step: Retain adjustments input by user
9716 --which have updated flag = 'Y'
9717
9718 /*
9719 upd2 indxno index used
9720 */
9721 --bug 2264566 update the child lines of manual PBH which get
9722 --passed with applied_flag null and updated_flag = 'Y'
9723 UPDATE qp_npreq_ldets_tmp ldet SET ldet.process_code = G_STATUS_NEW
9724 WHERE ldet.pricing_status_code = G_STATUS_UNCHANGED AND
9725 --fix for bug 2515762 automatic overrideable break
9726 ldet.updated_flag = G_YES;
9727 -- ((ldet.updated_flag = G_YES and ldet.applied_flag = G_YES)
9728 -- or (ldet.updated_flag = G_YES
9729 -- and nvl(ldet.automatic_flag, G_NO) = G_NO
9730 -- and ldet.line_detail_index in
9731 -- (select rltd.related_line_detail_index
9732 -- from qp_npreq_rltd_lines_tmp rltd
9733 -- where rltd.relationship_type_code = G_PBH_LINE)));
9734
9735 IF l_debug = FND_API.G_TRUE THEN
9736 QP_PREQ_GRP.ENGINE_DEBUG('PROCESS ADJUSTMENTS: Step1.5');
9737 END IF;
9738 --summary line adjustments with price flag 'N' need to be considered for calc
9739 --reqt from contracts for performance
9740 UPDATE qp_npreq_ldets_tmp ldet SET ldet.process_code = G_STATUS_NEW
9741 WHERE ldet.line_index IN
9742 (SELECT line.line_index FROM qp_npreq_lines_tmp line
9743 WHERE line.line_type_code = G_ORDER_LEVEL
9744 AND line.price_flag = G_NO);
9745
9746 IF l_debug = FND_API.G_TRUE THEN
9747 QP_PREQ_GRP.ENGINE_DEBUG('PROCESS ADJUSTMENTS: Step2');
9748
9749
9750 END IF;
9751 --Third Step : Mark the lines returned by the engine
9752 --changed this update because GRP will default process_code N for all ldets
9753
9754 /*
9755 upd3 indxno index used
9756 */
9757 UPDATE qp_npreq_ldets_tmp ldet SET ldet.process_code = G_STATUS_DELETED
9758 WHERE ldet.process_code = G_STATUS_NEW
9759 AND ldet.pricing_status_code NOT IN
9760 (G_STATUS_NEW, G_STATUS_UNCHANGED); -- and ldet.applied_flag = 'Y';
9761
9762 /*
9763 open lcur1; LOOP
9764 fetch lcur1 into lrec1;
9765 EXIT when lcur1%NOTFOUND;
9766 IF l_debug = FND_API.G_TRUE THEN
9767 QP_PREQ_GRP.ENGINE_DEBUG('list_line_id'||lrec1.created_from_list_line_id);
9768 END IF;
9769 END LOOP;
9770 CLOSE lcur1;
9771 */
9772
9773 IF l_debug = FND_API.G_TRUE THEN
9774 QP_PREQ_GRP.ENGINE_DEBUG('PROCESS ADJUSTMENTS: Step3');
9775
9776 END IF;
9777 --Fourth Step : Among the lines with process_code = G_STATUS_NEW
9778 -- remove the duplicates. Retain lines passed by user with updated_flag 'Y' or
9779 --applied_flag 'Y' otherwise retain lines passed back by engine
9780
9781
9782
9783 l_dup_adj_tbl.DELETE;
9784 i := 0;
9785
9786 OPEN l_duplicate_cur; LOOP
9787 FETCH l_duplicate_cur INTO l_duplicate_rec;
9788 FETCH l_duplicate_cur INTO l_duplicate_rec1;
9789
9790 EXIT WHEN l_duplicate_cur%NOTFOUND;
9791 i := i + 1;
9792
9793
9794
9795 IF l_debug = FND_API.G_TRUE THEN
9796 QP_PREQ_GRP.ENGINE_DEBUG('DUPLICATE REC:
9797 line index '|| l_duplicate_rec.line_index ||
9798 ' detail_index '|| l_duplicate_rec.line_detail_index ||
9799 'list_line_id '|| l_duplicate_rec.created_from_list_line_id ||
9800 'pricing_status_code '|| l_duplicate_rec.pricing_status_code ||
9801 ' process_code '|| l_duplicate_rec.process_code ||
9802 ' applied_flag '|| l_duplicate_rec.applied_flag ||
9803 ' updated_flag '|| l_duplicate_rec.updated_flag);
9804 QP_PREQ_GRP.ENGINE_DEBUG('DUPLICATE REC1:
9805 line index '|| l_duplicate_rec1.line_index ||
9806 ' detail_index '|| l_duplicate_rec1.line_detail_index ||
9807 'list_line_id '|| l_duplicate_rec1.created_from_list_line_id ||
9808 'pricing_status_code '|| l_duplicate_rec1.pricing_status_code ||
9809 ' process_code '|| l_duplicate_rec1.process_code ||
9810 ' applied_flag '|| l_duplicate_rec1.applied_flag ||
9811 ' updated_flag '|| l_duplicate_rec1.updated_flag);
9812
9813 END IF;
9814 IF l_duplicate_rec1.pricing_status_code = G_STATUS_NEW THEN
9815 IF (l_duplicate_rec.pricing_status_code = G_STATUS_UNCHANGED AND
9816 ((nvl(l_duplicate_rec.updated_flag, G_NO) = G_YES)
9817 OR (nvl(l_duplicate_rec.applied_flag, G_NO) = G_YES))) THEN
9818 --retain adj passed by user
9819 IF l_debug = FND_API.G_TRUE THEN
9820 QP_PREQ_GRP.ENGINE_DEBUG('retain user passed');
9821 END IF;
9822 l_duplicate_rec.process_code := G_STATUS_NEW;
9823 l_duplicate_rec1.process_code := G_STATUS_UNCHANGED;
9824 l_duplicate_rec1.pricing_status_code := G_STATUS_DELETED;
9825 l_duplicate_rec1.pricing_status_text := 'QP_PREQ_PUB:DUPLICATE RECORD';
9826
9827 ELSIF (l_duplicate_rec.pricing_status_code = G_STATUS_UNCHANGED AND
9828 ((nvl(l_duplicate_rec.updated_flag, G_NO) = G_NO) OR
9829 (nvl(l_duplicate_rec.updated_flag, G_NO) = G_NO))) THEN
9830 --retain adj passed by user
9831 IF l_debug = FND_API.G_TRUE THEN
9832 QP_PREQ_GRP.ENGINE_DEBUG('retain engine passed');
9833 END IF;
9834 l_duplicate_rec.process_code := G_STATUS_UNCHANGED;
9835 l_duplicate_rec.pricing_status_code := G_STATUS_DELETED;
9836 l_duplicate_rec1.pricing_status_text := 'QP_PREQ_PUB:DUPLICATE RECORD';
9837 l_duplicate_rec1.process_code := G_STATUS_NEW;
9838 ELSE
9839 --retain adj passed by engine
9840 IF l_debug = FND_API.G_TRUE THEN
9841 QP_PREQ_GRP.ENGINE_DEBUG('else retain engine');
9842
9843 END IF;
9844 l_duplicate_rec.process_code := G_STATUS_UNCHANGED;
9845 l_duplicate_rec.pricing_status_code := G_STATUS_DELETED;
9846 l_duplicate_rec.pricing_status_text := 'QP_PREQ_PUB:DUPLICATE RECORD';
9847 l_duplicate_rec1.process_code := G_STATUS_NEW;
9848 END IF;
9849 ELSE
9850 NULL;
9851 END IF;
9852
9853 l_dup_adj_tbl(i) := l_duplicate_rec;
9854
9855 IF l_debug = FND_API.G_TRUE THEN
9856 QP_PREQ_GRP.ENGINE_DEBUG('Processed duplicate adj:
9857 line index '|| l_dup_adj_tbl(i).line_detail_index ||
9858 'list_line_id '|| l_dup_adj_tbl(i).created_from_list_line_id ||
9859 'process_code '|| l_dup_adj_tbl(i).process_code ||
9860 ' applied_flag '|| l_dup_adj_tbl(i).applied_flag ||
9861 ' updated_flag '|| l_dup_adj_tbl(i).updated_flag);
9862 END IF;
9863 i := i + 1;
9864 l_dup_adj_tbl(i) := l_duplicate_rec1;
9865 IF l_debug = FND_API.G_TRUE THEN
9866 QP_PREQ_GRP.ENGINE_DEBUG('Processed duplicate adj:
9867 line index '|| l_dup_adj_tbl(i).line_detail_index ||
9868 'list_line_id '|| l_dup_adj_tbl(i).created_from_list_line_id ||
9869 'process_code '|| l_dup_adj_tbl(i).process_code ||
9870 ' applied_flag '|| l_dup_adj_tbl(i).applied_flag ||
9871 ' updated_flag '|| l_dup_adj_tbl(i).updated_flag);
9872 END IF;
9873 END LOOP;
9874
9875
9876 i := l_dup_adj_tbl.FIRST;
9877 WHILE i IS NOT NULL LOOP
9878
9879 /*
9880 INDX,QP_PREQ_PUB.process_adjustments.upd4,qp_npreq_ldets_tmp_U1,LINE_DETAIL_INDEX,1
9881 */
9882 UPDATE qp_npreq_ldets_tmp SET
9883 process_code = l_dup_adj_tbl(i).process_code
9884 , pricing_status_code = l_dup_adj_tbl(i).pricing_status_code
9885 , pricing_status_text = l_dup_adj_tbl(i).pricing_status_text
9886 WHERE line_detail_index = l_dup_adj_tbl(i).line_detail_index;
9887
9888 IF l_debug = FND_API.G_TRUE THEN
9889 QP_PREQ_GRP.ENGINE_DEBUG('Update processed adjustments:
9890 list_line_id '|| l_dup_adj_tbl(i).created_from_list_line_id ||
9891 ' pricing_status_code '|| l_dup_adj_tbl(i).pricing_status_code ||
9892 'process_code '|| l_dup_adj_tbl(i).process_code);
9893
9894 END IF;
9895 i := l_dup_adj_tbl.NEXT(i);
9896 END LOOP;
9897
9898 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE THEN
9899
9900 OPEN lcur1; LOOP
9901 FETCH lcur1 INTO lrec1;
9902 EXIT WHEN lcur1%NOTFOUND;
9903 IF l_debug = FND_API.G_TRUE THEN
9904 QP_PREQ_GRP.ENGINE_DEBUG('line_index '|| lrec1.line_index ||
9905 ' line_dtl_index '|| lrec1.line_detail_index ||
9906 ' line_qty '|| lrec1.line_quantity ||
9907 ' list_line_id '|| lrec1.created_from_list_line_id ||
9908 ' applied '|| lrec1.applied_flag ||' status '|| lrec1.pricing_status_code ||
9909 ' updated '|| lrec1.updated_flag ||' process '|| lrec1.process_code);
9910 END IF;
9911 END LOOP;
9912 CLOSE lcur1;
9913 END IF;
9914 Cleanup_rltd_lines(x_return_status, x_return_status_text);
9915 IF l_debug = FND_API.G_TRUE THEN
9916 QP_PREQ_GRP.engine_debug('------------------------------------------');
9917
9918 END IF;
9919 IF x_return_status = FND_API.G_RET_STS_ERROR
9920 THEN
9921 RAISE Process_Exc;
9922 END IF;
9923
9924 Update_Related_Line_Info(x_return_status, x_return_status_text);
9925 IF l_debug = FND_API.G_TRUE THEN
9926 QP_PREQ_GRP.engine_debug('------------------------------------------');
9927 END IF;
9928 IF x_return_status = FND_API.G_RET_STS_ERROR
9929 THEN
9930 RAISE Process_Exc;
9931 END IF;
9932
9933 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE THEN
9934
9935 OPEN lcur1; LOOP
9936 FETCH lcur1 INTO lrec1;
9937 EXIT WHEN lcur1%NOTFOUND;
9938 IF l_debug = FND_API.G_TRUE THEN
9939 QP_PREQ_GRP.ENGINE_DEBUG('line_index '|| lrec1.line_index ||
9940 ' list_line_id '|| lrec1.created_from_list_line_id ||
9941 ' applied '|| lrec1.applied_flag ||' status '|| lrec1.pricing_status_code ||
9942 ' updated '|| lrec1.updated_flag ||' process '|| lrec1.process_code);
9943 END IF;
9944 END LOOP;
9945 CLOSE lcur1;
9946 END IF;
9947
9948 IF l_debug = FND_API.G_TRUE THEN
9949 QP_PREQ_GRP.ENGINE_DEBUG('PROCESS ADJUSTMENTS: Step4');
9950
9951 END IF;
9952 X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;
9953 X_RETURN_STATUS_TEXT := l_routine ||' SUCCESS ';
9954
9955 IF l_debug = FND_API.G_TRUE THEN
9956 QP_PREQ_GRP.ENGINE_DEBUG('END PROCESS ADJUSTMENTS');
9957 END IF;
9958 EXCEPTION
9959 WHEN Process_Exc THEN
9960 IF l_debug = FND_API.G_TRUE THEN
9961 QP_PREQ_GRP.ENGINE_DEBUG('EXCEPTION PROCESS ADJUSTMENTS: '|| X_RETURN_STATUS_TEXT);
9962 END IF;
9963 WHEN OTHERS THEN
9964 IF l_debug = FND_API.G_TRUE THEN
9965 QP_PREQ_GRP.ENGINE_DEBUG('EXCEPTION PROCESS ADJUSTMENTS: '|| SQLERRM);
9966 END IF;
9967 x_return_status := FND_API.G_RET_STS_ERROR;
9968 x_return_status_text := l_routine ||' '|| SQLERRM;
9969 END PROCESS_ADJUSTMENTS;
9970
9971
9972 --This is to populate the qualifier_value in the rltd_lines_tmp
9973 --for PBH adjustments inserted by calling application during
9974 --BILLING call for usage pricing. The pricing engine would have
9975 --returned PBH adjustments and rltd_lines_tmp records for them
9976 --during the AUTHORING call
9977 --but qualifier_value would not have been populated as there
9978 --is no quantity during the AUTHORING call
9979 PROCEDURE UPDATE_QUALIFIER_VALUE(x_return_status OUT NOCOPY VARCHAR2,
9980 x_return_status_text OUT NOCOPY VARCHAR2)
9981 IS
9982 BEGIN
9983 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
9984 IF l_debug = FND_API.G_TRUE THEN
9985 QP_PREQ_GRP.engine_debug('Begin UPDATE_QUALIFIER_VALUE routine');
9986
9987 END IF;
9988 UPDATE qp_npreq_rltd_lines_tmp rltd
9989 SET rltd.qualifier_value = (SELECT
9990 decode(qpa.pricing_attribute,
9991 G_LINE_AMT_ATTRIBUTE,
9992 (nvl(line.priced_quantity, line.line_quantity)
9993 * nvl(line.unit_price, 0)),
9994 nvl(line.priced_quantity, line.line_quantity))
9995 FROM qp_npreq_lines_tmp line,
9996 qp_pricing_attributes qpa
9997 WHERE line.line_index = rltd.line_index
9998 AND qpa.list_line_id = rltd.related_list_line_id
9999 AND qpa.pricing_attribute_context =
10000 G_PRIC_VOLUME_CONTEXT)
10001 WHERE rltd.line_index IN (SELECT line.line_index
10002 FROM qp_npreq_lines_tmp line
10003 WHERE line.line_index = rltd.line_index
10004 AND rltd.relationship_type_code = G_PBH_LINE
10005 AND line.pricing_status_code IN
10006 (G_STATUS_UNCHANGED, G_STATUS_UPDATED,
10007 G_STATUS_GSA_VIOLATION)
10008 AND line.usage_pricing_type =
10009 QP_PREQ_GRP.G_BILLING_TYPE);
10010 IF l_debug = FND_API.G_TRUE THEN
10011 QP_PREQ_GRP.engine_debug('End UPDATE_QUALIFIER_VALUE routine');
10012 END IF;
10013 EXCEPTION
10014 WHEN OTHERS THEN
10015 IF l_debug = FND_API.G_TRUE THEN
10016 QP_PREQ_GRP.engine_debug('Error UPDATE_QUALIFIER_VALUE routine '|| SQLERRM);
10017 END IF;
10018 x_return_status := FND_API.G_RET_STS_ERROR;
10019 x_return_status_text := 'QP_PREQ_PUB.UPDATE_QUALIFIER_VALUE: '|| SQLERRM;
10020 END UPDATE_QUALIFIER_VALUE;
10021
10022 --This is to update the status on the child break lines after calculation
10023 PROCEDURE Update_Child_Break_Lines(x_return_status OUT NOCOPY VARCHAR2,
10024 x_return_status_text OUT NOCOPY VARCHAR2) IS
10025
10026 --[julin/pbperf] tuned to use QP_PREQ_LDETS_TMP_U1
10027 CURSOR l_child_break_cur IS
10028 SELECT /*+ ORDERED index(ldet QP_PREQ_LDETS_TMP_U1) */ldet.process_code,
10029 rltd.related_line_detail_index
10030 FROM qp_npreq_rltd_lines_tmp rltd,
10031 -- qp_npreq_ldets_tmp ldet1,
10032 qp_npreq_ldets_tmp ldet
10033 WHERE rltd.relationship_type_code = G_PBH_LINE
10034 AND rltd.pricing_status_code = G_STATUS_NEW
10035 AND ldet.line_index = rltd.line_index
10036 AND ldet.line_detail_index = rltd.line_detail_index
10037 AND ldet.pricing_status_code = G_STATUS_NEW
10038 AND ldet.process_code = G_STATUS_NEW;
10039 -- and ldet1.line_index = rltd.related_line_index
10040 -- and ldet1.line_detail_index = rltd.related_line_detail_index;
10041
10042 l_line_dtl_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
10043 l_child_sts_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
10044 nRows CONSTANT NUMBER := 500;
10045 I PLS_INTEGER;
10046 BEGIN
10047 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
10048 --This is to update the status on the child break lines after calculation
10049 IF l_debug = FND_API.G_TRUE THEN
10050 QP_PREQ_GRP.engine_debug('In Update_Child_break_lines routine');
10051 END IF;
10052 OPEN l_child_break_cur;
10053 IF l_debug = FND_API.G_TRUE THEN
10054 QP_PREQ_GRP.engine_debug('open l_child_break_cur');
10055 END IF;
10056 -- LOOP
10057 l_child_sts_code_tbl.DELETE;
10058 l_line_dtl_index_tbl.DELETE;
10059 FETCH l_child_break_cur
10060 BULK COLLECT INTO l_child_sts_code_tbl, l_line_dtl_index_tbl;
10061 IF l_debug = FND_API.G_TRUE THEN
10062 QP_PREQ_GRP.engine_debug('fetch l_child_break_cur');
10063 END IF;
10064 -- LIMIT nRows;
10065 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
10066 THEN
10067 I := l_line_dtl_index_tbl.FIRST;
10068 WHILE I IS NOT NULL
10069 -- FOR I in l_line_dtl_index_tbl.FIRST..l_line_dtl_index_tbl.LAST
10070 LOOP
10071 IF l_debug = FND_API.G_TRUE THEN
10072 QP_PREQ_GRP.engine_debug('l_child_break_cur count '|| i
10073 ||' childdtl index '|| l_line_dtl_index_tbl(i)
10074 ||' status code '|| l_child_sts_code_tbl(i));
10075 END IF;
10076 I := l_line_dtl_index_tbl.NEXT(I);
10077 END LOOP;
10078 END IF;
10079
10080 IF l_line_dtl_index_tbl.COUNT > 0
10081 THEN
10082 IF l_debug = FND_API.G_TRUE THEN
10083 QP_PREQ_GRP.engine_debug('before update');
10084 END IF;
10085 FORALL j IN l_line_dtl_index_tbl.FIRST..l_line_dtl_index_tbl.LAST
10086 UPDATE qp_npreq_ldets_tmp
10087 SET process_code = l_child_sts_code_tbl(j)
10088 WHERE line_detail_index = l_line_dtl_index_tbl(j);
10089 IF l_debug = FND_API.G_TRUE THEN
10090 QP_PREQ_GRP.engine_debug('after update');
10091 END IF;
10092 END IF;
10093 -- EXIT WHEN l_line_dtl_index_tbl.COUNT =0;
10094 -- END LOOP;
10095 IF l_debug = FND_API.G_TRUE THEN
10096 QP_PREQ_GRP.engine_debug('END LOOP');
10097 END IF;
10098 CLOSE l_child_break_cur;
10099 IF l_debug = FND_API.G_TRUE THEN
10100 QP_PREQ_GRP.engine_debug('fetch l_child_break_cur');
10101 END IF;
10102
10103 IF l_debug = FND_API.G_TRUE THEN
10104 QP_PREQ_GRP.engine_debug('End Update_Child_break_lines routine');
10105 END IF;
10106 EXCEPTION
10107 WHEN OTHERS THEN
10108 IF l_debug = FND_API.G_TRUE THEN
10109 QP_PREQ_GRP.engine_debug('Error Update_Child_break_lines routine '|| SQLERRM);
10110 END IF;
10111 x_return_status := FND_API.G_RET_STS_ERROR;
10112 x_return_status_text := 'QP_PREQ_PUB.Update_Child_Break_lines: '|| SQLERRM;
10113
10114 END Update_Child_Break_Lines;
10115
10116
10117 --This is to calculate the line quantity on each child break line
10118 PROCEDURE PROCESS_PRICE_BREAK(p_rounding_flag IN VARCHAR2,
10119 p_processing_order IN NUMBER,
10120 x_line_index_tbl OUT NOCOPY QP_PREQ_GRP.NUMBER_TYPE,
10121 x_list_price_tbl OUT NOCOPY QP_PREQ_GRP.NUMBER_TYPE,
10122 x_pricing_sts_code_tbl OUT NOCOPY QP_PREQ_GRP.VARCHAR_TYPE,
10123 x_pricing_sts_txt_tbl OUT NOCOPY QP_PREQ_GRP.VARCHAR_TYPE,
10124 x_return_status OUT NOCOPY VARCHAR2,
10125 x_return_status_text OUT NOCOPY VARCHAR2) IS
10126
10127 CURSOR l_request_line_detail_cur(p_processing_order NUMBER) IS
10128 SELECT rltd.line_detail_index parent_detail_index,
10129 rltd.line_index parent_line_index,
10130 ldet.line_detail_index child_detail_index,
10131 ldet.line_index child_line_index,
10132 ldet.line_detail_type_code,
10133 ldet.created_from_list_line_type,
10134 qpa.pricing_attr_value_from value_from,
10135 qpa.pricing_attr_value_to value_to,
10136 line.priced_quantity ordered_quantity,
10137 attr.value_from break_quantity,
10138 line.uom_quantity service_duration,
10139 line.rounding_factor,
10140 -- ldet.line_quantity line_qty,
10141 ldet.created_from_list_line_id,
10142 ldet.price_break_type_code price_break_type,
10143 ldet.modifier_level_code,
10144 ldet.group_quantity,
10145 ldet.operand_calculation_code,
10146 ldet.operand_value,
10147 ldet.group_amount,
10148 line.parent_price
10149 FROM qp_npreq_lines_tmp line,
10150 qp_npreq_rltd_lines_tmp rltd,
10151 qp_npreq_ldets_tmp ldet,
10152 qp_pricing_attributes qpa,
10153 qp_npreq_line_attrs_tmp attr
10154 WHERE line.pricing_status_code IN (G_STATUS_UNCHANGED, G_STATUS_UPDATED)
10155 AND line.price_flag = G_CALCULATE_ONLY
10156 AND nvl(line.processing_order, 1) = p_processing_order
10157 AND line.usage_pricing_type = QP_PREQ_GRP.G_BILLING_TYPE
10158 AND line.line_index = rltd.line_index
10159 AND rltd.relationship_type_code = G_PBH_LINE
10160 AND ldet.line_index = line.line_index
10161 AND ldet.pricing_status_code = 'X'
10162 AND ldet.line_detail_index = rltd.related_line_detail_index
10163 AND qpa.list_line_id = ldet.created_from_list_line_id
10164 AND qpa.pricing_attribute_context = G_PRIC_VOLUME_CONTEXT
10165 AND attr.line_index = line.line_index
10166 AND attr.line_detail_index IS NULL
10167 AND attr.context = G_PRIC_VOLUME_CONTEXT
10168 AND attr.attribute = qpa.pricing_attribute
10169 ORDER BY child_detail_index, parent_detail_index;
10170
10171 l_quantity NUMBER;
10172 l_satisfied_qty NUMBER;
10173 l_line_dtl_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
10174 l_line_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
10175 l_adj_amt_tbl QP_PREQ_GRP.NUMBER_TYPE;
10176 l_total_qty_tbl QP_PREQ_GRP.NUMBER_TYPE;
10177 --l_pricing_sts_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
10178 --l_pricing_sts_txt_tbl QP_PREQ_GRP.VARCHAR_TYPE;
10179 l_total_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
10180 l_percent_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
10181 l_line_quantity_tbl QP_PREQ_GRP.NUMBER_TYPE;
10182 l_applied_flag_tbl QP_PREQ_GRP.FLAG_TYPE;
10183
10184 i NUMBER := 0;
10185 l_break_satisfied VARCHAR2(1) := G_NO;
10186
10187 BEGIN
10188
10189 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
10190 IF l_debug = FND_API.G_TRUE THEN
10191 QP_PREQ_GRP.engine_debug('Begin process_price_break');
10192
10193 END IF;
10194 FOR I IN l_request_line_detail_cur(p_processing_order)
10195 LOOP
10196 IF l_debug = FND_API.G_TRUE THEN
10197 QP_PREQ_GRP.engine_debug('Loop thru child break '|| I.parent_detail_index
10198 ||' child index '|| I.child_detail_index ||' list_line_id '
10199 || I.created_from_list_line_id ||' level '|| I.modifier_level_code
10200 ||' parent price '|| I.parent_price
10201 ||' val from '|| I.value_from ||' to '|| I.value_to
10202 ||' grpqty '|| I.group_quantity ||' grpamt '|| I.group_amount
10203 ||' ordqty '|| I.ordered_quantity ||' brktype '|| I.price_break_type
10204 ||' brk qty '|| I.break_quantity);
10205 END IF;
10206 --this is not applicable for price lists
10207 IF I.modifier_level_code = G_LINE_GROUP
10208 THEN
10209 IF l_debug = FND_API.G_TRUE THEN
10210 QP_PREQ_GRP.engine_debug('this is line group');
10211 END IF;
10212 l_quantity := nvl(nvl(nvl(I.group_quantity
10213 , I.group_amount),
10214 nvl(I.break_quantity, I.ordered_quantity)), 0);
10215 ELSE
10216 IF l_debug = FND_API.G_TRUE THEN
10217 QP_PREQ_GRP.engine_debug('this is not line group');
10218 END IF;
10219 l_quantity := nvl(nvl(I.break_quantity,
10220 I.ordered_quantity), 0);
10221 END IF;
10222
10223 IF x_line_index_tbl.COUNT = 0
10224 THEN
10225 l_break_satisfied := G_NO;
10226 ELSIF x_line_index_tbl.COUNT > 0
10227 AND x_line_index_tbl(x_line_index_tbl.COUNT) <> I.child_line_index
10228 THEN
10229 l_break_satisfied := G_NO;
10230 END IF;
10231
10232 IF l_debug = FND_API.G_TRUE THEN
10233 QP_PREQ_GRP.engine_debug('process_price_break1');
10234 END IF;
10235 IF I.price_break_type = G_POINT_BREAK
10236 THEN
10237 IF l_debug = FND_API.G_TRUE THEN
10238 QP_PREQ_GRP.engine_debug('this is point break');
10239 END IF;
10240 IF l_quantity BETWEEN I.value_from AND I.value_to
10241 THEN
10242 IF l_debug = FND_API.G_TRUE THEN
10243 QP_PREQ_GRP.engine_debug('point break satisfied');
10244 END IF;
10245 l_line_quantity_tbl(l_line_quantity_tbl.COUNT + 1)
10246 := l_quantity;
10247 l_line_index_tbl(l_line_index_tbl.COUNT + 1) :=
10248 I.child_line_index;
10249 l_applied_flag_tbl(l_applied_flag_tbl.COUNT + 1) := G_YES;
10250 l_line_dtl_index_tbl(l_line_dtl_index_tbl.COUNT + 1)
10251 := I.child_detail_index;
10252 ELSE
10253 IF l_debug = FND_API.G_TRUE THEN
10254 QP_PREQ_GRP.engine_debug('point break not satisfied');
10255 END IF;
10256 l_line_quantity_tbl(l_line_quantity_tbl.COUNT + 1) := 0;
10257 l_line_index_tbl(l_line_index_tbl.COUNT + 1) :=
10258 I.child_line_index;
10259 l_applied_flag_tbl(l_applied_flag_tbl.COUNT + 1) := G_NO;
10260 l_line_dtl_index_tbl(l_line_dtl_index_tbl.COUNT + 1)
10261 := I.child_detail_index;
10262 END IF;
10263
10264 ELSIF I.price_break_type = G_RANGE_BREAK
10265 THEN
10266 IF l_debug = FND_API.G_TRUE THEN
10267 QP_PREQ_GRP.engine_debug('this is range break');
10268 END IF;
10269 l_satisfied_qty := 0;
10270 QP_Calculate_Price_PUB.Get_Satisfied_Range
10271 (p_value_from => I.value_from
10272 , p_value_to => I.value_to
10273 , p_qualifier_value => l_quantity
10274 , x_satisfied_value => l_satisfied_qty);
10275 IF l_debug = FND_API.G_TRUE THEN
10276 QP_PREQ_GRP.engine_debug('range break '|| l_satisfied_qty);
10277
10278 END IF;
10279 IF l_satisfied_qty <> 0
10280 THEN
10281 IF l_debug = FND_API.G_TRUE THEN
10282 QP_PREQ_GRP.engine_debug('range break satisfied');
10283 END IF;
10284 l_line_quantity_tbl(l_line_quantity_tbl.COUNT + 1)
10285 := l_satisfied_qty;
10286 l_line_index_tbl(l_line_index_tbl.COUNT + 1) :=
10287 I.child_line_index;
10288 l_applied_flag_tbl(l_applied_flag_tbl.COUNT + 1) := G_YES;
10289 l_line_dtl_index_tbl(l_line_dtl_index_tbl.COUNT + 1)
10290 := I.child_detail_index;
10291 ELSE
10292 IF l_debug = FND_API.G_TRUE THEN
10293 QP_PREQ_GRP.engine_debug('range break not satisfied');
10294 END IF;
10295 l_line_quantity_tbl(l_line_quantity_tbl.COUNT + 1) := 0;
10296 l_applied_flag_tbl(l_applied_flag_tbl.COUNT + 1) := G_NO;
10297 l_line_index_tbl(l_line_index_tbl.COUNT + 1) :=
10298 I.child_line_index;
10299 l_line_dtl_index_tbl(l_line_dtl_index_tbl.COUNT + 1)
10300 := I.child_detail_index;
10301 END IF;
10302 END IF;
10303
10304 IF l_line_quantity_tbl.COUNT > 0
10305 AND l_line_quantity_tbl(l_line_quantity_tbl.COUNT) > 0
10306 THEN
10307 l_break_satisfied := G_YES;
10308 QP_Calculate_Price_PUB.Calculate_List_Price
10309 (I.OPERAND_CALCULATION_CODE,
10310 I.OPERAND_VALUE,
10311 l_line_quantity_tbl(l_line_quantity_tbl.COUNT),
10312 I.parent_price,
10313 nvl(I.service_duration, 1),
10314 p_rounding_flag,
10315 I.rounding_factor,
10316 l_adj_amt_tbl(l_line_quantity_tbl.COUNT),
10317 l_percent_price_tbl(l_line_quantity_tbl.COUNT),
10318 x_return_status,
10319 x_return_status_text);
10320
10321 IF l_debug = FND_API.G_TRUE THEN
10322 QP_PREQ_GRP.engine_debug('plsql tbl info dtlindex '
10323 || l_line_dtl_index_tbl(l_line_dtl_index_tbl.COUNT)
10324 ||' appl flag '|| l_applied_flag_tbl(l_line_dtl_index_tbl.COUNT)
10325 ||' line qty '|| l_line_quantity_tbl(l_line_dtl_index_tbl.COUNT)
10326 ||' list price '|| l_adj_amt_tbl(l_line_dtl_index_tbl.COUNT)
10327 ||' percent price '|| l_percent_price_tbl(l_line_dtl_index_tbl.COUNT));
10328 END IF;
10329 ELSE
10330 l_adj_amt_tbl(l_line_quantity_tbl.COUNT) := NULL;
10331 END IF;
10332
10333 IF x_line_index_tbl.COUNT = 0
10334 THEN
10335 x_line_index_tbl(x_line_index_tbl.COUNT + 1) :=
10336 l_line_index_tbl(l_line_index_tbl.COUNT);
10337 l_total_qty_tbl(x_line_index_tbl.COUNT) :=
10338 I.ordered_quantity;
10339 l_total_price_tbl(x_line_index_tbl.COUNT) :=
10340 l_line_quantity_tbl(l_line_dtl_index_tbl.COUNT)
10341 * nvl(l_adj_amt_tbl(l_line_dtl_index_tbl.COUNT), 0);
10342 IF l_debug = FND_API.G_TRUE THEN
10343 QP_PREQ_GRP.engine_debug('first line '
10344 || l_total_qty_tbl(x_line_index_tbl.COUNT) ||' '
10345 || l_total_price_tbl(x_line_index_tbl.COUNT)
10346 ||' qty '|| l_line_quantity_tbl(l_line_dtl_index_tbl.COUNT)
10347 ||' adjamt '|| l_adj_amt_tbl(l_line_dtl_index_tbl.COUNT)
10348 ||' brk satisfied '|| l_break_satisfied);
10349 END IF;
10350 ELSIF x_line_index_tbl.COUNT > 0
10351 AND x_line_index_tbl(x_line_index_tbl.COUNT) =
10352 l_line_index_tbl(l_line_index_tbl.COUNT)
10353 THEN
10354 l_total_price_tbl(x_line_index_tbl.COUNT) :=
10355 l_total_price_tbl(x_line_index_tbl.COUNT) +
10356 l_line_quantity_tbl(l_line_dtl_index_tbl.COUNT)
10357 * nvl(l_adj_amt_tbl(l_line_dtl_index_tbl.COUNT), 0);
10358 IF l_debug = FND_API.G_TRUE THEN
10359 QP_PREQ_GRP.engine_debug('same line '
10360 || l_total_qty_tbl(x_line_index_tbl.COUNT) ||' '
10361 || l_total_price_tbl(x_line_index_tbl.COUNT)
10362 ||' qty '|| l_line_quantity_tbl(l_line_dtl_index_tbl.COUNT)
10363 ||' adjamt '|| l_adj_amt_tbl(l_line_dtl_index_tbl.COUNT)
10364 ||' brk satisfied '|| l_break_satisfied);
10365 END IF;
10366 ELSIF x_line_index_tbl.COUNT > 0
10367 AND x_line_index_tbl(x_line_index_tbl.COUNT) <>
10368 l_line_index_tbl(l_line_index_tbl.COUNT)
10369 THEN
10370 --Calculation for pervious line
10371 x_list_price_tbl(x_line_index_tbl.COUNT) :=
10372 l_total_price_tbl(x_line_index_tbl.COUNT) /
10373 l_total_qty_tbl(x_line_index_tbl.COUNT);
10374 IF l_break_satisfied = G_NO
10375 THEN
10376 x_pricing_sts_code_tbl(x_line_index_tbl.COUNT) :=
10377 G_STATUS_CALC_ERROR;
10378 x_pricing_sts_txt_tbl(x_line_index_tbl.COUNT) :=
10379 'UNABLE TO PRICE LINE';
10380 ELSE
10381 x_pricing_sts_code_tbl(x_line_index_tbl.COUNT) :=
10382 G_STATUS_UPDATED;
10383 x_pricing_sts_txt_tbl(x_line_index_tbl.COUNT) :=
10384 '';
10385 END IF;
10386 IF l_debug = FND_API.G_TRUE THEN
10387 QP_PREQ_GRP.engine_debug('next line ');
10388 END IF;
10389 x_line_index_tbl(x_line_index_tbl.COUNT + 1) :=
10390 l_line_index_tbl(l_line_index_tbl.COUNT);
10391 l_total_qty_tbl(x_line_index_tbl.COUNT) :=
10392 I.ordered_quantity;
10393 IF l_debug = FND_API.G_TRUE THEN
10394 QP_PREQ_GRP.engine_debug('price info: line index '
10395 || x_line_index_tbl(x_line_index_tbl.COUNT)
10396 ||' price '|| x_list_price_tbl(x_line_index_tbl.COUNT)
10397 ||' qty '|| l_line_quantity_tbl(l_line_dtl_index_tbl.COUNT)
10398 ||' adjamt '|| l_adj_amt_tbl(l_line_dtl_index_tbl.COUNT)
10399 ||' brk satisfied '|| l_break_satisfied);
10400 END IF;
10401 END IF;
10402 END LOOP;
10403
10404 IF x_line_index_tbl.COUNT > 0
10405 --for the last line
10406 THEN
10407 IF l_debug = FND_API.G_TRUE THEN
10408 QP_PREQ_GRP.engine_debug('price info: line index ');
10409 END IF;
10410 IF l_break_satisfied = G_NO
10411 THEN
10412 x_pricing_sts_code_tbl(x_line_index_tbl.COUNT) :=
10413 G_STATUS_CALC_ERROR;
10414 x_pricing_sts_txt_tbl(x_line_index_tbl.COUNT) :=
10415 'UNABLE TO PRICE LINE';
10416 ELSE
10417 x_pricing_sts_code_tbl(x_line_index_tbl.COUNT) :=
10418 G_STATUS_UPDATED;
10419 x_pricing_sts_txt_tbl(x_line_index_tbl.COUNT) :=
10420 '';
10421 END IF;
10422 x_list_price_tbl(x_line_index_tbl.COUNT) :=
10423 l_total_price_tbl(x_line_index_tbl.COUNT) /
10424 l_total_qty_tbl(x_line_index_tbl.COUNT);
10425 IF l_debug = FND_API.G_TRUE THEN
10426 QP_PREQ_GRP.engine_debug('price info: line index '
10427 || x_line_index_tbl(x_line_index_tbl.COUNT)
10428 ||' price '|| x_list_price_tbl(x_line_index_tbl.COUNT) ||' '
10429 || l_total_qty_tbl(x_line_index_tbl.COUNT) ||' '
10430 || l_total_price_tbl(x_line_index_tbl.COUNT)
10431 ||' qty '|| l_line_quantity_tbl(l_line_dtl_index_tbl.COUNT)
10432 ||' adjamt '|| l_adj_amt_tbl(l_line_dtl_index_tbl.COUNT)
10433 ||' brk satisfied '|| l_break_satisfied);
10434 END IF;
10435 END IF;
10436
10437 IF l_line_quantity_tbl.COUNT > 0
10438 THEN
10439 IF l_debug = FND_API.G_TRUE THEN
10440 QP_PREQ_GRP.engine_debug('process_price_break5: count '
10441 || l_line_quantity_tbl.COUNT ||' first '
10442 || l_line_quantity_tbl.FIRST ||' last '
10443 || l_line_quantity_tbl.LAST);
10444 END IF;
10445 FORALL i IN l_line_quantity_tbl.FIRST..l_line_quantity_tbl.LAST
10446 UPDATE qp_npreq_ldets_tmp
10447 SET line_quantity = l_line_quantity_tbl(i)
10448 , applied_flag = l_applied_flag_tbl(i)
10449 , adjustment_amount = l_adj_amt_tbl(i)
10450 WHERE line_detail_index = l_line_dtl_index_tbl(i);
10451 END IF;
10452
10453 IF l_debug = FND_API.G_TRUE THEN
10454 QP_PREQ_GRP.engine_debug('process_price_break5');
10455
10456 END IF;
10457 IF x_line_index_tbl.COUNT > 0
10458 THEN
10459 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
10460 THEN
10461 FOR i IN x_line_index_tbl.FIRST..x_line_index_tbl.LAST
10462 LOOP
10463 IF l_debug = FND_API.G_TRUE THEN
10464 QP_PREQ_GRP.engine_debug('line details '|| x_line_index_tbl(i)
10465 ||' price '|| x_list_price_tbl(i) ||' sts '
10466 || x_pricing_sts_code_tbl(i));
10467 END IF;
10468 END LOOP;
10469 END IF; --QP_PREQ_GRP.G_DEBUG_ENGINE
10470 IF l_debug = FND_API.G_TRUE THEN
10471 QP_PREQ_GRP.engine_debug('update PBH ');
10472 END IF;
10473 FORALL i IN x_line_index_tbl.FIRST..x_line_index_tbl.LAST
10474 UPDATE qp_npreq_ldets_tmp
10475 SET line_quantity = l_total_qty_tbl(i)
10476 , applied_flag = G_YES
10477 , adjustment_amount = x_list_price_tbl(i)
10478 WHERE line_index = x_line_index_tbl(i)
10479 AND created_from_list_line_type = G_BY_PBH
10480 AND created_from_list_type_code IN
10481 (G_PRICE_LIST_HEADER, G_AGR_LIST_HEADER)
10482 AND x_pricing_sts_code_tbl(i) = G_STATUS_UPDATED;
10483 END IF; --x_line_index_tbl.COUNT
10484
10485 UPDATE qp_npreq_ldets_tmp
10486 SET applied_flag = G_NO
10487 WHERE created_from_list_line_type = G_PRICE_BREAK_TYPE
10488 AND created_from_list_type_code IN
10489 (G_PRICE_LIST_HEADER, G_AGR_LIST_HEADER)
10490 AND adjustment_amount IS NULL;
10491
10492 IF l_debug = FND_API.G_TRUE THEN
10493 QP_PREQ_GRP.engine_debug('End process_price_break');
10494 END IF;
10495 EXCEPTION
10496 WHEN OTHERS THEN
10497 x_return_status := FND_API.G_RET_STS_ERROR;
10498 x_return_status_text := 'QP_PREQ_PUB.Process_Price_Break Exception: '
10499 || SQLERRM;
10500 IF l_debug = FND_API.G_TRUE THEN
10501 QP_PREQ_GRP.engine_debug('Exception process_price_break '|| SQLERRM);
10502 END IF;
10503 END PROCESS_PRICE_BREAK;
10504
10505 PROCEDURE Update_Service_Lines(x_return_status OUT NOCOPY VARCHAR2,
10506 x_return_status_text OUT NOCOPY VARCHAR2) IS
10507 /*
10508 INDX,QP_PREQ_PUB.Usage_pricing.l_Service_Cur,-No Index Used-,NA,NA
10509 */
10510 CURSOR l_Service_Cur IS
10511 SELECT rltd.line_index,
10512 rltd.related_line_index,
10513 line.unit_price,
10514 line.priced_quantity,
10515 line.priced_uom_code
10516 FROM qp_npreq_rltd_lines_tmp rltd, qp_npreq_lines_tmp line
10517 WHERE rltd.line_index IS NOT NULL
10518 AND rltd.related_line_index IS NOT NULL
10519 AND rltd.relationship_type_code = G_SERVICE_LINE
10520 AND line.line_index = rltd.line_index;
10521
10522 l_parent_line_tbl QP_PREQ_GRP.NUMBER_TYPE;
10523 l_service_line_tbl QP_PREQ_GRP.NUMBER_TYPE;
10524 l_unit_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
10525 l_priced_quantity_tbl QP_PREQ_GRP.NUMBER_TYPE;
10526 l_priced_uom_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
10527
10528 BEGIN
10529
10530 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
10531 IF l_debug = FND_API.G_TRUE THEN
10532 QP_PREQ_GRP.engine_debug('Begin Update_Service_Lines');
10533
10534 END IF;
10535 OPEN l_Service_Cur;
10536 FETCH l_Service_Cur
10537 BULK COLLECT INTO
10538 l_parent_line_tbl,
10539 l_service_line_tbl,
10540 l_unit_price_tbl,
10541 l_priced_quantity_tbl,
10542 l_priced_uom_code_tbl;
10543 CLOSE l_Service_Cur;
10544
10545 IF l_service_line_tbl.COUNT > 0
10546 THEN
10547 FORALL i IN l_service_line_tbl.FIRST..l_service_line_tbl.LAST
10548 UPDATE qp_npreq_lines_tmp
10549 SET parent_price = l_unit_price_tbl(i),
10550 parent_uom_code = l_priced_uom_code_tbl(i),
10551 processing_order = 2,
10552 parent_quantity = l_priced_quantity_tbl(i)
10553 WHERE line_index = l_service_line_tbl(i);
10554 FORALL i IN l_parent_line_tbl.FIRST..l_parent_line_tbl.LAST
10555 UPDATE qp_npreq_lines_tmp
10556 SET processing_order = 1
10557 WHERE line_index = l_parent_line_tbl(i);
10558 END IF;
10559
10560 IF l_debug = FND_API.G_TRUE THEN
10561 QP_PREQ_GRP.engine_debug('End Update_Service_Lines');
10562 END IF;
10563 EXCEPTION
10564 WHEN OTHERS THEN
10565 x_return_status := FND_API.G_RET_STS_ERROR;
10566 x_return_status_text := 'QP_PREQ_PUB.Update_Service_Lines Exception: '
10567 || SQLERRM;
10568 IF l_debug = FND_API.G_TRUE THEN
10569 QP_PREQ_GRP.engine_debug('Exception Update_Service_Lines '|| SQLERRM);
10570 END IF;
10571 END Update_Service_Lines;
10572
10573
10574 PROCEDURE Usage_pricing(p_rounding_flag IN VARCHAR2,
10575 x_return_status OUT NOCOPY VARCHAR2,
10576 x_return_status_text OUT NOCOPY VARCHAR2) IS
10577
10578 CURSOR l_get_price_cur(p_processing_order NUMBER) IS
10579 SELECT ldet.created_from_list_line_id
10580 , line.line_index line_ind
10581 , ldet.line_detail_index
10582 , ldet.created_from_list_line_type
10583 , ldet.modifier_level_code
10584 , ldet.applied_flag
10585 -- , 1.0 amount_changed
10586 -- , line.adjusted_unit_price
10587 --changed to make sure lumpsum on order level frt charge divide by 1 quantity
10588 , ldet.line_quantity priced_quantity
10589 , line.priced_quantity priced_qty
10590 , ldet.group_quantity
10591 , ldet.group_amount
10592 , ldet.operand_calculation_code
10593 , ldet.operand_value
10594 , ldet.adjustment_amount
10595 , line.unit_price
10596 , ldet.process_code
10597 , ldet.price_break_type_code
10598 , line.rounding_factor
10599 , line.uom_quantity service_duration
10600 , line.processing_order
10601 , line.parent_price
10602 FROM qp_npreq_lines_tmp line, qp_npreq_ldets_tmp ldet
10603 WHERE line.usage_pricing_type = QP_PREQ_GRP.G_BILLING_TYPE
10604 AND ldet.line_index = line.line_index
10605 AND line.price_flag = G_CALCULATE_ONLY
10606 AND nvl(processing_order, 1) = p_processing_order
10607 AND ldet.applied_flag = G_YES
10608 AND ldet.created_from_list_type_code IN
10609 (G_PRICE_LIST_HEADER, G_AGR_LIST_HEADER)
10610 AND ldet.created_from_list_line_type = G_PRICE_LIST_TYPE
10611 AND nvl(ldet.line_detail_type_code, 'NULL') <>
10612 G_CHILD_DETAIL_TYPE
10613 ORDER BY line_ind;
10614
10615
10616
10617 l_line_dtl_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
10618 l_unit_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
10619 l_adj_amt_tbl QP_PREQ_GRP.NUMBER_TYPE;
10620 l_percent_price_tbl QP_PREQ_GRP.NUMBER_TYPE;
10621 l_related_item_price NUMBER;
10622 l_line_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
10623 --l_detail_type_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
10624 l_pricing_sts_code_tbl QP_PREQ_GRP.VARCHAR_TYPE;
10625 l_pricing_sts_txt_tbl QP_PREQ_GRP.VARCHAR_TYPE;
10626
10627 USAGE_EXCEPTION EXCEPTION;
10628 BEGIN
10629
10630 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
10631 IF l_debug = FND_API.G_TRUE THEN
10632 QP_PREQ_GRP.engine_debug('Begin Usage Pricing');
10633
10634
10635 END IF;
10636 Process_Price_Break(p_rounding_flag => p_rounding_flag,
10637 p_processing_order => 1,
10638 x_line_index_tbl => l_line_index_tbl,
10639 x_list_price_tbl => l_unit_price_tbl,
10640 x_pricing_sts_code_tbl => l_pricing_sts_code_tbl,
10641 x_pricing_sts_txt_tbl => l_pricing_sts_txt_tbl,
10642 x_return_status => x_return_status,
10643 x_return_status_text => x_return_status_text);
10644 IF x_return_status = FND_API.G_RET_STS_ERROR
10645 THEN
10646 RAISE Usage_Exception;
10647 END IF;
10648 FOR cl IN l_get_price_cur(1)
10649 LOOP
10650 IF l_debug = FND_API.G_TRUE THEN
10651 QP_PREQ_GRP.engine_debug('Begin Usage Pricing LOOP');
10652 QP_PREQ_GRP.engine_debug('PRL line type '
10653 || cl.created_from_list_line_type ||' operator '
10654 || cl.OPERAND_CALCULATION_CODE ||' operand '
10655 || cl.OPERAND_VALUE ||' svc duration '
10656 || nvl(cl.service_duration, 1) ||' rounding fac '
10657 || cl.rounding_factor ||' rounding flag '
10658 || p_rounding_flag);
10659 END IF;
10660 IF cl.created_from_list_line_type = G_PRICE_LIST_TYPE
10661 THEN
10662 l_line_dtl_index_tbl(l_line_dtl_index_tbl.COUNT + 1) :=
10663 cl.line_detail_index;
10664 l_line_index_tbl(l_line_index_tbl.COUNT + 1) :=
10665 cl.line_ind;
10666
10667 QP_Calculate_Price_PUB.Calculate_List_Price
10668 (p_operand_calc_code => cl.OPERAND_CALCULATION_CODE,
10669 p_operand_value => cl.OPERAND_VALUE,
10670 p_request_qty => cl.priced_qty,
10671 p_rltd_item_price => l_related_item_price,
10672 p_service_duration => nvl(cl.service_duration, 1),
10673 p_rounding_flag => p_rounding_flag,
10674 p_rounding_factor => cl.rounding_factor,
10675 x_list_price => l_adj_amt_tbl(l_line_dtl_index_tbl.COUNT),
10676 x_percent_price => l_percent_price_tbl(l_percent_price_tbl.COUNT + 1),
10677 x_return_status => x_return_status,
10678 x_return_status_txt => x_return_status_text);
10679
10680 l_unit_price_tbl(l_unit_price_tbl.COUNT + 1) :=
10681 l_adj_amt_tbl(l_adj_amt_tbl.COUNT);
10682
10683 IF l_unit_price_tbl(l_unit_price_tbl.COUNT) IS NULL
10684 THEN
10685 l_pricing_sts_code_tbl(l_pricing_sts_code_tbl.COUNT + 1)
10686 := G_STATUS_CALC_ERROR;
10687 l_pricing_sts_txt_tbl(l_pricing_sts_txt_tbl.COUNT + 1)
10688 := 'UNABLE TO PRICE LINE';
10689 ELSE
10690 l_pricing_sts_code_tbl(l_pricing_sts_code_tbl.COUNT + 1)
10691 := G_STATUS_UPDATED;
10692 l_pricing_sts_txt_tbl(l_pricing_sts_txt_tbl.COUNT + 1)
10693 := '';
10694 END IF; --l_unit_price_tbl
10695
10696 IF l_debug = FND_API.G_TRUE THEN
10697 QP_PREQ_GRP.engine_debug('price returned '
10698 || l_adj_amt_tbl(l_line_dtl_index_tbl.COUNT)
10699 ||' %price '|| l_percent_price_tbl(l_percent_price_tbl.COUNT)
10700 ||' line index '|| l_line_index_tbl(l_line_index_tbl.COUNT)
10701 ||' unit price '|| l_unit_price_tbl(l_unit_price_tbl.COUNT)
10702 ||' status '|| l_pricing_sts_code_tbl(l_line_index_tbl.COUNT)
10703 ||' text '|| l_pricing_sts_txt_tbl(l_line_index_tbl.COUNT));
10704 END IF;
10705 END IF;
10706
10707 END LOOP;
10708
10709 IF l_line_dtl_index_tbl.COUNT > 0
10710 THEN
10711 IF l_debug = FND_API.G_TRUE THEN
10712 QP_PREQ_GRP.engine_debug('Begin Usage Pricing LOOP1');
10713 END IF;
10714 FORALL i IN l_line_dtl_index_tbl.FIRST..l_line_dtl_index_tbl.LAST
10715 UPDATE qp_npreq_ldets_tmp
10716 SET adjustment_amount = l_adj_amt_tbl(i)
10717 WHERE line_detail_index = l_line_dtl_index_tbl(i);
10718 END IF; --l_line_dtl_index_tbl.COUNT
10719
10720 IF l_line_index_tbl.COUNT > 0
10721 THEN
10722 IF l_debug = FND_API.G_TRUE THEN
10723 QP_PREQ_GRP.engine_debug('Begin LINES Usage Pricing LOOP1');
10724 END IF;
10725 FORALL i IN l_line_index_tbl.FIRST..l_line_index_tbl.LAST
10726 UPDATE qp_npreq_lines_tmp
10727 SET unit_price = l_unit_price_tbl(i),
10728 pricing_status_code = l_pricing_sts_code_tbl(i),
10729 pricing_status_text = l_pricing_sts_txt_tbl(i)
10730 WHERE line_index = l_line_index_tbl(i);
10731 END IF; --l_line_index_tbl.COUNT
10732
10733 --now service lines need to be priced
10734 l_line_index_tbl.DELETE;
10735 l_unit_price_tbl.DELETE;
10736 l_pricing_sts_code_tbl.DELETE;
10737 l_pricing_sts_txt_tbl.DELETE;
10738 l_adj_amt_tbl.DELETE;
10739 l_line_dtl_index_tbl.DELETE;
10740
10741
10742 Update_Service_Lines(x_return_status, x_return_status_text);
10743
10744 IF x_return_status = FND_API.G_RET_STS_ERROR
10745 THEN
10746 RAISE Usage_Exception;
10747 END IF;
10748
10749
10750 Process_Price_Break(p_rounding_flag => p_rounding_flag,
10751 p_processing_order => 2,
10752 x_line_index_tbl => l_line_index_tbl,
10753 x_list_price_tbl => l_unit_price_tbl,
10754 x_pricing_sts_code_tbl => l_pricing_sts_code_tbl,
10755 x_pricing_sts_txt_tbl => l_pricing_sts_txt_tbl,
10756 x_return_status => x_return_status,
10757 x_return_status_text => x_return_status_text);
10758 IF x_return_status = FND_API.G_RET_STS_ERROR
10759 THEN
10760 RAISE Usage_Exception;
10761 END IF;
10762
10763 FOR cl IN l_get_price_cur(2)
10764 LOOP
10765 IF l_debug = FND_API.G_TRUE THEN
10766 QP_PREQ_GRP.engine_debug('Begin Usage Pricing LOOP2');
10767 QP_PREQ_GRP.engine_debug('PRL line type '
10768 || cl.created_from_list_line_type ||' operator '
10769 || cl.OPERAND_CALCULATION_CODE ||' operand '
10770 || cl.OPERAND_VALUE ||' svc duration '
10771 || nvl(cl.service_duration, 1) ||' rounding fac '
10772 || cl.rounding_factor ||' rounding flag '
10773 || p_rounding_flag ||' parent price '|| cl.parent_price);
10774 END IF;
10775 IF cl.created_from_list_line_type = G_PRICE_LIST_TYPE
10776 THEN
10777 l_line_dtl_index_tbl(l_line_dtl_index_tbl.COUNT + 1) :=
10778 cl.line_detail_index;
10779 l_line_index_tbl(l_line_index_tbl.COUNT + 1) :=
10780 cl.line_ind;
10781
10782 QP_Calculate_Price_PUB.Calculate_List_Price
10783 (p_operand_calc_code => cl.OPERAND_CALCULATION_CODE,
10784 p_operand_value => cl.OPERAND_VALUE,
10785 p_request_qty => cl.priced_qty,
10786 p_rltd_item_price => cl.parent_price,
10787 p_service_duration => nvl(cl.service_duration, 1),
10788 p_rounding_flag => p_rounding_flag,
10789 p_rounding_factor => cl.rounding_factor,
10790 x_list_price => l_adj_amt_tbl(l_line_dtl_index_tbl.COUNT),
10791 x_percent_price => l_percent_price_tbl(l_percent_price_tbl.COUNT + 1),
10792 x_return_status => x_return_status,
10793 x_return_status_txt => x_return_status_text);
10794
10795 l_unit_price_tbl(l_unit_price_tbl.COUNT + 1) :=
10796 l_adj_amt_tbl(l_adj_amt_tbl.COUNT);
10797
10798 IF l_unit_price_tbl(l_unit_price_tbl.COUNT) IS NULL
10799 THEN
10800 l_pricing_sts_code_tbl(l_pricing_sts_code_tbl.COUNT + 1)
10801 := G_STATUS_CALC_ERROR;
10802 l_pricing_sts_txt_tbl(l_pricing_sts_txt_tbl.COUNT + 1)
10803 := 'UNABLE TO PRICE LINE';
10804 ELSE
10805 l_pricing_sts_code_tbl(l_pricing_sts_code_tbl.COUNT + 1)
10806 := G_STATUS_UPDATED;
10807 l_pricing_sts_txt_tbl(l_pricing_sts_txt_tbl.COUNT + 1)
10808 := '';
10809 END IF; --l_unit_price_tbl
10810 IF l_debug = FND_API.G_TRUE THEN
10811 QP_PREQ_GRP.engine_debug('price returned '
10812 || l_adj_amt_tbl(l_line_dtl_index_tbl.COUNT)
10813 ||' %price '|| l_percent_price_tbl(l_percent_price_tbl.COUNT)
10814 ||' unit price '|| l_unit_price_tbl(l_unit_price_tbl.COUNT)
10815 ||' status '|| l_pricing_sts_code_tbl(l_line_index_tbl.COUNT)
10816 ||' text '|| l_pricing_sts_txt_tbl(l_line_index_tbl.COUNT));
10817 END IF;
10818 END IF;
10819
10820 END LOOP;
10821
10822 IF l_line_dtl_index_tbl.COUNT > 0
10823 THEN
10824 IF l_debug = FND_API.G_TRUE THEN
10825 QP_PREQ_GRP.engine_debug('Begin Usage Pricing LOOP2');
10826 END IF;
10827 FORALL i IN l_line_dtl_index_tbl.FIRST..l_line_dtl_index_tbl.LAST
10828 UPDATE qp_npreq_ldets_tmp
10829 SET adjustment_amount = l_adj_amt_tbl(i)
10830 WHERE line_detail_index = l_line_dtl_index_tbl(i);
10831 END IF; --l_line_dtl_index_tbl.COUNT
10832
10833 IF l_line_index_tbl.COUNT > 0
10834 THEN
10835 IF l_debug = FND_API.G_TRUE THEN
10836 QP_PREQ_GRP.engine_debug('Begin LINES Usage Pricing LOOP2');
10837 END IF;
10838 FORALL i IN l_line_index_tbl.FIRST..l_line_index_tbl.LAST
10839 UPDATE qp_npreq_lines_tmp
10840 SET unit_price = l_unit_price_tbl(i),
10841 pricing_status_code = l_pricing_sts_code_tbl(i),
10842 pricing_status_text = l_pricing_sts_txt_tbl(i)
10843 WHERE line_index = l_line_index_tbl(i);
10844 END IF; --l_line_index_tbl.COUNT
10845
10846
10847
10848 IF l_debug = FND_API.G_TRUE THEN
10849 QP_PREQ_GRP.engine_debug('End Usage Pricing');
10850
10851 END IF;
10852 EXCEPTION
10853 WHEN USAGE_EXCEPTION THEN
10854 IF l_debug = FND_API.G_TRUE THEN
10855 QP_PREQ_GRP.engine_debug('Exception Usage Pricing '|| SQLERRM);
10856 END IF;
10857 x_return_status := FND_API.G_RET_STS_ERROR;
10858 WHEN OTHERS THEN
10859 IF l_debug = FND_API.G_TRUE THEN
10860 QP_PREQ_GRP.engine_debug('Exception Usage Pricing '|| SQLERRM);
10861 END IF;
10862 x_return_status := FND_API.G_RET_STS_ERROR;
10863 x_return_status_text := 'QP_PREQ_PUB.Usage_Pricing Exception: '
10864 || SQLERRM;
10865 END Usage_pricing;
10866
10867 FUNCTION Call_Usage_Pricing RETURN VARCHAR2 IS
10868
10869 CURSOR l_chk_usage_cur IS
10870 SELECT G_YES
10871 FROM qp_npreq_lines_tmp line
10872 WHERE line.pricing_status_code IN
10873 (G_STATUS_UPDATED, G_STATUS_UNCHANGED, G_STATUS_GSA_VIOLATION)
10874 AND line.usage_pricing_type = QP_PREQ_GRP.G_BILLING_TYPE;
10875
10876 x_call_usage_pricing VARCHAR2(1) := G_NO;
10877 BEGIN
10878 OPEN l_chk_usage_cur;
10879 FETCH l_chk_usage_cur INTO x_call_usage_pricing;
10880 CLOSE l_chk_usage_cur;
10881 RETURN x_call_usage_pricing;
10882 EXCEPTION
10883 WHEN OTHERS THEN
10884 IF l_debug = FND_API.G_TRUE THEN
10885 QP_PREQ_GRP.engine_debug('QP_PREQ_PUB.Call_Usage_Pricing Exception: '|| SQLERRM);
10886 END IF;
10887 x_call_usage_pricing := NULL;
10888 END Call_Usage_Pricing;
10889
10890 /***********************************************************************
10891 PRG PROCESSING CODE
10892 ***********************************************************************/
10893
10894 --this procedure identifies the passed in freegood lines
10895 --and updates the process_status on them with the get line's list_line_id
10896 PROCEDURE Identify_freegood_lines(p_event_code IN VARCHAR2
10897 , x_return_status OUT NOCOPY VARCHAR2
10898 , x_return_status_text OUT NOCOPY VARCHAR2) IS
10899
10900 --this cursor identifies the passed in freegood lines
10901 CURSOR l_Identify_freegood_cur IS
10902 SELECT /*+ ORDERED USE_NL(ev ph oldprg oldrltd oldfgdis oldfreeline)*/
10903 oldfreeline.line_index,
10904 oldfgdis.list_line_id,
10905 nvl(oldfgdis.operand_per_pqty, oldfgdis.operand) operand_value,
10906 oldfgdis.arithmetic_operator operand_calculation_code,
10907 buyline.line_index,
10908 oldprg.list_line_id,
10909 oldprg.updated_flag
10910 FROM qp_npreq_lines_tmp buyline
10911 , qp_event_phases ev
10912 , qp_pricing_phases ph
10913 , oe_price_adjustments oldprg
10914 , oe_price_adj_assocs oldrltd
10915 , oe_price_adjustments oldfgdis
10916 , qp_npreq_lines_tmp oldfreeline
10917 --where G_REQUEST_TYPE_CODE = 'ONT'
10918 --bug 3085453 handle pricing availability UI
10919 -- they pass reqtype ONT and insert adj into ldets
10920 --bug 3085453 handle pricing availability UI
10921 -- they pass reqtype ONT and insert adj into ldets
10922 WHERE QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = G_YES
10923 --need not do freegoods cleanup if PRG line has price_flag 'P' or 'N'
10924 AND buyline.price_flag = G_YES --in (G_YES, G_PHASE)
10925 AND instr(p_event_code, ev.pricing_event_code || ',') > 0
10926 AND ph.pricing_phase_id = ev.pricing_phase_id
10927 AND NVL(ev.start_date_active,sysdate) >= SYSDATE --9446733
10928 AND NVL(ev.end_date_active,sysdate) <= SYSDATE --9446733
10929 AND ((G_GET_FREIGHT_FLAG = G_YES AND ph.freight_exists = 'Y')
10930 OR (G_GET_FREIGHT_FLAG = G_NO))
10931 AND (buyline.line_type_code = G_LINE_LEVEL
10932 AND oldprg.line_id = buyline.line_id)
10933 AND oldprg.list_line_type_code = G_PROMO_GOODS_DISCOUNT
10934 --we need to look for in phase PRGs only otherwise
10935 --OM will keep deleting the fg lines between LINE and ORDER event
10936 --after every reprice
10937 AND oldprg.pricing_phase_id = ph.pricing_phase_id
10938 --commented this out as OM passes price_flag as 'N' on fg line
10939 --and ((oldprg.pricing_phase_id = ev.pricing_phase_id
10940 --and buyline.price_flag = G_YES)
10941 --or (oldprg.pricing_phase_id = ev.pricing_phase_id
10942 --and buyline.price_flag = G_PHASE
10943 --and ph.freeze_override_flag = G_YES))
10944 AND oldrltd.price_adjustment_id = oldprg.price_adjustment_id
10945 AND oldfgdis.price_adjustment_id = oldrltd.rltd_price_adj_id
10946 AND oldfgdis.list_line_type_code = 'DIS'
10947 --and ((oldfgdis.line_id is null
10948 --and oldfreeline.line_type_code = G_ORDER_LEVEL
10949 --and oldfreeline.line_id = oldfgdis.header_id)
10950 --freegood line is always a line need not match header
10951 AND (oldfgdis.line_id IS NOT NULL
10952 AND oldfreeline.line_type_code = G_LINE_LEVEL
10953 AND oldfreeline.line_id = oldfgdis.line_id)
10954 --Commented this UNION as there wont be any FREEGOOD type modifier
10955 --at ORDER level. this is causing perf issue for 8407425
10956 -- UNION
10957 -- SELECT /*+ ORDERED USE_NL(ev ph oldprg oldrltd oldfgdis oldfreeline)*/
10958 -- oldfreeline.line_index,
10959 -- oldfgdis.list_line_id,
10960 -- nvl(oldfgdis.operand_per_pqty, oldfgdis.operand) operand_value,
10961 -- oldfgdis.arithmetic_operator operand_calculation_code,
10962 -- buyline.line_index,
10963 -- oldprg.list_line_id,
10964 -- oldprg.updated_flag
10965 -- FROM qp_npreq_lines_tmp buyline
10966 -- , qp_event_phases ev
10967 -- , qp_pricing_phases ph
10968 -- , oe_price_adjustments oldprg
10969 -- , oe_price_adj_assocs oldrltd
10970 -- , oe_price_adjustments oldfgdis
10971 -- , qp_npreq_lines_tmp oldfreeline
10972 --where G_REQUEST_TYPE_CODE = 'ONT'
10973 --bug 3085453 handle pricing availability UI
10974 -- they pass reqtype ONT and insert adj into ldets
10975 -- WHERE QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = G_YES
10976 --need not do freegoods cleanup if PRG line has price_flag 'P' or 'N'
10977 -- AND buyline.price_flag = G_YES --in (G_YES, G_PHASE)
10978 -- AND instr(p_event_code, ev.pricing_event_code || ',') > 0
10979 -- AND ph.pricing_phase_id = ev.pricing_phase_id
10980 -- AND ((G_GET_FREIGHT_FLAG = G_YES AND ph.freight_exists = 'Y')
10981 -- OR (G_GET_FREIGHT_FLAG = G_NO))
10982 -- AND (buyline.line_type_code = G_ORDER_LEVEL
10983 -- AND oldprg.header_id = buyline.line_id
10984 -- AND oldprg.line_id IS NULL)
10985 -- AND oldprg.list_line_type_code = G_PROMO_GOODS_DISCOUNT
10986 --we need to look for in phase PRGs only otherwise
10987 --OM will keep deleting the fg lines between LINE and ORDER event
10988 --after every reprice
10989 -- AND oldprg.pricing_phase_id = ph.pricing_phase_id
10990 --commented this out as OM passes price_flag as 'N' on fg line
10991 --and ((oldprg.pricing_phase_id = ev.pricing_phase_id
10992 --and buyline.price_flag = G_YES)
10993 --or (oldprg.pricing_phase_id = ev.pricing_phase_id
10994 --and buyline.price_flag = G_PHASE
10995 --and ph.freeze_override_flag = G_YES))
10996 -- AND oldrltd.price_adjustment_id = oldprg.price_adjustment_id
10997 -- AND oldfgdis.price_adjustment_id = oldrltd.rltd_price_adj_id
10998 -- AND oldfgdis.list_line_type_code = 'DIS'
10999 --and ((oldfgdis.line_id is null
11000 --and oldfreeline.line_type_code = G_ORDER_LEVEL
11001 --and oldfreeline.line_id = oldfgdis.header_id)
11002 --freegood line is always a line need not match header
11003 -- AND (oldfgdis.line_id IS NOT NULL
11004 -- AND oldfreeline.line_type_code = G_LINE_LEVEL
11005 -- AND oldfreeline.line_id = oldfgdis.line_id)
11006 -- End comment 8407425
11007 UNION
11008 SELECT /*+ ORDERED USE_NL(ev ph oldprg oldrltd oldfgdis oldfreeline)*/
11009 oldfreeline.line_index,
11010 oldfgdis.created_from_list_line_id,
11011 oldfgdis.operand_value,
11012 oldfgdis.operand_calculation_code,
11013 buyline.line_index,
11014 oldprg.created_from_list_line_id,
11015 oldprg.updated_flag
11016 FROM qp_npreq_lines_tmp buyline
11017 , qp_event_phases ev
11018 , qp_pricing_phases ph
11019 , qp_npreq_ldets_tmp oldprg
11020 , qp_npreq_rltd_lines_tmp oldrltd
11021 , qp_npreq_ldets_tmp oldfgdis
11022 , qp_npreq_lines_tmp oldfreeline
11023 --where G_REQUEST_TYPE_CODE <> 'ONT'
11024 --bug 3085453 handle pricing availability UI
11025 -- they pass reqtype ONT and insert adj into ldets
11026 WHERE QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG <> G_YES
11027 AND buyline.price_flag = G_YES --in (G_YES, G_PHASE)
11028 AND instr(p_event_code, ev.pricing_event_code || ',') > 0
11029 AND ph.pricing_phase_id = ev.pricing_phase_id
11030 AND NVL(ev.start_date_active,sysdate) >= SYSDATE --9446733
11031 AND NVL(ev.end_date_active,sysdate) <= SYSDATE --9446733
11032 AND ((G_GET_FREIGHT_FLAG = G_YES AND ph.freight_exists = 'Y')
11033 OR (G_GET_FREIGHT_FLAG = G_NO))
11034 AND oldprg.line_index = buyline.line_index
11035 AND oldprg.created_from_list_line_type = G_PROMO_GOODS_DISCOUNT
11036 --we need to look for in phase PRGs only otherwise
11037 --OC will keep deleting the fg lines between LINE and ORDER event
11038 AND oldprg.pricing_phase_id = ph.pricing_phase_id
11039 -- and oldprg.pricing_status_code = G_STATUS_UNCHANGED
11040 AND oldprg.applied_flag = G_YES
11041 AND oldrltd.line_detail_index = oldprg.line_detail_index
11042 AND oldrltd.relationship_type_code = G_GENERATED_LINE
11043 -- and oldrltd.pricing_status_code = G_STATUS_UNCHANGED
11044 AND oldfgdis.line_detail_index = oldrltd.related_line_detail_index
11045 AND oldfgdis.pricing_status_code = G_STATUS_UNCHANGED
11046 AND oldfgdis.applied_flag = G_YES
11047 AND oldfgdis.created_from_list_line_type = 'DIS'
11048 AND oldfreeline.line_index = oldrltd.related_line_index;
11049 --commented this out as OM passes price_flag as 'N' on fg line
11050 --and ((buyline.price_flag = G_YES
11051 --and oldprg.pricing_phase_id = ev.pricing_phase_id)
11052 --or (buyline.price_flag = G_PHASE
11053 --and oldprg.pricing_phase_id = ev.pricing_phase_id
11054 --and ph.freeze_override_flag = G_YES));
11055
11056 l_fg_line_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
11057 l_fg_list_line_id_tbl QP_PREQ_GRP.NUMBER_TYPE;
11058 l_buy_list_line_id_tbl QP_PREQ_GRP.NUMBER_TYPE;
11059 l_buy_line_index_tbl QP_PREQ_GRP.NUMBER_TYPE;
11060 l_buy_updated_flag_tbl QP_PREQ_GRP.FLAG_TYPE;
11061 l_fg_operand_tbl QP_PREQ_GRP.NUMBER_TYPE;
11062 l_fg_operator_tbl QP_PREQ_GRP.VARCHAR_TYPE;
11063
11064 -- bug 3639169 - changed from dynamic sql to static sql for performance
11065 CURSOR l_prg_debug IS
11066 SELECT prg.line_id buy_line_id, prg.list_line_id prg_list_line_id,
11067 fgdis.list_line_id fgdis_list_line_id, prg.pricing_phase_id prg_phase_id,
11068 prg.price_adjustment_id prg_price_adj_id,
11069 fgdis.price_adjustment_id fg_price_adj_id, fgdis.line_id fg_line_id,
11070 prg.updated_flag
11071 FROM qp_npreq_lines_tmp line, oe_price_adjustments prg,
11072 oe_price_adj_assocs ass, oe_price_adjustments fgdis
11073 WHERE line.line_type_code = G_LINE_LEVEL
11074 AND prg.line_id = line.line_id
11075 AND prg.list_line_type_code = 'PRG'
11076 AND ass.price_adjustment_id = prg.price_adjustment_id
11077 AND fgdis.price_adjustment_id = ass.rltd_price_adj_id
11078 UNION
11079 SELECT prg.line_id buy_line_id, prg.list_line_id prg_list_line_id,
11080 fgdis.list_line_id fgdis_list_line_id, prg.pricing_phase_id prg_phase_id,
11081 prg.price_adjustment_id prg_price_adj_id,
11082 fgdis.price_adjustment_id fg_price_adj_id, fgdis.line_id fg_line_id,
11083 prg.updated_flag
11084 FROM qp_npreq_lines_tmp line, oe_price_adjustments prg,
11085 oe_price_adj_assocs ass, oe_price_adjustments fgdis
11086 WHERE line.line_type_code = G_ORDER_LEVEL
11087 AND prg.header_id = line.line_id
11088 AND prg.line_id IS NULL
11089 AND prg.list_line_type_code = 'PRG'
11090 AND ass.price_adjustment_id = prg.price_adjustment_id
11091 AND fgdis.price_adjustment_id = ass.rltd_price_adj_id;
11092
11093 l_fgdline_exist NUMBER := 0; --bug 14396941
11094 l_routine VARCHAR2(100) := 'QP_PREQ_PUB.Identify_freegood_lines ';
11095 BEGIN
11096 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
11097 IF l_debug = FND_API.G_TRUE THEN
11098 QP_PREQ_GRP.engine_debug('Begin Identify_freegood_lines: '|| p_event_code);
11099
11100 END IF;
11101 x_return_status := FND_API.G_RET_STS_SUCCESS;
11102 x_return_status_text := '';
11103
11104 IF l_debug = FND_API.G_TRUE THEN
11105 -- bug 3639169 - changed from dynamic sql to static sql for performance
11106 FOR cl IN l_prg_debug
11107 LOOP
11108 QP_PREQ_GRP.engine_debug('Printing out all PRGs irrespective of phases: '
11109 ||' buylineid '|| cl.buy_line_id ||' prglistlineid '|| cl.prg_list_line_id
11110 ||' prgpriceadjid '|| cl.prg_price_adj_id ||' prgupdatedflag '|| cl.updated_flag
11111 ||' fglineid '|| cl.fg_line_id ||' fgdis_listlineid '|| cl.fgdis_list_line_id
11112 ||' fgpriceadjid '|| cl.fg_price_adj_id ||' prg_phase_id '|| cl.prg_phase_id);
11113 END LOOP;
11114 END IF; --l_debug
11115
11116 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
11117 AND l_debug = FND_API.G_TRUE
11118 THEN
11119 FOR cl IN
11120 (SELECT buyline.line_index
11121 , oldprg.list_line_id, oldfgdis.line_id
11122 , oldprg.updated_flag
11123 FROM qp_npreq_lines_tmp buyline
11124 , qp_event_phases ev
11125 , qp_pricing_phases ph
11126 , oe_price_adjustments oldprg
11127 , oe_price_adj_assocs oldrltd
11128 , oe_price_adjustments oldfgdis
11129 -- where G_REQUEST_TYPE_CODE = 'ONT'
11130 --bug 3085453 handle pricing availability UI
11131 -- they pass reqtype ONT and insert adj into ldets
11132 WHERE QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = G_YES
11133 AND instr(p_event_code, ev.pricing_event_code || ',') > 0
11134 AND ph.pricing_phase_id = ev.pricing_phase_id
11135 AND ((buyline.line_type_code = G_LINE_LEVEL
11136 AND oldprg.line_id = buyline.line_id)
11137 OR (buyline.line_type_code = G_ORDER_LEVEL
11138 AND oldprg.header_id = buyline.line_id
11139 AND oldprg.line_id IS NULL))
11140 AND oldprg.list_line_type_code = 'PRG'
11141 AND oldprg.pricing_phase_id = ph.pricing_phase_id
11142 -- and ((oldprg.pricing_phase_id = ev.pricing_phase_id
11143 -- and buyline.price_flag = G_YES)
11144 -- or (oldprg.pricing_phase_id = ev.pricing_phase_id
11145 -- and buyline.price_flag = G_PHASE
11146 -- and ph.freeze_override_flag = G_YES))
11147 AND oldrltd.price_adjustment_id = oldprg.price_adjustment_id
11148 AND oldfgdis.price_adjustment_id = oldrltd.rltd_price_adj_id
11149 AND oldfgdis.list_line_type_code = 'DIS')
11150 LOOP
11151 IF l_debug = FND_API.G_TRUE THEN
11152 qp_preq_grp.engine_debug('ident fg dtls: buylineindex '|| cl.line_index
11153 ||' prg-list_line_id '|| cl.list_line_id
11154 ||' fgline_id '|| cl.line_id ||' updated_flag '|| cl.updated_flag);
11155 END IF;
11156 END LOOP; --for cl
11157 END IF; --debug
11158
11159 --bug 14396941 start
11160 IF QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG <> G_YES
11161 THEN
11162 l_fgdline_exist := 1;
11163
11164 begin
11165
11166 SELECT 1
11167 INTO l_fgdline_exist
11168 FROM dual
11169 WHERE EXISTS (SELECT 1
11170 FROM qp_npreq_rltd_lines_tmp oldrltd,
11171 qp_npreq_ldets_tmp oldprg,
11172 qp_event_phases ev
11173 WHERE oldrltd.relationship_type_code = G_GENERATED_LINE
11174 AND oldrltd.line_detail_index = oldprg.line_detail_index
11175 AND oldrltd.line_index = oldprg.line_index
11176 AND oldprg.created_from_list_line_type = G_PROMO_GOODS_DISCOUNT
11177 AND oldprg.applied_flag = G_YES
11178 AND oldprg.pricing_phase_id = ev.pricing_phase_id
11179 AND instr(p_event_code, ev.pricing_event_code || ',') > 0);
11180
11181 EXCEPTION
11182 WHEN NO_DATA_FOUND THEN
11183 l_fgdline_exist := 0;
11184 end;
11185
11186 IF l_debug = FND_API.G_TRUE THEN
11187 QP_PREQ_GRP.engine_debug('l_fgdline_exist 1 '|| l_fgdline_exist);
11188 END IF;
11189 ELSE
11190 l_fgdline_exist := 1;
11191 IF l_debug = FND_API.G_TRUE THEN
11192 QP_PREQ_GRP.engine_debug('l_fgdline_exist 2 '|| l_fgdline_exist);
11193 END IF;
11194 END IF;
11195 --bug 14396941
11196
11197 l_fg_line_index_tbl.DELETE;
11198 l_fg_list_line_id_tbl.DELETE;
11199 l_fg_operand_tbl.DELETE;
11200 l_fg_operator_tbl.DELETE;
11201 l_buy_line_index_tbl.DELETE;
11202 l_buy_list_line_id_tbl.DELETE;
11203
11204 IF l_fgdline_exist = 1 THEN --bug 14396941
11205 OPEN l_Identify_freegood_cur;
11206
11207 FETCH l_Identify_freegood_cur
11208 BULK COLLECT INTO l_fg_line_index_tbl
11209 , l_fg_list_line_id_tbl
11210 , l_fg_operand_tbl
11211 , l_fg_operator_tbl
11212 , l_buy_line_index_tbl
11213 , l_buy_list_line_id_tbl
11214 , l_buy_updated_flag_tbl;
11215 CLOSE l_Identify_freegood_cur;
11216 END IF; --bug 14396941
11217 IF l_fg_line_index_tbl.COUNT > 0
11218 THEN
11219 IF l_debug = FND_API.G_TRUE THEN
11220 QP_PREQ_GRP.engine_debug('Freegood lines exist: '|| l_fg_line_index_tbl.COUNT);
11221
11222 END IF;
11223 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
11224 THEN
11225 FOR i IN l_fg_line_index_tbl.FIRST..l_fg_line_index_tbl.LAST
11226 LOOP
11227 IF l_debug = FND_API.G_TRUE THEN
11228 QP_PREQ_GRP.engine_debug('process_sts: line_ind '
11229 || l_fg_line_index_tbl(i) ||' fglist_line_id '
11230 || l_fg_list_line_id_tbl(i) ||' fgdis operand '
11231 || l_fg_operand_tbl(i) ||' fgdis operator '
11232 || l_fg_operator_tbl(i) ||' prglist_line_id '
11233 || l_buy_list_line_id_tbl(i) ||' prg-updated_flag '
11234 || l_buy_updated_flag_tbl(i));
11235 END IF;
11236 END LOOP; --l_fg_line_index_tbl
11237 END IF; --debug
11238
11239 FORALL i IN l_fg_line_index_tbl.FIRST..l_fg_line_index_tbl.LAST
11240 UPDATE qp_npreq_lines_tmp
11241 SET process_status = G_FREEGOOD || l_fg_list_line_id_tbl(i) || G_BUYLINE
11242 || l_buy_line_index_tbl(i) || G_PROMO_GOODS_DISCOUNT || l_buy_list_line_id_tbl(i)
11243 || G_PROMO_GOODS_DISCOUNT || nvl(l_buy_updated_flag_tbl(i), G_NO)
11244 || G_STATUS_UPDATED || l_fg_operand_tbl(i) || l_fg_operator_tbl(i)
11245 || G_PROMO_GOODS_DISCOUNT
11246 , priced_quantity = nvl(priced_quantity, line_quantity) -- 2970402, 2997007
11247 , priced_uom_code = nvl(priced_uom_code, line_uom_code) -- 2970402, 2997007
11248 WHERE line_index = l_fg_line_index_tbl(i);
11249
11250 END IF; --l_fg_line_index_tbl.count
11251
11252 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
11253 THEN
11254 FOR cl IN (SELECT line_index, process_status FROM qp_npreq_lines_tmp
11255 WHERE instr(process_status, G_FREEGOOD) > 0)
11256 LOOP
11257 IF l_debug = FND_API.G_TRUE THEN
11258 QP_PREQ_GRP.engine_debug('Freegood line dtl: line_ind '
11259 || cl.line_index ||' process_sts '|| cl.process_status);
11260 END IF;
11261 END LOOP; --for cl
11262 END IF; --debug
11263
11264 IF l_debug = FND_API.G_TRUE THEN
11265 QP_PREQ_GRP.engine_debug('End Identify_freegood_lines');
11266 END IF;
11267 EXCEPTION
11268 WHEN OTHERS THEN
11269 x_return_status := FND_API.G_RET_STS_ERROR;
11270 x_return_status_text := 'Exception in '|| l_routine ||' '|| SQLERRM;
11271 IF l_debug = FND_API.G_TRUE THEN
11272 QP_PREQ_GRP.engine_debug('Exception in '|| l_routine ||' '|| SQLERRM);
11273 END IF;
11274 END Identify_freegood_lines;
11275
11276 --procedure to mark the prg lines as deleted if
11277 --called by OC or any other application other than OM
11278 --this is because there will be 2 prg adjustments one passed-in
11279 --and other inserted the pricing engine
11280 --the prg against the line which is marked as invalid needs to
11281 --be marked as deleted so that it is not visible to calling application
11282 --(created for bug 2970368)
11283 PROCEDURE Update_prg_pricing_status(x_return_status OUT NOCOPY VARCHAR2,
11284 x_return_status_text OUT NOCOPY VARCHAR2) IS
11285 CURSOR l_mark_prg_delete_cur IS
11286 SELECT rltd.line_detail_index, rltd.related_line_detail_index
11287 FROM qp_npreq_rltd_lines_tmp rltd, qp_npreq_lines_tmp line
11288 WHERE rltd.pricing_status_code = G_STATUS_NEW
11289 AND rltd.relationship_type_code = G_GENERATED_LINE
11290 AND line.line_index = rltd.related_line_index
11291 AND line.process_status IN (G_NOT_VALID, G_STATUS_DELETED); --bug 3126969
11292
11293 l_mark_prg_delete_index QP_PREQ_GRP.number_type;
11294 l_mark_fgdis_delete_index QP_PREQ_GRP.number_type;
11295 l_prg_list_line_id NUMBER;
11296
11297 l_debug VARCHAR2(3);
11298 l_routine VARCHAR2(50) := 'QP_PREQ_PUB.Update_prg_pricing_status';
11299 BEGIN
11300 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
11301 IF l_debug = FND_API.G_TRUE THEN
11302 QP_PREQ_GRP.engine_debug('Begin Update_prg_pricing_status');
11303 END IF;
11304 OPEN l_mark_prg_delete_cur;
11305 l_mark_prg_delete_index.DELETE;
11306 l_mark_fgdis_delete_index.DELETE;
11307 FETCH l_mark_prg_delete_cur BULK COLLECT INTO
11308 l_mark_prg_delete_index, l_mark_fgdis_delete_index;
11309 CLOSE l_mark_prg_delete_cur;
11310
11311 IF l_mark_prg_delete_index.COUNT > 0 THEN
11312 IF l_debug = FND_API.G_TRUE THEN
11313 FOR i IN l_mark_prg_delete_index.FIRST..l_mark_prg_delete_index.LAST
11314 LOOP
11315 BEGIN
11316 SELECT created_from_list_line_id INTO l_prg_list_line_id
11317 FROM qp_npreq_ldets_tmp
11318 WHERE line_detail_index = l_mark_prg_delete_index(i);
11319 QP_PREQ_GRP.engine_debug('Mark delete prg '|| l_mark_prg_delete_index(i)
11320 ||' list_line_id '|| l_prg_list_line_id);
11321 EXCEPTION
11322 WHEN OTHERS THEN
11323 QP_PREQ_GRP.engine_debug('Mark delete prg list_line_id -1');
11324 END;
11325 END LOOP;
11326 END IF; --l_debug
11327 IF QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = 'N' THEN
11328 FORALL i IN l_mark_prg_delete_index.FIRST..l_mark_prg_delete_index.LAST
11329 UPDATE qp_npreq_ldets_tmp SET pricing_status_code = G_STATUS_DELETED
11330 WHERE line_detail_index = l_mark_prg_delete_index(i);
11331 END IF;
11332 END IF; --l_mark_prg_delete_index.COUNT
11333
11334 IF l_mark_fgdis_delete_index.COUNT > 0 THEN
11335
11336 IF l_debug = FND_API.G_TRUE THEN
11337 FOR i IN l_mark_fgdis_delete_index.FIRST..l_mark_fgdis_delete_index.LAST
11338 LOOP
11339 BEGIN
11340 SELECT created_from_list_line_id INTO l_prg_list_line_id
11341 FROM qp_npreq_ldets_tmp
11342 WHERE line_detail_index = l_mark_fgdis_delete_index(i);
11343 QP_PREQ_GRP.engine_debug('Mark delete fgdis '|| l_mark_fgdis_delete_index
11344 (i)
11345 ||' list_line_id '|| l_prg_list_line_id);
11346 EXCEPTION
11347 WHEN OTHERS THEN
11348 QP_PREQ_GRP.engine_debug('Mark delete fgdis list_line_id -1');
11349 END;
11350 END LOOP;
11351 END IF; --l_debug
11352 FORALL i IN l_mark_fgdis_delete_index.FIRST..l_mark_fgdis_delete_index.LAST
11353 UPDATE qp_npreq_ldets_tmp SET pricing_status_code = G_STATUS_DELETED
11354 WHERE line_detail_index = l_mark_fgdis_delete_index(i);
11355 END IF; --l_mark_fgdis_delete_index.count
11356 IF l_debug = FND_API.G_TRUE THEN
11357 QP_PREQ_GRP.engine_debug('End Update_prg_pricing_status');
11358 END IF;
11359 x_return_status := FND_API.G_RET_STS_SUCCESS;
11360 EXCEPTION
11361 WHEN OTHERS THEN
11362 x_return_status := FND_API.G_RET_STS_ERROR;
11363 x_return_status_text := 'Exception in '|| l_routine ||' '|| SQLERRM;
11364 IF l_debug = FND_API.G_TRUE THEN
11365 QP_PREQ_GRP.engine_debug('Exception in '|| l_routine ||' '|| SQLERRM);
11366 END IF;
11367 END Update_prg_pricing_status;
11368
11369 --This procedure processes the passed in freegood lines marked from the
11370 --previous procedure and tries to find matching newly created PRG modifiers
11371 --applied against the buy line
11372 --If there are no PRG modifiers applied, the passed in freegood line is
11373 --marked as deleted for the calling application to delete them
11374 --If there are matching PRG modifiers applied, then we compare the
11375 --passed in freegood lines against what the engine has newly created
11376 --If they do not match, the newly created lines are marked UPDATED
11377 --for the calling application to update
11378 --If they match, then we mark them as UNCHANGED prefixing OLD or NEW
11379 --to identify the old and new freegood line. This is to compare the
11380 --selling price later on, may be that could have changed
11381 PROCEDURE Process_PRG(x_return_status OUT NOCOPY VARCHAR2,
11382 x_return_status_text OUT NOCOPY VARCHAR2) IS
11383
11384 PRG_Exception EXCEPTION;
11385
11386 CURSOR l_compare_freegood_cur IS
11387 SELECT newfgline.line_index new_line_index,
11388 newfgline.line_quantity new_line_quantity,
11389 newfgline.line_uom_code new_line_uom_code,
11390 newfgline.priced_quantity new_priced_quantity,
11391 newfgline.priced_uom_code new_priced_uom_code,
11392 newfgitem.value_from new_item,
11393 newfgline.UOM_QUANTITY new_UOM_QUANTITY,
11394 newfgline.CURRENCY_CODE new_CURRENCY_CODE,
11395 newfgline.UNIT_PRICE new_UNIT_PRICE,
11396 newfgline.PERCENT_PRICE new_PERCENT_PRICE,
11397 newfgline.ADJUSTED_UNIT_PRICE new_ADJUSTED_UNIT_PRICE,
11398 newfgline.PARENT_PRICE new_PARENT_PRICE,
11399 newfgline.PARENT_QUANTITY new_PARENT_QUANTITY,
11400 newfgline.PARENT_UOM_CODE new_PARENT_UOM_CODE,
11401 newfgline.PROCESSING_ORDER new_PROCESSING_ORDER,
11402 newfgline.PROCESSED_FLAG new_PROCESSED_FLAG,
11403 newfgline.PROCESSED_CODE new_PROCESSED_CODE,
11404 newfgline.PRICE_FLAG new_PRICE_FLAG,
11405 newfgline.PRICING_STATUS_CODE new_PRICING_STATUS_CODE,
11406 newfgline.PRICING_STATUS_TEXT new_PRICING_STATUS_TEXT,
11407 newfgline.START_DATE_ACTIVE_FIRST new_START_DATE_ACTIVE_FIRST,
11408 newfgline.ACTIVE_DATE_FIRST_TYPE new_ACTIVE_DATE_FIRST_TYPE,
11409 newfgline.START_DATE_ACTIVE_SECOND new_START_DATE_ACTIVE_SECOND,
11410 newfgline.ACTIVE_DATE_SECOND_TYPE new_ACTIVE_DATE_SECOND_TYPE,
11411 newfgline.GROUP_QUANTITY new_GROUP_QUANTITY,
11412 newfgline.GROUP_AMOUNT new_GROUP_AMOUNT,
11413 newfgline.LINE_AMOUNT new_LINE_AMOUNT,
11414 newfgline.ROUNDING_FLAG new_ROUNDING_FLAG,
11415 newfgline.ROUNDING_FACTOR new_ROUNDING_FACTOR,
11416 newfgline.UPDATED_ADJUSTED_UNIT_PRICE new_upd_ADJUSTED_UNIT_PRICE,
11417 newfgline.PRICE_REQUEST_CODE new_PRICE_REQUEST_CODE,
11418 newfgline.HOLD_CODE new_HOLD_CODE,
11419 newfgline.HOLD_TEXT new_HOLD_TEXT,
11420 newfgline.PRICE_LIST_HEADER_ID new_PRICE_LIST_HEADER_ID,
11421 newfgline.VALIDATED_FLAG new_VALIDATED_FLAG,
11422 newfgline.QUALIFIERS_EXIST_FLAG new_QUALIFIERS_EXIST_FLAG,
11423 newfgline.PRICING_ATTRS_EXIST_FLAG new_PRICING_ATTRS_EXIST_FLAG,
11424 newfgline.PRIMARY_QUALIFIERS_MATCH_FLAG new_PRIMARY_QUAL_MATCH_FLAG,
11425 newfgline.USAGE_PRICING_TYPE new_USAGE_PRICING_TYPE,
11426 newfgline.LINE_CATEGORY new_LINE_CATEGORY,
11427 newfgline.CONTRACT_START_DATE new_CONTRACT_START_DATE,
11428 newfgline.CONTRACT_END_DATE new_CONTRACT_END_DATE,
11429 newfgline.LINE_UNIT_PRICE new_LINE_UNIT_PRICE,
11430 newfgline.SERVICE_DURATION new_SERVICE_DURATION, -- service project
11431 newfgline.SERVICE_PERIOD new_SERVICE_PERIOD, -- service project
11432 oldfreeline.line_index old_line_index,
11433 oldfreeline.line_id old_line_id,
11434 oldfreeline.line_quantity old_line_quantity,
11435 oldfreeline.line_uom_code old_line_uom_code,
11436 oldfreeline.priced_quantity old_priced_quantity,
11437 oldfreeline.priced_uom_code old_priced_uom_code,
11438 oldfreeitem.value_from old_item,
11439 oldfreeline.UOM_QUANTITY old_UOM_QUANTITY,
11440 oldfreeline.CURRENCY_CODE old_CURRENCY_CODE,
11441 oldfreeline.UNIT_PRICE old_UNIT_PRICE,
11442 oldfreeline.PERCENT_PRICE old_PERCENT_PRICE,
11443 oldfreeline.ADJUSTED_UNIT_PRICE old_ADJUSTED_UNIT_PRICE,
11444 oldfreeline.PARENT_PRICE old_PARENT_PRICE,
11445 oldfreeline.PARENT_QUANTITY old_PARENT_QUANTITY,
11446 oldfreeline.PARENT_UOM_CODE old_PARENT_UOM_CODE,
11447 oldfreeline.PROCESSING_ORDER old_PROCESSING_ORDER,
11448 oldfreeline.PROCESSED_FLAG old_PROCESSED_FLAG,
11449 oldfreeline.PROCESSED_CODE old_PROCESSED_CODE,
11450 oldfreeline.PRICE_FLAG old_PRICE_FLAG,
11451 oldfreeline.PRICING_STATUS_CODE old_PRICING_STATUS_CODE,
11452 oldfreeline.PRICING_STATUS_TEXT old_PRICING_STATUS_TEXT,
11453 oldfreeline.START_DATE_ACTIVE_FIRST old_START_DATE_ACTIVE_FIRST,
11454 oldfreeline.ACTIVE_DATE_FIRST_TYPE old_ACTIVE_DATE_FIRST_TYPE,
11455 oldfreeline.START_DATE_ACTIVE_SECOND old_START_DATE_ACTIVE_SECOND,
11456 oldfreeline.ACTIVE_DATE_SECOND_TYPE old_ACTIVE_DATE_SECOND_TYPE,
11457 oldfreeline.GROUP_QUANTITY old_GROUP_QUANTITY,
11458 oldfreeline.GROUP_AMOUNT old_GROUP_AMOUNT,
11459 oldfreeline.LINE_AMOUNT old_LINE_AMOUNT,
11460 oldfreeline.ROUNDING_FLAG old_ROUNDING_FLAG,
11461 oldfreeline.ROUNDING_FACTOR old_ROUNDING_FACTOR,
11462 oldfreeline.UPDATED_ADJUSTED_UNIT_PRICE
11463 old_upd_ADJUSTED_UNIT_PRICE,
11464 oldfreeline.PRICE_REQUEST_CODE old_PRICE_REQUEST_CODE,
11465 oldfreeline.HOLD_CODE old_HOLD_CODE,
11466 oldfreeline.HOLD_TEXT old_HOLD_TEXT,
11467 oldfreeline.PRICE_LIST_HEADER_ID old_PRICE_LIST_HEADER_ID,
11468 oldfreeline.VALIDATED_FLAG old_VALIDATED_FLAG,
11469 oldfreeline.QUALIFIERS_EXIST_FLAG old_QUALIFIERS_EXIST_FLAG,
11470 oldfreeline.PRICING_ATTRS_EXIST_FLAG old_PRICING_ATTRS_EXIST_FLAG,
11471 oldfreeline.PRIMARY_QUALIFIERS_MATCH_FLAG
11472 old_PRIMARY_QUAL_MATCH_FLAG,
11473 oldfreeline.USAGE_PRICING_TYPE old_USAGE_PRICING_TYPE,
11474 oldfreeline.LINE_CATEGORY old_LINE_CATEGORY,
11475 oldfreeline.CONTRACT_START_DATE old_CONTRACT_START_DATE,
11476 oldfreeline.CONTRACT_END_DATE old_CONTRACT_END_DATE,
11477 oldfreeline.LINE_UNIT_PRICE old_LINE_UNIT_PRICE,
11478 oldfreeline.process_status old_list_line_id,
11479 newfgdis.created_from_list_line_id newfgdis_list_line_id,
11480 newfgdis.operand_value || newfgdis.operand_calculation_code newfgdis_operand,
11481 oldfreeline.SERVICE_DURATION old_SERVICE_DURATION, -- service project
11482 oldfreeline.SERVICE_PERIOD old_SERVICE_PERIOD -- service project
11483 FROM qp_npreq_lines_tmp oldfreeline
11484 , qp_npreq_rltd_lines_tmp newrltd
11485 , qp_npreq_ldets_tmp newfgdis
11486 , qp_npreq_lines_tmp newfgline
11487 , qp_npreq_line_attrs_tmp oldfreeitem
11488 , qp_npreq_line_attrs_tmp newfgitem
11489 --where G_REQUEST_TYPE_CODE = 'ONT'
11490 --bug 3085453 handle pricing availability UI
11491 -- they pass reqtype ONT and insert adj into ldets
11492 WHERE QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = G_YES
11493 AND instr(oldfreeline.process_status, G_FREEGOOD) > 0
11494 AND newrltd.pricing_status_code = G_STATUS_NEW
11495 AND instr(oldfreeline.process_status
11496 , G_BUYLINE || newrltd.line_index || G_PROMO_GOODS_DISCOUNT) > 0
11497 AND newfgdis.pricing_status_code = G_STATUS_NEW
11498 AND newfgdis.applied_flag = G_YES
11499 AND instr(oldfreeline.process_status
11500 , G_FREEGOOD || newfgdis.created_from_list_line_id || G_BUYLINE) > 0
11501 AND newfgdis.line_detail_index = newrltd.related_line_detail_index
11502 AND newfgline.line_index = newfgdis.line_index
11503 AND oldfreeitem.line_index = oldfreeline.line_index
11504 AND oldfreeitem.line_detail_index IS NULL
11505 AND oldfreeitem.context = G_ITEM_CONTEXT
11506 AND oldfreeitem.attribute = G_PRIC_ATTRIBUTE1
11507 AND newfgitem.line_index = newfgline.line_index
11508 AND newfgitem.context = G_ITEM_CONTEXT
11509 AND newfgitem.attribute = G_PRIC_ATTRIBUTE1
11510 UNION
11511 SELECT newfgline.line_index new_line_index,
11512 newfgline.line_quantity new_line_quantity,
11513 newfgline.line_uom_code new_line_uom_code,
11514 newfgline.priced_quantity new_priced_quantity,
11515 newfgline.priced_uom_code new_priced_uom_code,
11516 newfgitem.value_from new_item,
11517 newfgline.UOM_QUANTITY new_UOM_QUANTITY,
11518 newfgline.CURRENCY_CODE new_CURRENCY_CODE,
11519 newfgline.UNIT_PRICE new_UNIT_PRICE,
11520 newfgline.PERCENT_PRICE new_PERCENT_PRICE,
11521 newfgline.ADJUSTED_UNIT_PRICE new_ADJUSTED_UNIT_PRICE,
11522 newfgline.PARENT_PRICE new_PARENT_PRICE,
11523 newfgline.PARENT_QUANTITY new_PARENT_QUANTITY,
11524 newfgline.PARENT_UOM_CODE new_PARENT_UOM_CODE,
11525 newfgline.PROCESSING_ORDER new_PROCESSING_ORDER,
11526 newfgline.PROCESSED_FLAG new_PROCESSED_FLAG,
11527 newfgline.PROCESSED_CODE new_PROCESSED_CODE,
11528 newfgline.PRICE_FLAG new_PRICE_FLAG,
11529 newfgline.PRICING_STATUS_CODE new_PRICING_STATUS_CODE,
11530 newfgline.PRICING_STATUS_TEXT new_PRICING_STATUS_TEXT,
11531 newfgline.START_DATE_ACTIVE_FIRST new_START_DATE_ACTIVE_FIRST,
11532 newfgline.ACTIVE_DATE_FIRST_TYPE new_ACTIVE_DATE_FIRST_TYPE,
11533 newfgline.START_DATE_ACTIVE_SECOND new_START_DATE_ACTIVE_SECOND,
11534 newfgline.ACTIVE_DATE_SECOND_TYPE new_ACTIVE_DATE_SECOND_TYPE,
11535 newfgline.GROUP_QUANTITY new_GROUP_QUANTITY,
11536 newfgline.GROUP_AMOUNT new_GROUP_AMOUNT,
11537 newfgline.LINE_AMOUNT new_LINE_AMOUNT,
11538 newfgline.ROUNDING_FLAG new_ROUNDING_FLAG,
11539 newfgline.ROUNDING_FACTOR new_ROUNDING_FACTOR,
11540 newfgline.UPDATED_ADJUSTED_UNIT_PRICE new_upd_ADJUSTED_UNIT_PRICE,
11541 newfgline.PRICE_REQUEST_CODE new_PRICE_REQUEST_CODE,
11542 newfgline.HOLD_CODE new_HOLD_CODE,
11543 newfgline.HOLD_TEXT new_HOLD_TEXT,
11544 newfgline.PRICE_LIST_HEADER_ID new_PRICE_LIST_HEADER_ID,
11545 newfgline.VALIDATED_FLAG new_VALIDATED_FLAG,
11546 newfgline.QUALIFIERS_EXIST_FLAG new_QUALIFIERS_EXIST_FLAG,
11547 newfgline.PRICING_ATTRS_EXIST_FLAG new_PRICING_ATTRS_EXIST_FLAG,
11548 newfgline.PRIMARY_QUALIFIERS_MATCH_FLAG new_PRIMARY_QUAL_MATCH_FLAG,
11549 newfgline.USAGE_PRICING_TYPE new_USAGE_PRICING_TYPE,
11550 newfgline.LINE_CATEGORY new_LINE_CATEGORY,
11551 newfgline.CONTRACT_START_DATE new_CONTRACT_START_DATE,
11552 newfgline.CONTRACT_END_DATE new_CONTRACT_END_DATE,
11553 newfgline.LINE_UNIT_PRICE new_LINE_UNIT_PRICE,
11554 newfgline.SERVICE_DURATION new_SERVICE_DURATION, -- service project
11555 newfgline.SERVICE_PERIOD new_SERVICE_PERIOD, -- service project
11556 oldfreeline.line_index old_line_index,
11557 oldfreeline.line_id old_line_id,
11558 oldfreeline.line_quantity old_line_quantity,
11559 oldfreeline.line_uom_code old_line_uom_code,
11560 oldfreeline.priced_quantity old_priced_quantity,
11561 oldfreeline.priced_uom_code old_priced_uom_code,
11562 oldfreeitem.value_from old_item,
11563 oldfreeline.UOM_QUANTITY old_UOM_QUANTITY,
11564 oldfreeline.CURRENCY_CODE old_CURRENCY_CODE,
11565 oldfreeline.UNIT_PRICE old_UNIT_PRICE,
11566 oldfreeline.PERCENT_PRICE old_PERCENT_PRICE,
11567 oldfreeline.ADJUSTED_UNIT_PRICE old_ADJUSTED_UNIT_PRICE,
11568 oldfreeline.PARENT_PRICE old_PARENT_PRICE,
11569 oldfreeline.PARENT_QUANTITY old_PARENT_QUANTITY,
11570 oldfreeline.PARENT_UOM_CODE old_PARENT_UOM_CODE,
11571 oldfreeline.PROCESSING_ORDER old_PROCESSING_ORDER,
11572 oldfreeline.PROCESSED_FLAG old_PROCESSED_FLAG,
11573 oldfreeline.PROCESSED_CODE old_PROCESSED_CODE,
11574 oldfreeline.PRICE_FLAG old_PRICE_FLAG,
11575 oldfreeline.PRICING_STATUS_CODE old_PRICING_STATUS_CODE,
11576 oldfreeline.PRICING_STATUS_TEXT old_PRICING_STATUS_TEXT,
11577 oldfreeline.START_DATE_ACTIVE_FIRST old_START_DATE_ACTIVE_FIRST,
11578 oldfreeline.ACTIVE_DATE_FIRST_TYPE old_ACTIVE_DATE_FIRST_TYPE,
11579 oldfreeline.START_DATE_ACTIVE_SECOND old_START_DATE_ACTIVE_SECOND,
11580 oldfreeline.ACTIVE_DATE_SECOND_TYPE old_ACTIVE_DATE_SECOND_TYPE,
11581 oldfreeline.GROUP_QUANTITY old_GROUP_QUANTITY,
11582 oldfreeline.GROUP_AMOUNT old_GROUP_AMOUNT,
11583 oldfreeline.LINE_AMOUNT old_LINE_AMOUNT,
11584 oldfreeline.ROUNDING_FLAG old_ROUNDING_FLAG,
11585 oldfreeline.ROUNDING_FACTOR old_ROUNDING_FACTOR,
11586 oldfreeline.UPDATED_ADJUSTED_UNIT_PRICE
11587 old_upd_ADJUSTED_UNIT_PRICE,
11588 oldfreeline.PRICE_REQUEST_CODE old_PRICE_REQUEST_CODE,
11589 oldfreeline.HOLD_CODE old_HOLD_CODE,
11590 oldfreeline.HOLD_TEXT old_HOLD_TEXT,
11591 oldfreeline.PRICE_LIST_HEADER_ID old_PRICE_LIST_HEADER_ID,
11592 oldfreeline.VALIDATED_FLAG old_VALIDATED_FLAG,
11593 oldfreeline.QUALIFIERS_EXIST_FLAG old_QUALIFIERS_EXIST_FLAG,
11594 oldfreeline.PRICING_ATTRS_EXIST_FLAG old_PRICING_ATTRS_EXIST_FLAG,
11595 oldfreeline.PRIMARY_QUALIFIERS_MATCH_FLAG
11596 old_PRIMARY_QUAL_MATCH_FLAG,
11597 oldfreeline.USAGE_PRICING_TYPE old_USAGE_PRICING_TYPE,
11598 oldfreeline.LINE_CATEGORY old_LINE_CATEGORY,
11599 oldfreeline.CONTRACT_START_DATE old_CONTRACT_START_DATE,
11600 oldfreeline.CONTRACT_END_DATE old_CONTRACT_END_DATE,
11601 oldfreeline.LINE_UNIT_PRICE old_LINE_UNIT_PRICE,
11602 oldfreeline.process_status old_list_line_id,
11603 newfgdis.created_from_list_line_id newfgdis_list_line_id,
11604 newfgdis.operand_value || newfgdis.operand_calculation_code newfgdis_operand,
11605 oldfreeline.SERVICE_DURATION old_SERVICE_DURATION, -- service project
11606 oldfreeline.SERVICE_PERIOD old_SERVICE_PERIOD -- service project
11607 FROM qp_npreq_lines_tmp oldfreeline
11608 , qp_npreq_rltd_lines_tmp newrltd
11609 , qp_npreq_ldets_tmp newfgdis
11610 , qp_npreq_lines_tmp newfgline
11611 , qp_npreq_line_attrs_tmp newfgitem
11612 , qp_npreq_line_attrs_tmp oldfreeitem
11613 --WHERE G_REQUEST_TYPE_CODE <> 'ONT'
11614 --bug 3085453 handle pricing availability UI
11615 -- they pass reqtype ONT and insert adj into ldets
11616 WHERE QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG <> G_YES
11617 AND instr(oldfreeline.process_status, G_FREEGOOD) > 0
11618 AND newfgdis.pricing_status_code = G_STATUS_NEW
11619 AND newfgdis.applied_flag = G_YES
11620 AND instr(oldfreeline.process_status, G_FREEGOOD || newfgdis.created_from_list_line_id || G_BUYLINE) > 0
11621 AND newrltd.pricing_status_code = G_STATUS_NEW
11622 AND newrltd.related_line_index = newfgdis.line_index -- 2970380
11623 AND newrltd.related_line_detail_index = newfgdis.line_detail_index -- 2970380
11624 AND instr(oldfreeline.process_status
11625 , G_BUYLINE || newrltd.line_index || G_PROMO_GOODS_DISCOUNT) > 0
11626 AND newfgline.line_index = newfgdis.line_index
11627 AND newfgline.line_index = newrltd.related_line_index -- 2970380
11628 AND newfgitem.line_detail_index = newfgdis.line_detail_index
11629 AND newfgitem.context = G_ITEM_CONTEXT
11630 AND newfgitem.attribute = G_PRIC_ATTRIBUTE1
11631 AND oldfreeitem.line_index = oldfreeline.line_index
11632 AND oldfreeitem.line_detail_index IS NULL
11633 AND oldfreeitem.context = G_ITEM_CONTEXT
11634 AND oldfreeitem.attribute = G_PRIC_ATTRIBUTE1;
11635
11636 CURSOR l_updated_prg_fg_cur IS
11637 SELECT /*+ INDEX(prg OE_PRICE_ADJUSTMENTS_N2) */ rltd.related_line_index
11638 FROM qp_npreq_lines_tmp buyline, oe_price_adjustments prg,
11639 qp_npreq_ldets_tmp ldet, qp_npreq_rltd_lines_tmp rltd
11640 --WHERE G_REQUEST_TYPE_CODE = 'ONT'
11641 --bug 3085453 handle pricing availability UI
11642 -- they pass reqtype ONT and insert adj into ldets
11643 WHERE QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = G_YES
11644 AND buyline.line_type_code = G_LINE_LEVEL
11645 AND prg.line_id = buyline.line_id
11646 AND prg.list_line_type_code = G_PROMO_GOODS_DISCOUNT
11647 AND prg.updated_flag = G_YES
11648 AND ldet.line_index = buyline.line_index
11649 AND ldet.pricing_status_code = G_STATUS_NEW
11650 AND ldet.created_from_list_line_id = prg.list_line_id
11651 AND ldet.applied_flag = G_YES
11652 AND rltd.line_index = ldet.line_index
11653 AND rltd.line_detail_index = ldet.line_detail_index
11654 AND rltd.pricing_status_code = G_STATUS_NEW
11655 UNION
11656 SELECT /*+ INDEX(prg OE_PRICE_ADJUSTMENTS_N1) */ rltd.related_line_index
11657 FROM qp_npreq_lines_tmp buyline, oe_price_adjustments prg,
11658 qp_npreq_ldets_tmp ldet, qp_npreq_rltd_lines_tmp rltd
11659 --WHERE G_REQUEST_TYPE_CODE = 'ONT'
11660 --bug 3085453 handle pricing availability UI
11661 -- they pass reqtype ONT and insert adj into ldets
11662 WHERE QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = G_YES
11663 AND buyline.line_type_code = G_ORDER_LEVEL
11664 AND prg.line_id IS NULL
11665 AND prg.header_id = buyline.line_id
11666 AND prg.list_line_type_code = G_PROMO_GOODS_DISCOUNT
11667 AND prg.updated_flag = G_YES
11668 AND ldet.line_index = buyline.line_index
11669 AND ldet.pricing_status_code = G_STATUS_NEW
11670 AND ldet.created_from_list_line_id = prg.list_line_id
11671 AND ldet.applied_flag = G_YES
11672 AND rltd.line_index = ldet.line_index
11673 AND rltd.line_detail_index = ldet.line_detail_index
11674 AND rltd.pricing_status_code = G_STATUS_NEW
11675 UNION
11676 -- hint added for 5575718
11677 SELECT /*+ ORDERED */ rltd.related_line_index
11678 FROM qp_npreq_lines_tmp buyline, qp_npreq_ldets_tmp prg,
11679 qp_npreq_ldets_tmp ldet, qp_npreq_rltd_lines_tmp rltd
11680 --WHERE G_REQUEST_TYPE_CODE <> 'ONT'
11681 --bug 3085453 handle pricing availability UI
11682 -- they pass reqtype ONT and insert adj into ldets
11683 WHERE QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG <> G_YES
11684 AND prg.line_index = buyline.line_index
11685 AND prg.pricing_status_code = G_STATUS_UNCHANGED
11686 AND prg.created_from_list_line_type = G_PROMO_GOODS_DISCOUNT
11687 AND prg.updated_flag = G_YES
11688 AND ldet.line_index = buyline.line_index
11689 AND ldet.pricing_status_code = G_STATUS_NEW
11690 AND ldet.created_from_list_line_id = prg.created_from_list_line_id
11691 AND ldet.applied_flag = G_YES
11692 AND rltd.line_index = ldet.line_index
11693 AND rltd.line_detail_index = ldet.line_detail_index
11694 AND rltd.pricing_status_code = G_STATUS_NEW;
11695
11696 l_prg_line_ind_tbl QP_PREQ_GRP.NUMBER_TYPE;
11697 l_prg_process_sts_tbl QP_PREQ_GRP.VARCHAR_TYPE;
11698 l_prg_line_id_tbl QP_PREQ_GRP.NUMBER_TYPE;
11699 l_prg_price_flag_tbl QP_PREQ_GRP.VARCHAR_TYPE; -- Ravi
11700
11701 l_upd_engine_fg_index QP_PREQ_GRP.NUMBER_TYPE;
11702
11703 l_Process_PRG VARCHAR2(1) := G_NO;
11704 l_routine VARCHAR2(100) := 'QP_PREQ_PUB.Process_PRG ';
11705 l_oldfgdis_list_line_id VARCHAR2(2000);
11706 l_old_operand VARCHAR2(240);
11707
11708 i PLS_INTEGER;
11709 BEGIN
11710 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
11711 IF l_debug = FND_API.G_TRUE THEN
11712 QP_PREQ_GRP.engine_debug('Begin process_prg');
11713 QP_PREQ_GRP.engine_debug('Process_prg req_type '|| G_REQUEST_TYPE_CODE);
11714
11715 END IF;
11716 --initialize pl/sql tables
11717 l_prg_line_ind_tbl.DELETE;
11718 l_prg_process_sts_tbl.DELETE;
11719 l_prg_line_id_tbl.DELETE;
11720 l_prg_price_flag_tbl.DELETE;
11721
11722 --initialize global pl/sql tables
11723 G_prg_unch_calc_price_tbl.DELETE;
11724 G_prg_unch_line_id_tbl.DELETE;
11725 G_prg_unch_line_ind_tbl.DELETE;
11726 G_prg_unch_new_index_tbl.DELETE;
11727 G_prg_unch_line_index_tbl.DELETE;
11728 G_prg_unch_process_sts_tbl.DELETE;
11729
11730 BEGIN
11731 SELECT 'Y' INTO l_Process_PRG
11732 FROM qp_npreq_ldets_tmp
11733 WHERE created_from_list_line_type = G_PROMO_GOODS_DISCOUNT
11734 AND pricing_status_code = G_STATUS_NEW
11735 AND applied_flag = 'Y'
11736 AND ROWNUM = 1;
11737 EXCEPTION
11738 WHEN NO_DATA_FOUND THEN
11739 IF l_debug = FND_API.G_TRUE THEN
11740 QP_PREQ_GRP.engine_debug('No PRG: ');
11741 END IF;
11742 l_Process_PRG := G_NO;
11743 WHEN OTHERS THEN
11744 IF l_debug = FND_API.G_TRUE THEN
11745 QP_PREQ_GRP.engine_debug('Error in PRG: '|| SQLERRM);
11746 END IF;
11747 --x_return_status := FND_API.G_RET_STS_ERROR;
11748 --x_return_status_text := l_routine||SQLERRM;
11749 RAISE PRG_Exception;
11750 END;
11751
11752 IF l_debug = FND_API.G_TRUE THEN
11753 QP_PREQ_GRP.engine_debug('Value of process_PRG '|| l_Process_PRG);
11754
11755
11756 END IF;
11757 IF l_Process_PRG = G_NO
11758 THEN
11759 BEGIN
11760 SELECT 'Y' INTO l_Process_PRG
11761 FROM qp_npreq_lines_tmp line
11762 WHERE line.pricing_status_code IN (G_STATUS_UNCHANGED,
11763 G_STATUS_UPDATED, G_STATUS_NEW, G_STATUS_GSA_VIOLATION, G_STATUS_INVALID_PRICE_LIST)
11764 AND instr(line.process_status, G_FREEGOOD) > 0
11765 AND ROWNUM = 1;
11766
11767 IF l_debug = FND_API.G_TRUE THEN
11768 QP_PREQ_GRP.engine_debug('Value of process_PRG after fg '|| l_Process_PRG);
11769 END IF; --l_debug
11770
11771 IF l_Process_PRG = G_NO THEN
11772 SELECT 'Y' INTO l_Process_PRG
11773 FROM qp_npreq_lines_tmp line
11774 WHERE line.pricing_status_code IN (G_STATUS_UNCHANGED,
11775 G_STATUS_UPDATED, G_STATUS_NEW, G_STATUS_GSA_VIOLATION)
11776 AND EXISTS
11777 (SELECT 'Y' FROM oe_price_adjustments adj
11778 WHERE line.line_type_code = G_LINE_LEVEL
11779 AND adj.line_id = line.line_id
11780 AND adj.list_line_type_code = G_PROMO_GOODS_DISCOUNT
11781 AND adj.updated_flag = G_YES
11782 UNION
11783 SELECT 'Y' FROM oe_price_adjustments adj
11784 WHERE line.line_type_code = G_ORDER_LEVEL
11785 AND adj.header_id = line.line_id
11786 AND adj.line_id IS NULL
11787 AND adj.list_line_type_code = G_PROMO_GOODS_DISCOUNT
11788 AND adj.updated_flag = G_YES
11789 UNION
11790 SELECT 'Y' FROM qp_npreq_ldets_tmp adj
11791 WHERE adj.created_from_list_line_type = G_PROMO_GOODS_DISCOUNT
11792 AND adj.pricing_status_code = G_STATUS_UNCHANGED
11793 AND adj.updated_flag = G_YES);
11794 END IF; --l_PROCESS_PRG
11795 IF l_debug = FND_API.G_TRUE THEN
11796 QP_PREQ_GRP.engine_debug('Value of process_PRG after over '|| l_Process_PRG);
11797 END IF; --Bug No - 4033618
11798 EXCEPTION
11799 WHEN NO_DATA_FOUND THEN
11800 l_Process_PRG := G_NO;
11801 IF l_debug = FND_API.G_TRUE THEN
11802 QP_PREQ_GRP.engine_debug('No PRG in oe_price_adj');
11803 END IF;
11804 WHEN OTHERS THEN
11805 l_Process_PRG := G_NO;
11806 IF l_debug = FND_API.G_TRUE THEN
11807 QP_PREQ_GRP.engine_debug('Exception in prg '|| SQLERRM);
11808 END IF;
11809 END;
11810 END IF; --l_Process_PRG
11811
11812 IF l_debug = FND_API.G_TRUE THEN
11813 QP_PREQ_GRP.engine_debug('Value of process_PRG after query '|| l_Process_PRG);
11814
11815 END IF;
11816
11817 IF l_debug = FND_API.G_TRUE THEN
11818 FOR cl IN
11819 (SELECT adj.list_line_id, adj.updated_flag, line.line_index, --removed index oe_price_adjustments_n1 smbalara 14393164
11820 adj.pricing_phase_id, adj.price_adjustment_id, adj.line_id
11821 FROM qp_npreq_lines_tmp line, oe_price_adjustments adj
11822 WHERE line.line_type_code = G_LINE_LEVEL
11823 AND adj.line_id = line.line_id
11824 AND adj.list_line_type_code = G_PROMO_GOODS_DISCOUNT
11825 UNION
11826 SELECT adj.list_line_id, adj.updated_flag, line.line_index,
11827 adj.pricing_phase_id, adj.price_adjustment_id, adj.line_id
11828 FROM qp_npreq_lines_tmp line, oe_price_adjustments adj
11829 WHERE line.line_type_code = G_ORDER_LEVEL
11830 AND adj.header_id = line.line_id
11831 AND adj.line_id IS NULL
11832 AND adj.list_line_type_code = G_PROMO_GOODS_DISCOUNT)
11833 LOOP
11834 QP_PREQ_GRP.engine_debug('PRGs check whether update_flag: '
11835 ||'prg listlineid '|| cl.list_line_id ||' updatedflag '|| cl.updated_flag
11836 ||' buylineid '|| cl.line_id ||' prgphaseid '|| cl.pricing_phase_id);
11837 FOR fg IN
11838 (SELECT rltd.related_line_index, ldet.created_from_list_line_id
11839 FROM qp_npreq_ldets_tmp ldet, qp_npreq_rltd_lines_tmp rltd
11840 WHERE ldet.line_index = cl.line_index
11841 AND ldet.pricing_status_code = G_STATUS_NEW
11842 AND ldet.applied_flag = G_YES
11843 AND ldet.created_from_list_line_id = cl.list_line_id
11844 AND rltd.line_index = ldet.line_index
11845 AND rltd.line_detail_index = ldet.line_detail_index)
11846 LOOP
11847 QP_PREQ_GRP.engine_debug('PRGs check whether engine_prg: '
11848 ||'engine prg listlineid '|| fg.created_from_list_line_id
11849 ||' fg line_index '|| fg.related_line_index);
11850 END LOOP; --fgline
11851 END LOOP; --cl
11852
11853 END IF; --l_debug
11854
11855
11856 --need to mark the freegood lines if the PRG has been overridden
11857 --this means that one or more freegood lines have been deleted by the
11858 --calling application in which case all the adjustments and relationships
11859 --on the deleted freegood line have been deleted and the PRG adjustment
11860 --is marked with updated_flag = 'Y'
11861 --if there are such PRG adjustments overridden, then the freegood lines
11862 --created by the pricing engine need to be ignored and marked as
11863 --process_status = G_NOT_VALID and the freegood lines not deleted
11864 --need to be marked as process_status = G_STATUS_UNCHANGED. If there
11865 --are any changes to the setup, say the quantity on the remaining freegood
11866 --line has been increased, that will not apply to the freegood line that
11867 --has not been deleted as the PRG has been overridden
11868 --pricing_status_code needs to be set to G_NOT_VALID so that this does not get into OM's
11869 --update statement to update lines with UPDATE status
11870
11871 IF l_debug = FND_API.G_TRUE THEN
11872 QP_PREQ_GRP.engine_debug('Updated PRGs No. of passed-in fg lines updated '
11873 || SQL%ROWCOUNT);
11874 END IF; --l_debug
11875
11876 OPEN l_updated_prg_fg_cur;
11877 l_upd_engine_fg_index.DELETE;
11878 FETCH l_updated_prg_fg_cur
11879 BULK COLLECT INTO
11880 l_upd_engine_fg_index; --, l_upd_passedin_fg_index;
11881 CLOSE l_updated_prg_fg_cur;
11882
11883 IF l_debug = FND_API.G_TRUE THEN
11884 -- QP_PREQ_GRP.engine_debug('Count. of passed-in fg lines '
11885 -- ||l_upd_passedin_fg_index.count);
11886 QP_PREQ_GRP.engine_debug('Count. of engine-created fg lines '
11887 || l_upd_engine_fg_index.COUNT);
11888 END IF;
11889
11890
11891 IF l_upd_engine_fg_index.COUNT > 0 THEN
11892 --update the engine inserted fg line to G_NOT_VALID
11893 FORALL i IN l_upd_engine_fg_index.FIRST..l_upd_engine_fg_index.LAST
11894 UPDATE qp_npreq_lines_tmp SET
11895 pricing_status_code = G_NOT_VALID, process_status = G_NOT_VALID
11896 WHERE line_index = l_upd_engine_fg_index(i);
11897
11898
11899 --the following update will mark the overridden PRG's passed in
11900 --freegood lines as process_status = G_STATUS_UNCHANGED
11901 UPDATE qp_npreq_lines_tmp oldfg SET process_status = G_STATUS_UNCHANGED
11902 --fix for bug 2691794
11903 , processed_flag = G_FREEGOOD_LINE
11904 WHERE oldfg.pricing_status_code IN (G_STATUS_UPDATED, G_STATUS_UNCHANGED)
11905 AND instr(oldfg.process_status, G_PROMO_GOODS_DISCOUNT || G_YES || G_STATUS_UPDATED) > 0;
11906
11907
11908 END IF; --l_upd_engine_fg_index
11909
11910
11911 IF l_Process_PRG = G_YES
11912 THEN
11913 --only if there are prg based modifiers
11914 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
11915 AND l_debug = FND_API.G_TRUE
11916 THEN
11917 FOR cl IN (SELECT newprg.line_index line_ind
11918 , newprg.created_from_list_line_id
11919 FROM qp_npreq_lines_tmp oldfgline
11920 , qp_npreq_ldets_tmp newprg
11921 WHERE --ldet.line_index = oldfgline.line_index
11922 instr(oldfgline.process_status
11923 , G_BUYLINE || newprg.line_index || G_PROMO_GOODS_DISCOUNT) > 0
11924 AND newprg.applied_flag = G_YES
11925 AND newprg.pricing_status_code = G_STATUS_NEW
11926 AND instr(oldfgline.process_status
11927 , G_PROMO_GOODS_DISCOUNT || newprg.created_from_list_line_id || G_PROMO_GOODS_DISCOUNT) > 0)
11928 LOOP
11929 IF l_debug = FND_API.G_TRUE THEN
11930 QP_PREQ_GRP.engine_debug('prg fgline: ind '|| cl.line_ind
11931 ||' prg '|| cl.created_from_list_line_id);
11932 END IF;
11933 END LOOP; --for cl
11934 END IF; --QP_PREQ_GRP.G_DEBUG_ENGINE
11935
11936 --the following update will update the process_status on freegood lines
11937 --identified from the previous identify_freegood_lines procedure
11938 --to G_STATUS_DELETED if the pricing engine has not created matching
11939 --PRG modifiers against its buy line
11940 UPDATE qp_npreq_lines_tmp oldfgline
11941 SET oldfgline.process_status = G_STATUS_DELETED
11942 WHERE NOT EXISTS (SELECT newprg.line_index
11943 FROM qp_npreq_ldets_tmp newprg
11944 --, qp_npreq_line_attrs_tmp newfgitem <-- commented out, sql repos
11945 WHERE --G_REQUEST_TYPE_CODE = 'ONT'
11946 newprg.pricing_status_code = G_STATUS_NEW
11947 AND newprg.applied_flag = G_YES
11948 AND instr(oldfgline.process_status
11949 , G_BUYLINE || newprg.line_index || G_PROMO_GOODS_DISCOUNT) > 0
11950 AND newprg.created_from_list_line_type = G_PROMO_GOODS_DISCOUNT
11951 AND instr(oldfgline.process_status
11952 , G_PROMO_GOODS_DISCOUNT || newprg.created_from_list_line_id || G_PROMO_GOODS_DISCOUNT) > 0)
11953 AND instr(oldfgline.process_status, G_FREEGOOD) > 0;
11954
11955 IF l_debug = FND_API.G_TRUE THEN
11956 QP_PREQ_GRP.engine_debug('updated delete prg lines rowcnt: '|| SQL%ROWCOUNT);
11957
11958 END IF;
11959 FOR freegood IN l_compare_freegood_cur
11960 LOOP
11961 IF l_debug = FND_API.G_TRUE THEN
11962 QP_PREQ_GRP.engine_debug('In compare_cur '
11963 ||' new_priced_qty '|| freegood.new_priced_quantity
11964 ||' old_priced_qty '|| freegood.old_priced_quantity
11965 ||' new_priced_uom '|| freegood.new_priced_uom_code
11966 ||' old_priced_uom '|| freegood.old_priced_uom_code
11967 ||' new_item '|| freegood.new_item ||' old_item '|| freegood.old_item
11968 ||' new_currency '|| freegood.new_CURRENCY_CODE
11969 ||' old_currency '|| freegood.old_CURRENCY_CODE
11970 ||' new_unit_price '|| freegood.new_unit_price
11971 ||' old_unit_price '|| freegood.old_unit_price
11972 ||' new_adj_price '|| freegood.new_ADJUSTED_UNIT_PRICE
11973 ||' old_adj_unit_price '|| freegood.old_ADJUSTED_UNIT_PRICE
11974 ||' new_pricelist_id '|| freegood.new_PRICE_LIST_HEADER_ID
11975 ||' old_pricelist_id '|| freegood.old_PRICE_LIST_HEADER_ID
11976 ||' new_rounding_fac '|| freegood.new_rounding_factor
11977 ||' old_rounding_fac '|| freegood.old_rounding_factor
11978 ||' old_price_flag '|| freegood.old_price_flag
11979 ||' new_price_flag '|| freegood.new_price_flag
11980 ||' old_line_index '|| freegood.old_line_index
11981 ||' new_line_index '|| freegood.new_line_index
11982 ||' old_line_id '|| freegood.old_line_id
11983 ||' old_process_status '|| freegood.old_list_line_id
11984 ||' newfgdis_list_line_id '|| freegood.newfgdis_list_line_id
11985 ||' newoperand '|| freegood.newfgdis_operand
11986 -- service project
11987 ||' new_SERVICE_DURATION '|| freegood.new_SERVICE_DURATION
11988 ||' old_SERVICE_DURATION '|| freegood.old_SERVICE_DURATION
11989 ||' new_SERVICE_PERIOD '|| freegood.new_SERVICE_PERIOD
11990 ||' old_SERVICE_PERIOD '|| freegood.old_SERVICE_PERIOD); -- service project
11991 END IF;
11992
11993 --this is to get the old_list_line_id for bug 2970384
11994 l_oldfgdis_list_line_id := REPLACE(substr(freegood.old_list_line_id, 1,
11995 -- need to subtract 1 from instr o/p to exclude the
11996 --position of 'B' from the string 'BUYLINE'
11997 instr(freegood.old_list_line_id, G_BUYLINE) - 1),
11998 G_FREEGOOD, '');
11999 l_old_operand := REPLACE(substr(freegood.old_list_line_id,
12000 instr(freegood.old_list_line_id, G_STATUS_UPDATED) + 7),
12001 G_PROMO_GOODS_DISCOUNT, '');
12002
12003 IF l_debug = FND_API.G_TRUE THEN
12004 QP_PREQ_GRP.engine_debug(' The old_fg_list_line_id is '
12005 || l_oldfgdis_list_line_id
12006 ||' the old_operand is '|| l_old_operand);
12007 END IF; --l_debug
12008
12009
12010 IF ((nvl(freegood.new_priced_quantity, freegood.new_line_quantity) =
12011 nvl(freegood.old_priced_quantity, freegood.old_line_quantity))
12012 AND (nvl(freegood.new_priced_uom_code, freegood.new_line_uom_code) =
12013 nvl(freegood.old_priced_uom_code, freegood.old_line_uom_code))
12014 AND (nvl(freegood.new_item, 'NULL') =
12015 nvl(freegood.old_item, 'NULL'))
12016 AND (nvl(freegood.new_CURRENCY_CODE, 'NULL') =
12017 nvl(freegood.old_CURRENCY_CODE, 'NULL'))
12018 AND (nvl(freegood.new_unit_price, 0) =
12019 nvl(freegood.old_unit_price, 0)))
12020 --and (nvl(freegood.new_ADJUSTED_UNIT_PRICE, 0) =
12021 --nvl(freegood.old_ADJUSTED_UNIT_PRICE, 0))
12022 --and (nvl(freegood.new_PRICING_STATUS_CODE, 'NULL') =
12023 --nvl(freegood.old_PRICING_STATUS_CODE, 'NULL'))
12024 --and (nvl(freegood.new_START_DATE_ACTIVE_FIRST, sysdate) =
12025 --nvl(freegood.old_START_DATE_ACTIVE_FIRST, sysdate))
12026 --and (nvl(freegood.new_ACTIVE_DATE_FIRST_TYPE, 'NULL') =
12027 --nvl(freegood.old_ACTIVE_DATE_FIRST_TYPE, 'NULL'))
12028 --and (nvl(freegood.new_START_DATE_ACTIVE_SECOND, sysdate) =
12029 --nvl(freegood.old_START_DATE_ACTIVE_SECOND, sysdate))
12030 --and (nvl(freegood.new_ACTIVE_DATE_SECOND_TYPE, 'NULL') =
12031 --nvl(freegood.old_ACTIVE_DATE_SECOND_TYPE, 'NULL'))
12032 AND (nvl(freegood.new_PRICE_LIST_HEADER_ID, - 1) =
12033 nvl(freegood.old_PRICE_LIST_HEADER_ID, - 1))
12034 -- service project
12035 AND (nvl(freegood.new_SERVICE_DURATION, - 1) =
12036 nvl(freegood.old_SERVICE_DURATION, - 1))
12037 AND (nvl(freegood.new_SERVICE_PERIOD, 'NULL') =
12038 nvl(freegood.old_SERVICE_PERIOD, 'NULL'))
12039 -- service project
12040 --and (nvl(freegood.new_list_line_id, -1) =
12041 --nvl(freegood.old_list_line_id, -1))
12042 --and (nvl(freegood.new_rounding_factor, 0) =
12043 --nvl(freegood.old_rounding_factor, 0)))
12044 --and (nvl(freegood.new_rounding_flag, 'NULL') =
12045 --nvl(freegood.old_rounding_flag, 'NULL')))
12046 --for bug 2970384 to compare if it the fglist_line_id is the same
12047 --and if the operand has not changed in the setup
12048 AND (nvl(l_oldfgdis_list_line_id, 0) =
12049 nvl(freegood.newfgdis_list_line_id, 0))
12050 AND (nvl(l_old_operand, 0) = nvl(freegood.newfgdis_operand, 0))
12051 THEN
12052 IF l_debug = FND_API.G_TRUE THEN
12053 QP_PREQ_GRP.engine_debug('In PRG if data unchanged ');
12054 END IF;
12055 G_prg_unch_line_index_tbl(G_prg_unch_line_index_tbl.COUNT + 1) :=
12056 freegood.old_line_index;
12057 --fix for bug 2931437 this may not get populated if calculation does
12058 --not take place and raise a no_data_found populating the old
12059 --selling price just in case
12060 G_prg_unch_calc_price_tbl(G_prg_unch_line_index_tbl.COUNT) :=
12061 freegood.old_adjusted_unit_price;
12062 G_prg_unch_new_index_tbl(G_prg_unch_line_index_tbl.COUNT) :=
12063 freegood.new_line_index;
12064 -- G_prg_unch_adj_price_tbl(G_prg_unch_line_index_tbl.COUNT) :=
12065 -- freegood.old_ADJUSTED_UNIT_PRICE;
12066 G_prg_unch_line_id_tbl(G_prg_unch_line_index_tbl.COUNT) :=
12067 freegood.old_line_id;
12068 --this will be used in calculation
12069 G_prg_unch_line_ind_tbl(freegood.old_line_index) :=
12070 G_prg_unch_line_index_tbl.COUNT;
12071
12072 IF l_debug = FND_API.G_TRUE THEN
12073 QP_PREQ_GRP.engine_debug('if data unchanged: oldfg_lineindex '
12074 || G_prg_unch_line_index_tbl(G_prg_unch_line_index_tbl.COUNT) ||' selprice '
12075 || G_prg_unch_calc_price_tbl(G_prg_unch_line_index_tbl.COUNT));
12076 END IF; --l_debug
12077
12078 l_prg_line_ind_tbl(l_prg_line_ind_tbl.COUNT + 1) :=
12079 freegood.old_line_index;
12080 l_prg_process_sts_tbl(l_prg_line_ind_tbl.COUNT) := G_STATUS_UNCHANGED;
12081 -- 'OLD'||G_STATUS_UNCHANGED;
12082 l_prg_line_id_tbl(l_prg_line_ind_tbl.COUNT) := freegood.old_line_id;
12083 l_prg_price_flag_tbl(l_prg_line_ind_tbl.COUNT) := freegood.old_price_flag; -- Ravi
12084 l_prg_line_ind_tbl(l_prg_line_ind_tbl.COUNT + 1) := freegood.new_line_index;
12085 l_prg_process_sts_tbl(l_prg_line_ind_tbl.COUNT) := G_NOT_VALID;
12086 -- 'NEW'||G_STATUS_UNCHANGED;
12087 l_prg_line_id_tbl(l_prg_line_ind_tbl.COUNT) := freegood.old_line_id;
12088 l_prg_price_flag_tbl(l_prg_line_ind_tbl.COUNT) := freegood.old_price_flag; -- Ravi
12089 ELSE --freegood cur
12090 IF l_debug = FND_API.G_TRUE THEN
12091 QP_PREQ_GRP.engine_debug('In PRG if data updated ');
12092 END IF;
12093 l_prg_line_ind_tbl(l_prg_line_ind_tbl.COUNT + 1) := freegood.old_line_index;
12094 l_prg_process_sts_tbl(l_prg_line_ind_tbl.COUNT) := G_NOT_VALID;
12095 l_prg_line_id_tbl(l_prg_line_ind_tbl.COUNT) := freegood.old_line_id;
12096 l_prg_price_flag_tbl(l_prg_line_ind_tbl.COUNT) := freegood.old_price_flag; -- Ravi
12097 l_prg_line_ind_tbl(l_prg_line_ind_tbl.COUNT + 1) := freegood.new_line_index;
12098 l_prg_process_sts_tbl(l_prg_line_ind_tbl.COUNT) := G_STATUS_UPDATED;
12099 l_prg_line_id_tbl(l_prg_line_ind_tbl.COUNT) := freegood.old_line_id;
12100 l_prg_price_flag_tbl(l_prg_line_ind_tbl.COUNT) := freegood.old_price_flag; -- Ravi
12101 END IF; --freegood cur
12102 END LOOP; --freegood
12103
12104 IF l_prg_line_ind_tbl.COUNT > 0
12105 THEN
12106 IF l_debug = FND_API.G_TRUE THEN
12107 QP_PREQ_GRP.engine_debug('prg details Here #1000');
12108 END IF; -- Bug No 4033618
12109 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
12110 THEN
12111 FOR i IN l_prg_line_ind_tbl.FIRST..l_prg_line_ind_tbl.LAST
12112 LOOP
12113 IF l_debug = FND_API.G_TRUE THEN
12114 QP_PREQ_GRP.engine_debug('prg details: line_index '
12115 || l_prg_line_ind_tbl(i) ||' process_status '
12116 || l_prg_process_sts_tbl(i) ||' line_id '|| l_prg_line_id_tbl(i)
12117 || 'price flag ' || l_prg_price_flag_tbl(i));
12118 END IF;
12119 END LOOP; --l_prg_line_ind_tbl
12120 END IF; --QP_PREQ_GRP.G_DEBUG_ENGINE
12121
12122 IF l_debug = FND_API.G_TRUE THEN
12123 QP_PREQ_GRP.engine_debug('passed in frg update '|| l_prg_line_ind_tbl.COUNT);
12124
12125 END IF;
12126 FORALL i IN l_prg_line_ind_tbl.FIRST..l_prg_line_ind_tbl.LAST
12127 UPDATE qp_npreq_lines_tmp line SET
12128 line.process_status = l_prg_process_sts_tbl(i)
12129 --pricing_status_code needs to be set to G_NOT_VALID so that
12130 --this does not get into OM's
12131 --update statement to update lines with UPDATE status
12132 , line.pricing_status_code = decode(l_prg_process_sts_tbl(i), G_NOT_VALID
12133 , l_prg_process_sts_tbl(i), line.pricing_status_code)
12134 --fix for bug 2691794
12135 , line.processed_flag = G_FREEGOOD_LINE
12136 , line.line_id = l_prg_line_id_tbl(i)
12137 , line.price_flag = l_prg_price_flag_tbl(i) -- Ravi
12138 WHERE line.line_index = l_prg_line_ind_tbl(i);
12139 END IF; --l_prg_line_ind_tbl.COUNT
12140
12141 IF l_debug = FND_API.G_TRUE THEN
12142 QP_PREQ_GRP.engine_debug('End process_prg');
12143 END IF;
12144 END IF; --l_process_prg
12145 -- service project
12146 IF QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG <> G_YES THEN
12147 UPDATE qp_npreq_lines_tmp SET pricing_status_code = G_NOT_VALID, process_status = G_NOT_VALID
12148 WHERE PROCESSED_CODE = G_BY_ENGINE AND SERVICE_PERIOD IS NOT NULL;
12149 QP_PREQ_GRP.engine_debug('deleted service rows'||SQL%rowcount);
12150 END IF;
12151 -- service project
12152 --bug 2970368
12153 --IF G_REQUEST_TYPE_CODE <> 'ONT' THEN
12154 --bug 3085453 handle pricing availability UI
12155 -- they pass reqtype ONT and insert adj into ldets
12156
12157 -- Bug 3348208
12158 -- the following if condition for check_cust_view_flag is commented out so that
12159 -- update_prg_pricing_status is always run. Previously, it was introduced only
12160 -- for ASO, not OM, but we discovered it needs to go for OM as well.
12161 --IF QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG <> G_YES THEN
12162 update_prg_pricing_status(x_return_status, x_return_status_text);
12163
12164 x_return_status := FND_API.G_RET_STS_SUCCESS;
12165 x_return_status_text := NULL;
12166 EXCEPTION
12167 WHEN PRG_Exception THEN
12168 x_return_status := FND_API.G_RET_STS_ERROR;
12169 x_return_status_text := 'Exception in '|| l_routine ||' '|| SQLERRM;
12170 IF l_debug = FND_API.G_TRUE THEN
12171 QP_PREQ_GRP.engine_debug('Exception in '|| l_routine ||' '|| SQLERRM);
12172 END IF;
12173 WHEN OTHERS THEN
12174 x_return_status := FND_API.G_RET_STS_ERROR;
12175 x_return_status_text := 'Exception in '|| l_routine ||' '|| SQLERRM;
12176 IF l_debug = FND_API.G_TRUE THEN
12177 QP_PREQ_GRP.engine_debug('Exception in '|| l_routine ||' '|| SQLERRM);
12178 END IF;
12179 END Process_PRG;
12180
12181 --This procedure compares the selling price of the old and new
12182 --unchanged freegood lines that resulted from the previous procedure
12183 --If the selling price changed, then it marks the newly created line
12184 --as UPDATED, else the passed in freegood line is marked as unchanged
12185 PROCEDURE Update_PRG_Process_status(x_return_status OUT NOCOPY VARCHAR2,
12186 x_return_status_text OUT NOCOPY VARCHAR2) IS
12187 l_routine VARCHAR2(100) := 'QP_PREQ_PUB.Update_PRG_Process_status ';
12188
12189 BEGIN
12190 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
12191 IF l_debug = FND_API.G_TRUE THEN
12192 QP_PREQ_GRP.engine_debug('Begin Update_PRG_Process_status');
12193
12194 END IF;
12195 IF G_prg_unch_line_index_tbl.COUNT > 0
12196 THEN
12197 IF l_debug = FND_API.G_TRUE THEN
12198 QP_PREQ_GRP.engine_debug('unchanged prg update '
12199 || G_prg_unch_line_index_tbl.COUNT);
12200
12201 END IF;
12202 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
12203 THEN
12204 FOR j IN G_prg_unch_line_index_tbl.FIRST..G_prg_unch_line_index_tbl.LAST
12205 LOOP
12206 IF l_debug = FND_API.G_TRUE THEN
12207 QP_PREQ_GRP.engine_debug('Unchanged details unch line_index '
12208 || G_prg_unch_line_index_tbl(j) ||' new line_index '
12209 || G_prg_unch_new_index_tbl(j) ||' adj_unit_price '
12210 || G_prg_unch_calc_price_tbl(j));
12211 END IF;
12212 END LOOP; --G_prg_unch_line_index_tbl
12213 END IF; --QP_PREQ_GRP.G_DEBUG_ENGINE
12214
12215 FORALL i IN G_prg_unch_line_index_tbl.FIRST..G_prg_unch_line_index_tbl.LAST
12216 UPDATE qp_npreq_lines_tmp line SET line.process_status =
12217 --fix for bug 2831270
12218 decode(line.adjusted_unit_price, G_prg_unch_calc_price_tbl(i),
12219 G_NOT_VALID, G_STATUS_UPDATED)
12220 --Calling application looks at pricing_status_code this also needs to be updated
12221 --pricing_status_code needs to be set to G_NOT_VALID
12222 --so that this does not get into OM's
12223 --update statement to update lines with UPDATE status
12224 , line.pricing_status_code = decode(line.adjusted_unit_price,
12225 G_prg_unch_calc_price_tbl(i), G_NOT_VALID, line.pricing_status_code)
12226 , line.line_id = G_prg_unch_line_id_tbl(i)
12227 WHERE line.line_index = G_prg_unch_new_index_tbl(i)
12228 RETURNING line.process_status BULK COLLECT INTO G_prg_unch_process_sts_tbl;
12229
12230 FORALL i IN G_prg_unch_line_index_tbl.FIRST..G_prg_unch_line_index_tbl.LAST
12231 UPDATE qp_npreq_lines_tmp line SET line.process_status =
12232 decode(G_prg_unch_process_sts_tbl(i), G_NOT_VALID
12233 , G_STATUS_UNCHANGED, G_STATUS_UPDATED, G_NOT_VALID)
12234 --pricing_status_code needs to be set
12235 --to G_NOT_VALID so that this does not get into OM's
12236 --update statement to update lines with UPDATE status
12237 , line.pricing_status_code = decode(G_prg_unch_process_sts_tbl(i)
12238 , G_NOT_VALID, line.pricing_status_code, G_STATUS_UPDATED, G_NOT_VALID)
12239 WHERE line.process_status = 'OLD' || G_STATUS_UNCHANGED
12240 AND line.line_index = G_prg_unch_line_index_tbl(i);
12241 END IF; --G_prg_unch_line_index_tbl.COUNT
12242
12243 --bug 2970368
12244 --IF G_REQUEST_TYPE_CODE <> 'ONT' THEN
12245 --bug 3085453 handle pricing availability UI
12246 -- they pass reqtype ONT and insert adj into ldets
12247 IF QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG <> G_YES THEN
12248 update_prg_pricing_status(x_return_status, x_return_status_text);
12249 END IF; --G_REQUEST_TYPE_CODE
12250
12251 x_return_status := FND_API.G_RET_STS_SUCCESS;
12252
12253 IF l_debug = FND_API.G_TRUE THEN
12254 QP_PREQ_GRP.engine_debug('End Update_PRG_Process_status');
12255
12256 END IF;
12257 EXCEPTION
12258 WHEN OTHERS THEN
12259 x_return_status := FND_API.G_RET_STS_ERROR;
12260 x_return_status_text := 'Exception in '|| l_routine ||' '|| SQLERRM;
12261 IF l_debug = FND_API.G_TRUE THEN
12262 QP_PREQ_GRP.engine_debug('Exception in '|| l_routine ||' '|| SQLERRM);
12263 END IF;
12264 END Update_PRG_Process_status;
12265
12266 --This procedure will populate g_buyline_price_flag
12267 --This information will be used to select out-of-phase adjustments
12268 --from oe tables or engine selected based on the price_flag on
12269 --the buy line for OID/PRG's child discounts
12270 PROCEDURE Populate_buy_line_price_flag(x_return_status OUT NOCOPY VARCHAR2,
12271 x_return_status_text OUT NOCOPY VARCHAR2) IS
12272
12273 -- 3493716: added prg.line_detail_index to cursor
12274 CURSOR l_buyline_price_flag_cur IS
12275 SELECT /*+ ORDERED USE_NL(buyline prg dis)*/
12276 dis.created_from_list_line_id, prg.line_detail_index, buyline.price_flag, 'Y' is_ldet, dis.line_index
12277 FROM qp_npreq_rltd_lines_tmp rltd, qp_npreq_lines_tmp buyline
12278 , qp_npreq_ldets_tmp prg, qp_npreq_ldets_tmp dis
12279 WHERE rltd.pricing_status_code = G_STATUS_NEW
12280 AND rltd.relationship_type_code = G_GENERATED_LINE
12281 AND buyline.line_index = rltd.line_index
12282 AND prg.line_detail_index = rltd.line_detail_index
12283 AND prg.created_from_list_line_type IN
12284 (G_OTHER_ITEM_DISCOUNT, G_PROMO_GOODS_DISCOUNT)
12285 AND prg.pricing_status_code = G_STATUS_NEW
12286 AND dis.line_detail_index = rltd.related_line_detail_index
12287 AND dis.pricing_status_code = G_STATUS_NEW;
12288
12289 I PLS_INTEGER;
12290 l_routine VARCHAR2(100) := 'QP_PREQ_PUB.Populate_buy_line_price_flag';
12291 BEGIN
12292 IF l_debug = FND_API.G_TRUE THEN
12293 QP_PREQ_GRP.engine_debug('Begin Populate_buy_line_price_flag');
12294
12295 END IF;
12296 --G_buyline_price_flag.delete;
12297 G_BUYLINE_INDEXES_FOR_LINE_ID.DELETE;
12298
12299 IF l_debug = FND_API.G_TRUE THEN
12300 FOR c1 IN (SELECT line_detail_index, related_line_detail_index, line_index
12301 FROM qp_npreq_rltd_lines_tmp WHERE pricing_status_code = G_STATUS_NEW
12302 AND relationship_type_code = G_GENERATED_LINE)
12303 LOOP
12304 IF l_debug = FND_API.G_TRUE THEN
12305 QP_PREQ_GRP.engine_debug('loop linedtl '|| c1.line_detail_index ||' rltddtl '
12306 || c1.related_line_detail_index ||' lineind '|| c1.line_index);
12307 END IF;
12308 FOR c2 IN (SELECT line_index, line_detail_index FROM qp_npreq_ldets_tmp
12309 WHERE line_detail_index = c1.line_detail_index
12310 AND pricing_status_code = G_STATUS_NEW
12311 AND created_from_list_line_type IN
12312 (G_OTHER_ITEM_DISCOUNT, G_PROMO_GOODS_DISCOUNT))
12313 LOOP
12314 IF l_debug = FND_API.G_TRUE THEN
12315 QP_PREQ_GRP.engine_debug('loop ldet linedtl '|| c2.line_detail_index);
12316 END IF;
12317 END LOOP; --c2
12318 END LOOP; --c1
12319 END IF; --QP_PREQ_GRP.G_DEBUG_ENGINE
12320
12321 FOR buyline IN l_buyline_price_flag_cur
12322 LOOP
12323 IF l_debug = FND_API.G_TRUE THEN
12324 QP_PREQ_GRP.engine_debug('In buyline loop list_line_id '
12325 || buyline.created_from_list_line_id
12326 ||' w/PRG ldet '|| buyline.line_detail_index -- 3493716
12327 ||' price_flag '|| buyline.price_flag
12328 ||' get line_index '|| buyline.line_index);
12329 END IF;
12330 --G_buyline_price_flag(buyline.created_from_list_line_id) := buyline.price_flag;
12331 -- bug 3721860 - G_BUYLINE_INDEXES_FOR_LINE_ID stores the info like - ,line_index1,line_index2,line_index3, - for a line_id
12332 IF G_BUYLINE_INDEXES_FOR_LINE_ID.EXISTS(buyline.created_from_list_line_id) THEN
12333 G_BUYLINE_INDEXES_FOR_LINE_ID(buyline.created_from_list_line_id) := G_BUYLINE_INDEXES_FOR_LINE_ID(buyline.created_from_list_line_id) || buyline.line_index || ',';
12334 ELSE
12335 G_BUYLINE_INDEXES_FOR_LINE_ID(buyline.created_from_list_line_id) := ',' || buyline.line_index || ',';
12336 END IF;
12337 END LOOP;
12338 /*
12339 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE THEN
12340 i := G_buyline_price_flag.FIRST;
12341 WHILE i IS NOT NULL
12342 LOOP
12343 IF l_debug = FND_API.G_TRUE THEN
12344 QP_PREQ_GRP.engine_debug('In g_buyline loop list_line_id '
12345 ||I||' price_flag '||G_buyline_price_flag(I));
12346 END IF;
12347 I := G_buyline_price_flag.NEXT(I);
12348 END LOOP;--while
12349 END IF;--QP_PREQ_GRP.G_DEBUG_ENGINE
12350
12351 OPEN l_buyline_price_flag_cur;
12352 FETCH l_buyline_price_flag_cur BULK COLLECT INTO
12353 G_buyline_list_line_id, G_buyline_price_flag;
12354 CLOSE l_buyline_price_flag_cur;
12355 UPDATE qp_npreq_ldets_tmp freegood_dis set buy_line_price_flag =
12356 (select buyline.price_flag
12357 from qp_npreq_rltd_lines_tmp rl, qp_npreq_lines_tmp buyline
12358 where rl.pricing_status_code = G_STATUS_NEW
12359 and rl.relationship_type_code = G_GENERATED_LINE
12360 and rl.related_line_detail_index = freegood_dis.line_detail_index
12361 and buyline.line_index = rl.line_index)
12362 where freegood_dis.pricing_status_code = G_STATUS_NEW
12363 and freegood_dis.applied_flag = G_YES
12364 and freegood_dis.created_from_list_line_type in (G_OTHER_ITEM_DISCOUNT,
12365 G_PROMO_GOODS_DISCOUNT)
12366 and freegood_dis.line_detail_index in (select rltd.related_line_detail_index
12367 from qp_npreq_rltd_lines_tmp rltd
12368 where rltd.pricing_status_code = G_STATUS_NEW
12369 and rltd.relationship_type_code = G_GENERATED_LINE
12370 and rltd.line_detail_index = freegood_dis.line_detail_index);
12371 */
12372
12373 IF l_debug = FND_API.G_TRUE THEN
12374 QP_PREQ_GRP.engine_debug('End Populate_buy_line_price_flag');
12375 END IF;
12376 x_return_status := FND_API.G_RET_STS_SUCCESS;
12377 EXCEPTION
12378 WHEN OTHERS THEN
12379 x_return_status := FND_API.G_RET_STS_ERROR;
12380 x_return_status_text := 'Exception in '|| l_routine ||' '|| SQLERRM;
12381 IF l_debug = FND_API.G_TRUE THEN
12382 QP_PREQ_GRP.Engine_debug(x_return_status_text);
12383 END IF;
12384 END Populate_buy_line_price_flag;
12385
12386 -- 3721860: Added a parameter p_line_index
12387 FUNCTION Get_buy_line_price_flag(p_list_line_id IN NUMBER,
12388 p_line_index IN NUMBER)
12389 RETURN VARCHAR2 IS
12390
12391 i PLS_INTEGER;
12392 l_routine VARCHAR2(100) := 'QP_PREQ_PUB.Get_buy_line_price_flag';
12393 l_count NUMBER;
12394 BEGIN
12395 IF l_debug = FND_API.G_TRUE THEN
12396 QP_PREQ_GRP.engine_debug('Begin Get_buy_line_price_flag, p_list_line_id p_line_index: '|| p_list_line_id || ' ' || p_line_index);
12397
12398 END IF;
12399 IF G_BUYLINE_INDEXES_FOR_LINE_ID.COUNT > 0 THEN
12400 IF G_BUYLINE_INDEXES_FOR_LINE_ID.EXISTS(p_list_line_id) THEN
12401 l_count := instr(G_BUYLINE_INDEXES_FOR_LINE_ID(p_list_line_id), ',' || p_line_index || ',');
12402 IF l_debug = FND_API.G_TRUE THEN
12403 QP_PREQ_GRP.engine_debug('G_BUYLINE_INDEXES_FOR_LINE_ID(p_list_line_id) ' || G_BUYLINE_INDEXES_FOR_LINE_ID(p_list_line_id));
12404 QP_PREQ_GRP.engine_debug('l_count ' || l_count);
12405 END IF;
12406 IF l_count > 0 THEN
12407 RETURN 'Y';
12408 ELSE
12409 RETURN NULL;
12410 END IF;
12411 ELSE
12412 RETURN NULL;
12413 END IF; --G_BUYLINE_INDEXES_FOR_LINE_ID.EXISTS
12414 ELSE
12415 RETURN NULL;
12416 END IF; --G_BUYLINE_INDEXES_FOR_LINE_ID.count
12417
12418 EXCEPTION
12419 WHEN OTHERS THEN
12420 IF l_debug = FND_API.G_TRUE THEN
12421 QP_PREQ_GRP.Engine_debug('Exception in '|| l_routine ||' '|| SQLERRM);
12422 END IF;
12423 RETURN NULL;
12424 END Get_buy_line_price_flag;
12425
12426
12427 /*****************************************************************
12428 --------------------Coupon Issue Processing-----------------------
12429 *****************************************************************/
12430 --This procedure will call QP_Process_Other_Benefits_PVT.process_coupon_issue
12431 --for every coupon issue modifier applied by the search engine
12432 --We do not want to do this in GRP because, GRP would generate coupons
12433 --during every reprice. During reprice, new coupons should not be
12434 --generated for existing adjustments
12435
12436 PROCEDURE Process_coupon_issue(p_pricing_event IN VARCHAR2,
12437 p_simulation_flag IN VARCHAR2,
12438 x_return_status OUT NOCOPY VARCHAR2,
12439 x_return_status_text OUT NOCOPY VARCHAR2) IS
12440
12441 CURSOR l_get_list_lines_cur IS
12442 SELECT /*+ index (ldets qp_preq_ldets_tmp_N2) */
12443 created_from_list_line_id
12444 , line_quantity
12445 , line_detail_index
12446 , pricing_phase_id
12447 FROM qp_npreq_ldets_tmp ldets
12448 WHERE created_from_list_line_type = G_COUPON_ISSUE
12449 AND applied_flag = G_YES
12450 /*
12451 --you don't need to match the phase as this will be called after cleanup
12452 --and by the time adjustments w/b picked up from oe_price_adj and ldets
12453 --from the right phases
12454 AND pricing_phase_id in (select ph.pricing_phase_id
12455 from qp_event_phases evt , qp_pricing_phases ph, qp_npreq_lines_tmp line
12456 where ph.pricing_phase_id = evt.pricing_phase_id
12457 and instr(p_pricing_event,evt.pricing_event_code||',') > 0
12458 and line.line_index = ldets.line_index
12459 and (line.price_flag = G_YES
12460 or (line.price_flag = G_PHASE
12461 and ph.freeze_override_flag = G_YES)
12462 */
12463 -- AND LINE_INDEX = p_line_index
12464 -- AND ASK_FOR_FLAG IN (G_YES,G_NO)
12465 AND pricing_status_code = G_STATUS_NEW
12466 AND process_code = G_STATUS_NEW;
12467
12468 Coupon_Exception EXCEPTION;
12469
12470 BEGIN
12471 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
12472 FOR ldet IN l_get_list_lines_cur
12473 LOOP
12474 QP_COUPON_PVT.PROCESS_COUPON_ISSUE(
12475 p_line_detail_index => ldet.line_detail_index,
12476 p_pricing_phase_id => ldet.pricing_phase_id,
12477 p_line_quantity => ldet.line_quantity,
12478 p_simulation_flag => p_simulation_flag,
12479 x_return_status => x_return_status,
12480 x_return_status_txt => x_return_status_text);
12481 IF (x_return_status = FND_API.G_RET_STS_ERROR) THEN
12482 RAISE Coupon_Exception;
12483 END IF; --x_return_status
12484 END LOOP; --get_list_lines_cur
12485
12486 EXCEPTION
12487 WHEN Coupon_Exception THEN
12488 IF l_debug = FND_API.G_TRUE THEN
12489 QP_PREQ_GRP.engine_debug('Exception in QP_PREQ_PUB.Process_coupon_issue '|| x_return_status_text);
12490 END IF;
12491 WHEN OTHERS THEN
12492 x_return_status := FND_API.G_RET_STS_ERROR;
12493 x_return_status_text := 'Exception in QP_PREQ_PUB.Process_coupon_issue '|| SQLERRM;
12494 IF l_debug = FND_API.G_TRUE THEN
12495 QP_PREQ_GRP.engine_debug(x_return_status_text);
12496 END IF;
12497 END Process_coupon_issue;
12498
12499 --This procedure will update the line_quantity on ldets
12500 --in case of a recurring break to reflect the right quantity
12501 PROCEDURE Update_Recurring_Quantity(x_return_status OUT NOCOPY VARCHAR2,
12502 x_return_status_text OUT NOCOPY VARCHAR2) IS
12503
12504 --[julin/pbperf] tuned to use QP_PREQ_LDETS_TMP_N2
12505 CURSOR l_get_recurring_cur IS
12506 SELECT /*+ ORDERED index(ldet QP_PREQ_LDETS_TMP_N2) */ ldet.line_detail_index
12507 , lattr.context
12508 , lattr.attribute
12509 , lattr.value_from
12510 , lattr.setup_value_from
12511 , ldet.modifier_level_code
12512 -- , ldet.line_detail_index
12513 , ldet.line_quantity
12514 , ldet.group_quantity
12515 , ldet.group_amount
12516 , ldet.created_from_list_line_type
12517 , ldet.operand_value
12518 , qpl.operand
12519 , ldet.benefit_qty
12520 , ldet.accrual_flag
12521 , qpl.accrual_conversion_rate
12522 , qpl.estim_accrual_rate
12523 -- , qpl.benefit_qty
12524 FROM qp_npreq_ldets_tmp ldet, qp_npreq_line_attrs_tmp lattr, qp_list_lines qpl
12525 WHERE ldet.pricing_phase_id > 1
12526 AND ldet.pricing_status_code = G_STATUS_NEW
12527 AND ldet.line_index > -1
12528 AND ldet.created_from_list_line_type IN ('DIS', 'SUR', 'FREIGHT_CHARGE',
12529 'CIE', 'PBH', 'IUE', 'TSN')
12530 AND ldet.price_break_type_code = G_RECURRING_BREAK
12531 AND nvl(ldet.created_from_list_type_code, 'NULL') NOT IN ('PRL', 'AGR')
12532 AND lattr.line_detail_index = ldet.line_detail_index
12533 AND lattr.context = G_PRIC_VOLUME_CONTEXT
12534 AND qpl.list_line_id = ldet.created_from_list_line_id
12535 AND qpl.automatic_flag = 'N' ; -- this procedure is needed only for manual modifiers since for automatic modifiers will be calculated in QPXGPREB
12536
12537 l_recur_dtl_index_tbl QP_PREQ_GRP.number_type;
12538 l_recur_tot_benefit_qty_tbl QP_PREQ_GRP.number_type;
12539 l_recur_benefit_qty_tbl QP_PREQ_GRP.number_type; --Bug 2804053
12540 l_recur_benefit_qty NUMBER;
12541 l_recur_base_qty NUMBER;
12542 l_recur_qualifying_qty NUMBER;
12543 l_routine VARCHAR2(100) := 'QP_PREQ_PUB.Update_recurring_quantity';
12544
12545 BEGIN
12546 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
12547 l_recur_dtl_index_tbl.DELETE;
12548 l_recur_tot_benefit_qty_tbl.DELETE;
12549
12550 FOR recurring IN l_get_recurring_cur
12551 LOOP
12552 IF l_debug = FND_API.G_TRUE THEN -- shu 2702384
12553 QP_PREQ_GRP.engine_debug ('------in l_get_recurring_cur loop------');
12554 END IF; -- END IF l_debug
12555
12556 IF recurring.created_from_list_line_type IN (G_DISCOUNT, G_SURCHARGE,
12557 G_PROMO_GOODS_DISCOUNT, G_COUPON_ISSUE) THEN
12558 l_recur_dtl_index_tbl(l_recur_dtl_index_tbl.COUNT + 1) :=
12559 recurring.line_detail_index;
12560 IF recurring.created_from_list_line_type IN (G_DISCOUNT, G_SURCHARGE) THEN
12561 -- gets the engine calculated value from the grp calculation engine which is wrong
12562 l_recur_benefit_qty := recurring.operand_value; -- reverted fix 2747387 for bug 4127734
12563 --l_recur_benefit_qty := recurring.operand; -- get the original value bug# 2747387
12564 ELSIF recurring.created_from_list_line_type = G_PROMO_GOODS_DISCOUNT THEN
12565 l_recur_benefit_qty := recurring.benefit_qty;
12566 ELSIF recurring.created_from_list_line_type = G_COUPON_ISSUE THEN
12567 l_recur_benefit_qty := 1;
12568 END IF; --recurring.created_from_list_line_type
12569
12570 IF l_debug = FND_API.G_TRUE THEN -- shu 2702384
12571 QP_PREQ_GRP.engine_debug ('l_recur_benefit_qty' || l_recur_benefit_qty);
12572 END IF;
12573
12574 IF recurring.modifier_level_code IN (G_LINE_LEVEL, G_ORDER_LEVEL) THEN
12575 l_recur_qualifying_qty := recurring.line_quantity;
12576 ELSE
12577 IF recurring.attribute = G_QUANTITY_ATTRIBUTE THEN
12578 --l_recur_qualifying_qty := recurring.group_quantity; -- SHU this is null
12579 l_recur_qualifying_qty := nvl(recurring.group_quantity, recurring.line_quantity) ; -- 2388011, SHU FIX.
12580 ELSE
12581 --l_recur_qualifying_qty := recurring.group_amount; -- SHU, wrong since group_amount is per_unit value
12582 l_recur_qualifying_qty := recurring.line_quantity; -- 2388011, SHU FIX.
12583 END IF; --recurring.attribute
12584 END IF; --recurring.modifier_level_code
12585
12586 l_recur_base_qty := recurring.setup_value_from;
12587
12588 l_recur_tot_benefit_qty_tbl(l_recur_dtl_index_tbl.COUNT) :=
12589 TRUNC((l_recur_qualifying_qty / l_recur_base_qty))
12590 * l_recur_benefit_qty;
12591 --Bug 2804053
12592 IF recurring.accrual_flag = G_YES THEN
12593 l_recur_benefit_qty_tbl(l_recur_dtl_index_tbl.COUNT) :=
12594 l_recur_tot_benefit_qty_tbl(l_recur_dtl_index_tbl.COUNT) *
12595 1 / nvl(recurring.accrual_conversion_rate, 1) *
12596 nvl(recurring.estim_accrual_rate, 100) / 100;
12597 ELSE
12598 l_recur_benefit_qty_tbl(l_recur_dtl_index_tbl.COUNT) :=
12599 recurring.benefit_qty;
12600 END IF;
12601
12602 IF l_debug = FND_API.G_TRUE THEN -- shu 2702384
12603 QP_PREQ_GRP.engine_debug ('l_recur_qualifying_qty' || l_recur_qualifying_qty);
12604 QP_PREQ_GRP.engine_debug ('l_recur_base_qty' || l_recur_base_qty);
12605 QP_PREQ_GRP.engine_debug ('l_recur_tot_benefit_qty' || l_recur_tot_benefit_qty_tbl(l_recur_dtl_index_tbl.COUNT));
12606 QP_PREQ_GRP.engine_debug ('l_recur_benefit_qty' || l_recur_benefit_qty_tbl(l_recur_dtl_index_tbl.COUNT));
12607 END IF; -- END IF l_debug
12608
12609 END IF; --recurring.created_from_list_line_type
12610 END LOOP; --recurring
12611
12612 IF l_recur_dtl_index_tbl.COUNT > 0 THEN
12613 IF l_debug = FND_API.G_TRUE THEN
12614 QP_PREQ_GRP.engine_debug('Updating recurring qty '|| l_recur_dtl_index_tbl.COUNT);
12615 END IF;
12616 FORALL i IN l_recur_dtl_index_tbl.FIRST .. l_recur_dtl_index_tbl.LAST
12617 UPDATE qp_npreq_ldets_tmp recur SET operand_value = -- shu fix 2702384
12618 l_recur_tot_benefit_qty_tbl(i)
12619 , benefit_qty = l_recur_benefit_qty_tbl(i) --Bug 2804053
12620 WHERE recur.line_detail_index = l_recur_dtl_index_tbl(i);
12621 END IF; --l_recur_dtl_index_tbl.COUNT
12622 EXCEPTION
12623 WHEN OTHERS THEN
12624 x_return_status := FND_API.G_RET_STS_ERROR;
12625 x_return_status_text := l_routine ||' '|| SQLERRM;
12626 IF l_debug = FND_API.G_TRUE THEN
12627 QP_PREQ_GRP.engine_debug('Exception in '|| x_return_status_text);
12628 END IF;
12629 END Update_recurring_quantity;
12630
12631 --added by yangli for Java Engine
12632 --This is for debugging purposes
12633 PROCEDURE Populate_Output_INT(x_return_status OUT NOCOPY VARCHAR2,
12634 x_return_status_text OUT NOCOPY VARCHAR2) IS
12635
12636 /*
12637 INDX,QP_PREQ_PUB.populate_output_int.l_lines_cur,- No Index Used -,NA,NA
12638 */
12639 CURSOR l_lines_cur IS
12640 SELECT LINE_INDEX,
12641 LINE_ID,
12642 LINE_TYPE_CODE,
12643 LINE_QUANTITY,
12644 LINE_UOM_CODE,
12645 LINE_UNIT_PRICE, --shu_latest
12646 PRICED_QUANTITY,
12647 UOM_QUANTITY,
12648 PRICED_UOM_CODE,
12649 CURRENCY_CODE,
12650 UNIT_PRICE,
12651 PERCENT_PRICE,
12652 PARENT_PRICE,
12653 PARENT_QUANTITY,
12654 PARENT_UOM_CODE,
12655 PRICE_FLAG,
12656 ADJUSTED_UNIT_PRICE,
12657 UPDATED_ADJUSTED_UNIT_PRICE,
12658 PROCESSING_ORDER,
12659 PROCESSED_CODE,
12660 PROCESSED_FLAG,
12661 PRICING_STATUS_CODE,
12662 PRICING_STATUS_TEXT,
12663 HOLD_CODE,
12664 HOLD_TEXT,
12665 PRICE_REQUEST_CODE,
12666 PRICING_EFFECTIVE_DATE,
12667 PRICE_LIST_HEADER_ID,
12668 PROCESS_STATUS,
12669 CATCHWEIGHT_QTY,
12670 ACTUAL_ORDER_QUANTITY,
12671 ORDER_UOM_SELLING_PRICE
12672 FROM QP_INT_LINES;
12673
12674 /*
12675 INDX,QP_PREQ_GRP.populate_output_int.l_ldets_cur,QP_LIST_LINES_PK,LIST_LINE_ID,1
12676 INDX,QP_PREQ_GRP.populate_output_int.l_ldets_cur,QP_INT_LDETS_N4,PRICING_STATUS_CODE,1
12677 INDX,QP_PREQ_GRP.populate_output_int.l_ldets_cur,QP_LIST_HEADERS_B_PK,LIST_HEADER_ID,1
12678 */
12679 CURSOR l_ldets_cur(p_line_index NUMBER) IS
12680 SELECT /*+ ORDERED USE_NL(A B C) l_ldets_cur */
12681 a.LINE_DETAIL_INDEX,
12682 a.LINE_DETAIL_TYPE_CODE,
12683 a.LINE_INDEX,
12684 a.CREATED_FROM_LIST_HEADER_ID LIST_HEADER_ID,
12685 a.CREATED_FROM_LIST_LINE_ID LIST_LINE_ID,
12686 a.CREATED_FROM_LIST_LINE_TYPE LIST_LINE_TYPE_CODE,
12687 a.PRICE_BREAK_TYPE_CODE,
12688 a.LINE_QUANTITY,
12689 a.ADJUSTMENT_AMOUNT,
12690 a.AUTOMATIC_FLAG,
12691 a.PRICING_PHASE_ID,
12692 a.OPERAND_CALCULATION_CODE,
12693 a.OPERAND_VALUE,
12694 a.PRICING_GROUP_SEQUENCE,
12695 a.CREATED_FROM_LIST_TYPE_CODE,
12696 a.APPLIED_FLAG,
12697 a.PRICING_STATUS_CODE,
12698 a.PRICING_STATUS_TEXT,
12699 a.LIMIT_CODE,
12700 a.LIMIT_TEXT,
12701 a.LIST_LINE_NO,
12702 a.GROUP_QUANTITY,
12703 a.UPDATED_FLAG,
12704 a.PROCESS_CODE,
12705 a.CALCULATION_CODE,
12706 a.PRICE_ADJUSTMENT_ID,
12707 b.SUBSTITUTION_VALUE SUBSTITUTION_VALUE_TO,
12708 b.SUBSTITUTION_ATTRIBUTE,
12709 b.ACCRUAL_FLAG,
12710 a.modifier_level_code,
12711 b.ESTIM_GL_VALUE,
12712 b.ACCRUAL_CONVERSION_RATE,
12713 --Pass throuh components
12714 b.OVERRIDE_FLAG,
12715 b.PRINT_ON_INVOICE_FLAG,
12716 b.INVENTORY_ITEM_ID,
12717 b.ORGANIZATION_ID,
12718 b.RELATED_ITEM_ID,
12719 b.RELATIONSHIP_TYPE_ID,
12720 b.ESTIM_ACCRUAL_RATE,
12721 b.EXPIRATION_DATE,
12722 b.BENEFIT_PRICE_LIST_LINE_ID,
12723 b.RECURRING_FLAG,
12724 b.BENEFIT_LIMIT,
12725 b.CHARGE_TYPE_CODE,
12726 b.CHARGE_SUBTYPE_CODE,
12727 a.BENEFIT_QTY, --bug 2804053
12728 b.BENEFIT_UOM_CODE,
12729 b.PRORATION_TYPE_CODE,
12730 b.INCLUDE_ON_RETURNS_FLAG,
12731 b.REBATE_TRANSACTION_TYPE_CODE,
12732 b.NUMBER_EXPIRATION_PERIODS,
12733 b.EXPIRATION_PERIOD_UOM,
12734 b.COMMENTS,
12735 a.ORDER_QTY_OPERAND,
12736 a.ORDER_QTY_ADJ_AMT
12737 FROM QP_INT_LDETS a,
12738 QP_LIST_LINES b
12739 WHERE a.line_index = p_line_index
12740 AND a.CREATED_FROM_LIST_LINE_ID = b.LIST_LINE_ID
12741 AND a.PRICING_STATUS_CODE = G_STATUS_NEW;
12742
12743 BEGIN
12744
12745 IF l_debug = FND_API.G_TRUE THEN
12746 QP_PREQ_GRP.engine_debug('---------------------------------------------------');
12747 END IF;
12748
12749 FOR l_line IN l_lines_cur LOOP
12750 IF l_debug = FND_API.G_TRUE THEN
12751 QP_PREQ_GRP.engine_debug('----price line info--------------------------------');
12752 QP_PREQ_GRP.engine_debug('---------------------------------------------------');
12753 END IF;
12754
12755 IF l_debug = FND_API.G_TRUE THEN
12756 QP_PREQ_GRP.engine_debug('*LINE_INDEX :='|| l_line.LINE_INDEX);
12757 QP_PREQ_GRP.engine_debug('*LINE_ID :='|| l_line.LINE_ID);
12758 QP_PREQ_GRP.engine_debug('LINE_TYPE_CODE :='|| l_line.LINE_TYPE_CODE);
12759 QP_PREQ_GRP.engine_debug('UOM_QUANTITY :='|| l_line.UOM_QUANTITY);
12760 QP_PREQ_GRP.engine_debug('CURRENCY_CODE :='|| l_line.CURRENCY_CODE);
12761 QP_PREQ_GRP.engine_debug('PRICED_QUANTITY :='|| l_line.PRICED_QUANTITY);
12762 QP_PREQ_GRP.engine_debug('PRICED_UOM_CODE :='|| l_line.PRICED_UOM_CODE);
12763 QP_PREQ_GRP.engine_debug('*UNIT_PRICE :='|| l_line.UNIT_PRICE);
12764 QP_PREQ_GRP.engine_debug('*PRICE_LIST_ID :='|| l_line.PRICE_LIST_HEADER_ID);
12765 QP_PREQ_GRP.engine_debug('LINE_QUANTITY:=' || l_line.LINE_QUANTITY);
12766 QP_PREQ_GRP.engine_debug('LINE_UOM_CODE:=' || l_line.LINE_UOM_CODE);
12767 QP_PREQ_GRP.engine_debug('LINE_UNIT_PRICE:=' || l_line.LINE_UNIT_PRICE); -- shu_latest
12768 QP_PREQ_GRP.engine_debug('PERCENT_PRICE :='|| l_line.PERCENT_PRICE);
12769 QP_PREQ_GRP.engine_debug('*ADJUSTED_UNIT_PRICE :='|| l_line.ADJUSTED_UNIT_PRICE);
12770 QP_PREQ_GRP.engine_debug('PARENT_PRICE :='|| l_line.PARENT_PRICE);
12771 QP_PREQ_GRP.engine_debug('PARENT_QUANTITY :='|| l_line.PARENT_QUANTITY);
12772 QP_PREQ_GRP.engine_debug('PARENT_UOM_CODE :='|| l_line.PARENT_UOM_CODE);
12773 QP_PREQ_GRP.engine_debug('processed_code :='|| l_line.processed_code);
12774 QP_PREQ_GRP.engine_debug('processed_flag :='|| l_line.processed_flag);
12775 QP_PREQ_GRP.engine_debug('Price Flag :='|| l_line.price_flag);
12776 QP_PREQ_GRP.engine_debug('*STATUS_CODE :='|| l_line.PRICING_STATUS_CODE);
12777 QP_PREQ_GRP.engine_debug('*STATUS_TEXT :='|| substr(l_line.PRICING_STATUS_TEXT, 1, 2000));
12778 QP_PREQ_GRP.engine_debug('HOLD_CODE := '|| l_line.HOLD_CODE);
12779 QP_PREQ_GRP.engine_debug('HOLD_TEXT := '|| substr(l_line.HOLD_TEXT, 1, 240));
12780 QP_PREQ_GRP.engine_debug('PRICE_REQUEST_CODE := '|| l_line.PRICE_REQUEST_CODE);
12781 QP_PREQ_GRP.engine_debug('PRICING_DATE := '|| l_line.PRICING_EFFECTIVE_DATE);
12782 QP_PREQ_GRP.engine_debug('*PROCESS_STATUS :='|| l_line.PROCESS_STATUS);
12783 QP_PREQ_GRP.engine_debug('*CATCHWEIGHT_QTY :='|| l_line.CATCHWEIGHT_QTY);
12784 QP_PREQ_GRP.engine_debug('*ACTUAL_ORDER_QTY :='|| l_line.ACTUAL_ORDER_QUANTITY);
12785 QP_PREQ_GRP.engine_debug('*ORDER_UOM_SELLING_PRICE :='|| l_line.ORDER_UOM_SELLING_PRICE);
12786 END IF;
12787
12788 IF l_debug = FND_API.G_TRUE THEN
12789 QP_PREQ_GRP.engine_debug('---------------------------------------------------');
12790
12791 END IF;
12792 --Populate Line detail
12793 FOR l_dets IN l_ldets_cur(l_line.LINE_INDEX) LOOP
12794
12795 IF l_debug = FND_API.G_TRUE THEN
12796 QP_PREQ_GRP.engine_debug('-----------Line detail Info -----------------------');
12797 QP_PREQ_GRP.engine_debug('---------------------------------------------------');
12798 QP_PREQ_GRP.engine_debug('*LINE_DETAIL_INDEX :='|| l_dets.LINE_DETAIL_INDEX);
12799 QP_PREQ_GRP.engine_debug('LINE_DETAIL_TYPE_CODE:=' || l_dets.LINE_DETAIL_TYPE_CODE);
12800 QP_PREQ_GRP.engine_debug('*LINE_INDEX:=' || l_dets.LINE_INDEX);
12801 QP_PREQ_GRP.engine_debug('*PROCESS_CODE:=' || l_dets.PROCESS_CODE);
12802 QP_PREQ_GRP.engine_debug('*CALCULATION_CODE:=' || l_dets.CALCULATION_CODE);
12803 QP_PREQ_GRP.engine_debug('*LIST_HEADER_ID:=' || l_dets.LIST_HEADER_ID);
12804 QP_PREQ_GRP.engine_debug('*LIST_LINE_ID:=' || l_dets.LIST_LINE_ID);
12805 QP_PREQ_GRP.engine_debug('*PRICE_ADJUSTMENT_ID:=' || l_dets.PRICE_ADJUSTMENT_ID);
12806 QP_PREQ_GRP.engine_debug('LIST_LINE_TYPE_CODE:=' || l_dets.LIST_LINE_TYPE_CODE);
12807 QP_PREQ_GRP.engine_debug('SUBSTITUTION_TO:=' || l_dets.SUBSTITUTION_VALUE_TO);
12808 QP_PREQ_GRP.engine_debug('LINE_QUANTITY :='|| l_dets.LINE_QUANTITY);
12809 QP_PREQ_GRP.engine_debug('*ADJUSTMENT_AMOUNT :='|| l_dets.ADJUSTMENT_AMOUNT);
12810 QP_PREQ_GRP.engine_debug('*AUTOMATIC_FLAG :='|| l_dets.AUTOMATIC_FLAG);
12811 QP_PREQ_GRP.engine_debug('APPLIED_FLAG :='|| l_dets.APPLIED_FLAG);
12812 QP_PREQ_GRP.engine_debug('UPDATED_FLAG :='|| l_dets.UPDATED_FLAG);
12813 QP_PREQ_GRP.engine_debug('PRICING_GROUP_SEQUENCE :='|| l_dets.PRICING_GROUP_SEQUENCE);
12814 QP_PREQ_GRP.engine_debug('CREATED_FROM_LIST_TYPE_CODE:=' || l_dets.CREATED_FROM_LIST_TYPE_CODE);
12815 QP_PREQ_GRP.engine_debug('PRICE_BREAK_TYPE_CODE :='|| l_dets.PRICE_BREAK_TYPE_CODE);
12816 QP_PREQ_GRP.engine_debug('*OVERRIDE_FLAG :='|| l_dets.override_flag);
12817 QP_PREQ_GRP.engine_debug('PRINT_ON_INVOICE_FLAG :='|| l_dets.print_on_invoice_flag);
12818 QP_PREQ_GRP.engine_debug('PRICING_PHASE_ID :='|| l_dets.PRICING_PHASE_ID);
12819 QP_PREQ_GRP.engine_debug('*OPERAND_CALCULATION_CODE :='|| l_dets.OPERAND_CALCULATION_CODE);
12820 QP_PREQ_GRP.engine_debug('*OPERAND_VALUE :='|| l_dets.OPERAND_VALUE);
12821 QP_PREQ_GRP.engine_debug('*ORDER_QTY_OPERAND :='|| l_dets.ORDER_QTY_OPERAND);
12822 QP_PREQ_GRP.engine_debug('*ORDER_QTY_ADJ_AMT :='|| l_dets.ORDER_QTY_ADJ_AMT);
12823 QP_PREQ_GRP.engine_debug('*STATUS_CODE:=' || l_dets.PRICING_STATUS_CODE);
12824 QP_PREQ_GRP.engine_debug('*STATUS_TEXT:=' || substr(l_dets.PRICING_STATUS_TEXT, 1, 240));
12825 QP_PREQ_GRP.engine_debug('SUBSTITUTION_ATTRIBUTE:=' || l_dets.SUBSTITUTION_ATTRIBUTE);
12826 QP_PREQ_GRP.engine_debug('ACCRUAL_FLAG:=' || l_dets.ACCRUAL_FLAG);
12827 QP_PREQ_GRP.engine_debug('LIST_LINE_NO:=' || l_dets.LIST_LINE_NO);
12828 QP_PREQ_GRP.engine_debug('ESTIM_GL_VALUE:=' || l_dets.ESTIM_GL_VALUE);
12829 QP_PREQ_GRP.engine_debug('ACCRUAL_CONVERSION_RATE:=' || l_dets.ACCRUAL_CONVERSION_RATE);
12830 END IF;
12831 --Pass throuh components
12832 IF l_debug = FND_API.G_TRUE THEN
12833 QP_PREQ_GRP.engine_debug('OVERRIDE_FLAG:=' || l_dets.OVERRIDE_FLAG);
12834 QP_PREQ_GRP.engine_debug('INVENTORY_ITEM_ID:=' || l_dets.INVENTORY_ITEM_ID);
12835 QP_PREQ_GRP.engine_debug('ORGANIZATION_ID:=' || l_dets.ORGANIZATION_ID);
12836 QP_PREQ_GRP.engine_debug('RELATED_ITEM_ID:=' || l_dets.RELATED_ITEM_ID);
12837 QP_PREQ_GRP.engine_debug('RELATIONSHIP_TYPE_ID:=' || l_dets.RELATIONSHIP_TYPE_ID);
12838 QP_PREQ_GRP.engine_debug('ESTIM_ACCRUAL_RATE:=' || l_dets.ESTIM_ACCRUAL_RATE);
12839 QP_PREQ_GRP.engine_debug('EXPIRATION_DATE:=' || l_dets.EXPIRATION_DATE);
12840 QP_PREQ_GRP.engine_debug('BENEFIT_PRICE_LIST_LINE_ID:=' || l_dets.BENEFIT_PRICE_LIST_LINE_ID);
12841 QP_PREQ_GRP.engine_debug('RECURRING_FLAG:=' || l_dets.RECURRING_FLAG);
12842 QP_PREQ_GRP.engine_debug('BENEFIT_LIMIT:=' || l_dets.BENEFIT_LIMIT);
12843 QP_PREQ_GRP.engine_debug('CHARGE_TYPE_CODE:=' || l_dets.CHARGE_TYPE_CODE);
12844 QP_PREQ_GRP.engine_debug('CHARGE_SUBTYPE_CODE:=' || l_dets.CHARGE_SUBTYPE_CODE);
12845 QP_PREQ_GRP.engine_debug('BENEFIT_QTY:=' || l_dets.BENEFIT_QTY);
12846 QP_PREQ_GRP.engine_debug('BENEFIT_UOM_CODE:=' || l_dets.BENEFIT_UOM_CODE);
12847 QP_PREQ_GRP.engine_debug('PRORATION_TYPE_CODE:=' || l_dets.PRORATION_TYPE_CODE);
12848 QP_PREQ_GRP.engine_debug('INCLUDE_ON_RETURNS_FLAG :='|| l_dets.INCLUDE_ON_RETURNS_FLAG);
12849 QP_PREQ_GRP.engine_debug('MODIFIER_LEVEL_CODE :='|| l_dets.MODIFIER_LEVEL_CODE);
12850 QP_PREQ_GRP.engine_debug('GROUP VALUE :='|| l_dets.GROUP_QUANTITY);
12851 QP_PREQ_GRP.engine_debug('LIMIT_CODE :='|| l_dets.LIMIT_CODE);
12852 QP_PREQ_GRP.engine_debug('LIMIT_TEXT :='|| substr(l_dets.LIMIT_TEXT, 1, 240));
12853
12854 QP_PREQ_GRP.engine_debug('---------------------------------------------------');
12855 END IF;
12856 END LOOP; --l_ldets_cur
12857 END LOOP; --end l_lines_cur
12858 IF l_debug = FND_API.G_TRUE THEN
12859 QP_PREQ_GRP.engine_debug('---------------------------------------------------');
12860
12861 END IF;
12862 EXCEPTION
12863 WHEN OTHERS THEN
12864 IF l_debug = FND_API.G_TRUE THEN
12865 QP_PREQ_GRP.engine_debug('QP_PREQ_PUB.Populate_Output_INT: '|| SQLERRM);
12866 END IF;
12867 x_return_status := FND_API.G_RET_STS_ERROR;
12868 x_return_status_text := 'QP_PREQ_PUB.Populate_Output_INT: '|| SQLERRM;
12869 END Populate_Output_INT;
12870 --added by yangli for Java Engine project
12871
12872 --This is for debugging purposes
12873 PROCEDURE Populate_Output(x_return_status OUT NOCOPY VARCHAR2,
12874 x_return_status_text OUT NOCOPY VARCHAR2) IS
12875
12876 /*
12877 INDX,QP_PREQ_PUB.populate_output.l_lines_cur,- No Index Used -,NA,NA
12878 */
12879 CURSOR l_lines_cur IS
12880 SELECT LINE_INDEX,
12881 LINE_ID,
12882 LINE_TYPE_CODE,
12883 LINE_QUANTITY,
12884 LINE_UOM_CODE,
12885 LINE_UNIT_PRICE, --shu_latest
12886 PRICED_QUANTITY,
12887 UOM_QUANTITY,
12888 PRICED_UOM_CODE,
12889 CURRENCY_CODE,
12890 UNIT_PRICE,
12891 PERCENT_PRICE,
12892 PARENT_PRICE,
12893 PARENT_QUANTITY,
12894 PARENT_UOM_CODE,
12895 PRICE_FLAG,
12896 ADJUSTED_UNIT_PRICE,
12897 UPDATED_ADJUSTED_UNIT_PRICE,
12898 PROCESSING_ORDER,
12899 PROCESSED_CODE,
12900 PROCESSED_FLAG,
12901 PRICING_STATUS_CODE,
12902 PRICING_STATUS_TEXT,
12903 HOLD_CODE,
12904 HOLD_TEXT,
12905 PRICE_REQUEST_CODE,
12906 PRICING_EFFECTIVE_DATE,
12907 PRICE_LIST_HEADER_ID,
12908 PROCESS_STATUS,
12909 CATCHWEIGHT_QTY,
12910 ACTUAL_ORDER_QUANTITY,
12911 ORDER_UOM_SELLING_PRICE,
12912 SERVICE_DURATION,
12913 SERVICE_PERIOD
12914 FROM qp_npreq_lines_tmp;
12915
12916 /*
12917 INDX,QP_PREQ_GRP.populate_output.l_ldets_cur,QP_LIST_LINES_PK,LIST_LINE_ID,1
12918 INDX,QP_PREQ_GRP.populate_output.l_ldets_cur,qp_npreq_ldets_tmp_N4,PRICING_STATUS_CODE,1
12919 INDX,QP_PREQ_GRP.populate_output.l_ldets_cur,QP_LIST_HEADERS_B_PK,LIST_HEADER_ID,1
12920 */
12921 CURSOR l_ldets_cur(p_line_index NUMBER) IS
12922 SELECT /*+ ORDERED USE_NL(A B C) l_ldets_cur */
12923 a.LINE_DETAIL_INDEX,
12924 a.LINE_DETAIL_TYPE_CODE,
12925 a.LINE_INDEX,
12926 a.CREATED_FROM_LIST_HEADER_ID LIST_HEADER_ID,
12927 a.CREATED_FROM_LIST_LINE_ID LIST_LINE_ID,
12928 a.CREATED_FROM_LIST_LINE_TYPE LIST_LINE_TYPE_CODE,
12929 a.PRICE_BREAK_TYPE_CODE,
12930 a.LINE_QUANTITY,
12931 a.ADJUSTMENT_AMOUNT,
12932 a.AUTOMATIC_FLAG,
12933 a.PRICING_PHASE_ID,
12934 a.OPERAND_CALCULATION_CODE,
12935 a.OPERAND_VALUE,
12936 a.PRICING_GROUP_SEQUENCE,
12937 a.CREATED_FROM_LIST_TYPE_CODE,
12938 a.APPLIED_FLAG,
12939 a.PRICING_STATUS_CODE,
12940 a.PRICING_STATUS_TEXT,
12941 a.LIMIT_CODE,
12942 a.LIMIT_TEXT,
12943 a.LIST_LINE_NO,
12944 a.GROUP_QUANTITY,
12945 a.UPDATED_FLAG,
12946 a.PROCESS_CODE,
12947 a.CALCULATION_CODE,
12948 a.PRICE_ADJUSTMENT_ID,
12949 b.SUBSTITUTION_VALUE SUBSTITUTION_VALUE_TO,
12950 b.SUBSTITUTION_ATTRIBUTE,
12951 b.ACCRUAL_FLAG,
12952 a.modifier_level_code,
12953 b.ESTIM_GL_VALUE,
12954 b.ACCRUAL_CONVERSION_RATE,
12955 --Pass throuh components
12956 b.OVERRIDE_FLAG,
12957 b.PRINT_ON_INVOICE_FLAG,
12958 b.INVENTORY_ITEM_ID,
12959 b.ORGANIZATION_ID,
12960 b.RELATED_ITEM_ID,
12961 b.RELATIONSHIP_TYPE_ID,
12962 b.ESTIM_ACCRUAL_RATE,
12963 b.EXPIRATION_DATE,
12964 b.BENEFIT_PRICE_LIST_LINE_ID,
12965 b.RECURRING_FLAG,
12966 b.BENEFIT_LIMIT,
12967 b.CHARGE_TYPE_CODE,
12968 b.CHARGE_SUBTYPE_CODE,
12969 a.BENEFIT_QTY, --bug 2804053
12970 b.BENEFIT_UOM_CODE,
12971 b.SERVICE_DURATION, -- service project
12972 b.SERVICE_PERIOD, -- service project
12973 b.PRORATION_TYPE_CODE,
12974 b.INCLUDE_ON_RETURNS_FLAG,
12975 b.REBATE_TRANSACTION_TYPE_CODE,
12976 b.NUMBER_EXPIRATION_PERIODS,
12977 b.EXPIRATION_PERIOD_UOM,
12978 b.COMMENTS,
12979 a.ORDER_QTY_OPERAND,
12980 a.ORDER_QTY_ADJ_AMT
12981 FROM qp_npreq_ldets_tmp a,
12982 QP_LIST_LINES b
12983 WHERE a.line_index = p_line_index
12984 AND a.CREATED_FROM_LIST_LINE_ID = b.LIST_LINE_ID
12985 AND a.PRICING_STATUS_CODE = G_STATUS_NEW;
12986
12987 BEGIN
12988
12989 IF l_debug = FND_API.G_TRUE THEN
12990 QP_PREQ_GRP.engine_debug('---------------------------------------------------');
12991 END IF;
12992
12993 FOR l_line IN l_lines_cur LOOP
12994 IF l_debug = FND_API.G_TRUE THEN
12995 QP_PREQ_GRP.engine_debug('----price line info--------------------------------');
12996 QP_PREQ_GRP.engine_debug('---------------------------------------------------');
12997 END IF;
12998
12999 IF l_debug = FND_API.G_TRUE THEN
13000 QP_PREQ_GRP.engine_debug('*LINE_INDEX :='|| l_line.LINE_INDEX);
13001 QP_PREQ_GRP.engine_debug('*LINE_ID :='|| l_line.LINE_ID);
13002 QP_PREQ_GRP.engine_debug('LINE_TYPE_CODE :='|| l_line.LINE_TYPE_CODE);
13003 QP_PREQ_GRP.engine_debug('UOM_QUANTITY :='|| l_line.UOM_QUANTITY);
13004 QP_PREQ_GRP.engine_debug('CURRENCY_CODE :='|| l_line.CURRENCY_CODE);
13005 QP_PREQ_GRP.engine_debug('PRICED_QUANTITY :='|| l_line.PRICED_QUANTITY);
13006 QP_PREQ_GRP.engine_debug('PRICED_UOM_CODE :='|| l_line.PRICED_UOM_CODE);
13007 QP_PREQ_GRP.engine_debug('*UNIT_PRICE :='|| l_line.UNIT_PRICE);
13008 QP_PREQ_GRP.engine_debug('*PRICE_LIST_ID :='|| l_line.PRICE_LIST_HEADER_ID);
13009 QP_PREQ_GRP.engine_debug('LINE_QUANTITY:=' || l_line.LINE_QUANTITY);
13010 QP_PREQ_GRP.engine_debug('LINE_UOM_CODE:=' || l_line.LINE_UOM_CODE);
13011 QP_PREQ_GRP.engine_debug('LINE_UNIT_PRICE:=' || l_line.LINE_UNIT_PRICE); -- shu_latest
13012 QP_PREQ_GRP.engine_debug('PERCENT_PRICE :='|| l_line.PERCENT_PRICE);
13013 QP_PREQ_GRP.engine_debug('*ADJUSTED_UNIT_PRICE :='|| l_line.ADJUSTED_UNIT_PRICE);
13014 QP_PREQ_GRP.engine_debug('PARENT_PRICE :='|| l_line.PARENT_PRICE);
13015 QP_PREQ_GRP.engine_debug('PARENT_QUANTITY :='|| l_line.PARENT_QUANTITY);
13016 QP_PREQ_GRP.engine_debug('PARENT_UOM_CODE :='|| l_line.PARENT_UOM_CODE);
13017 QP_PREQ_GRP.engine_debug('processed_code :='|| l_line.processed_code);
13018 QP_PREQ_GRP.engine_debug('processed_flag :='|| l_line.processed_flag);
13019 QP_PREQ_GRP.engine_debug('Price Flag :='|| l_line.price_flag);
13020 QP_PREQ_GRP.engine_debug('*STATUS_CODE :='|| l_line.PRICING_STATUS_CODE);
13021 QP_PREQ_GRP.engine_debug('*STATUS_TEXT :='|| substr(l_line.PRICING_STATUS_TEXT, 1, 2000));
13022 QP_PREQ_GRP.engine_debug('HOLD_CODE := '|| l_line.HOLD_CODE);
13023 QP_PREQ_GRP.engine_debug('HOLD_TEXT := '|| substr(l_line.HOLD_TEXT, 1, 240));
13024 QP_PREQ_GRP.engine_debug('PRICE_REQUEST_CODE := '|| l_line.PRICE_REQUEST_CODE);
13025 QP_PREQ_GRP.engine_debug('PRICING_DATE := '|| l_line.PRICING_EFFECTIVE_DATE);
13026 QP_PREQ_GRP.engine_debug('*PROCESS_STATUS :='|| l_line.PROCESS_STATUS);
13027 QP_PREQ_GRP.engine_debug('*CATCHWEIGHT_QTY :='|| l_line.CATCHWEIGHT_QTY);
13028 QP_PREQ_GRP.engine_debug('*ACTUAL_ORDER_QTY :='|| l_line.ACTUAL_ORDER_QUANTITY);
13029 QP_PREQ_GRP.engine_debug('*ORDER_UOM_SELLING_PRICE :='|| l_line.ORDER_UOM_SELLING_PRICE);
13030 QP_PREQ_GRP.engine_debug('*SERVICE_DURATION :='|| l_line.SERVICE_DURATION); -- service project
13031 QP_PREQ_GRP.engine_debug('*SERVICE_PERIOD :='|| l_line.SERVICE_PERIOD); -- service project
13032 END IF;
13033
13034 IF l_debug = FND_API.G_TRUE THEN
13035 QP_PREQ_GRP.engine_debug('---------------------------------------------------');
13036
13037 END IF;
13038 --Populate Line detail
13039 FOR l_dets IN l_ldets_cur(l_line.LINE_INDEX) LOOP
13040
13041 IF l_debug = FND_API.G_TRUE THEN
13042 QP_PREQ_GRP.engine_debug('-----------Line detail Info -----------------------');
13043 QP_PREQ_GRP.engine_debug('---------------------------------------------------');
13044 QP_PREQ_GRP.engine_debug('*LINE_DETAIL_INDEX :='|| l_dets.LINE_DETAIL_INDEX);
13045 QP_PREQ_GRP.engine_debug('LINE_DETAIL_TYPE_CODE:=' || l_dets.LINE_DETAIL_TYPE_CODE);
13046 QP_PREQ_GRP.engine_debug('*LINE_INDEX:=' || l_dets.LINE_INDEX);
13047 QP_PREQ_GRP.engine_debug('*PROCESS_CODE:=' || l_dets.PROCESS_CODE);
13048 QP_PREQ_GRP.engine_debug('*CALCULATION_CODE:=' || l_dets.CALCULATION_CODE);
13049 QP_PREQ_GRP.engine_debug('*LIST_HEADER_ID:=' || l_dets.LIST_HEADER_ID);
13050 QP_PREQ_GRP.engine_debug('*LIST_LINE_ID:=' || l_dets.LIST_LINE_ID);
13051 QP_PREQ_GRP.engine_debug('*PRICE_ADJUSTMENT_ID:=' || l_dets.PRICE_ADJUSTMENT_ID);
13052 QP_PREQ_GRP.engine_debug('LIST_LINE_TYPE_CODE:=' || l_dets.LIST_LINE_TYPE_CODE);
13053 QP_PREQ_GRP.engine_debug('SUBSTITUTION_TO:=' || l_dets.SUBSTITUTION_VALUE_TO);
13054 QP_PREQ_GRP.engine_debug('LINE_QUANTITY :='|| l_dets.LINE_QUANTITY);
13055 QP_PREQ_GRP.engine_debug('*ADJUSTMENT_AMOUNT :='|| l_dets.ADJUSTMENT_AMOUNT);
13056 QP_PREQ_GRP.engine_debug('*AUTOMATIC_FLAG :='|| l_dets.AUTOMATIC_FLAG);
13057 QP_PREQ_GRP.engine_debug('APPLIED_FLAG :='|| l_dets.APPLIED_FLAG);
13058 QP_PREQ_GRP.engine_debug('UPDATED_FLAG :='|| l_dets.UPDATED_FLAG);
13059 QP_PREQ_GRP.engine_debug('PRICING_GROUP_SEQUENCE :='|| l_dets.PRICING_GROUP_SEQUENCE);
13060 QP_PREQ_GRP.engine_debug('CREATED_FROM_LIST_TYPE_CODE:=' || l_dets.CREATED_FROM_LIST_TYPE_CODE);
13061 QP_PREQ_GRP.engine_debug('PRICE_BREAK_TYPE_CODE :='|| l_dets.PRICE_BREAK_TYPE_CODE);
13062 QP_PREQ_GRP.engine_debug('*OVERRIDE_FLAG :='|| l_dets.override_flag);
13063 QP_PREQ_GRP.engine_debug('PRINT_ON_INVOICE_FLAG :='|| l_dets.print_on_invoice_flag);
13064 QP_PREQ_GRP.engine_debug('PRICING_PHASE_ID :='|| l_dets.PRICING_PHASE_ID);
13065 QP_PREQ_GRP.engine_debug('*OPERAND_CALCULATION_CODE :='|| l_dets.OPERAND_CALCULATION_CODE);
13066 QP_PREQ_GRP.engine_debug('*OPERAND_VALUE :='|| l_dets.OPERAND_VALUE);
13067 QP_PREQ_GRP.engine_debug('*ORDER_QTY_OPERAND :='|| l_dets.ORDER_QTY_OPERAND);
13068 QP_PREQ_GRP.engine_debug('*ORDER_QTY_ADJ_AMT :='|| l_dets.ORDER_QTY_ADJ_AMT);
13069 QP_PREQ_GRP.engine_debug('*STATUS_CODE:=' || l_dets.PRICING_STATUS_CODE);
13070 QP_PREQ_GRP.engine_debug('*STATUS_TEXT:=' || substr(l_dets.PRICING_STATUS_TEXT, 1, 240));
13071 QP_PREQ_GRP.engine_debug('SUBSTITUTION_ATTRIBUTE:=' || l_dets.SUBSTITUTION_ATTRIBUTE);
13072 QP_PREQ_GRP.engine_debug('ACCRUAL_FLAG:=' || l_dets.ACCRUAL_FLAG);
13073 QP_PREQ_GRP.engine_debug('LIST_LINE_NO:=' || l_dets.LIST_LINE_NO);
13074 QP_PREQ_GRP.engine_debug('ESTIM_GL_VALUE:=' || l_dets.ESTIM_GL_VALUE);
13075 QP_PREQ_GRP.engine_debug('ACCRUAL_CONVERSION_RATE:=' || l_dets.ACCRUAL_CONVERSION_RATE);
13076 END IF;
13077 --Pass throuh components
13078 IF l_debug = FND_API.G_TRUE THEN
13079 QP_PREQ_GRP.engine_debug('OVERRIDE_FLAG:=' || l_dets.OVERRIDE_FLAG);
13080 QP_PREQ_GRP.engine_debug('INVENTORY_ITEM_ID:=' || l_dets.INVENTORY_ITEM_ID);
13081 QP_PREQ_GRP.engine_debug('ORGANIZATION_ID:=' || l_dets.ORGANIZATION_ID);
13082 QP_PREQ_GRP.engine_debug('RELATED_ITEM_ID:=' || l_dets.RELATED_ITEM_ID);
13083 QP_PREQ_GRP.engine_debug('RELATIONSHIP_TYPE_ID:=' || l_dets.RELATIONSHIP_TYPE_ID);
13084 QP_PREQ_GRP.engine_debug('ESTIM_ACCRUAL_RATE:=' || l_dets.ESTIM_ACCRUAL_RATE);
13085 QP_PREQ_GRP.engine_debug('EXPIRATION_DATE:=' || l_dets.EXPIRATION_DATE);
13086 QP_PREQ_GRP.engine_debug('BENEFIT_PRICE_LIST_LINE_ID:=' || l_dets.BENEFIT_PRICE_LIST_LINE_ID);
13087 QP_PREQ_GRP.engine_debug('RECURRING_FLAG:=' || l_dets.RECURRING_FLAG);
13088 QP_PREQ_GRP.engine_debug('BENEFIT_LIMIT:=' || l_dets.BENEFIT_LIMIT);
13089 QP_PREQ_GRP.engine_debug('CHARGE_TYPE_CODE:=' || l_dets.CHARGE_TYPE_CODE);
13090 QP_PREQ_GRP.engine_debug('CHARGE_SUBTYPE_CODE:=' || l_dets.CHARGE_SUBTYPE_CODE);
13091 QP_PREQ_GRP.engine_debug('BENEFIT_QTY:=' || l_dets.BENEFIT_QTY);
13092 QP_PREQ_GRP.engine_debug('BENEFIT_UOM_CODE:=' || l_dets.BENEFIT_UOM_CODE);
13093 QP_PREQ_GRP.engine_debug('SERVICE_DURATION:=' || l_dets.SERVICE_DURATION); -- service project
13094 QP_PREQ_GRP.engine_debug('SERVICE_PERIOD:=' || l_dets.SERVICE_PERIOD); -- service project
13095 QP_PREQ_GRP.engine_debug('PRORATION_TYPE_CODE:=' || l_dets.PRORATION_TYPE_CODE);
13096 QP_PREQ_GRP.engine_debug('INCLUDE_ON_RETURNS_FLAG :='|| l_dets.INCLUDE_ON_RETURNS_FLAG);
13097 QP_PREQ_GRP.engine_debug('MODIFIER_LEVEL_CODE :='|| l_dets.MODIFIER_LEVEL_CODE);
13098 QP_PREQ_GRP.engine_debug('GROUP VALUE :='|| l_dets.GROUP_QUANTITY);
13099 QP_PREQ_GRP.engine_debug('LIMIT_CODE :='|| l_dets.LIMIT_CODE);
13100 QP_PREQ_GRP.engine_debug('LIMIT_TEXT :='|| substr(l_dets.LIMIT_TEXT, 1, 240));
13101
13102 QP_PREQ_GRP.engine_debug('---------------------------------------------------');
13103 END IF;
13104 END LOOP; --l_ldets_cur
13105 END LOOP; --end l_lines_cur
13106 IF l_debug = FND_API.G_TRUE THEN
13107 QP_PREQ_GRP.engine_debug('---------------------------------------------------');
13108
13109 END IF;
13110 EXCEPTION
13111 WHEN OTHERS THEN
13112 IF l_debug = FND_API.G_TRUE THEN
13113 QP_PREQ_GRP.engine_debug('QP_PREQ_PUB.Populate_Output: '|| SQLERRM);
13114 END IF;
13115 x_return_status := FND_API.G_RET_STS_ERROR;
13116 x_return_status_text := 'QP_PREQ_PUB.Populate_Output: '|| SQLERRM;
13117 END Populate_Output;
13118
13119
13120
13121
13122 PROCEDURE PRICE_REQUEST
13123 (p_line_tbl IN QP_PREQ_GRP.LINE_TBL_TYPE,
13124 p_qual_tbl IN QP_PREQ_GRP.QUAL_TBL_TYPE,
13125 p_line_attr_tbl IN QP_PREQ_GRP.LINE_ATTR_TBL_TYPE,
13126 p_line_detail_tbl IN QP_PREQ_GRP.LINE_DETAIL_TBL_TYPE,
13127 p_line_detail_qual_tbl IN QP_PREQ_GRP.LINE_DETAIL_QUAL_TBL_TYPE,
13128 p_line_detail_attr_tbl IN QP_PREQ_GRP.LINE_DETAIL_ATTR_TBL_TYPE,
13129 p_related_lines_tbl IN QP_PREQ_GRP.RELATED_LINES_TBL_TYPE,
13130 p_control_rec IN QP_PREQ_GRP.CONTROL_RECORD_TYPE,
13131 x_line_tbl OUT NOCOPY QP_PREQ_GRP.LINE_TBL_TYPE,
13132 x_line_qual OUT NOCOPY QP_PREQ_GRP.QUAL_TBL_TYPE,
13133 x_line_attr_tbl OUT NOCOPY QP_PREQ_GRP.LINE_ATTR_TBL_TYPE,
13134 x_line_detail_tbl OUT NOCOPY QP_PREQ_GRP.LINE_DETAIL_TBL_TYPE,
13135 x_line_detail_qual_tbl OUT NOCOPY QP_PREQ_GRP.LINE_DETAIL_QUAL_TBL_TYPE,
13136 x_line_detail_attr_tbl OUT NOCOPY QP_PREQ_GRP.LINE_DETAIL_ATTR_TBL_TYPE,
13137 x_related_lines_tbl OUT NOCOPY QP_PREQ_GRP.RELATED_LINES_TBL_TYPE,
13138 x_return_status OUT NOCOPY VARCHAR2,
13139 x_return_status_text OUT NOCOPY VARCHAR2
13140 ) IS
13141
13142 PRICE_REQUEST_EXC EXCEPTION;
13143 E_BYPASS_PRICING EXCEPTION;
13144 E_DEBUG_ROUTINE_ERROR EXCEPTION;
13145 --added by yangli for Java Engine projecct 3086881
13146 E_ROUTINE_ERRORS EXCEPTION;
13147 Pricing_Exception EXCEPTION;
13148 JAVA_ENGINE_PRICING_EXCEPTION EXCEPTION;
13149 --added by yangli for Java Engine projecct 3086881
13150 E_NO_LINES_TO_PRICE EXCEPTION; -- 4865787
13151
13152 l_control_rec QP_PREQ_GRP.CONTROL_RECORD_TYPE;
13153
13154 l_routine VARCHAR2(50) := 'Routine: QP_PREQ_PUB.PRICE_REQUEST';
13155 l_output_file VARCHAR2(240);
13156
13157 i PLS_INTEGER;
13158 j PLS_INTEGER;
13159
13160 /*
13161 INDX,QP_PREQ_PUB.price_request.lcur1,qp_npreq_ldets_tmp_N3,LINE_INDEX,1
13162 INDX,QP_PREQ_PUB.price_request.lcur1,qp_npreq_ldets_tmp_N3,PRICING_STATUS_CODE,4
13163 */
13164 CURSOR lcur1 IS
13165 SELECT ldet.created_from_list_line_id
13166 , line.line_index line_ind
13167 , line.price_flag
13168 , line.process_status
13169 , ldet.applied_flag
13170 , ldet.pricing_status_code
13171 , ldet.line_detail_index
13172 , ldet.process_code
13173 , ldet.automatic_flag
13174 , ldet.override_flag
13175 , line.unit_price
13176 , line.adjusted_unit_price
13177 , ldet.updated_flag
13178 , ldet.calculation_code
13179 , line.qualifiers_exist_flag
13180 , ldet.pricing_group_sequence bucket
13181 FROM qp_npreq_ldets_tmp ldet, qp_npreq_lines_tmp line
13182 WHERE line.line_index = ldet.line_index
13183 ORDER BY line_ind;
13184
13185 --3169430
13186 CURSOR modifier_exists IS
13187 SELECT 'X'
13188 FROM
13189 QP_LIST_LINES A
13190 WHERE A.PRICING_PHASE_ID >1
13191 AND modifier_level_code IN ('LINE', 'LINEGROUP', 'ORDER')
13192 AND ROWNUM = 1;
13193
13194 lrec1 lcur1%ROWTYPE;
13195 l_debug_switch CONSTANT VARCHAR2(30) := 'QP_DEBUG';
13196 l_return_status VARCHAR2(240);
13197 l_return_status_text VARCHAR2(240);
13198 l_pricing_event VARCHAR2(240);
13199 l_pricing_start_time NUMBER;
13200 l_pricing_end_time NUMBER;
13201 l_time_difference NUMBER;
13202 l_pricing_start_redo NUMBER;
13203 l_pricing_end_redo NUMBER;
13204 l_redo_difference NUMBER;
13205 l_request_type_code VARCHAR2(30);
13206 l_time_stats VARCHAR2(240);
13207 l_mod VARCHAR2(1);
13208 --added by yangli for JAVA ENGINE 3086881
13209 l_request_id NUMBER;
13210 l_status_text VARCHAR2(240);
13211 l_cleanup_flag VARCHAR2(1) := QP_PREQ_PUB.G_YES;
13212 --added by yangli for JAVA ENGINE 3086881
13213 l_no_of_lines NUMBER; -- 4865787
13214
13215 --added for moac
13216 l_default_org_id NUMBER;
13217 --perf fix for bug 7309551 smbalara
13218 l_dynamic_sampling_level NUMBER :=0;
13219 l_old_dynamic_sampling_level NUMBER :=0;
13220
13221 l_qp_license_product VARCHAR2(30) := NULL; /*Added for bug 8865594*/
13222
13223 l_total_engine_time NUMBER;
13224 BEGIN
13225
13226 qp_debug_util.addSummaryTimeLog('Total time taken in Fetching Input Attributes :' || qp_debug_util.getAttribute('BLD_CNTXT_ACCUM_TIME') || 'ms',0,1,1);
13227 qp_debug_util.tstart(x_Marker=>'ENGINE_CALL_QPXPPREB',x_Desc=>'QPXPPREB Price Request for Event : '||p_control_rec.PRICING_EVENT,x_PutLine=>true);
13228
13229 --===============START: Pre-pricing process needed by JAVA and PL/SQL engine====
13230 -- Set the debug variable G_DEBUG_ENGINE in QP_PREQ_GRP
13231 QP_PREQ_GRP.Set_QP_Debug;
13232 G_QP_DEBUG := FND_PROFILE.VALUE(l_debug_switch); --3085171
13233
13234 --Setting current event in debug util
13235 qp_debug_util.setCurrentEvent(p_control_rec.PRICING_EVENT);
13236 --QP_PREQ_GRP.G_CURR_PRICE_EVENT := p_control_rec.PRICING_EVENT;
13237
13238 l_debug := QP_PREQ_GRP.G_DEBUG_ENGINE;
13239 l_pricing_start_time := dbms_utility.get_time;
13240
13241 /* 4865787: error out if there are no lines to be priced */
13242 IF nvl(p_control_rec.temp_table_insert_flag, G_YES) = G_NO
13243 THEN
13244 -- temp table/direct insert path
13245 select count(*) into l_no_of_lines
13246 from qp_npreq_lines_tmp;
13247 ELSE
13248 -- PL/SQL table path
13249 l_no_of_lines := p_line_tbl.count;
13250 END IF;
13251
13252 IF l_no_of_lines = 0 THEN
13253 RAISE E_NO_LINES_TO_PRICE;
13254 END IF;
13255 /* 4865787 */
13256
13257 --moved down, since specific to only PL/SQL engine
13258 /*-- Changes made for bug 3169430 Customer Handleman as this customer has price lists only, no modifiers.
13259 open modifier_exists;
13260 fetch modifier_exists into l_mod;
13261 IF modifier_exists%NOTFOUND THEN
13262 G_NO_ADJ_PROCESSING := G_NO;
13263 ELSE
13264 G_NO_ADJ_PROCESSING := G_YES;
13265 END IF;
13266 CLOSE modifier_exists;
13267 */
13268 ----------------------------------------------------
13269 --setting time
13270 ----------------------------------------------------
13271 IF G_QP_DEBUG = G_ENGINE_TIME_TRACE_ON THEN --3085171
13272 -- l_pricing_start_time := dbms_utility.get_time;
13273 --added to note redo generation
13274 BEGIN
13275 SELECT VALUE INTO l_pricing_start_redo
13276 FROM v$mystat, v$statname
13277 WHERE v$mystat.statistic# = v$statname.statistic#
13278 AND v$statname.name = 'redo size';
13279 EXCEPTION
13280 WHEN OTHERS THEN
13281 IF l_debug = FND_API.G_TRUE THEN
13282 QP_PREQ_GRP.engine_debug('Error in looking up debug in PUB '|| SQLERRM);
13283 END IF; -- Bug No 4033618
13284 END;
13285 END IF;
13286
13287 --MOVED TO HERE SINCE BOTH JAVA ENGINE AND PL/SQL ENGINE NEED by yangli
13288 --ASO is not passing request_type_code on control_rec, it is passed
13289 --on the lines
13290 IF p_control_rec.request_type_code IS NULL THEN
13291 l_request_type_code := p_LINE_tbl(1).request_type_code;
13292 END IF; --p_control_rec.request_type_code
13293
13294 l_control_rec := p_control_rec;
13295
13296 --added for moac
13297 --Initialize MOAC and set org context to Org passed in nvl(p_control_rec.org_id, mo_default_org_id)
13298 --so that the pricing engine will look at data specific to the
13299 --passed org or mo_default_org plus global data only
13300
13301 IF MO_GLOBAL.get_access_mode is null THEN
13302 MO_GLOBAL.Init('QP');
13303 l_control_rec.org_id := nvl(p_control_rec.org_id, QP_UTIL.get_org_id);
13304 MO_GLOBAL.set_policy_context('S', l_control_rec.org_id);
13305 END IF;--MO_GLOBAL
13306
13307 --OC used to pass request_type_code only on the lines tbl
13308 l_control_rec.request_type_code := nvl(p_control_rec.request_type_code,
13309 l_request_type_code);
13310 G_CHECK_CUST_VIEW_FLAG := nvl(p_control_rec.check_cust_view_flag, G_NO);
13311 --3401941
13312 G_CALCULATE_FLAG := nvl(l_control_rec.CALCULATE_FLAG, 'NULL');
13313 G_REQUEST_TYPE_CODE := l_control_rec.request_type_code;
13314
13315 --this is added for the FTE get_freight functionality to return adj
13316 --from the freight charge phases
13317 G_GET_FREIGHT_FLAG := nvl(l_control_rec.get_freight_flag, G_NO);
13318
13319 -- for QP-PO integration
13320
13321 IF l_debug = FND_API.G_TRUE THEN
13322 QP_PREQ_GRP.engine_debug('G_REQUEST_TYPE_CODE = ' || G_REQUEST_TYPE_CODE);
13323 qp_debug_util.print_support_csv('START');
13324 END IF;
13325
13326
13327 IF G_REQUEST_TYPE_CODE IN ('PO', 'ICX') THEN
13328 IF G_LICENSED_FOR_PRODUCT IS NULL THEN
13329 G_LICENSED_FOR_PRODUCT := nvl(fnd_profile.VALUE('QP_LICENSED_FOR_PRODUCT'), 'ZZZZZZ');
13330 /*Added for bug 8865594*/
13331 --l_qp_license_product := FND_PROFILE.VALUE_SPECIFIC(NAME => 'QP_LICENSED_FOR_PRODUCT',application_id => 201);
13332
13333 END IF;
13334
13335 -- bug9285924
13336 l_qp_license_product := FND_PROFILE.VALUE_SPECIFIC(NAME => 'QP_LICENSED_FOR_PRODUCT',application_id => 201);
13337
13338 IF l_debug = FND_API.G_TRUE THEN
13339 QP_PREQ_GRP.engine_debug('G_LICENSED_FOR_PRODUCT = ' || G_LICENSED_FOR_PRODUCT);
13340 QP_PREQ_GRP.engine_debug('l_qp_license_product = ' || l_qp_license_product);
13341 END IF;
13342
13343 IF (G_LICENSED_FOR_PRODUCT = 'PO' OR
13344 nvl(l_qp_license_product, 'X') = 'PO') THEN -- Added for 8865594
13345 NULL;
13346 ELSE
13347 x_return_status := FND_API.G_RET_STS_ERROR;
13348 FND_MESSAGE.SET_NAME('QP', 'QP_NOT_LICENSED_PO');
13349 x_return_status_text := FND_MESSAGE.get;
13350 RETURN;
13351 END IF;
13352 END IF;
13353
13354 -- for QP-CMRO integration
13355 IF G_REQUEST_TYPE_CODE = 'AHL' THEN
13356 IF G_LICENSED_FOR_PRODUCT IS NULL THEN
13357 G_LICENSED_FOR_PRODUCT := nvl(fnd_profile.VALUE('QP_LICENSED_FOR_PRODUCT'), 'ZZZZZZ');
13358 END IF;
13359
13360 IF l_debug = FND_API.G_TRUE THEN
13361 QP_PREQ_GRP.engine_debug('G_LICENSED_FOR_PRODUCT = ' || G_LICENSED_FOR_PRODUCT);
13362 END IF;
13363
13364 IF G_LICENSED_FOR_PRODUCT = 'AHL' THEN
13365 NULL;
13366 ELSE
13367 x_return_status := FND_API.G_RET_STS_ERROR;
13368 FND_MESSAGE.SET_NAME('QP', 'QP_NOT_LICENSED_CMRO');
13369 x_return_status_text := FND_MESSAGE.get;
13370 RETURN;
13371 END IF;
13372 END IF;
13373
13374 IF (G_QP_DEBUG = G_YES) OR
13375 (G_QP_DEBUG = G_DONT_WRITE_TO_DEBUG) THEN -- If Debug is on
13376
13377 -- A call to QP_COPY_DEBUG_PVT.Generate_Debug_Req_Seq to initialize Global Variables
13378 QP_COPY_DEBUG_PVT.Generate_Debug_Req_Seq(l_return_status,
13379 l_return_status_text);
13380 x_return_status := l_return_status;
13381 x_return_status_text := l_return_status_text;
13382 IF x_return_status = FND_API.G_RET_STS_ERROR THEN
13383 RAISE E_DEBUG_ROUTINE_ERROR;
13384 END IF;
13385
13386 END IF;
13387 --MOVED TO HERE SINCE BOTH JAVA ENGINE AND PL/SQL ENGINE NEED by yangli
13388 --===========END: Pre-pricing process needed by JAVA and PL/SQL engine=========
13389
13390 --ADDED BY YANGLI FOR JAVA ENGINE PUB 3086881
13391 IF QP_JAVA_ENGINE_UTIL_PUB.Java_Engine_Running = 'N' THEN
13392 --===========START: Globals Initialization specific only to PL/SQL Engine=======
13393 IF l_debug = FND_API.G_TRUE THEN
13394 QP_PREQ_GRP.ENGINE_DEBUG('01 Java Engine not Installed ----------');
13395 END IF;
13396
13397 -- Changes made for bug 3169430 Customer Handleman as this customer has price lists only, no modifiers.
13398 OPEN modifier_exists;
13399 FETCH modifier_exists INTO l_mod;
13400 IF modifier_exists%NOTFOUND THEN
13401 G_NO_ADJ_PROCESSING := G_NO;
13402 ELSE
13403 G_NO_ADJ_PROCESSING := G_YES;
13404 END IF;
13405 CLOSE modifier_exists;
13406
13407 ----------------------------------------------------
13408 --setting debug level
13409 ----------------------------------------------------
13410 --QP_PREQ_GRP.G_DEBUG_ENGINE:= oe_debug_pub.G_DEBUG;
13411 ----------------------------------------------------
13412 --New QP profile to say whether to round adjustment_amt or selling/list_price
13413 --default to 'Y' if the profile or rounding_flag are null
13414 -- QP Profile QP_SELLING_PRICE_ROUNDING_OPTIONS
13415 --Values for the profile:
13416 --NO_ROUND - No rounding :
13417 -- Selling Price = unrounded list price + unrounded adjustments;
13418 --ROUND_ADJ - Round Selling Price and adjustments :
13419 -- Selling Price = round(list price) + round(adjustments);
13420 --NO_ROUND_ADJ - Round Selling Price after adding unrounded list price and adjustments :
13421 -- Selling price = round(list _price + adjustments);
13422 --Rounding Option Changes:
13423 --Control Record Variable mapping to profile for backword compatibility.
13424 -- NULL - ROUND_ADJ for non-ASO req_type and look at the QP profile for ASO
13425 -- Y - ROUND_ADJ
13426 -- N - NO_ROUND
13427 -- U - NO_ROUND_ADJ
13428 -- Q - look at the QP profile
13429 --Change for 2635440 - pass 'Q' as default value for OC if request_type is 'ASO'
13430 ----------------------------------------------------
13431 G_ROUNDING_OPTIONS := FND_PROFILE.VALUE('QP_SELLING_PRICE_ROUNDING_OPTIONS');
13432 IF (l_debug = FND_API.G_TRUE) THEN
13433 QP_PREQ_GRP.engine_debug('Rounding profile value '|| G_ROUNDING_OPTIONS);
13434 END IF;
13435
13436 /*--ASO is not passing request_type_code on control_rec, it is passed
13437 --on the lines
13438 IF p_control_rec.request_type_code IS NULL THEN
13439 l_request_type_code := p_LINE_tbl(1).request_type_code;
13440 END IF;--p_control_rec.request_type_code
13441
13442 l_control_rec := p_control_rec;
13443 --OC used to pass request_type_code only on the lines tbl
13444 l_control_rec.request_type_code := nvl(p_control_rec.request_type_code,
13445 l_request_type_code);
13446 G_REQUEST_TYPE_CODE := l_control_rec.request_type_code;
13447 */ --moved to top since both PL/SQL path and Java Engine path need.
13448
13449 /*--this is added for the FTE get_freight functionality to return adj
13450 --from the freight charge phases
13451 G_GET_FREIGHT_FLAG := nvl(l_control_rec.get_freight_flag, G_NO);
13452 */ --moved to top since needed by both PL/SQL and Java Engine
13453
13454 -- Added new profile (QP_MULTI_CURRENCY_USAGE) with default value 'N' to maintain
13455 -- current behaviour,bug 2943033
13456 IF p_control_rec.use_multi_currency = 'Y' THEN
13457 G_USE_MULTI_CURRENCY_PUB := p_control_rec.use_multi_currency;
13458 ELSE
13459 G_USE_MULTI_CURRENCY_PUB := nvl(fnd_profile.VALUE('QP_MULTI_CURRENCY_USAGE'), 'N');
13460 l_control_rec.use_multi_currency := G_USE_MULTI_CURRENCY_PUB;
13461 END IF;
13462
13463 IF nvl(p_control_rec.rounding_flag, G_YES) = G_ROUNDING_PROFILE
13464 THEN
13465 G_ROUND_INDIVIDUAL_ADJ := nvl(G_ROUNDING_OPTIONS, G_NO_ROUND);
13466 ELSIF nvl(p_control_rec.rounding_flag, G_YES) = G_YES
13467 THEN
13468 --this is done for bug 2635440 for OC to default the rounding_flag to 'Q'
13469 --to look at the profile for rounding if the rounding_flag is null
13470 --in the pl/sql code path. OC will pass Q for direct insert path
13471 IF G_REQUEST_TYPE_CODE = 'ASO'
13472 AND nvl(p_control_rec.temp_table_insert_flag, G_YES) = G_YES
13473 AND p_control_rec.rounding_flag IS NULL THEN
13474 G_ROUND_INDIVIDUAL_ADJ := nvl(G_ROUNDING_OPTIONS, G_NO_ROUND);
13475 ELSE
13476 G_ROUND_INDIVIDUAL_ADJ := G_ROUND_ADJ;
13477 END IF; --l_control_rec.request_type_code
13478 ELSIF nvl(p_control_rec.rounding_flag, G_YES) = G_NO
13479 THEN
13480 G_ROUND_INDIVIDUAL_ADJ := G_NO_ROUND;
13481 ELSIF nvl(p_control_rec.rounding_flag, G_YES) = 'U'
13482 THEN
13483 G_ROUND_INDIVIDUAL_ADJ := G_NO_ROUND_ADJ;
13484 ELSIF nvl(p_control_rec.rounding_flag, G_YES) = 'P' --[prarasto:Post Round] added condition to update
13485 --G_ROUND_INDIVIDUAL_ADJ for post rounding
13486 THEN
13487 G_ROUND_INDIVIDUAL_ADJ := G_POST_ROUND;
13488 END IF;
13489
13490 -- The below code is replaced with QP_PREQ_GRP.Set_QP_Debug
13491
13492 --getting debug profilE
13493 ----------------------------------------------------
13494 --G_QP_DEBUG := FND_PROFILE.VALUE(l_debug_switch); --3085171
13495 ----------------------------------------------------
13496
13497 /* ----------------------------------------------------
13498
13499 -- Introduced for facilitating debugging for non OM Applications
13500 IF (NOT OE_DEBUG_PUB.ISDebugOn) THEN --If om debug is not on , then only look at
13501 --qp_debug
13502
13503 IF (G_QP_DEBUG = G_YES) OR
13504 (G_QP_DEBUG = G_DONT_WRITE_TO_DEBUG) THEN -- If Debug is on
13505 oe_debug_pub.SetDebugLevel(10);
13506 oe_debug_pub.Initialize;
13507 oe_debug_pub.debug_on;
13508 l_output_file := oe_debug_pub.Set_Debug_Mode('FILE');
13509 IF l_debug = FND_API.G_TRUE THEN
13510 QP_PREQ_GRP.engine_debug ('The output file is : ' || l_output_file );
13511 END IF;
13512 QP_PREQ_GRP.G_DEBUG_ENGINE:= FND_API.G_TRUE;
13513 ELSE
13514 QP_PREQ_GRP.G_DEBUG_ENGINE:= FND_API.G_FALSE;
13515 END IF;
13516 ELSE
13517 QP_PREQ_GRP.G_DEBUG_ENGINE:= FND_API.G_TRUE;
13518 END IF;
13519
13520 */
13521
13522 --MOVED UP TO BOTH JAVA AND PL/SQL ENGINE PATH by yangli
13523 /* IF (G_QP_DEBUG = G_YES) OR
13524 (G_QP_DEBUG = G_DONT_WRITE_TO_DEBUG) THEN -- If Debug is on
13525
13526 -- A call to QP_COPY_DEBUG_PVT.Generate_Debug_Req_Seq to initialize Global Variables
13527 QP_COPY_DEBUG_PVT.Generate_Debug_Req_Seq(l_return_status,
13528 l_return_status_text);
13529 x_return_status := l_return_status;
13530 x_return_status_text := l_return_status_text;
13531 IF x_return_status = FND_API.G_RET_STS_ERROR THEN
13532 RAISE E_DEBUG_ROUTINE_ERROR;
13533 END IF;
13534
13535 END IF;
13536 */
13537
13538 --GSA Check
13539 IF l_debug = FND_API.G_TRUE THEN
13540 QP_PREQ_GRP.ENGINE_DEBUG('PRICE REQUEST PUB: Begin GSA check ');
13541 END IF;
13542 G_GSA_INDICATOR := Check_GSA_Indicator;
13543 IF l_debug = FND_API.G_TRUE THEN
13544 QP_PREQ_GRP.ENGINE_DEBUG('PRICE REQUEST PUB: GSA_indicator '|| G_GSA_INDICATOR);
13545 QP_PREQ_GRP.ENGINE_DEBUG('PRICE REQUEST PUB: GSA_profile '|| G_GSA_ENABLED_FLAG);
13546
13547 END IF;
13548 G_GSA_CHECK_FLAG := nvl(p_control_rec.GSA_CHECK_FLAG, G_YES);
13549 G_GSA_ENABLED_FLAG := nvl(FND_PROFILE.VALUE(G_GSA_Max_Discount_Enabled), G_NO);
13550
13551
13552 IF l_debug = FND_API.G_TRUE THEN
13553 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: request_type_code '|| G_REQUEST_TYPE_CODE);
13554 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: check_cust_view_flag '|| G_check_cust_view_flag);
13555 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: round_indv_adj '|| G_ROUND_INDIVIDUAL_ADJ);
13556
13557 END IF;
13558 --===========END: Globals Initialization specific only to PL/SQL Engine=======
13559 END IF; --java engine is not installed
13560
13561 --============START: Debug print needed by JAVA and PL/SQL Engine=====
13562 IF l_debug = FND_API.G_TRUE THEN
13563 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: Version '|| Get_Version);
13564 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: temp table insert flag '|| p_control_rec.temp_table_insert_flag);
13565 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: calculate_flag '|| p_control_rec.calculate_flag);
13566 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: check_cust_view_flag '|| p_control_rec.check_cust_view_flag ||' reqtype '|| l_control_rec.request_type_code);
13567 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: pricing_event '|| p_control_rec.pricing_event);
13568 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: rounding_flag '|| p_control_rec.rounding_flag);
13569 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: gsa_check '|| p_control_rec.gsa_check_flag);
13570 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: full_pricing '|| p_control_rec.full_pricing_call);
13571 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: get_freight_flag '|| G_GET_FREIGHT_FLAG);
13572 END IF;
13573 --============END: Debug print needed by JAVA and PL/SQL Engine=====
13574
13575 /*
13576 --GSA Check
13577 IF l_debug = FND_API.G_TRUE THEN
13578 QP_PREQ_GRP.ENGINE_DEBUG('PRICE REQUEST PUB: Begin GSA check ');
13579 END IF;
13580 G_GSA_INDICATOR := Check_GSA_Indicator;
13581 IF l_debug = FND_API.G_TRUE THEN
13582 QP_PREQ_GRP.ENGINE_DEBUG('PRICE REQUEST PUB: GSA_indicator '||G_GSA_INDICATOR);
13583 QP_PREQ_GRP.ENGINE_DEBUG('PRICE REQUEST PUB: GSA_profile '||G_GSA_ENABLED_FLAG);
13584
13585 END IF;
13586 G_GSA_CHECK_FLAG := nvl(p_control_rec.GSA_CHECK_FLAG, G_YES);
13587 G_GSA_ENABLED_FLAG := nvl(FND_PROFILE.VALUE(G_GSA_Max_Discount_Enabled), G_NO);
13588
13589
13590 IF l_debug = FND_API.G_TRUE THEN
13591 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: request_type_code '||G_REQUEST_TYPE_CODE);
13592 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: check_cust_view_flag '||G_check_cust_view_flag);
13593 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: round_indv_adj '||G_ROUND_INDIVIDUAL_ADJ);
13594
13595 END IF;
13596 */ --moved up into PL/SQL Engine specific path
13597
13598 --===========START: l_control_record needed by JAVA and PL/SQL Engine===
13599 --to convert multiple events passed as string to a readable format
13600 --to remove the commas and single quotes in the pricing_event in ctrl rec
13601 IF instr(l_control_rec.pricing_event, ',') > 0
13602 THEN
13603 IF l_debug = FND_API.G_TRUE THEN
13604 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: pricing_event '|| l_control_rec.pricing_event);
13605 END IF;
13606 --Changes for bug 2258525: Introduced local vairable l_pricing_event
13607 --instead of changing the control_rec
13608 --this is to remove any blank spaces in the string
13609 l_pricing_event := REPLACE(l_control_rec.pricing_event,' ', '');
13610 --this is to remove any single quotes in the string
13611 l_pricing_event := REPLACE(l_pricing_event, '''', '');
13612 ELSE
13613 l_pricing_event := l_control_rec.pricing_event;
13614 END IF;
13615
13616 --this is to make the cursor work for the last event
13617 l_pricing_event := l_pricing_event || ',';
13618 l_control_rec.pricing_event := l_pricing_event;
13619 IF l_debug = FND_API.G_TRUE THEN
13620 QP_PREQ_GRP.ENGINE_DEBUG('BEGIN PRICE REQUEST PUB: pricing_event '|| l_control_rec.pricing_event);
13621 END IF;
13622 l_control_rec.GSA_DUP_CHECK_FLAG := G_NO;
13623 l_control_rec.temp_table_insert_flag :=
13624 nvl(p_control_rec.temp_table_insert_flag, G_YES);
13625 l_control_rec.public_api_call_flag := G_YES;
13626 l_control_rec.check_cust_view_flag := nvl(p_control_rec.check_cust_view_flag, G_NO);
13627
13628 --changes for bug 2635440
13629 --default rounding_flag to 'Q' when called by ASO/OC and 'Y' otherwise
13630 IF p_control_rec.rounding_flag IS NULL
13631 AND l_control_rec.temp_table_insert_flag = G_YES
13632 AND G_REQUEST_TYPE_CODE = 'ASO' THEN
13633 l_control_rec.rounding_flag := G_ROUNDING_PROFILE;
13634 ELSE
13635 l_control_rec.rounding_flag := nvl(p_control_rec.rounding_flag, G_YES);
13636 END IF; --p_control_rec.rounding_flag
13637
13638 -- Added for Bug 2847866
13639 QP_PREQ_GRP.G_PUBLIC_API_CALL_FLAG := nvl(l_control_rec.public_api_call_flag, 'N');
13640 --============END: l_control_rec needed by JAVA and PL/SQL Engine====
13641
13642 IF QP_JAVA_ENGINE_UTIL_PUB.Java_Engine_Running = 'N' THEN
13643 --===========START: specific only to PL/SQL Engine=======
13644 IF l_debug = FND_API.G_TRUE THEN
13645 QP_PREQ_GRP.ENGINE_DEBUG('02 Java Engine not Installed ----------');
13646 END IF;
13647 -----------------------------------------------------------------
13648 --Need to set the global constants for the engine to see
13649 --if the calling application populates into the temp tables directly
13650 -----------------------------------------------------------------
13651
13652 --initialize for usage_pricing and OM calls
13653 IF l_control_rec.temp_table_insert_flag = G_NO THEN
13654 --removing this for bug 2830206 as calculate_flag can be 'Y', 'C' or 'N'.
13655 --l_control_rec.calculate_flag := G_SEARCH_ONLY;
13656
13657 /*-- Added for Bug 2847866
13658 QP_PREQ_GRP.G_PUBLIC_API_CALL_FLAG:=nvl(l_control_rec.public_api_call_flag,'N');*/--moved above, needed by Java and PL/SQL Engine
13659
13660 IF (G_NO_ADJ_PROCESSING = G_YES) AND (G_QP_INSTALL_STATUS = 'I') THEN -- Added for 3169430
13661 Identify_freegood_lines(l_control_rec.pricing_event
13662 , x_return_status, x_return_status_text);
13663
13664 IF x_return_status = FND_API.G_RET_STS_ERROR THEN
13665 IF l_debug = FND_API.G_TRUE THEN
13666 QP_PREQ_GRP.ENGINE_DEBUG('Exception Initialize_cons: '
13667 || x_return_status_text);
13668 END IF;
13669 RAISE PRICE_REQUEST_EXC;
13670 END IF; --x_return_status
13671 END IF;
13672 Initialize_constants(
13673 l_control_rec
13674 , x_return_status_text
13675 , x_return_status);
13676
13677 IF X_RETURN_STATUS = FND_API.G_RET_STS_ERROR THEN
13678
13679 IF l_debug = FND_API.G_TRUE THEN
13680 QP_PREQ_GRP.ENGINE_DEBUG('Exception Initialize_cons: '|| x_return_status_text);
13681 END IF;
13682 RAISE PRICE_REQUEST_EXC;
13683 ELSIF X_RETURN_STATUS = 'BYPASS_PRICING'
13684 THEN
13685 RAISE E_BYPASS_PRICING;
13686 END IF;
13687 END IF;
13688 --=======END: Specific only to PL/SQL Engine==================
13689 END IF; --java engine is not installed by yangli for Java Engine PUB 3086881
13690
13691 --added by yangli for Java Engine PUB 3086881
13692 IF QP_JAVA_ENGINE_UTIL_PUB.Java_Engine_Running = 'N' THEN
13693 --=======START: Specific only to PL/SQL Engine==================
13694 IF l_debug = FND_API.G_TRUE THEN
13695 QP_PREQ_GRP.ENGINE_DEBUG('03 Java Engine not Installed ----------');
13696 END IF;
13697 --added by yangli for Java Engine PUB 3086881
13698 IF l_control_rec.calculate_flag IN
13699 (QP_PREQ_GRP.G_SEARCH_N_CALCULATE, QP_PREQ_GRP.G_SEARCH_ONLY)
13700 THEN
13701
13702 --Performance bug fix 7309551
13703 BEGIN
13704 SELECT VALUE INTO l_old_dynamic_sampling_level
13705 FROM v$parameter
13706 WHERE name = 'optimizer_dynamic_sampling';
13707 IF l_debug = FND_API.G_TRUE THEN
13708 QP_PREQ_GRP.engine_debug('Default Dynamic sampling Level :'|| l_old_dynamic_sampling_level);
13709 END IF;
13710 l_dynamic_sampling_level := TO_NUMBER(NVL(FND_PROFILE.VALUE(G_DYNAMIC_SAMPLING_LEVEL),1));
13711 IF l_debug = FND_API.G_TRUE THEN
13712 QP_PREQ_GRP.engine_debug('QP Profile Dynamic sampling level :'|| l_dynamic_sampling_level);
13713 END If;
13714 EXCEPTION
13715 WHEN OTHERS THEN
13716 IF l_debug = FND_API.G_TRUE THEN
13717 QP_PREQ_GRP.engine_debug('Error in looking up Dynamic sampling level '|| SQLERRM);
13718 QP_PREQ_GRP.engine_debug('Setting Dynamic Sampling level to 1');
13719 END IF;
13720 l_dynamic_sampling_level := 1;
13721 END;
13722
13723 IF (l_dynamic_sampling_level IN (1) AND l_dynamic_sampling_level <> l_old_dynamic_sampling_level) THEN
13724 IF l_debug = FND_API.G_TRUE THEN
13725 QP_PREQ_GRP.ENGINE_DEBUG('Setting dynamic sampling level to '|| l_dynamic_sampling_level);
13726 END IF;
13727 BEGIN
13728 Execute immediate 'Alter session set optimizer_dynamic_sampling = '||l_dynamic_sampling_level;
13729 EXCEPTION
13730 WHEN OTHERS THEN
13731 IF l_debug = FND_API.G_TRUE THEN
13732 QP_PREQ_GRP.engine_debug('Error in setting dynamic sampling level'|| SQLERRM);
13733 END IF;
13734 END;
13735 END IF;
13736 ----7309551
13737
13738 --Call pricing engine only if calculate flag is search_only or search and calculate
13739 QP_PREQ_GRP.PRICE_REQUEST
13740 (p_line_tbl => p_line_tbl,
13741 p_qual_tbl => p_qual_tbl,
13742 p_line_attr_tbl => p_line_attr_tbl,
13743 p_LINE_DETAIL_tbl => p_line_detail_tbl,
13744 p_LINE_DETAIL_qual_tbl => p_line_detail_qual_tbl,
13745 p_LINE_DETAIL_attr_tbl => p_line_detail_attr_tbl,
13746 p_related_lines_tbl => p_related_lines_tbl,
13747 p_control_rec => l_control_rec,
13748 x_line_tbl => x_line_tbl,
13749 x_line_qual => x_line_qual,
13750 x_line_attr_tbl => x_line_attr_tbl,
13751 x_line_detail_tbl => x_line_detail_tbl,
13752 x_line_detail_qual_tbl => x_line_detail_qual_tbl,
13753 x_line_detail_attr_tbl => x_line_detail_attr_tbl,
13754 x_related_lines_tbl => x_related_lines_tbl,
13755 x_return_status => x_return_status,
13756 x_return_status_text => x_return_status_text
13757 );
13758 END IF;
13759
13760
13761 IF X_RETURN_STATUS IN (FND_API.G_RET_STS_ERROR
13762 , FND_API.G_RET_STS_UNEXP_ERROR) THEN
13763
13764 IF l_debug = FND_API.G_TRUE THEN
13765 QP_PREQ_GRP.ENGINE_DEBUG('Exception Price Request GRP: '|| x_return_status_text);
13766 END IF;
13767 RAISE PRICE_REQUEST_EXC;
13768 END IF;
13769
13770 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE THEN
13771 OPEN lcur1; LOOP
13772 FETCH lcur1 INTO lrec1;
13773 EXIT WHEN lcur1%NOTFOUND;
13774 IF l_debug = FND_API.G_TRUE THEN
13775 QP_PREQ_GRP.ENGINE_DEBUG('line_index '|| lrec1.line_ind ||
13776 ' list_line_id '|| lrec1.created_from_list_line_id ||
13777 ' line_detail_index '|| lrec1.line_detail_index ||
13778 ' pricess_sts '|| lrec1.process_status ||
13779 ' price_flag '|| lrec1.price_flag ||
13780 ' automatic '|| lrec1.automatic_flag ||' overr '|| lrec1.override_flag ||
13781 ' applied '|| lrec1.applied_flag ||' status '|| lrec1.pricing_status_code ||
13782 ' unitprice '|| lrec1.unit_price ||' adjprice '|| lrec1.adjusted_unit_price
13783 ||' process_code '|| lrec1.process_code ||' updated '|| lrec1.updated_flag
13784 ||' calc_code '|| lrec1.calculation_code ||' qualex '
13785 || lrec1.qualifiers_exist_flag ||
13786 ' bucket '|| nvl(lrec1.bucket, - 1));
13787 END IF;
13788 END LOOP;
13789 CLOSE lcur1;
13790 END IF;
13791
13792 IF nvl(l_control_rec.temp_table_insert_flag, G_YES) = G_YES
13793 AND nvl(l_control_rec.check_cust_view_flag, G_NO) = G_NO
13794 AND nvl(Call_Usage_Pricing, G_NO) = G_YES
13795 THEN
13796 --rounding of list price will be taken care of in Calculate_price_pub
13797 Usage_pricing(l_control_rec.rounding_flag,
13798 x_return_status, x_return_status_text);
13799
13800 IF x_return_status IN (FND_API.G_RET_STS_ERROR
13801 , FND_API.G_RET_STS_UNEXP_ERROR)
13802 THEN
13803 IF l_debug = FND_API.G_TRUE THEN
13804 QP_PREQ_GRP.ENGINE_DEBUG('Exception Price Request PUB: '
13805 || x_return_status_text);
13806 END IF;
13807 RAISE PRICE_REQUEST_EXC;
13808 END IF;
13809 Update_Qualifier_Value(x_return_status, x_return_status_text);
13810 IF x_return_status IN (FND_API.G_RET_STS_ERROR
13811 , FND_API.G_RET_STS_UNEXP_ERROR)
13812 THEN
13813 IF l_debug = FND_API.G_TRUE THEN
13814 QP_PREQ_GRP.ENGINE_DEBUG('Exception Price Request PUB: '
13815 || x_return_status_text);
13816 END IF;
13817 RAISE PRICE_REQUEST_EXC;
13818 END IF;
13819
13820 END IF;
13821 IF (G_NO_ADJ_PROCESSING = G_YES) AND (G_QP_INSTALL_STATUS = 'I') THEN -- Added for 3169430
13822 QP_PREQ_PUB.process_prg(x_return_status, x_return_status_text);
13823
13824 IF x_return_status = FND_API.G_RET_STS_ERROR THEN
13825 RAISE PRICE_REQUEST_EXC;
13826 END IF; --x_return_status
13827 END IF;
13828
13829 IF p_control_rec.calculate_flag IN
13830 (QP_PREQ_GRP.G_SEARCH_N_CALCULATE, QP_PREQ_GRP.G_CALCULATE_ONLY)
13831 AND nvl(l_control_rec.check_cust_view_flag, G_NO) = G_NO
13832 --this needs to be changed for OC and others who do direct insert
13833 AND nvl(l_control_rec.temp_table_insert_flag, G_YES) = G_YES
13834 THEN
13835 --call calculate portion only if calculate flag is calculate or
13836 --calculate and search and overridden adjustments exist
13837
13838 Process_Adjustments(l_CONTROL_REC.PRICING_EVENT
13839 , x_return_status
13840 , x_return_status_text);
13841
13842 IF X_RETURN_STATUS = FND_API.G_RET_STS_ERROR THEN
13843
13844 IF l_debug = FND_API.G_TRUE THEN
13845 QP_PREQ_GRP.ENGINE_DEBUG('Exception Process_Adjustments: '|| x_return_status_text);
13846 END IF;
13847 RAISE PRICE_REQUEST_EXC;
13848 END IF;
13849 END IF;
13850
13851
13852 IF p_control_rec.calculate_flag IN
13853 (QP_PREQ_GRP.G_SEARCH_N_CALCULATE, QP_PREQ_GRP.G_CALCULATE_ONLY)
13854 AND nvl(l_control_rec.check_cust_view_flag, G_NO) = G_NO
13855 --this needs to be changed for OC and others who do direct insert
13856 AND nvl(l_control_rec.temp_table_insert_flag, G_YES) = G_YES
13857 THEN
13858 --call calculate portion only if calculate flag is calculate or
13859 --calculate and search and overridden adjustments exist
13860 Calculate_price(nvl(l_control_rec.rounding_flag, G_YES)
13861 , x_return_status
13862 , x_return_status_text);
13863
13864 IF X_RETURN_STATUS = FND_API.G_RET_STS_ERROR THEN
13865
13866 IF l_debug = FND_API.G_TRUE THEN
13867 QP_PREQ_GRP.ENGINE_DEBUG('Exception Calculate_price: '|| x_return_status_text);
13868 END IF;
13869 RAISE PRICE_REQUEST_EXC;
13870 END IF;
13871
13872 -- begin 2892848 instructed to add this
13873 Update_Unit_Price (x_return_status
13874 , x_return_status_text);
13875 IF X_RETURN_STATUS = FND_API.G_RET_STS_ERROR THEN
13876
13877 IF l_debug = FND_API.G_TRUE THEN
13878 QP_PREQ_GRP.ENGINE_DEBUG('Exception Update_Unit_Price: '|| x_return_status_text);
13879 END IF; -- end debug
13880 RAISE PRICE_REQUEST_EXC;
13881 END IF;
13882 -- end 2892848
13883
13884 END IF;
13885
13886
13887 IF p_control_rec.calculate_flag IN
13888 (QP_PREQ_GRP.G_SEARCH_N_CALCULATE, QP_PREQ_GRP.G_CALCULATE_ONLY)
13889 --and nvl(l_control_rec.check_cust_view_flag,G_NO) = G_YES
13890 --this needs to be changed for OC and others who do direct insert
13891 AND nvl(l_control_rec.temp_table_insert_flag, G_YES) = G_NO
13892 AND G_NO_ADJ_PROCESSING = G_YES -- Added for 3169430
13893 THEN
13894
13895 --before doing calculation we need to populate g_buyline_price_flag
13896 Populate_buy_line_price_flag(x_return_status, x_return_status_text);
13897
13898 IF x_return_status = FND_API.G_RET_STS_ERROR THEN
13899 IF l_debug = FND_API.G_TRUE THEN
13900 QP_PREQ_GRP.ENGINE_DEBUG('Exception Populate_buy_line_price_flag: '
13901 || x_return_status_text);
13902 END IF; --l_debug
13903 RAISE PRICE_REQUEST_EXC;
13904 END IF;
13905
13906 Update_recurring_quantity(x_return_status, x_return_status_text);
13907
13908 IF x_return_status = FND_API.G_RET_STS_ERROR THEN
13909 IF l_debug = FND_API.G_TRUE THEN
13910 QP_PREQ_GRP.ENGINE_DEBUG('Exception Update_recurring_quantity: '
13911 || x_return_status_text);
13912 END IF; --l_debug
13913 RAISE PRICE_REQUEST_EXC;
13914 END IF;
13915
13916 IF G_QP_INSTALL_STATUS = 'I' THEN -- Added for 3169430
13917 Process_Coupon_issue(l_control_rec.pricing_event,
13918 l_control_rec.simulation_flag,
13919 x_return_status, x_return_status_text);
13920 IF x_return_status = FND_API.G_RET_STS_ERROR THEN
13921 IF l_debug = FND_API.G_TRUE THEN
13922 QP_PREQ_GRP.ENGINE_DEBUG('Exception Process_Coupon_issue: '
13923 || x_return_status_text);
13924 END IF; --debug
13925 RAISE PRICE_REQUEST_EXC;
13926 END IF;
13927 END IF; --G_QP_INSTALL_STATUS
13928
13929 QP_CLEANUP_ADJUSTMENTS_PVT.fetch_adjustments
13930 (
13931 p_view_code => l_control_rec.view_code
13932 , p_event_code => l_control_rec.pricing_event
13933 , p_calculate_flag => l_control_rec.calculate_flag
13934 , p_rounding_flag => nvl(l_control_rec.rounding_flag, G_YES)
13935 , p_request_type_code => G_REQUEST_TYPE_CODE
13936 , x_return_status => x_return_status
13937 , x_return_status_text => x_return_status_text
13938 );
13939
13940 -- Update_Child_Break_Lines(x_return_status,
13941 -- x_return_status_text);
13942
13943
13944 IF X_RETURN_STATUS = FND_API.G_RET_STS_ERROR THEN
13945
13946 IF l_debug = FND_API.G_TRUE THEN
13947 QP_PREQ_GRP.ENGINE_DEBUG('Exception Calculate_price: '|| x_return_status_text);
13948 END IF;
13949 RAISE PRICE_REQUEST_EXC;
13950 END IF;
13951 -- bug 3487840 - duplicate PBH child lines causing ORA-01427: single-row subquery returns more than one row
13952 Cleanup_rltd_lines(x_return_status, x_return_status_text);
13953 IF X_RETURN_STATUS = FND_API.G_RET_STS_ERROR THEN
13954 IF l_debug = FND_API.G_TRUE THEN
13955 QP_PREQ_GRP.ENGINE_DEBUG('Exception Cleanup_rltd_lines: '|| x_return_status_text);
13956 END IF;
13957 RAISE PRICE_REQUEST_EXC;
13958 END IF;
13959
13960 Update_Adj_orderqty_cols(x_return_status, x_return_status_text);
13961 IF x_return_status = FND_API.G_RET_STS_ERROR THEN
13962 IF l_debug = FND_API.G_TRUE THEN
13963 QP_PREQ_GRP.ENGINE_DEBUG('Exception Update_Adj_orderqty_cols: '
13964 || x_return_status_text);
13965 END IF; --debug
13966 RAISE PRICE_REQUEST_EXC;
13967 END IF;
13968
13969 --to check if new order level adj are inserted when changed
13970 --lines are passed
13971 IF l_control_rec.full_pricing_call = G_NO
13972 THEN
13973 IF l_debug = FND_API.G_TRUE THEN
13974 QP_PREQ_GRP.engine_debug('Starting changed lines check');
13975 END IF;
13976 CHECK_ORDER_LINE_CHANGES(p_request_type_code =>
13977 G_REQUEST_TYPE_CODE,
13978 p_full_pricing_call =>
13979 l_control_rec.full_pricing_call,
13980 x_return_status => x_return_status,
13981 x_return_status_text => x_return_status_text);
13982 IF X_RETURN_STATUS = FND_API.G_RET_STS_ERROR THEN
13983 IF l_debug = FND_API.G_TRUE THEN
13984 QP_PREQ_GRP.ENGINE_DEBUG('Exception CHECK_ORDER_LINE_CHANGES: '|| x_return_status_text);
13985 END IF;
13986 RAISE PRICE_REQUEST_EXC;
13987 END IF;
13988 END IF;
13989
13990 -- Update_PRG_Process_status(x_return_status, x_return_status_text);
13991 IF x_return_status = FND_API.G_RET_STS_ERROR THEN
13992 IF l_debug = FND_API.G_TRUE THEN
13993 QP_PREQ_GRP.ENGINE_DEBUG('Exception Update_PRG_Process_status: '
13994 || x_return_status_text);
13995 END IF; --debug
13996 RAISE PRICE_REQUEST_EXC;
13997 END IF;
13998
13999 --this needs to be done for OC/ASO as they pass in adj as G_STATUS_UNCHANGED
14000 /*
14001 indxno index used
14002 */
14003 UPDATE qp_npreq_ldets_tmp
14004 SET pricing_status_code = G_STATUS_NEW
14005 WHERE process_code = G_STATUS_NEW
14006 --changes for bug 2264566
14007 --changed to populate w/updated_flag = Y for child lines of manualPBH
14008 AND (applied_flag = G_YES OR updated_flag = G_YES)
14009 AND pricing_status_code = G_STATUS_UNCHANGED;
14010
14011
14012 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
14013 THEN
14014 Populate_Output(x_return_status, x_return_status);
14015
14016 IF X_RETURN_STATUS = FND_API.G_RET_STS_ERROR
14017 THEN
14018 IF l_debug = FND_API.G_TRUE THEN
14019 QP_PREQ_GRP.ENGINE_DEBUG('Exception Populate_Output: '|| x_return_status_text);
14020 END IF;
14021 RAISE PRICE_REQUEST_EXC;
14022 END IF; --X_RETURN_STATUS
14023 END IF; --QP_PREQ_GRP.G_DEBUG_ENGINE
14024
14025 IF l_debug = FND_API.G_TRUE THEN
14026 QP_PREQ_GRP.engine_debug('-------------------rltd info--------------------');
14027
14028 END IF;
14029 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE THEN
14030 --this is for debug for rltd lines
14031 FOR cl IN (SELECT line_index,
14032 related_line_index,
14033 line_detail_index,
14034 related_line_detail_index,
14035 relationship_type_code,
14036 list_line_id,
14037 related_list_line_id,
14038 related_list_line_type,
14039 operand_calculation_code,
14040 operand,
14041 pricing_group_sequence,
14042 setup_value_from,
14043 setup_value_to,
14044 qualifier_value
14045 FROM qp_npreq_rltd_lines_tmp
14046 WHERE pricing_status_code = G_STATUS_NEW)
14047 LOOP
14048 IF l_debug = FND_API.G_TRUE THEN
14049 QP_PREQ_GRP.engine_debug('related records with status N '
14050 ||' line_dtl_index '|| cl.line_detail_index
14051 ||' rltd_line_dtl_index '|| cl.related_line_detail_index
14052 ||' line_index '|| cl.line_index
14053 ||' rltd_line_index '|| cl.related_line_index
14054 ||' list_line_id '|| cl.list_line_id
14055 ||' rltd_list_line_id '|| cl.related_list_line_id
14056 ||' rltd_list_line_type '|| cl.related_list_line_type
14057 ||' operand '|| cl.operand
14058 ||' operator '|| cl.operand_calculation_code
14059 ||' bucket '|| cl.pricing_group_sequence
14060 ||' setval_from '|| cl.setup_value_from
14061 ||' setval_to '|| cl.setup_value_to
14062 ||' qual_value '|| cl.qualifier_value);
14063 END IF;
14064 END LOOP; --for cl
14065 END IF; --QP_PREQ_GRP.G_DEBUG_ENGINE
14066 END IF;
14067
14068
14069
14070 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE THEN
14071 OPEN lcur1; LOOP
14072 FETCH lcur1 INTO lrec1;
14073 EXIT WHEN lcur1%NOTFOUND;
14074 IF l_debug = FND_API.G_TRUE THEN
14075 QP_PREQ_GRP.ENGINE_DEBUG('line_index '|| lrec1.line_ind ||
14076 ' list_line_id '|| lrec1.created_from_list_line_id ||
14077 ' line_detail_index '|| lrec1.line_detail_index ||
14078 ' applied '|| lrec1.applied_flag ||' status '|| lrec1.pricing_status_code
14079 ||' process_code '|| lrec1.process_code);
14080 END IF;
14081 END LOOP;
14082 CLOSE lcur1;
14083 END IF;
14084 --Performance bug fix 7309551
14085 IF (l_dynamic_sampling_level IN (1) AND l_dynamic_sampling_level <> l_old_dynamic_sampling_level) THEN
14086 QP_PREQ_GRP.ENGINE_DEBUG('Setting dynamic sampling level back to '|| l_old_dynamic_sampling_level);
14087 BEGIN
14088 Execute immediate 'alter session set optimizer_dynamic_sampling = '||l_old_dynamic_sampling_level;
14089 EXCEPTION
14090 WHEN OTHERS THEN
14091 IF l_debug = FND_API.G_TRUE THEN
14092 QP_PREQ_GRP.engine_debug('Error in resetting the dynamic sampling level to old value'|| SQLERRM);
14093 END IF;
14094 END;
14095 END IF;
14096 --End 7309551
14097
14098 --Update_PRG_Process_status;
14099 --=======END: Specific only to PL/SQL Engine==================
14100 --added by yangli for Java Engine PUB 3086881
14101 ELSE -- java engine is installed
14102 --=======START: Specific only to JAVA Engine==================
14103 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE THEN
14104 QP_PREQ_GRP.ENGINE_DEBUG('03 Java Engine is installed');
14105 QP_PREQ_GRP.ENGINE_DEBUG('temp_table_insert_flag:' || l_control_rec.temp_table_insert_flag);
14106 QP_PREQ_GRP.ENGINE_DEBUG('QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG:' || QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG);
14107 END IF;
14108
14109 --for OM call, need Pre-Insert Logic to fetch/format data from OE tables into
14110 --Java Engine interface tables
14111 IF l_control_rec.temp_table_insert_flag = G_NO THEN
14112 --Initialize_Constants() logic for Interface Tables
14113
14114 -- IF G_REQUEST_TYPE_CODE = 'ONT' THEN
14115 --bug 3085453 handle pricing availability UI
14116 -- they pass reqtype ONT and insert adj into ldets
14117 IF QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = G_YES THEN
14118 --Preinsert Logic for OM call
14119 --to fetch out-of-phases modifiers and in-phase PRG modifiers
14120 --to fetch rltd information
14121 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE THEN
14122 QP_PREQ_GRP.ENGINE_DEBUG('Before calling INT_TABLES_PREINSERT');
14123 END IF;
14124 INT_TABLES_PREINSERT(p_calculate_flag => l_control_rec.calculate_flag,
14125 p_event_code => l_control_rec.pricing_event,
14126 x_return_status => l_return_status,
14127 x_return_status_text => l_status_Text);
14128 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE THEN
14129 QP_PREQ_GRP.ENGINE_DEBUG('Existing INT_TABLES_PREINSERT');
14130 END IF;
14131 IF(l_return_status = FND_API.G_RET_STS_ERROR) THEN
14132 l_status_text := 'INT_TABLES_PREINSERT:' || l_status_text;
14133 RAISE E_ROUTINE_ERRORS;
14134 END IF;
14135 END IF;
14136 END IF;
14137
14138 IF l_control_rec.temp_table_insert_flag = G_NO THEN
14139 l_request_id := QP_Price_Request_Context.GET_REQUEST_ID;
14140 IF l_debug = FND_API.G_TRUE THEN
14141 QP_PREQ_GRP.engine_debug('Request Id:'|| l_request_id);
14142 END IF;
14143 QP_JAVA_ENGINE.request_price(request_id => l_request_id,
14144 p_control_rec => l_control_rec,
14145 x_return_status => l_return_status,
14146 x_return_status_text => l_status_Text);
14147
14148 IF(l_return_status = FND_API.G_RET_STS_ERROR) THEN
14149 --l_status_text:= 'QP_JAVA_ENGINE.request_price failed for request id:'||l_request_id||l_status_text;
14150 IF l_debug = FND_API.G_TRUE THEN
14151 QP_PREQ_GRP.engine_debug(l_status_text);
14152 END IF; --Bug No 4033618
14153 x_return_status := l_return_status;
14154 x_return_status_text := l_status_text;
14155 RAISE JAVA_ENGINE_PRICING_EXCEPTION;
14156 END IF;
14157 ELSE
14158 IF l_debug = FND_API.G_TRUE THEN
14159 QP_PREQ_GRP.engine_debug('Before calling QP_PREQ_GRP.PRICE_REQUEST.....');
14160 END IF;
14161 QP_PREQ_GRP.PRICE_REQUEST
14162 (p_line_tbl => p_line_tbl,
14163 p_qual_tbl => p_qual_tbl,
14164 p_line_attr_tbl => p_line_attr_tbl,
14165 p_LINE_DETAIL_tbl => p_line_detail_tbl,
14166 p_LINE_DETAIL_qual_tbl => p_line_detail_qual_tbl,
14167 p_LINE_DETAIL_attr_tbl => p_line_detail_attr_tbl,
14168 p_related_lines_tbl => p_related_lines_tbl,
14169 p_control_rec => l_control_rec,
14170 x_line_tbl => x_line_tbl,
14171 x_line_qual => x_line_qual,
14172 x_line_attr_tbl => x_line_attr_tbl,
14173 x_line_detail_tbl => x_line_detail_tbl,
14174 x_line_detail_qual_tbl => x_line_detail_qual_tbl,
14175 x_line_detail_attr_tbl => x_line_detail_attr_tbl,
14176 x_related_lines_tbl => x_related_lines_tbl,
14177 x_return_status => x_return_status,
14178 x_return_status_text => x_return_status_text
14179 );
14180 IF X_RETURN_STATUS IN (FND_API.G_RET_STS_ERROR
14181 , FND_API.G_RET_STS_UNEXP_ERROR) THEN
14182
14183 IF l_debug = FND_API.G_TRUE THEN
14184 QP_PREQ_GRP.ENGINE_DEBUG('Exception Price Request GRP: '|| x_return_status_text);
14185 END IF;
14186 RAISE PRICE_REQUEST_EXC;
14187 END IF;
14188 END IF; --TEMP_TABLE_INSERT_FLAG=Y
14189
14190 -- IF G_REQUEST_TYPE_CODE = 'ONT' THEN
14191 --bug 3085453 handle pricing availability UI
14192 -- they pass reqtype ONT and insert adj into ldets
14193 IF QP_PREQ_PUB.G_CHECK_CUST_VIEW_FLAG = G_YES THEN
14194 -- still need Cleanup_Adjustments logic
14195 -- and Populate_Price_Adj_Id logic
14196 -- from QP_CLEANUP_ADJUSTMENTS_PVT.Fetch_Adjustments
14197 --call cleanup of adj only for OM
14198
14199 IF l_debug = FND_API.G_TRUE THEN
14200 QP_PREQ_GRP.engine_debug('deleting related lines');
14201 END IF;
14202 DELETE FROM qp_int_rltd_lines
14203 WHERE pricing_status_code = QP_PREQ_PUB.G_STATUS_NEW
14204 AND relationship_type_code = QP_PREQ_PUB.G_PBH_LINE
14205 AND pricing_status_text = 'INSERTED FOR CALCULATION';
14206 IF l_debug = FND_API.G_TRUE THEN
14207 QP_PREQ_GRP.engine_debug('deleted related lines '|| SQL%ROWCOUNT);
14208 END IF;
14209
14210 IF l_control_rec.calculate_flag IN
14211 (QP_PREQ_GRP.G_SEARCH_N_CALCULATE, QP_PREQ_GRP.G_CALCULATE_ONLY)
14212 THEN
14213 l_cleanup_flag := QP_PREQ_PUB.G_YES;
14214 --added for bug 3399997 by yangli
14215 Update_Line_Status(x_return_status, x_return_status_text);
14216 IF x_return_status = FND_API.G_RET_STS_ERROR
14217 THEN
14218 RAISE Pricing_Exception;
14219 END IF;
14220 --added for bug 3399997 by yangli
14221
14222 IF l_debug = FND_API.G_TRUE THEN
14223 QP_PREQ_GRP.engine_debug('Java Engine calling QP_CLEANUP_ADJUSTMENTS_PVT.cleanup_adjustments');
14224 END IF;
14225 QP_CLEANUP_ADJUSTMENTS_PVT.cleanup_adjustments('ONTVIEW',
14226 G_REQUEST_TYPE_CODE,
14227 l_cleanup_flag,
14228 x_return_status,
14229 x_return_status_text);
14230 IF x_return_status = FND_API.G_RET_STS_ERROR
14231 THEN
14232 RAISE Pricing_Exception;
14233 END IF;
14234 --moved down per bug3238607
14235 /*IF l_debug = FND_API.G_TRUE THEN
14236 QP_PREQ_GRP.engine_debug('Java Engine calling QP_CLEANUP_ADJUSTMENTS_PVT.Populate_Price_Adj_ID');
14237 END IF;
14238
14239 --populate the price adjustment id from sequence for rec with process_code = N
14240 QP_CLEANUP_ADJUSTMENTS_PVT.Populate_Price_Adj_ID(x_return_status,x_return_status_text);
14241
14242 IF x_return_status = FND_API.G_RET_STS_ERROR
14243 THEN
14244 Raise Pricing_Exception;
14245 END IF;*/
14246 --moved down per bug3238607
14247 END IF;
14248 END IF;
14249 --per bug3238607's decision, OM will pass simulation_flag=N
14250 --to indicate populate_price_adj_id is needed
14251 IF G_REQUEST_TYPE_CODE = 'ONT' AND
14252 l_control_rec.simulation_flag = G_NO THEN
14253 IF l_control_rec.calculate_flag IN
14254 (QP_PREQ_GRP.G_SEARCH_N_CALCULATE, QP_PREQ_GRP.G_CALCULATE_ONLY)
14255 THEN
14256 IF l_debug = FND_API.G_TRUE THEN
14257 QP_PREQ_GRP.engine_debug('Java Engine calling QP_CLEANUP_ADJUSTMENTS_PVT.Populate_Price_Adj_ID');
14258 END IF;
14259
14260 --populate the price adjustment id from sequence for rec with process_code = N
14261 QP_CLEANUP_ADJUSTMENTS_PVT.Populate_Price_Adj_ID(x_return_status, x_return_status_text);
14262
14263 IF x_return_status = FND_API.G_RET_STS_ERROR
14264 THEN
14265 RAISE Pricing_Exception;
14266 END IF;
14267 END IF;
14268 END IF;
14269
14270 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE
14271 THEN
14272 Populate_Output_INT(x_return_status, x_return_status);
14273
14274 IF X_RETURN_STATUS = FND_API.G_RET_STS_ERROR
14275 THEN
14276 IF l_debug = FND_API.G_TRUE THEN
14277 QP_PREQ_GRP.ENGINE_DEBUG('Exception Populate_Output: '|| x_return_status_text);
14278 END IF;
14279 RAISE PRICE_REQUEST_EXC;
14280 END IF; --X_RETURN_STATUS
14281 END IF; --QP_PREQ_GRP.G_DEBUG_ENGINE
14282 --=======END: Specific only to JAVA Engine==================
14283 END IF; -- java engine is installed
14284 --added by yangli for Java Engine PUB 3086881
14285
14286
14287 ------------------------------------------------------------
14288 --POPULATE OUT TEMPORARY TABLES
14289 ------------------------------------------------------------
14290 IF l_control_rec.temp_table_insert_flag = G_YES
14291 AND l_control_rec.check_cust_view_flag = G_NO
14292 THEN
14293
14294 --added by yangli for Java Engine PUB 3086881
14295 IF QP_JAVA_ENGINE_UTIL_PUB.Java_Engine_Running = 'N' THEN
14296 ------------------------------------------------------------
14297 --POPULATE OUT PROCESS CODE IN PRICING_STATUS_CODE
14298 --ONLY UPDATE THE RECORDS INPUT BY USER WHCH WERE USED IN CALCULATION
14299 ------------------------------------------------------------
14300 IF l_debug = FND_API.G_TRUE THEN
14301 QP_PREQ_GRP.ENGINE_DEBUG('Java Engine not Installed ----------');
14302 END IF;
14303 --added by yangli for Java Engine PUB 3086881
14304
14305 IF l_debug = FND_API.G_TRUE THEN
14306 QP_PREQ_GRP.ENGINE_DEBUG('Update Process code to Pricing Code ');
14307 END IF;
14308 /*
14309 indxno index used Ravi
14310 */
14311 UPDATE qp_npreq_ldets_tmp
14312 SET pricing_status_code = G_STATUS_NEW
14313 WHERE process_code = G_STATUS_NEW
14314 --changes for bug 2264566
14315 --changed to populate w/updated_flag = Y for child lines of manualPBH
14316 AND (applied_flag = G_YES OR updated_flag = G_YES)
14317 AND pricing_status_code = G_STATUS_UNCHANGED;
14318
14319 --added by yangli for Java Engine PUB 3086881
14320 END IF; --Java Engine is not installed;
14321 --added by yangli for Java Engine PUB 3086881
14322 QP_PREQ_GRP.POPULATE_OUTPUT(
14323 x_line_tbl => x_line_tbl,
14324 x_line_qual_tbl => x_line_qual,
14325 x_line_attr_tbl => x_line_attr_tbl,
14326 x_line_detail_tbl => x_line_detail_tbl,
14327 x_line_detail_qual_tbl => x_line_detail_qual_tbl,
14328 x_line_detail_attr_tbl => x_line_detail_attr_tbl,
14329 x_related_lines_tbl => x_related_lines_tbl);
14330
14331
14332 IF l_debug = FND_API.G_TRUE THEN
14333 QP_PREQ_GRP.ENGINE_DEBUG('Line Detail Count : ' || x_line_detail_tbl.COUNT);
14334
14335 END IF;
14336 --*******************************************************************
14337 --DEBUG
14338
14339 IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE THEN
14340 j := x_line_tbl.FIRST;
14341 WHILE j IS NOT NULL
14342 LOOP
14343 IF l_debug = FND_API.G_TRUE THEN
14344 QP_PREQ_GRP.ENGINE_DEBUG('PRICE LINE : '||
14345 x_line_tbl(j).line_index ||
14346 ' list price '|| x_line_tbl(j).unit_price ||
14347 ' adj price '|| x_line_tbl(j).adjusted_unit_price ||
14348 ' up adj price '|| x_line_tbl(j).updated_adjusted_unit_price ||
14349 ' process code '|| x_line_tbl(j).processed_code);
14350
14351 QP_PREQ_GRP.ENGINE_DEBUG('---------------------------------------------------');
14352 END IF;
14353 i := x_line_detail_tbl.FIRST;
14354 WHILE i IS NOT NULL
14355 LOOP
14356 IF x_line_detail_tbl(i).line_index = x_line_tbl(j).line_index THEN
14357 IF l_debug = FND_API.G_TRUE THEN
14358 QP_PREQ_GRP.ENGINE_DEBUG('PRICE ADJUSTMENTS: '
14359 ||' mod_id '|| x_line_detail_tbl(i).list_line_id
14360 ||' dtl_index '|| x_line_detail_tbl(i).line_detail_index
14361 ||' adj amount '|| x_line_detail_tbl(i).adjustment_amount
14362 ||' op '|| x_line_detail_tbl(i).operand_calculation_code
14363 ||' operand value '|| x_line_detail_tbl(i).operand_value
14364 ||' applied '|| x_line_detail_tbl(i).applied_flag
14365 ||' updated '|| x_line_detail_tbl(i).updated_flag
14366 ||' process_code '|| x_line_detail_tbl(i).process_code
14367 ||' pricing_status '|| x_line_detail_tbl(i).status_code);
14368 END IF;
14369 END IF;
14370 i := x_line_detail_tbl.NEXT(i);
14371 END LOOP;
14372 IF l_debug = FND_API.G_TRUE THEN
14373 QP_PREQ_GRP.ENGINE_DEBUG('---------------------------------------------------');
14374 END IF;
14375 j := x_line_tbl.NEXT(j);
14376 END LOOP;
14377
14378 --fix for bug 2515762 automatic overrideable break debug for rltd info
14379 IF l_debug = FND_API.G_TRUE THEN
14380 QP_PREQ_GRP.ENGINE_DEBUG('------------Rltd Info----------------');
14381 QP_PREQ_GRP.ENGINE_DEBUG('Rltd Info count '|| x_related_lines_tbl.COUNT);
14382 END IF;
14383 j := x_related_lines_tbl.FIRST;
14384 WHILE j IS NOT NULL
14385 LOOP
14386 IF l_debug = FND_API.G_TRUE THEN
14387 QP_PREQ_GRP.ENGINE_DEBUG('line_index '
14388 || x_related_lines_tbl(j).line_index ||' related_line_index '
14389 || x_related_lines_tbl(j).related_line_index ||' dtl_index '
14390 || x_related_lines_tbl(j).line_detail_index ||' rltd_dtl_index '
14391 || x_related_lines_tbl(j).related_line_detail_index ||' relation '
14392 || x_related_lines_tbl(j).relationship_type_code);
14393 END IF;
14394 j := x_related_lines_tbl.NEXT(j);
14395 END LOOP;
14396
14397 END IF; --IF QP_PREQ_GRP.G_DEBUG_ENGINE = FND_API.G_TRUE THEN
14398 --*******************************************************************
14399 END IF; --temp_table_insert_flag = G_YES and check_cust_view_flag = G_NO
14400
14401
14402 --Fix for bug 3550303 need to reset QP_BULK_PREQ_GRP.G_HVOP_PRICING_ON
14403 --at the end of HVOP call
14404 QP_UTIL_PUB.RESET_HVOP_PRICING_ON;
14405
14406
14407
14408 --============START: Post-pricing process needed by JAVA and PL/SQL Engine======
14409 --to write temp table data into debug tables
14410 IF (G_QP_DEBUG = G_YES) OR
14411 (G_QP_DEBUG = G_DONT_WRITE_TO_DEBUG) THEN -- If Debug is on
14412 QP_COPY_DEBUG_PVT.WRITE_TO_DEBUG_TABLES(p_control_rec,
14413 l_return_status,
14414 l_return_status_text
14415 );
14416 x_return_status := l_return_status;
14417 x_return_status_text := l_return_status_text;
14418 IF x_return_status = FND_API.G_RET_STS_ERROR THEN
14419 RAISE E_DEBUG_ROUTINE_ERROR;
14420 END IF;
14421 END IF;
14422
14423 X_RETURN_STATUS := FND_API.G_RET_STS_SUCCESS;
14424 X_RETURN_STATUS_TEXT := l_routine ||' SUCCESS';
14425
14426 l_pricing_end_time := dbms_utility.get_time;
14427
14428 IF G_QP_DEBUG = G_ENGINE_TIME_TRACE_ON THEN --3085171
14429 --added to note redo log
14430 BEGIN
14431 SELECT VALUE INTO l_pricing_end_redo
14432 FROM v$mystat, v$statname
14433 WHERE v$mystat.statistic# = v$statname.statistic#
14434 AND v$statname.name = 'redo size';
14435 EXCEPTION
14436 WHEN OTHERS THEN
14437 IF l_debug = FND_API.G_TRUE THEN
14438 QP_PREQ_GRP.engine_debug('Error in looking up redo end in PUB '|| SQLERRM);
14439 END IF;
14440 END;
14441 END IF;
14442
14443 l_time_difference := (l_pricing_end_time - l_pricing_start_time) / 100 ;
14444 l_redo_difference := l_pricing_end_redo - l_pricing_start_redo ;
14445
14446 IF l_debug = FND_API.G_TRUE THEN
14447 QP_PREQ_GRP.engine_debug('Total time taken in PUB Pkg: '|| l_time_difference);
14448 QP_PREQ_GRP.engine_debug('redo log in PUB: '|| l_redo_difference);
14449
14450 END IF;
14451
14452 --Changes for bug2961617
14453
14454 /*
14455 execute immediate 'select '||''''|| ' Total Time in QP_PREQ_PUB(in sec) : ' ||
14456 l_time_difference||' Total redo in QP_PREQ_PUB : '|| l_redo_difference||''''||' from dual ';
14457 */
14458
14459 IF G_QP_DEBUG = G_ENGINE_TIME_TRACE_ON THEN --3085171
14460 BEGIN
14461
14462 /*
14463 select 'Total Time in QP_PREQ_PUB(in sec) : ' ||l_time_difference ||
14464 ' Total redo in QP_PREQ_PUB : '||l_redo_difference into l_time_stats from dual ;
14465 */
14466
14467 EXECUTE IMMEDIATE 'select '|| '''' || ' Total Time in QP_PREQ_PUB(in sec) : ' ||
14468 l_time_difference ||' Total redo in QP_PREQ_PUB : '|| l_redo_difference || '''' ||' from dual ';
14469
14470 EXCEPTION
14471
14472 WHEN OTHERS THEN
14473 IF l_debug = FND_API.G_TRUE THEN
14474 QP_PREQ_GRP.engine_debug('Failed to get time statistics in QP_PREQ_PUB');
14475 END IF;
14476 END;
14477 END IF;
14478 IF l_debug = FND_API.G_TRUE THEN
14479 QP_PREQ_GRP.ENGINE_DEBUG('End Price Request');
14480 qp_debug_util.print_support_csv('END');
14481 END IF;
14482 --============END: Post-pricing process needed by JAVA and PL/SQL Engine======
14483
14484 qp_debug_util.tstop('ENGINE_CALL_QPXPPREB',l_total_engine_time);
14485 qp_debug_util.addSummaryTimeLog('Total Pricing Engine time (search and calculation included): '||l_total_engine_time||'ms',1,1,0);
14486 qp_debug_util.dumpSummaryTimeLog;
14487 qp_debug_util.tdump;
14488 qp_debug_util.tflush;
14489
14490 EXCEPTION
14491 WHEN E_BYPASS_PRICING THEN
14492 IF l_debug = FND_API.G_TRUE THEN
14493 QP_PREQ_GRP.ENGINE_DEBUG('Bypassed Pricing Engine');
14494 END IF;
14495 x_return_status := FND_API.G_RET_STS_SUCCESS;
14496 --to write temp table data into debug tables
14497 IF (G_QP_DEBUG = G_YES) OR
14498 (G_QP_DEBUG = G_DONT_WRITE_TO_DEBUG) THEN -- If Debug is on
14499 QP_COPY_DEBUG_PVT.WRITE_TO_DEBUG_TABLES(p_control_rec,
14500 l_return_status,
14501 l_return_status_text
14502 );
14503 IF l_return_status = FND_API.G_RET_STS_ERROR THEN
14504 IF l_debug = FND_API.G_TRUE THEN
14505 QP_PREQ_GRP.engine_debug('Error occured in Debug Routine: ' || l_return_status_text);
14506 END IF;
14507 END IF;
14508 END IF;
14509 --added by yangli for Java Engine PUB 3086881
14510 WHEN PRICING_EXCEPTION THEN
14511 x_return_status := FND_API.G_RET_STS_ERROR;
14512 IF l_debug = FND_API.G_TRUE THEN
14513 QP_PREQ_GRP.engine_debug('error in fetch_adjustments: '|| SQLERRM);
14514 QP_PREQ_GRP.engine_debug('error in fetch_adjustments: '|| x_return_status_text);
14515 END IF;
14516 WHEN JAVA_ENGINE_PRICING_EXCEPTION THEN
14517 x_return_status := FND_API.G_RET_STS_ERROR;
14518 IF l_debug = FND_API.G_TRUE THEN
14519 QP_PREQ_GRP.engine_debug('error in QP_JAVA_ENGINE.price_request():'|| SQLERRM);
14520 QP_PREQ_GRP.engine_debug('error in QP_JAVA_ENGINE.price_request():'|| x_return_status_text);
14521 END IF;
14522 --added by yangli for Java Engine PUB 3086881
14523
14524 WHEN PRICE_REQUEST_EXC THEN
14525 IF l_debug = FND_API.G_TRUE THEN
14526 QP_PREQ_GRP.ENGINE_DEBUG('Exception Price Request: '|| SQLERRM);
14527 END IF;
14528 NULL;
14529 x_return_status := FND_API.G_RET_STS_ERROR;
14530 -- x_return_status_TEXT := l_routine||' '||SQLERRM;
14531 --to write temp table data into debug tables
14532 IF (G_QP_DEBUG = G_YES) OR
14533 (G_QP_DEBUG = G_DONT_WRITE_TO_DEBUG) THEN -- If Debug is on
14534 QP_COPY_DEBUG_PVT.WRITE_TO_DEBUG_TABLES(p_control_rec,
14535 l_return_status,
14536 l_return_status_text
14537 );
14538 IF l_return_status = FND_API.G_RET_STS_ERROR THEN
14539 IF l_debug = FND_API.G_TRUE THEN
14540 QP_PREQ_GRP.engine_debug('Error occured in Debug Routine: ' || l_return_status_text);
14541 END IF;
14542 END IF;
14543 END IF;
14544 WHEN E_DEBUG_ROUTINE_ERROR THEN
14545 IF l_debug = FND_API.G_TRUE THEN
14546 QP_PREQ_GRP.engine_debug('Error occured in Debug Routine: ' || x_return_status_text);
14547 END IF;
14548 WHEN E_NO_LINES_TO_PRICE THEN -- 4865787
14549 IF l_debug = FND_API.G_TRUE THEN
14550 QP_PREQ_GRP.engine_debug('Error in QP_PREQ_PUB.Price_Request: There are no lines to price!');
14551 END IF;
14552 x_return_status := FND_API.G_RET_STS_ERROR;
14553 x_return_status_text := l_routine ||' '|| ': There are no lines to price!';
14554 WHEN OTHERS THEN
14555 IF l_debug = FND_API.G_TRUE THEN
14556 QP_PREQ_GRP.ENGINE_DEBUG('Exception Price Request: '|| SQLERRM);
14557 END IF;
14558 x_return_status := FND_API.G_RET_STS_ERROR;
14559 x_return_status_TEXT := l_routine ||' '|| SQLERRM;
14560 --to write temp table data into debug tables
14561 IF (G_QP_DEBUG = G_YES) OR
14562 (G_QP_DEBUG = G_DONT_WRITE_TO_DEBUG) THEN -- If Debug is on
14563 QP_COPY_DEBUG_PVT.WRITE_TO_DEBUG_TABLES(p_control_rec,
14564 l_return_status,
14565 l_return_status_text
14566 );
14567 IF l_return_status = FND_API.G_RET_STS_ERROR THEN
14568 IF l_debug = FND_API.G_TRUE THEN
14569 QP_PREQ_GRP.engine_debug('Error occured in Debug Routine: ' || l_return_status_text);
14570 END IF;
14571 END IF;
14572 END IF;
14573
14574
14575 END PRICE_REQUEST;
14576
14577 -- returns TRUE if given price is lower or equal than GSA price for non-GSA customer, else FALSE
14578 FUNCTION Raise_GSA_Error
14579 (
14580 p_request_type_code IN VARCHAR2
14581 , p_inventory_item_id IN NUMBER
14582 , p_pricing_date IN DATE
14583 , p_unit_price IN NUMBER
14584 , p_cust_account_id IN NUMBER
14585 )
14586 RETURN BOOLEAN
14587
14588 IS
14589
14590 l_operand NUMBER := 0;
14591 l_gsa_indicator_flag VARCHAR2(5) := 'N';
14592 v_return_value BOOLEAN := NULL;
14593
14594
14595 BEGIN
14596
14597
14598 IF p_cust_account_id IS NOT NULL THEN
14599
14600 --obtain_gsa indicator_flag
14601 /*
14602 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel1,HZ_CUST_ACCOUNTS_U1,CUST_ACCOUNT_ID,1
14603 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel1,HZ_PARTIES_U1,PARTY_ID,1
14604 */
14605
14606
14607
14608 /* begin changes made for tracking bug 2693700 */
14609 BEGIN
14610 SELECT NVL(gsa_indicator, 'N')
14611 INTO l_gsa_indicator_flag
14612 FROM hz_cust_site_uses_all hsu
14613 WHERE site_use_id = OE_ORDER_PUB.G_HDR.invoice_to_org_id
14614 AND NVL(hsu.org_id,
14615 NVL(TO_NUMBER(DECODE(SUBSTRB(USERENV('CLIENT_INFO'), 1, 1), ' ', NULL,
14616 SUBSTRB(USERENV('CLIENT_INFO'), 1, 10))), - 99)) =
14617 NVL(TO_NUMBER(DECODE(SUBSTRB(USERENV('CLIENT_INFO'), 1, 1), ' ', NULL,
14618 SUBSTRB(USERENV('CLIENT_INFO'), 1, 10))), - 99);
14619
14620 EXCEPTION
14621
14622 WHEN NO_DATA_FOUND THEN
14623 l_gsa_indicator_flag := 'N';
14624
14625 END;
14626
14627 IF l_gsa_indicator_flag = 'N' THEN
14628
14629 BEGIN
14630
14631 SELECT NVL(gsa_indicator_flag, 'N')
14632 INTO l_gsa_indicator_flag
14633 FROM hz_parties hp, hz_cust_accounts hca
14634 WHERE hp.party_id = hca.party_id
14635 AND hca.cust_account_id = p_cust_account_id ;
14636
14637 EXCEPTION
14638
14639 WHEN NO_DATA_FOUND THEN
14640 l_gsa_indicator_flag := NULL;
14641
14642 END;
14643
14644 END IF;
14645 /* SELECT nvl(gsa_indicator_flag,'N') into l_gsa_indicator_flag
14646 FROM hz_parties hp, hz_cust_accounts hca
14647 WHERE hp.party_id = hca.party_id and hca.cust_account_id = p_cust_account_id;
14648 ELSE
14649 -- treat it as non-GSA customer if p_cust_account_id is NULL
14650 l_gsa_indicator_flag := 'N';
14651 */
14652 --end bug 2693700
14653
14654 END IF;
14655
14656
14657 -- Perform the GSA check if l_gsa_indicator_flag is N
14658 -- 'N' or NULL means it is not a GSA customer, then check if GSA error should be raised
14659 IF l_gsa_indicator_flag = 'N' THEN
14660
14661 /*
14662 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_QUALIFIERS_N7,QUALIFIER_CONTEXT,1
14663 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_QUALIFIERS_N7,QUALIFIER_ATTRIBUTE,2
14664 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_QUALIFIERS_N7,LIST_HEADER_ID,3
14665 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_QUALIFIERS_N7,ACTIVE_FLAG,4
14666 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_QUALIFIERS_N7,QUALIFIER_ATTR_VALUE,5
14667 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_PRICING_ATTRIBUTES_N5,PRICING_PHASE_ID,1
14668 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_PRICING_ATTRIBUTES_N5,QUALIFICATION_IND,2
14669 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_PRICING_ATTRIBUTES_N5,PRODUCT_ATTRIBUTE_CONTEXT,3
14670 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_PRICING_ATTRIBUTES_N5,PRODUCT_ATTRIBUTE,4
14671 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_PRICING_ATTRIBUTES_N5,PRODUCT_ATTR_VALUE,5
14672 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_PRICING_ATTRIBUTES_N5,EXCLUDER_FLAG,6
14673 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_PRICING_ATTRIBUTES_N5,LIST_HEADER_ID,7
14674 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_PRICING_ATTRIBUTES_N5,LIST_LINE_ID,8
14675 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_LIST_HEADERS_B_PK,LIST_HEADER_ID,1
14676 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_PRICE_REQ_SOURCES_PK,REQUEST_TYPE_CODE,1
14677 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_PRICE_REQ_SOURCES_PK,SOURCE_SYSTEM_CODE,2
14678 INDX,QP_PREQ_PUB.Raise_GSA_Error.sel2,QP_LIST_LINES_PK,LIST_LINE_ID,1
14679 */
14680 SELECT MIN(qpll.operand) INTO l_operand
14681 FROM
14682 QP_QUALIFIERS qpq,
14683 QP_PRICING_ATTRIBUTES qppa,
14684 QP_LIST_LINES qpll,
14685 QP_LIST_HEADERS_B qplh,
14686 QP_PRICE_REQ_SOURCES_V qpprs
14687 WHERE
14688 qpq.qualifier_context = 'CUSTOMER' AND
14689 qpq.qualifier_attribute = 'QUALIFIER_ATTRIBUTE15' AND
14690 qpq.qualifier_attr_value = 'Y' AND
14691 qppa.list_header_id = qplh.list_header_id AND
14692 qplh.active_flag = 'Y' AND
14693 qpprs.request_type_code = p_request_type_code AND
14694 qpprs.source_system_code = qplh.source_system_code AND
14695 qppa.pricing_phase_id = 2 AND
14696 qppa.qualification_ind = 6 AND
14697 qppa.product_attribute_context = 'ITEM' AND
14698 qppa.product_attribute = 'PRICING_ATTRIBUTE1' AND
14699 qppa.product_attr_value = p_inventory_item_id AND
14700 qppa.excluder_flag = 'N' AND
14701 qppa.list_header_id = qpq.list_header_id AND
14702 qppa.list_line_id = qpll.list_line_id AND
14703 p_pricing_date BETWEEN nvl(trunc(qplh.start_date_active), p_pricing_date) AND nvl(trunc(qplh.end_date_active), p_pricing_date);
14704
14705 IF l_operand IS NOT NULL THEN
14706
14707 -- if given price is lower than GSA price, then raise GSA error
14708 IF p_unit_price <= l_operand THEN
14709 v_return_value := TRUE;
14710 ELSE
14711 v_return_value := FALSE;
14712 END IF;
14713 ELSE
14714 -- return FALSE if l_operand is NULL
14715 v_return_value := FALSE;
14716 END IF;
14717
14718
14719 ELSE -- l_gsa_indicator_flag != 'N'
14720 -- No need to check GSA error if it is a GSA customer, return FALSE
14721 v_return_value := FALSE;
14722 END IF;
14723
14724 RETURN v_return_value;
14725 END Raise_GSA_Error;
14726
14727 --overloaded for applications who insert into temp tables directly
14728 PROCEDURE PRICE_REQUEST
14729 (p_control_rec IN QP_PREQ_GRP.CONTROL_RECORD_TYPE,
14730 x_return_status OUT NOCOPY VARCHAR2,
14731 x_return_status_text OUT NOCOPY VARCHAR2
14732 ) IS
14733
14734 l_line_tbl QP_PREQ_GRP.LINE_TBL_TYPE;
14735 l_qual_tbl QP_PREQ_GRP.QUAL_TBL_TYPE;
14736 l_line_attr_tbl QP_PREQ_GRP.LINE_ATTR_TBL_TYPE;
14737 l_line_detail_tbl QP_PREQ_GRP.LINE_DETAIL_TBL_TYPE;
14738 l_line_detail_qual_tbl QP_PREQ_GRP.LINE_DETAIL_QUAL_TBL_TYPE;
14739 l_line_detail_attr_tbl QP_PREQ_GRP.LINE_DETAIL_ATTR_TBL_TYPE;
14740 l_related_lines_tbl QP_PREQ_GRP.RELATED_LINES_TBL_TYPE;
14741 l_control_rec QP_PREQ_GRP.CONTROL_RECORD_TYPE;
14742 --l_return_status VARCHAR2(30);
14743 --l_return_status_text VARCHAR2(240);
14744
14745 PRICE_REQUEST_EXC EXCEPTION;
14746
14747 l_routine VARCHAR2(50) := 'Routine :QP_PREQ_PUB.Price_Request ';
14748
14749
14750 BEGIN
14751
14752
14753 PRICE_REQUEST
14754 (p_line_tbl => l_line_tbl,
14755 p_qual_tbl => l_qual_tbl,
14756 p_line_attr_tbl => l_line_attr_tbl,
14757 p_line_detail_tbl => l_line_detail_tbl,
14758 p_line_detail_qual_tbl => l_line_detail_qual_tbl,
14759 p_line_detail_attr_tbl => l_line_detail_attr_tbl,
14760 p_related_lines_tbl => l_related_lines_tbl,
14761 p_control_rec => p_control_rec,
14762 x_line_tbl => l_line_tbl,
14763 x_line_qual => l_qual_tbl,
14764 x_line_attr_tbl => l_line_attr_tbl,
14765 x_line_detail_tbl => l_line_detail_tbl,
14766 x_line_detail_qual_tbl => l_line_detail_qual_tbl,
14767 x_line_detail_attr_tbl => l_line_detail_attr_tbl,
14768 x_related_lines_tbl => l_related_lines_tbl,
14769 x_return_status => x_return_status,
14770 x_return_status_text => x_return_status_text
14771 );
14772
14773 /*
14774 IF l_return_status IN (FND_API.G_RET_STS_ERROR
14775 ,FND_API.G_RET_STS_UNEXP_ERROR)
14776 THEN
14777
14778 RAISE PRICE_REQUEST_EXC;
14779 END IF;
14780 */
14781
14782
14783
14784 EXCEPTION
14785 WHEN PRICE_REQUEST_EXC THEN
14786 IF l_debug = FND_API.G_TRUE THEN
14787 QP_PREQ_GRP.ENGINE_DEBUG('Exception Price Request: '|| SQLERRM);
14788 END IF;
14789 NULL;
14790 -- x_return_status := FND_API.G_RET_STS_ERROR;
14791 -- x_return_status_TEXT := l_routine||' '||SQLERRM;
14792 WHEN OTHERS THEN
14793 IF l_debug = FND_API.G_TRUE THEN
14794 QP_PREQ_GRP.ENGINE_DEBUG('Exception Price Request: '|| SQLERRM);
14795 END IF;
14796 x_return_status := FND_API.G_RET_STS_ERROR;
14797 x_return_status_TEXT := l_routine ||' '|| SQLERRM;
14798
14799 END PRICE_REQUEST;
14800
14801 --procedure to return price and status code and text -- needed by PO team
14802 -- changed the out param value for x_adjusted_unit_price to qp_npreq_lines_tmp.order_uom_selling_price
14803 PROCEDURE get_price_for_line(p_line_index IN NUMBER,
14804 p_line_id IN NUMBER,
14805 x_line_unit_price OUT NOCOPY NUMBER,
14806 x_adjusted_unit_price OUT NOCOPY NUMBER,
14807 x_return_status OUT NOCOPY VARCHAR2,
14808 x_pricing_status_code OUT NOCOPY VARCHAR2,
14809 x_pricing_status_text OUT NOCOPY VARCHAR2
14810 )
14811 IS
14812
14813 l_routine VARCHAR2(100) := 'Routine :QP_PREQ_PUB.get_price_for_line ';
14814 BEGIN
14815
14816 IF l_debug = FND_API.G_TRUE THEN
14817 QP_PREQ_GRP.ENGINE_DEBUG('In : ' || l_routine);
14818 QP_PREQ_GRP.ENGINE_DEBUG('p_line_index : ' || p_line_index);
14819 QP_PREQ_GRP.ENGINE_DEBUG('p_line_id : ' || p_line_id);
14820 END IF;
14821
14822 --added by yangli for java engine
14823 IF QP_JAVA_ENGINE_UTIL_PUB.Java_Engine_Running = 'N' THEN
14824 IF l_debug = FND_API.G_TRUE THEN
14825 QP_PREQ_GRP.ENGINE_DEBUG('java engine is not running');
14826 END IF;
14827 IF p_line_index IS NOT NULL THEN
14828 SELECT line_unit_price,
14829 order_uom_selling_price,
14830 pricing_status_code,
14831 pricing_status_text
14832 INTO x_line_unit_price,
14833 x_adjusted_unit_price,
14834 x_pricing_status_code,
14835 x_pricing_status_text
14836 FROM QP_NPREQ_LINES_TMP
14837 WHERE line_index = p_line_index;
14838 ELSIF p_line_id IS NOT NULL THEN
14839 SELECT line_unit_price,
14840 order_uom_selling_price,
14841 pricing_status_code,
14842 pricing_status_text
14843 INTO x_line_unit_price,
14844 x_adjusted_unit_price,
14845 x_pricing_status_code,
14846 x_pricing_status_text
14847 FROM QP_NPREQ_LINES_TMP
14848 WHERE line_id = p_line_id;
14849 ELSE
14850 x_return_status := FND_API.G_RET_STS_ERROR;
14851 x_pricing_status_text := 'Must pass either p_line_index or p_line_id while calling ' || l_routine;
14852 END IF;
14853 --added by yangli for java engine
14854 ELSE
14855 IF l_debug = FND_API.G_TRUE THEN
14856 QP_PREQ_GRP.ENGINE_DEBUG('java engine running');
14857 END IF;
14858 IF p_line_index IS NOT NULL THEN
14859 SELECT line_unit_price,
14860 order_uom_selling_price,
14861 pricing_status_code,
14862 pricing_status_text
14863 INTO x_line_unit_price,
14864 x_adjusted_unit_price,
14865 x_pricing_status_code,
14866 x_pricing_status_text
14867 FROM QP_INT_LINES
14868 WHERE line_index = p_line_index;
14869 ELSIF p_line_id IS NOT NULL THEN
14870 SELECT line_unit_price,
14871 order_uom_selling_price,
14872 pricing_status_code,
14873 pricing_status_text
14874 INTO x_line_unit_price,
14875 x_adjusted_unit_price,
14876 x_pricing_status_code,
14877 x_pricing_status_text
14878 FROM QP_INT_LINES
14879 WHERE line_id = p_line_id;
14880 ELSE
14881 x_return_status := FND_API.G_RET_STS_ERROR;
14882 x_pricing_status_text := 'Must pass either p_line_index or p_line_id while calling ' || l_routine;
14883 END IF;
14884 END IF;
14885
14886 IF l_debug = FND_API.G_TRUE THEN
14887 QP_PREQ_GRP.ENGINE_DEBUG('x_line_unit_price : ' || x_line_unit_price);
14888 QP_PREQ_GRP.ENGINE_DEBUG('x_adjusted_unit_price : ' || x_adjusted_unit_price);
14889 QP_PREQ_GRP.ENGINE_DEBUG('x_pricing_status_code : ' || x_pricing_status_code);
14890 QP_PREQ_GRP.ENGINE_DEBUG('x_pricing_status_text : ' || x_pricing_status_text);
14891 END IF;
14892
14893 IF x_pricing_status_code IN (QP_PREQ_GRP.G_STATUS_NEW, QP_PREQ_GRP.G_STATUS_UPDATED, QP_PREQ_GRP.G_STATUS_UNCHANGED) THEN
14894 x_return_status := FND_API.G_RET_STS_SUCCESS;
14895 ELSE
14896 x_return_status := FND_API.G_RET_STS_ERROR;
14897 END IF;
14898
14899 EXCEPTION
14900
14901 WHEN NO_DATA_FOUND THEN
14902 IF l_debug = FND_API.G_TRUE THEN
14903 QP_PREQ_GRP.ENGINE_DEBUG('no_data_found Exception in : ' || l_routine || ' ' || SQLERRM);
14904 END IF;
14905 x_return_status := FND_API.G_RET_STS_ERROR;
14906 x_pricing_status_text := 'No record found for line_index ' || p_line_index || ' or line_id ' || p_line_id || ' in ' || l_routine;
14907
14908 WHEN OTHERS THEN
14909 IF l_debug = FND_API.G_TRUE THEN
14910 QP_PREQ_GRP.ENGINE_DEBUG('Others Exception in : ' || l_routine || ' ' || SQLERRM);
14911 END IF;
14912 x_return_status := FND_API.G_RET_STS_ERROR;
14913 x_pricing_status_text := 'Others Exception in : ' || l_routine || ' ' || SQLERRM;
14914 END get_price_for_line;
14915
14916
14917 END QP_PREQ_PUB;