[Home] [Help]
PACKAGE BODY: APPS.CSI_COUNTER_READINGS_PVT
Source
1 PACKAGE BODY CSI_COUNTER_READINGS_PVT as
2 /* $Header: csivcrdb.pls 120.41.12010000.3 2008/11/25 22:43:29 anjgupta ship $ */
3 --
4 G_PKG_NAME CONSTANT VARCHAR2(30):= 'CSI_COUNTER_READINGS_PVT';
5 G_FILE_NAME CONSTANT VARCHAR2(12) := 'csivcrdb.pls';
6 --
7 FUNCTION get_reading_before_reset(p_counter_id NUMBER,
8 p_value_timestamp DATE)
9 RETURN NUMBER IS
10
11 CURSOR c1 IS
12 SELECT counter_reading
13 FROM csi_counter_readings
14 WHERE counter_id = p_counter_id
15 AND value_timestamp < p_value_timestamp
16 AND nvl(disabled_flag,'N') = 'N'
17 ORDER BY value_timestamp desc;
18 --
19 l_reading_before_reset NUMBER;
20 BEGIN
21 OPEN c1;
22 FETCH c1 INTO l_reading_before_reset;
23 CLOSE c1;
24 --
25 RETURN l_reading_before_reset;
26 END get_reading_before_reset;
27 --
28 FUNCTION get_previous_net_reading(p_counter_id NUMBER,
29 p_value_timestamp DATE)
30 RETURN NUMBER IS
31
32 CURSOR c1 IS
33 SELECT net_reading
34 FROM csi_counter_readings
35 WHERE counter_id = p_counter_id
36 AND value_timestamp < p_value_timestamp
37 AND nvl(disabled_flag,'N') = 'N'
38 ORDER BY value_timestamp desc;
39 --
40 l_prev_net_reading NUMBER;
41 BEGIN
42 OPEN c1;
43 FETCH c1 INTO l_prev_net_reading;
44 CLOSE c1;
45 --
46 RETURN l_prev_net_reading;
47 END get_previous_net_reading;
48 --
49 FUNCTION get_latest_reading(p_counter_id NUMBER)
50 RETURN NUMBER IS
51 l_counter_value_id NUMBER;
52 BEGIN
53 --Modified function for bug 7563117
54 BEGIN
55 SELECT ctr_val_max_seq_no
56 INTO l_counter_value_id
57 FROM csi_counters_b
58 WHERE counter_id = p_counter_id
59 AND EXISTS(SELECT 'Y' FROM csi_counter_readings WHERE counter_value_id=ctr_val_max_seq_no);
60 EXCEPTION
61 WHEN NO_DATA_FOUND THEN
62 l_counter_value_id := NULL;
63 END;
64
65 RETURN l_counter_value_id;
66 END get_latest_reading;
67 --
68 FUNCTION Transaction_ID_Exists
69 (p_transaction_id IN NUMBER)
70 RETURN BOOLEAN IS
71 l_return_value BOOLEAN := FALSE;
72 l_exists VARCHAR2(1);
73 BEGIN
74 Begin
75 select 'x'
76 into l_exists
77 from CSI_TRANSACTIONS
78 where transaction_id = p_transaction_id;
79 l_return_value := TRUE;
80 Exception
81 when no_data_found then
82 l_return_value := FALSE;
83 End;
84 RETURN l_return_value;
85 END Transaction_ID_Exists;
86 --
87 FUNCTION Counter_Value_Exists
88 (p_ctr_value_id IN NUMBER)
89 RETURN BOOLEAN IS
90 l_return_value BOOLEAN := FALSE;
91 l_exists VARCHAR2(1);
92 BEGIN
93 Begin
94 select 'x'
95 into l_exists
96 from CSI_COUNTER_READINGS
97 where counter_value_id = p_ctr_value_id;
98 l_return_value := TRUE;
99 Exception
100 when no_data_found then
101 l_return_value := FALSE;
102 End;
103 RETURN l_return_value;
104 END Counter_Value_Exists;
105 --
106 FUNCTION Counter_Prop_Value_Exists
107 (p_ctr_prop_value_id IN NUMBER)
108 RETURN BOOLEAN IS
109 l_return_value BOOLEAN := FALSE;
110 l_exists VARCHAR2(1);
111 BEGIN
112 Begin
113 select 'x'
114 into l_exists
115 from CSI_CTR_PROPERTY_READINGS
116 where counter_prop_value_id = p_ctr_prop_value_id;
117 l_return_value := TRUE;
118 Exception
119 when no_data_found then
120 l_return_value := FALSE;
121 End;
122 RETURN l_return_value;
123 END Counter_Prop_Value_Exists;
124 --
125 FUNCTION Estimated_Rdg_ID_Exists
126 (p_estimated_rdg_id IN NUMBER)
127 RETURN BOOLEAN IS
128 l_return_value BOOLEAN := FALSE;
129 l_exists VARCHAR2(1);
130 BEGIN
131 Begin
132 select 'x'
133 into l_exists
134 from CSI_CTR_ESTIMATED_READINGS
135 where estimated_reading_id = p_estimated_rdg_id;
136 l_return_value := TRUE;
137 Exception
138 when no_data_found then
139 l_return_value := FALSE;
140 End;
141 RETURN l_return_value;
142 END Estimated_Rdg_ID_Exists;
143 --
144 FUNCTION Is_Formula_Counter
145 (p_counter_id IN NUMBER)
146 RETURN BOOLEAN IS
147 l_return_value BOOLEAN := FALSE;
148 l_exists VARCHAR2(1);
149 l_rel_type VARCHAR2(30) := 'FORMULA';
150 BEGIN
151 Begin
152 select '1'
153 into l_exists
154 from dual
155 where exists (select 'x'
156 from CSI_COUNTER_RELATIONSHIPS
157 where object_counter_id = p_counter_id
158 and relationship_type_code = l_rel_type);
159 l_return_value := TRUE;
160 Exception
161 when no_data_found then
162 l_return_value := FALSE;
163 End;
164 RETURN l_return_value;
165 END Is_Formula_Counter;
166 --
167 FUNCTION Is_Target_Counter
168 (p_counter_id IN NUMBER)
169 RETURN BOOLEAN IS
170 l_return_value BOOLEAN := FALSE;
171 l_exists VARCHAR2(1);
172 l_rel_type VARCHAR2(30) := 'CONFIGURATION';
173 BEGIN
174 Begin
175 select '1'
176 into l_exists
177 from dual
178 where exists (select 'x'
179 from CSI_COUNTER_RELATIONSHIPS
180 where object_counter_id = p_counter_id
181 and relationship_type_code = l_rel_type
182 and nvl(active_end_date,(sysdate+1)) > sysdate);
183 l_return_value := TRUE;
184 Exception
185 when no_data_found then
186 l_return_value := FALSE;
187 End;
188 RETURN l_return_value;
189 END Is_Target_Counter;
190 --
191 FUNCTION Valid_Adjustment_Type
192 (p_adjustment_type IN VARCHAR2)
193 RETURN BOOLEAN IS
194 l_return_value BOOLEAN := FALSE;
195 l_exists VARCHAR2(1);
196 l_adj_type VARCHAR2(30) := 'CSI_CTR_ADJUST_READING_TYPE';
197 BEGIN
198 Begin
199 select 'x'
200 into l_exists
201 from CSI_LOOKUPS
202 where lookup_type = l_adj_type
203 and lookup_code = p_adjustment_type;
204 l_return_value := TRUE;
205 Exception
206 when no_data_found then
207 l_return_value := FALSE;
208 End;
209 RETURN l_return_value;
210 END Valid_Adjustment_Type;
211 --
212 FUNCTION Valid_Reset_Mode
213 (p_reset_mode IN VARCHAR2)
214 RETURN BOOLEAN IS
215 l_return_value BOOLEAN := FALSE;
216 l_exists VARCHAR2(1);
217 l_adj_type VARCHAR2(30) := 'CSI_CTR_READING_RESET_TYPE';
218 BEGIN
219 Begin
220 select 'x'
221 into l_exists
222 from CSI_LOOKUPS
223 where lookup_type = l_adj_type
224 and lookup_code = p_reset_mode;
225 l_return_value := TRUE;
226 Exception
227 when no_data_found then
228 l_return_value := FALSE;
229 End;
230 RETURN l_return_value;
231 END Valid_Reset_Mode;
232 --
233 FUNCTION Valid_Ctr_Property_ID
234 (p_ctr_value_id IN NUMBER
235 ,p_ctr_prop_id IN NUMBER)
236 RETURN BOOLEAN IS
237 l_return_value BOOLEAN := FALSE;
238 l_exists VARCHAR2(1);
239 BEGIN
240 Begin
241 select 'x'
242 into l_exists
243 from CSI_COUNTER_READINGS ccr,
244 CSI_COUNTER_PROPERTIES_B ccp
245 where ccr.counter_value_id = p_ctr_value_id
246 and ccp.counter_id = ccr.counter_id
247 and ccp.counter_property_id = p_ctr_prop_id
248 and nvl(ccp.end_date_active,(sysdate+1)) > sysdate;
249 --
250 l_return_value := TRUE;
251 Exception
252 when no_data_found then
253 l_return_value := FALSE;
254 End;
255 RETURN l_return_value;
256 END Valid_Ctr_Property_ID;
257 --
258 FUNCTION HAS_PROPERTY_VALUE(
259 p_counter_property_id in number,
260 p_counter_value_id in number
261 ) RETURN VARCHAR2
262 IS
263 l_s_temp varchar2(1);
264 BEGIN
265 select 'x'
266 into l_s_temp
267 from CSI_CTR_PROPERTY_READINGS
268 where counter_property_id = p_counter_property_id
269 and counter_value_id = p_counter_value_id;
270 return 'T';
271 EXCEPTION
272 when no_data_found then
273 return 'F';
274 END HAS_PROPERTY_VALUE;
275 --
276 PROCEDURE Calculate_Net_Reading
277 (
278 p_prev_net_rdg IN NUMBER
279 ,p_prev_ltd_rdg IN NUMBER
280 ,p_curr_rdg IN NUMBER
281 ,p_prev_rdg IN NUMBER
282 ,p_curr_adj IN NUMBER
283 ,p_rdg_type IN NUMBER
284 ,p_direction IN VARCHAR2
285 ,l_ctr_rdg_rec IN csi_ctr_datastructures_pub.counter_readings_rec
286 ,px_net_rdg OUT NOCOPY NUMBER
287 ,px_ltd_rdg OUT NOCOPY NUMBER
288 ) IS
289 l_curr_adj NUMBER;
290 BEGIN
291 -- For Bi-directional counters, Net and LTD will be same as Counter Reading
292 -- Read the debug profiles values in to global variable 7197402
293 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
294
295 csi_ctr_gen_utility_pvt.put_line('Calculate Net Reading Procedure');
296 csi_ctr_gen_utility_pvt.put_line('6398254: p_prev_net_rdg' || p_prev_net_rdg);
297 csi_ctr_gen_utility_pvt.put_line('6398254: p_prev_ltd_rdg' || p_prev_ltd_rdg);
298 csi_ctr_gen_utility_pvt.put_line('6398254: p_curr_rdg' || p_curr_rdg);
299 csi_ctr_gen_utility_pvt.put_line('6398254: p_prev_rdg' || p_prev_rdg);
300 csi_ctr_gen_utility_pvt.put_line(' p_curr_adj' || p_curr_adj);
301 csi_ctr_gen_utility_pvt.put_line('6398254: p_rdg_type' || p_rdg_type);
302 csi_ctr_gen_utility_pvt.put_line('p_direction' || p_direction);
303 csi_ctr_gen_utility_pvt.put_line('6398254: l_ctr_rdg_rec.reset_mode' || l_ctr_rdg_rec.reset_mode); -- added 6398254
304 csi_ctr_gen_utility_pvt.put_line('6398254: l_ctr_rdg_rec.reset_reason' || l_ctr_rdg_rec.reset_reason); -- added 6398254
305 /* Only return if a Bi-directional counter AND a reset flow */
306
307 --
308
309 /* Treat Adjustments of Fluctuating counters like Ascending counters */
310 IF p_curr_adj IS NULL OR p_curr_adj = FND_API.G_MISS_NUM THEN
311 l_curr_adj := 0;
312 ELSE
313 l_curr_adj := p_curr_adj;
314 END IF;
315 -- Adjustment will get added if Descending. To retain the same formula we just mutiply with -1
316 IF NVL(p_direction,'X') = 'D' THEN
317 l_curr_adj := l_curr_adj * -1;
318 END IF;
319 --
320 IF p_rdg_type = 1 THEN -- Absolute
321 -- Net Reading = Prev Net + (Curr Rdg - Prev Rdg) - Curr Adj
322 -- LTD Reading = Prev LTD + (Curr Rdg - Prev Rdg)
323 px_net_rdg := nvl(p_prev_net_rdg,0) +
324 (nvl(p_curr_rdg,0) - nvl(p_prev_rdg,0)) - l_curr_adj;
325 px_ltd_rdg := nvl(p_prev_ltd_rdg,0) + (nvl(p_curr_rdg,0) - nvl(p_prev_rdg,0));
326 ELSIF p_rdg_type = 2 THEN -- Change
327 -- Net Reading = Prev Net + Curr Rdg - Curr Adj -- For Ascending
328 -- Net Reading = Prev Net - Curr Rdg - Curr Adj -- For Descending
329 IF NVL(p_direction,'X') = 'A' or NVL(p_direction,'X') = 'B' THEN
330 csi_ctr_gen_utility_pvt.put_line('Inside the IF block');
331 px_net_rdg := nvl(p_prev_net_rdg,0) + nvl(p_curr_rdg,0) - l_curr_adj;
332 px_ltd_rdg := nvl(p_prev_ltd_rdg,0) + nvl(p_curr_rdg,0);
333 ELSIF NVL(p_direction,'X') = 'D' THEN
334 csi_ctr_gen_utility_pvt.put_line('Calculate Net Reading for Desc');
335 csi_ctr_gen_utility_pvt.put_line('Prev Reading = '||to_char(p_prev_rdg));
336 csi_ctr_gen_utility_pvt.put_line('Prev Net Reading = '||to_char(nvl(p_prev_net_rdg,0)));
337 csi_ctr_gen_utility_pvt.put_line('Prev LTD Reading = '||to_char(nvl(p_prev_ltd_rdg,0)));
338 csi_ctr_gen_utility_pvt.put_line('Current Reading = '||to_char(nvl(p_curr_rdg,0)));
339 IF nvl(p_prev_net_rdg,0) = 0 THEN
340 /* Check if there is a previous reading */
341 IF p_prev_rdg IS NOT NULL THEN
342 px_net_rdg := nvl(p_prev_net_rdg,0) - nvl(p_curr_rdg,0);
343 ELSE
344 px_net_rdg := nvl(p_curr_rdg,0) - l_curr_adj;
345 END IF;
346 ELSE
347 px_net_rdg := nvl(p_prev_net_rdg,0) - nvl(p_curr_rdg,0) - l_curr_adj;
348 END IF;
349
350 IF nvl(p_prev_ltd_rdg,0) = 0 THEN
351 IF p_prev_rdg IS NOT NULL THEN
352 px_ltd_rdg := nvl(p_prev_ltd_rdg,0) - nvl(p_curr_rdg,0);
353 ELSE
354 px_ltd_rdg := nvl(p_curr_rdg,0);
355 END IF;
356 ELSE
357 px_ltd_rdg := nvl(p_prev_ltd_rdg,0) - nvl(p_curr_rdg,0);
358 END IF;
359 csi_ctr_gen_utility_pvt.put_line('New Net Reading = '||to_char(px_net_rdg));
360 csi_ctr_gen_utility_pvt.put_line('New LTD Reading = '||to_char(px_ltd_rdg));
361 END IF;
362 END IF;
363 /* added 6398254 */
364 csi_ctr_gen_utility_pvt.put_line('6398254: New Net Reading = '||to_char(px_net_rdg));
365 csi_ctr_gen_utility_pvt.put_line('6398254: New LTD Reading = '||to_char(px_ltd_rdg));
366 /* end addition */
367 IF NVL(p_direction,'X') = 'B' AND p_rdg_type = 2 THEN
368 IF p_curr_adj IS NULL OR p_curr_adj = FND_API.G_MISS_NUM THEN
369 IF l_ctr_rdg_rec.reset_mode = 'SOFT' THEN
370 -- AND NVL(l_ctr_rdg_rec.reset_mode,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR THEN
371 -- csi_ctr_gen_utility_pvt.put_line('6398254: Inside Bidir Reset Block p_curr_rdg' || p_curr_rdg);
372
373 px_net_rdg := nvl(p_curr_rdg,0);
374 px_ltd_rdg := nvl(p_prev_ltd_rdg,0);
375 -- Return;
376 END IF;
377 END IF;
378 END IF;
379
380 END Calculate_Net_Reading;
381 --
382 PROCEDURE Reset_Target_Counters
383 (
384 p_txn_rec IN csi_datastructures_pub.transaction_rec
385 ,p_ctr_rdg_rec IN csi_ctr_datastructures_pub.counter_readings_rec
386 ,x_return_status OUT NOCOPY VARCHAR2
387 ,x_msg_count OUT NOCOPY NUMBER
388 ,x_msg_data OUT NOCOPY VARCHAR2
389 )
390 IS
391 l_rel_type VARCHAR2(30) := 'CONFIGURATION';
392 l_counter_reading NUMBER;
393 l_ctr_rdg_rec csi_ctr_datastructures_pub.counter_readings_rec;
394 l_temp_ctr_rdg_rec csi_ctr_datastructures_pub.counter_readings_rec;
395 l_process_flag BOOLEAN;
396 l_mode VARCHAR2(30);
397 --
398 CURSOR OBJECT_CTR_CUR IS
399 select ccr.object_counter_id,nvl(ccr.factor,1) factor,
400 ccv.direction,ccv.reading_type, ccv.uom_code object_uom_code
401 from CSI_COUNTER_RELATIONSHIPS ccr,
402 CSI_COUNTERS_B ccv
403 where ccr.source_counter_id = p_ctr_rdg_rec.counter_id
404 and ccr.relationship_type_code =l_rel_type
405 and nvl(ccr.active_start_date,sysdate) <= p_ctr_rdg_rec.value_timestamp
406 and nvl(ccr.active_end_date,(sysdate+1)) > p_ctr_rdg_rec.value_timestamp
407 and ccv.counter_id = ccr.object_counter_id;
408 -- and ccv.reading_type <> 2; -- Exclude Change counters as resets are not allowed
409 --
410 CURSOR PREV_READING_CUR(p_counter_id IN NUMBER,p_value_timestamp IN DATE) IS
411 select counter_reading,net_reading,life_to_date_reading
412 from CSI_COUNTER_READINGS
413 where counter_id = p_counter_id
414 and nvl(disabled_flag,'N') = 'N'
415 and value_timestamp < p_value_timestamp
416 ORDER BY value_timestamp desc,counter_value_id desc;
417 --
418 CURSOR GET_UOM_CLASS(p_uom_code VARCHAR2) IS
419 SELECT uom_class
420 FROM mtl_units_of_measure
421 WHERE uom_code = p_uom_code;
422
423 l_previous_ctr_rdg NUMBER;
424 l_previous_net_rdg NUMBER;
425 l_previous_ltd_rdg NUMBER;
426
427 l_source_uom_class VARCHAR2(10);
428 l_object_uom_class VARCHAR2(10);
429 l_source_uom_code VARCHAR2(3);
430 l_source_direction VARCHAR2(1);
431 l_uom_rate NUMBER;
432 l_src_reading_type VARCHAR2(1);
433 BEGIN
434 SAVEPOINT reset_target_counters;
435 -- Initialize API return status to success
436 x_return_status := FND_API.G_RET_STS_SUCCESS;
437 --
438
439 -- Read the debug profiles values in to global variable 7197402
440 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
441
442 csi_ctr_gen_utility_pvt.put_line('6398254: Inside Reset_Target_Counters...');
443 csi_ctr_gen_utility_pvt.dump_counter_readings_rec(p_ctr_rdg_rec);
444 IF p_txn_rec.transaction_type_id in (88,91,92,94,95) THEN
445 l_mode := 'Meter';
446 ELSE
447 l_mode := 'Counter';
448 END IF;
449 --
450 FOR obj_cur IN OBJECT_CTR_CUR LOOP
451 -- Check previous reading exists
452 l_previous_ctr_rdg := NULL;
453 --
454 OPEN PREV_READING_CUR(obj_cur.object_counter_id,p_ctr_rdg_rec.value_timestamp);
455 FETCH PREV_READING_CUR
456 INTO l_previous_ctr_rdg,
457 l_previous_net_rdg,
458 l_previous_ltd_rdg;
459 CLOSE PREV_READING_CUR;
460 --
461 IF l_previous_ctr_rdg = NULL THEN
462 csi_ctr_gen_utility_pvt.put_line('Target Counter ID '||to_char(obj_cur.object_counter_id)||
463 ' does not have any prior readings. First reading cannot be reset');
464 csi_ctr_gen_utility_pvt.ExitWithErrMsg
465 ( p_msg_name => 'CSI_API_CTR_INVALID_FIRST_RDG',
466 p_token1_name => 'MODE',
467 p_token1_val => l_mode
468 );
469 END IF;
470 --
471 IF p_ctr_rdg_rec.counter_reading > l_previous_ctr_rdg THEN
472 csi_ctr_gen_utility_pvt.put_line('Reset counter reading has to be less than the previous reading');
473 csi_ctr_gen_utility_pvt.ExitWithErrMsg
474 ( p_msg_name => 'CSI_API_CTR_LESS_RESET_RDG',
475 p_token1_name => 'PREV_RDG',
476 p_token1_val => to_char(l_previous_ctr_rdg),
477 p_token2_name => 'MODE',
478 p_token2_val => l_mode
479 );
480 END IF;
481 --
482 l_ctr_rdg_rec := l_temp_ctr_rdg_rec;
483 --
484
485 l_ctr_rdg_rec.counter_id := obj_cur.object_counter_id;
486 l_ctr_rdg_rec.source_counter_value_id := p_ctr_rdg_rec.counter_value_id;
487 l_ctr_rdg_rec.value_timestamp := p_ctr_rdg_rec.value_timestamp;
488 l_ctr_rdg_rec.counter_reading := p_ctr_rdg_rec.counter_reading;
489 l_ctr_rdg_rec.net_reading := l_previous_net_rdg;
490 l_ctr_rdg_rec.life_to_date_reading := l_previous_ltd_rdg;
491 l_ctr_rdg_rec.reset_mode := p_ctr_rdg_rec.reset_mode;
492 l_ctr_rdg_rec.reset_reason := p_ctr_rdg_rec.reset_reason;
493 l_ctr_rdg_rec.source_code := p_ctr_rdg_rec.source_code;
494 l_ctr_rdg_rec.source_line_id := p_ctr_rdg_rec.source_line_id;
495 l_ctr_rdg_rec.comments := p_ctr_rdg_rec.comments;
496
497 csi_ctr_gen_utility_pvt.put_line('6398254: reset reason' || l_ctr_rdg_rec.reset_reason);
498 csi_ctr_gen_utility_pvt.put_line('6398254: net reading' || l_ctr_rdg_rec.net_reading);
499
500 --
501 -- Generate the Value_id for insert
502 l_process_flag := TRUE;
503 WHILE l_process_flag LOOP
504 select CSI_COUNTER_READINGS_S.nextval
505 into l_ctr_rdg_rec.counter_value_id from dual;
506 IF NOT Counter_Value_Exists(l_ctr_rdg_rec.counter_value_id) THEN
507 l_process_flag := FALSE;
508 END IF;
509
510 END LOOP;
511
512 /* Check reset factor */
513 BEGIN
514 SELECT uom_code, direction, reading_type
515 INTO l_source_uom_code, l_source_direction, l_src_reading_type
516 FROM csi_counters_b
517 WHERE counter_id = p_ctr_rdg_rec.counter_id;
518 EXCEPTION
519 WHEN OTHERS THEN
520 NULL;
521 END;
522
523 IF obj_cur.object_uom_code <> l_source_uom_code THEN
524 /* Validate if same UOM class */
525 OPEN get_uom_class(obj_cur.object_uom_code);
526 FETCH get_uom_class into l_object_uom_class;
527
528 IF get_uom_class%notfound THEN
529 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_ALL_INVALID_UOM_CODE');
530 END IF;
531
532 IF get_uom_class%ISOPEN THEN
533 CLOSE get_uom_class;
534 END IF;
535
536 OPEN get_uom_class(l_source_uom_code);
537 FETCH get_uom_class into l_source_uom_class;
538
539 IF get_uom_class%notfound THEN
540 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_ALL_INVALID_UOM_CODE');
541 END IF;
542
543 IF get_uom_class%ISOPEN THEN
544 CLOSE get_uom_class;
545 END IF;
546
547 IF l_source_uom_class = l_object_uom_class THEN
548 /* Do a conversion */
549 INV_CONVERT.INV_UM_CONVERSION(l_source_uom_code
550 ,obj_cur.object_uom_code
551 ,null
552 ,l_uom_rate);
553
554 csi_ctr_gen_utility_pvt.put_line('Object UOM Code = '||obj_cur.object_uom_code);
555 csi_ctr_gen_utility_pvt.put_line('Source UOM Code = '||l_source_uom_code);
556 csi_ctr_gen_utility_pvt.put_line('UOM Rate = '||to_char(l_uom_rate));
557 IF l_uom_rate = -99999 then
558 csi_ctr_gen_utility_pvt.put_line(' Error during the conversion of UOM');
559 END IF;
560 ELSE
561 l_uom_rate := 1;
562 END IF;
563 ELSE
564 l_uom_rate := 1;
565 END IF;
566
567 IF obj_cur.reading_type = 1 THEN
568 IF l_source_direction = 'A' AND obj_cur.direction = 'D' THEN
569 l_counter_reading := ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor) * -1;
570 END IF;
571
572 IF l_source_direction = 'D' and obj_cur.direction = 'A' THEN
573 l_counter_reading := (p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor;
574 END IF;
575
576 IF obj_cur.direction = 'A' and l_source_direction = 'A' THEN
577 l_counter_reading := (p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor;
578 ELSIF obj_cur.direction = 'D' and l_source_direction = 'D' THEN
579 l_counter_reading := (p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor;
580 l_counter_reading := l_counter_reading * -1;
581 ELSIF obj_cur.direction = 'B' and l_source_direction = 'B' THEN
582 l_counter_reading := (p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor;
583 END IF;
584 ELSE
585 l_counter_reading := (p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor;
586 END IF;
587
588 l_ctr_rdg_rec.counter_reading := l_counter_reading;
589
590 --
591 -- Call the Table Handler to insert into CSI_COUNTER_READINGS
592 csi_ctr_gen_utility_pvt.put_line('Resetting target Counter '||to_char(l_ctr_rdg_rec.counter_id));
593 --
594 CSI_COUNTER_READINGS_PKG.Insert_Row(
595 px_COUNTER_VALUE_ID => l_ctr_rdg_rec.counter_value_id
596 ,p_COUNTER_ID => l_ctr_rdg_rec.counter_id
597 ,p_VALUE_TIMESTAMP => l_ctr_rdg_rec.value_timestamp
598 ,p_COUNTER_READING => l_ctr_rdg_rec.counter_reading
599 ,p_RESET_MODE => l_ctr_rdg_rec.reset_mode
600 ,p_RESET_REASON => l_ctr_rdg_rec.reset_reason
601 ,p_ADJUSTMENT_TYPE => NULL
602 ,p_ADJUSTMENT_READING => NULL
603 ,p_OBJECT_VERSION_NUMBER => 1
604 ,p_LAST_UPDATE_DATE => SYSDATE
605 ,p_LAST_UPDATED_BY => fnd_global.user_id
606 ,p_CREATION_DATE => SYSDATE
607 ,p_CREATED_BY => fnd_global.user_id
608 ,p_LAST_UPDATE_LOGIN => fnd_global.conc_login_id
609 ,p_ATTRIBUTE1 => l_ctr_rdg_rec.attribute1
610 ,p_ATTRIBUTE2 => l_ctr_rdg_rec.attribute2
611 ,p_ATTRIBUTE3 => l_ctr_rdg_rec.attribute3
612 ,p_ATTRIBUTE4 => l_ctr_rdg_rec.attribute4
613 ,p_ATTRIBUTE5 => l_ctr_rdg_rec.attribute5
614 ,p_ATTRIBUTE6 => l_ctr_rdg_rec.attribute6
615 ,p_ATTRIBUTE7 => l_ctr_rdg_rec.attribute7
616 ,p_ATTRIBUTE8 => l_ctr_rdg_rec.attribute8
617 ,p_ATTRIBUTE9 => l_ctr_rdg_rec.attribute9
618 ,p_ATTRIBUTE10 => l_ctr_rdg_rec.attribute10
619 ,p_ATTRIBUTE11 => l_ctr_rdg_rec.attribute11
620 ,p_ATTRIBUTE12 => l_ctr_rdg_rec.attribute12
621 ,p_ATTRIBUTE13 => l_ctr_rdg_rec.attribute13
622 ,p_ATTRIBUTE14 => l_ctr_rdg_rec.attribute14
623 ,p_ATTRIBUTE15 => l_ctr_rdg_rec.attribute15
624 ,p_ATTRIBUTE16 => l_ctr_rdg_rec.attribute16
625 ,p_ATTRIBUTE17 => l_ctr_rdg_rec.attribute17
626 ,p_ATTRIBUTE18 => l_ctr_rdg_rec.attribute18
627 ,p_ATTRIBUTE19 => l_ctr_rdg_rec.attribute19
628 ,p_ATTRIBUTE20 => l_ctr_rdg_rec.attribute20
629 ,p_ATTRIBUTE21 => l_ctr_rdg_rec.attribute21
630 ,p_ATTRIBUTE22 => l_ctr_rdg_rec.attribute22
631 ,p_ATTRIBUTE23 => l_ctr_rdg_rec.attribute23
632 ,p_ATTRIBUTE24 => l_ctr_rdg_rec.attribute24
633 ,p_ATTRIBUTE25 => l_ctr_rdg_rec.attribute25
634 ,p_ATTRIBUTE26 => l_ctr_rdg_rec.attribute26
635 ,p_ATTRIBUTE27 => l_ctr_rdg_rec.attribute27
636 ,p_ATTRIBUTE28 => l_ctr_rdg_rec.attribute28
637 ,p_ATTRIBUTE29 => l_ctr_rdg_rec.attribute29
638 ,p_ATTRIBUTE30 => l_ctr_rdg_rec.attribute30
639 ,p_ATTRIBUTE_CATEGORY => l_ctr_rdg_rec.attribute_category
640 ,p_MIGRATED_FLAG => 'N'
641 ,p_COMMENTS => l_ctr_rdg_rec.comments
642 ,p_LIFE_TO_DATE_READING => l_ctr_rdg_rec.life_to_date_reading
643 ,p_TRANSACTION_ID => p_txn_rec.transaction_id
644 ,p_AUTOMATIC_ROLLOVER_FLAG => l_ctr_rdg_rec.automatic_rollover_flag
645 ,p_INCLUDE_TARGET_RESETS => l_ctr_rdg_rec.include_target_resets
646 ,p_SOURCE_COUNTER_VALUE_ID => l_ctr_rdg_rec.source_counter_value_id
647 ,p_NET_READING => l_ctr_rdg_rec.net_reading
648 ,p_DISABLED_FLAG => 'N'
649 ,p_SOURCE_CODE => l_ctr_rdg_rec.source_code
650 ,p_SOURCE_LINE_ID => l_ctr_rdg_rec.source_line_id
651 ,p_INITIAL_READING_FLAG => l_ctr_rdg_rec.initial_reading_flag
652 );
653
654 --Add call to CSI_COUNTER_PVT.update_ctr_val_max_seq_no
655 --for bug 7374316
656 CSI_COUNTER_PVT.update_ctr_val_max_seq_no(
657 p_api_version => 1.0
658 ,p_commit => fnd_api.g_false
659 ,p_init_msg_list => fnd_api.g_true
660 ,p_validation_level => fnd_api.g_valid_level_full
661 ,p_counter_id => l_ctr_rdg_rec.counter_id
662 ,px_ctr_val_max_seq_no => l_ctr_rdg_rec.counter_value_id
663 ,x_return_status => x_return_status
664 ,x_msg_count => x_msg_count
665 ,x_msg_data => x_msg_data
666 );
667 END LOOP; -- Obj Cursor
668 --
669 EXCEPTION
670 WHEN FND_API.G_EXC_ERROR THEN
671 x_return_status := FND_API.G_RET_STS_ERROR ;
672 ROLLBACK TO reset_target_counters;
673 FND_MSG_PUB.Count_And_Get
674 ( p_count => x_msg_count,
675 p_data => x_msg_data
676 );
677 WHEN OTHERS THEN
678 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
679 ROLLBACK TO reset_target_counters;
680 END Reset_Target_Counters;
681 --
682 PROCEDURE Disable_Target_Derive_Rdg
683 ( p_src_counter_value_id IN NUMBER,
684 x_return_status OUT NOCOPY VARCHAR2
685 )
686 IS
687 l_ctr_val_max_seq_no NUMBER;
688 l_msg_data VARCHAR2(2000);
689 l_msg_index NUMBER;
690 l_msg_count NUMBER;
691 x_msg_data VARCHAR2(2000);
692 x_msg_count NUMBER;
693
694 CURSOR derived_readings_cur IS
695 SELECT counter_value_id, counter_id
696 FROM csi_counter_readings
697 WHERE source_counter_value_id = p_src_counter_value_id
698 AND nvl(disabled_flag,'N') <> 'Y';
699 BEGIN
700 x_return_status := FND_API.G_RET_STS_SUCCESS;
701 FOR derived_reading IN derived_readings_cur LOOP
702 UPDATE CSI_COUNTER_READINGS
703 SET disabled_flag = 'Y',
704 last_updated_by = fnd_global.user_id,
705 last_update_date = SYSDATE,
706 object_version_number = object_version_number + 1
707 WHERE counter_value_id = derived_reading.counter_value_id;
708
709 l_ctr_val_max_seq_no := NULL;
710
711 CSI_COUNTER_PVT.update_ctr_val_max_seq_no(
712 p_api_version => 1.0
713 ,p_commit => fnd_api.g_false
714 ,p_init_msg_list => fnd_api.g_true
715 ,p_validation_level => fnd_api.g_valid_level_full
716 ,p_counter_id => derived_reading.counter_id
717 ,px_ctr_val_max_seq_no => l_ctr_val_max_seq_no
718 ,x_return_status => x_return_status
719 ,x_msg_count => x_msg_count
720 ,x_msg_data => x_msg_data
721 );
722
723 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
724 l_msg_index := 1;
725 l_msg_count := x_msg_count;
726 WHILE l_msg_count > 0 LOOP
727 x_msg_data := FND_MSG_PUB.GET
728 (l_msg_index,
729 FND_API.G_FALSE
730 );
731 csi_ctr_gen_utility_pvt.put_line('ERROR FROM CSI_COUNTER_PVT.update_ctr_val_max_seq_no');
732 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
733 l_msg_index := l_msg_index + 1;
734 l_msg_count := l_msg_count - 1;
735 END LOOP;
736 RAISE FND_API.G_EXC_ERROR;
737 END IF;
738 END LOOP;
739 EXCEPTION
740 WHEN OTHERS THEN
741 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR;
742 END Disable_Target_Derive_Rdg;
743 --
744 PROCEDURE Calculate_Rollover_Reading
745 ( p_prev_net_rdg IN NUMBER
746 ,p_prev_ltd_rdg IN NUMBER
747 ,p_curr_rdg IN NUMBER
748 ,p_prev_rdg IN NUMBER
749 ,p_rollover_fm IN NUMBER
750 ,p_rollover_to IN NUMBER
751 ,px_net_rdg OUT NOCOPY NUMBER
752 ,px_ltd_rdg OUT NOCOPY NUMBER
753 )
754 IS
755 BEGIN
756 px_net_rdg := nvl(p_prev_net_rdg,0) +
757 (nvl(p_curr_rdg,0) - nvl(p_prev_rdg,0)) + p_rollover_fm - p_rollover_to;
758 px_ltd_rdg := nvl(p_prev_ltd_rdg,0) +
759 (nvl(p_curr_rdg,0) - nvl(p_prev_rdg,0)) + p_rollover_fm - p_rollover_to;
760 END Calculate_Rollover_Reading;
761 --
762 PROCEDURE Create_Reading_Transaction
763 ( p_api_version IN NUMBER
764 ,p_commit IN VARCHAR2
765 ,p_init_msg_list IN VARCHAR2
766 ,p_validation_level IN NUMBER
767 ,p_txn_rec IN OUT NOCOPY csi_datastructures_pub.transaction_rec
768 ,x_return_status OUT NOCOPY VARCHAR2
769 ,x_msg_count OUT NOCOPY NUMBER
770 ,x_msg_data OUT NOCOPY VARCHAR2
771 ) IS
772 --
773 l_process_flag BOOLEAN := TRUE;
774 l_dummy VARCHAR2(1);
775 l_api_name VARCHAR2(30) := 'CREATE_READING_TRANSACTION';
776 BEGIN
777 SAVEPOINT create_reading_transaction;
778 --
779 -- Read the debug profiles values in to global variable 7197402
780 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
781
782 -- Initialize message list if p_init_msg_list is set to TRUE.
783 IF FND_API.to_Boolean(nvl(p_init_msg_list,FND_API.G_FALSE)) THEN
784 FND_MSG_PUB.initialize;
785 END IF;
786 -- Initialize API return status to success
787 x_return_status := FND_API.G_RET_STS_SUCCESS;
788 --
789 -- Create Transaction
790 IF p_txn_rec.transaction_id IS NULL OR
791 p_txn_rec.transaction_id = FND_API.G_MISS_NUM THEN
792 l_process_flag := TRUE;
793 WHILE l_process_flag LOOP
794 select CSI_TRANSACTIONS_S.nextval
795 into p_txn_rec.transaction_id from dual;
796 IF NOT csi_counter_readings_pvt.Transaction_ID_Exists(p_txn_rec.transaction_id) THEN
797 l_process_flag := FALSE;
798 END IF;
799 END LOOP;
800 ELSE
801 IF csi_counter_readings_pvt.Transaction_ID_Exists(p_txn_rec.transaction_id) THEN
802 csi_ctr_gen_utility_pvt.ExitWithErrMsg
803 ( p_msg_name => 'CSI_TXN_ID_ALREADY_EXISTS'
804 ,p_token1_name => 'TRANSACTION_ID'
805 ,p_token1_val => to_char(p_txn_rec.transaction_id)
806 );
807 END IF;
808 END IF;
809 --
810 IF p_txn_rec.transaction_type_id IS NULL OR
811 p_txn_rec.transaction_type_id = FND_API.G_MISS_NUM THEN
812 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_NO_TXN_TYPE_ID');
813 ELSE
814 IF p_txn_rec.transaction_type_id NOT in (80,81,82,83,84,85,86,87,88,89,91,92,94,95)
815 THEN
816 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_INVALID_TXN_TYPE_ID');
817 ELSE
818 Begin
819 SELECT 'x'
820 INTO l_dummy
821 FROM csi_txn_types
822 WHERE transaction_type_id = p_txn_rec.transaction_type_id;
823 Exception
824 when no_data_found THEN
825 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_INVALID_TXN_TYPE_ID');
826 End;
827 END IF;
828 END IF;
829 --
830 IF p_txn_rec.source_transaction_date IS NULL OR
831 p_txn_rec.source_transaction_date = FND_API.G_MISS_DATE THEN
832 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_NO_TXN_DATE');
833 END IF;
834 --
835 IF p_txn_rec.transaction_date IS NULL OR
836 p_txn_rec.transaction_date = FND_API.G_MISS_DATE THEN
837 p_txn_rec.transaction_date := sysdate;
838 END IF;
839 --
840 p_txn_rec.object_version_number := 1;
841 p_txn_rec.gl_interface_status_code := 1; -- Pending
842 --
843 csi_ctr_gen_utility_pvt.put_line( '....create_reading_transactions' ||'-'||
844 p_api_version ||'-'||
845 nvl(p_commit,FND_API.G_FALSE) ||'-'||
846 nvl(p_init_msg_list,FND_API.G_FALSE) ||'-'||
847 nvl(p_validation_level,FND_API.G_VALID_LEVEL_FULL) );
848
849 CSI_TRANSACTIONS_PKG.Insert_Row
850 ( px_transaction_id => p_txn_rec.transaction_id,
851 p_transaction_date => p_txn_rec.transaction_date,
852 p_source_transaction_date => p_txn_rec.source_transaction_date,
853 p_transaction_type_id => p_txn_rec.transaction_type_id,
854 p_txn_sub_type_id => p_txn_rec.txn_sub_type_id,
855 p_source_group_ref_id => p_txn_rec.source_group_ref_id,
856 p_source_group_ref => p_txn_rec.source_group_ref,
857 p_source_header_ref_id => p_txn_rec.source_header_ref_id,
858 p_source_header_ref => p_txn_rec.source_header_ref,
859 p_source_line_ref_id => p_txn_rec.source_line_ref_id,
860 p_source_line_ref => p_txn_rec.source_line_ref,
861 p_source_dist_ref_id1 => p_txn_rec.source_dist_ref_id1,
862 p_source_dist_ref_id2 => p_txn_rec.source_dist_ref_id2,
863 p_inv_material_transaction_id => p_txn_rec.inv_material_transaction_id,
864 p_transaction_quantity => p_txn_rec.transaction_quantity,
865 p_transaction_uom_code => p_txn_rec.transaction_uom_code,
866 p_transacted_by => p_txn_rec.transacted_by,
867 p_transaction_status_code => p_txn_rec.transaction_status_code,
868 p_transaction_action_code => p_txn_rec.transaction_action_code,
869 p_message_id => p_txn_rec.message_id,
870 p_context => p_txn_rec.context,
871 p_attribute1 => p_txn_rec.attribute1,
872 p_attribute2 => p_txn_rec.attribute2,
873 p_attribute3 => p_txn_rec.attribute3,
874 p_attribute4 => p_txn_rec.attribute4,
875 p_attribute5 => p_txn_rec.attribute5,
876 p_attribute6 => p_txn_rec.attribute6,
877 p_attribute7 => p_txn_rec.attribute7,
878 p_attribute8 => p_txn_rec.attribute8,
879 p_attribute9 => p_txn_rec.attribute9,
880 p_attribute10 => p_txn_rec.attribute10,
881 p_attribute11 => p_txn_rec.attribute11,
882 p_attribute12 => p_txn_rec.attribute12,
883 p_attribute13 => p_txn_rec.attribute13,
884 p_attribute14 => p_txn_rec.attribute14,
885 p_attribute15 => p_txn_rec.attribute15,
886 p_created_by => fnd_global.user_id,
887 p_creation_date => SYSDATE,
888 p_last_updated_by => fnd_global.user_id,
889 p_last_update_date => SYSDATE,
890 p_last_update_login => fnd_global.conc_login_id,
891 p_object_version_number => p_txn_rec.object_version_number,
892 p_split_reason_code => p_txn_rec.split_reason_code,
893 p_gl_interface_status_code => p_txn_rec.gl_interface_status_code
894 );
895 --
896 IF FND_API.to_Boolean(nvl(p_commit,FND_API.G_FALSE)) THEN
897 COMMIT WORK;
898 END IF;
899 --
900 -- Standard call to get message count and IF count is get message info.
901 FND_MSG_PUB.Count_And_Get
902 ( p_count => x_msg_count,
903 p_data => x_msg_data
904 );
905 EXCEPTION
906 WHEN FND_API.G_EXC_ERROR THEN
907 x_return_status := FND_API.G_RET_STS_ERROR ;
908 ROLLBACK TO create_reading_transaction;
909 FND_MSG_PUB.Count_And_Get
910 ( p_count => x_msg_count,
911 p_data => x_msg_data
912 );
913 WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
914 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
915 ROLLBACK TO create_reading_transaction;
916 FND_MSG_PUB.Count_And_Get
917 ( p_count => x_msg_count,
918 p_data => x_msg_data
919 );
920 WHEN OTHERS THEN
921 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
922 ROLLBACK TO create_reading_transaction;
923 IF FND_MSG_PUB.Check_Msg_Level (FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
924 FND_MSG_PUB.Add_Exc_Msg
925 ( G_PKG_NAME,
926 l_api_name
927 );
928 END IF;
929 FND_MSG_PUB.Count_And_Get
930 ( p_count => x_msg_count,
931 p_data => x_msg_data
932 );
933 END Create_Reading_Transaction;
934 --
935 /*----------------------------------------------------*/
936 /* procedure name: Capture_Counter_Reading */
937 /* description : procedure used to */
938 /* capture counter readings */
939 /*----------------------------------------------------*/
940
941 PROCEDURE Capture_Counter_Reading
942 (
943 p_api_version IN NUMBER
944 ,p_commit IN VARCHAR2
945 ,p_init_msg_list IN VARCHAR2
946 ,p_validation_level IN NUMBER
947 ,p_txn_rec IN OUT NOCOPY csi_datastructures_pub.transaction_rec
948 ,p_ctr_rdg_rec IN OUT NOCOPY csi_ctr_datastructures_pub.counter_readings_rec
949 ,x_return_status OUT NOCOPY VARCHAR2
950 ,x_msg_count OUT NOCOPY NUMBER
951 ,x_msg_data OUT NOCOPY VARCHAR2
952 )
953 IS
954 l_api_name CONSTANT VARCHAR2(30) := 'CAPTURE_COUNTER_READING_PVT';
955 l_api_version CONSTANT NUMBER := 1.0;
956 l_msg_data VARCHAR2(2000);
957 l_msg_index NUMBER;
958 l_msg_count NUMBER;
959 l_prev_ctr_reading NUMBER;
960 l_prev_net_reading NUMBER;
961 l_prev_ltd_reading NUMBER;
962 l_prev_value_timestamp DATE;
963 l_next_ctr_reading NUMBER;
964 l_next_value_timestamp DATE;
965 l_next_reset_mode VARCHAR2(30);
966 l_ctr_name VARCHAR2(50);
967 l_ctr_type VARCHAR2(30);
968 l_rollover_last_rdg NUMBER;
969 l_rollover_first_rdg NUMBER;
970 l_direction VARCHAR2(1);
971 l_reading_type NUMBER;
972 l_auto_rollover VARCHAR2(1);
973 l_net_reading NUMBER;
974 l_ltd_reading NUMBER;
975 l_previous_rdg NUMBER;
976 l_previous_net NUMBER;
977 l_previous_ltd NUMBER;
978 l_process_flag BOOLEAN := TRUE;
979 l_reset_value_id NUMBER;
980 l_seq_num NUMBER;
981 l_rdg_lock_date DATE;
982 l_curr_adj NUMBER;
983 l_target_ctr_rec csi_ctr_datastructures_pub.counter_readings_rec;
984 l_reset_rdg_rec csi_ctr_datastructures_pub.counter_readings_rec;
985 l_recalc_fl_rdg_rec csi_ctr_datastructures_pub.counter_readings_rec;
986 l_temp_ctr_rdg_rec csi_ctr_datastructures_pub.counter_readings_rec;
987 l_disabled_ctr_rec csi_ctr_datastructures_pub.counter_readings_rec;
988 l_reset_timestamp DATE;
989 l_exists VARCHAR2(1);
990 l_target_ctr_exist VARCHAR2(1);
991 l_update_loop BOOLEAN := FALSE;
992 l_derive_ctr_rec csi_ctr_datastructures_pub.counter_readings_rec;
993 l_mode VARCHAR2(30);
994 l_prev_comments VARCHAR2(240);
995 l_next_comments VARCHAR2(240);
996 l_rec_count NUMBER;
997 l_counter_value_id NUMBER;
998 l_obj_version_num NUMBER;
999 Skip_Process EXCEPTION;
1000 --
1001
1002
1003 CURSOR PREV_READING_CUR(p_counter_id IN NUMBER,p_value_timestamp IN DATE) IS
1004 select counter_reading,net_reading,life_to_date_reading,
1005 value_timestamp, comments
1006 from CSI_COUNTER_READINGS
1007 where counter_id = p_counter_id
1008 and nvl(disabled_flag,'N') = 'N'
1009 and value_timestamp < p_value_timestamp
1010 ORDER BY value_timestamp desc,counter_value_id desc;
1011 --
1012 CURSOR NEXT_READING_CUR(p_counter_id IN NUMBER,p_value_timestamp IN DATE) IS
1013 select counter_reading,value_timestamp,reset_mode, comments
1014 from CSI_COUNTER_READINGS
1015 where counter_id = p_counter_id
1016 and nvl(disabled_flag,'N') = 'N'
1017 and value_timestamp > p_value_timestamp
1018 ORDER BY value_timestamp asc,counter_value_id asc;
1019 --
1020 CURSOR LATER_READINGS_CUR(p_counter_id IN NUMBER,p_value_timestamp IN DATE) IS
1021 select counter_value_id,counter_reading,net_reading,value_timestamp,adjustment_reading
1022 ,reset_mode,adjustment_type,include_target_resets, comments
1023 from CSI_COUNTER_READINGS
1024 where counter_id = p_counter_id
1025 and nvl(disabled_flag,'N') = 'N'
1026 and value_timestamp > p_value_timestamp
1027 ORDER BY value_timestamp asc, counter_value_id asc;
1028 --
1029 BEGIN
1030 -- Standard Start of API savepoint
1031 SAVEPOINT capture_counter_reading_pvt;
1032 -- Standard call to check for call compatibility.
1033
1034 IF NOT FND_API.Compatible_API_Call (l_api_version,
1035 p_api_version,
1036 l_api_name ,
1037 G_PKG_NAME ) THEN
1038 RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
1039 END IF;
1040 -- Initialize message list if p_init_msg_list is set to TRUE.
1041 IF FND_API.to_Boolean(nvl(p_init_msg_list,FND_API.G_FALSE)) THEN
1042 FND_MSG_PUB.initialize;
1043 END IF;
1044 -- Initialize API return status to success
1045 x_return_status := FND_API.G_RET_STS_SUCCESS;
1046 --
1047
1048 -- Read the debug profiles values in to global variable 7197402
1049 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
1050
1051 csi_ctr_gen_utility_pvt.put_line( '....capture_counter_reading_pvt' ||'-'||
1052 p_api_version ||'-'||
1053 nvl(p_commit,FND_API.G_FALSE) ||'-'||
1054 nvl(p_init_msg_list,FND_API.G_FALSE) ||'-'||
1055 nvl(p_validation_level,FND_API.G_VALID_LEVEL_FULL) );
1056 -- *
1057 csi_ctr_gen_utility_pvt.put_line('Passed Transaction ID is '||to_char(p_txn_rec.transaction_id));
1058 --
1059 IF p_txn_rec.transaction_type_id in (91,92,94,95) THEN
1060 l_mode := 'Meter';
1061 ELSE
1062 l_mode := 'Counter';
1063 END IF;
1064 --
1065 IF p_ctr_rdg_rec.counter_id IS NULL OR
1066 p_ctr_rdg_rec.counter_id = FND_API.G_MISS_NUM THEN
1067 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1068 ( p_msg_name => 'CSI_API_CTR_INVALID',
1069 p_token1_name => 'MODE',
1070 p_token1_val => l_mode
1071 );
1072 ELSE
1073 -- Get the counter definition
1074 Begin
1075 select name,counter_type,rollover_last_reading,
1076 rollover_first_reading,direction,reading_type,
1077 automatic_rollover
1078 into l_ctr_name,l_ctr_type,l_rollover_last_rdg,l_rollover_first_rdg,
1079 l_direction,l_reading_type,l_auto_rollover
1080 from CSI_COUNTERS_VL -- Need to be changed
1081 where counter_id = p_ctr_rdg_rec.counter_id
1082 and nvl(end_date_active,(sysdate+1)) > sysdate;
1083 Exception
1084 when no_data_found then
1085 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1086 ( p_msg_name => 'CSI_API_CTR_INVALID',
1087 p_token1_name => 'MODE',
1088 p_token1_val => l_mode
1089 );
1090 End;
1091 END IF;
1092 -- Atleast one reading should be captured.
1093 IF NVL(p_ctr_rdg_rec.counter_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM AND
1094 NVL(p_ctr_rdg_rec.adjustment_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM AND
1095 NVL(p_ctr_rdg_rec.reset_counter_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM THEN
1096 csi_ctr_gen_utility_pvt.put_line('At least one reading should be entered...');
1097 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1098 ( p_msg_name => 'CSI_API_CTR_RDG_MISSING',
1099 p_token1_name => 'MODE',
1100 p_token1_val => l_mode
1101 );
1102 END IF;
1103 --
1104 IF nvl(l_direction,'X') NOT IN ('A','D','B') THEN
1105 csi_ctr_gen_utility_pvt.put_line('Counter has invalid Direction...');
1106 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1107 ( p_msg_name => 'CSI_API_CTR_INVALID_DIR',
1108 p_token1_name => 'MODE',
1109 p_token1_val => l_mode
1110 );
1111 END IF;
1112 --
1113 IF nvl(p_ctr_rdg_rec.disabled_flag,'N') = 'Y' THEN
1114 csi_ctr_gen_utility_pvt.put_line('Cannot disable the value during Insert...');
1115 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1116 ( p_msg_name => 'CSI_API_CTR_NO_RDG_DISABLE',
1117 p_token1_name => 'MODE',
1118 p_token1_val => l_mode
1119 );
1120 END IF;
1121 --
1122 -- Cannot Capture Reading for Target Counters as they are driven by source counters
1123 IF Is_Target_Counter(p_ctr_rdg_rec.counter_id) THEN
1124 IF p_txn_rec.transaction_type_id in (91,92,94,95) THEN
1125 l_rec_count := 0;
1126 select count(*)
1127 into l_rec_count
1128 from CSI_COUNTER_READINGS
1129 where counter_id = p_ctr_rdg_rec.counter_id
1130 and ROWNUM = 1;
1131 --
1132 IF l_rec_count > 0 THEN
1133 csi_ctr_gen_utility_pvt.put_line('Only First Reading can be captured for a Target Counter manually');
1134 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1135 ( p_msg_name => 'CSI_API_NO_RDG_TARGET_CTR',
1136 p_token1_name => 'MODE',
1137 p_token1_val => l_mode
1138 );
1139 END IF;
1140 ELSE
1141 csi_ctr_gen_utility_pvt.put_line('Cannot Capture Reading for a Target Counter...');
1142 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1143 ( p_msg_name => 'CSI_API_NO_RDG_TARGET_CTR',
1144 p_token1_name => 'MODE',
1145 p_token1_val => l_mode
1146 );
1147 END IF;
1148 END IF;
1149 --
1150 -- Cannot Capture Reading for Formula Counters
1151 IF Is_Formula_Counter(p_ctr_rdg_rec.counter_id) THEN
1152 csi_ctr_gen_utility_pvt.put_line('Cannot Capture Reading for a Formula Counter...');
1153 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1154 ( p_msg_name => 'CSI_API_NO_RDG_FORMULA_CTR',
1155 p_token1_name => 'MODE',
1156 p_token1_val => l_mode
1157 );
1158 END IF;
1159 --
1160 IF p_ctr_rdg_rec.value_timestamp IS NULL OR
1161 p_ctr_rdg_rec.value_timestamp = FND_API.G_MISS_DATE THEN
1162 p_ctr_rdg_rec.value_timestamp := sysdate;
1163 -- csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_INVALID_RDG_DATE');
1164 END IF;
1165 --
1166
1167 Begin
1168 select counter_value_id, object_version_number
1169 into l_counter_value_id, l_obj_version_num
1170 from CSI_COUNTER_READINGS
1171 where counter_id = p_ctr_rdg_rec.counter_id
1172 and value_timestamp = p_ctr_rdg_rec.value_timestamp;
1173
1174 /* Readings return status fixes */
1175 IF p_txn_rec.transaction_type_id in (91,92,94,95) THEN
1176 BEGIN
1177 select 'x'
1178 into l_exists
1179 from dual
1180 where exists (select 'x'
1181 from CSI_COUNTER_READINGS
1182 where counter_id = p_ctr_rdg_rec.counter_id
1183 and value_timestamp = p_ctr_rdg_rec.value_timestamp
1184 and counter_reading = p_ctr_rdg_rec.counter_reading);
1185 raise skip_process;
1186 EXCEPTION
1187 WHEN NO_DATA_FOUND THEN
1188 IF p_txn_rec.transaction_type_id = 92 THEN
1189 /* ECO 5344596, Disable previous reading and capture new
1190 WO Recompletion Reading */
1191 l_disabled_ctr_rec.counter_value_id := l_counter_value_id;
1192 l_disabled_ctr_rec.disabled_flag := 'Y';
1193 l_disabled_ctr_rec.object_version_number := l_obj_version_num;
1194
1195 update_counter_reading
1196 (p_api_version => 1.0
1197 ,p_commit => p_commit
1198 ,p_init_msg_list => p_init_msg_list
1199 ,p_validation_level => p_validation_level
1200 ,p_ctr_rdg_rec => l_disabled_ctr_rec
1201 ,x_return_status => x_return_status
1202 ,x_msg_count => x_msg_count
1203 ,x_msg_data => x_msg_data
1204 );
1205 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
1206 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Update_Counter_Reading when disabling WO ');
1207 l_msg_index := 1;
1208 l_msg_count := x_msg_count;
1209 WHILE l_msg_count > 0 LOOP
1210 x_msg_data := FND_MSG_PUB.GET
1211 (l_msg_index,
1212 FND_API.G_FALSE
1213 );
1214 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
1215 l_msg_index := l_msg_index + 1;
1216 l_msg_count := l_msg_count - 1;
1217 END LOOP;
1218 RAISE FND_API.G_EXC_ERROR;
1219 END IF;
1220 ELSE
1221 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1222 (p_msg_name => 'CSI_API_CTR_RDG_DATE_EXISTS',
1223 p_token1_name => 'VALUE_TIMESTAMP',
1224 p_token1_val => to_char(p_ctr_rdg_rec.value_timestamp,nvl(fnd_profile.value('ICX_DATE_FORMAT_MASK'),'DD-MON-YYYY HH24:MI:SS')),
1225 p_token2_name => 'MODE',
1226 p_token2_val => l_mode
1227 );
1228 END IF;
1229 END;
1230 ELSE
1231 /* end of return status fixes */
1232 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1233 (p_msg_name => 'CSI_API_CTR_RDG_DATE_EXISTS',
1234 p_token1_name => 'VALUE_TIMESTAMP',
1235 p_token1_val => to_char(p_ctr_rdg_rec.value_timestamp,nvl(fnd_profile.value('ICX_DATE_FORMAT_MASK'),'DD-MON-YYYY HH24:MI:SS')),
1236 p_token2_name => 'MODE',
1237 p_token2_val => l_mode
1238 );
1239 END IF;
1240 Exception
1241 when no_data_found then
1242 null;
1243 End;
1244 --
1245 IF p_ctr_rdg_rec.value_timestamp > sysdate THEN
1246 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1247 ( p_msg_name => 'CSI_API_CTR_FUTURE_RDG_DATE',
1248 p_token1_name => 'VALUE_TIMESTAMP',
1249 p_token1_val => to_char(p_ctr_rdg_rec.value_timestamp,nvl(fnd_profile.value('ICX_DATE_FORMAT_MASK'),'DD-MON-YYYY HH24:MI:SS')),
1250 p_token2_name => 'MODE',
1251 p_token2_val => l_mode
1252 );
1253 END IF;
1254 -- *
1255 csi_ctr_gen_utility_pvt.put_line('Adjustment type is..' || p_ctr_rdg_rec.adjustment_type);
1256
1257 IF NVL(p_ctr_rdg_rec.adjustment_type,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR THEN
1258 -- Validate Adjustment Type against lookups
1259 IF NOT Valid_Adjustment_Type(p_ctr_rdg_rec.adjustment_type) THEN
1260 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1261 ( p_msg_name => 'CSI_API_CTR_INV_ADJ_TYPE',
1262 p_token1_name => 'ADJ_TYPE',
1263 p_token1_val => p_ctr_rdg_rec.adjustment_type
1264 );
1265 END IF;
1266 END IF;
1267 --
1268 IF NVL(p_ctr_rdg_rec.reset_mode,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR THEN
1269 -- Validate Reset Mode against lookups
1270 -- IF NOT Valid_Reset_Mode(p_ctr_rdg_rec.reset_mode) THEN
1271 -- Since we allow only SOFT reset at this point, no need to check against Lookups
1272 IF p_ctr_rdg_rec.reset_mode <> 'SOFT' THEN
1273 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1274 ( p_msg_name => 'CSI_API_CTR_INV_RESET_MODE',
1275 p_token1_name => 'RESET_MODE',
1276 p_token1_val => p_ctr_rdg_rec.reset_mode
1277 );
1278 END IF;
1279 --
1280 IF NVL(p_ctr_rdg_rec.reset_counter_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM THEN
1281 csi_ctr_gen_utility_pvt.put_line('Reset counter reading is mandatory for SOFT reset..');
1282 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1283 ( p_msg_name => 'CSI_API_CTR_SOFT_RDG_MISS',
1284 p_token1_name => 'MODE',
1285 p_token1_val => l_mode
1286 );
1287 END IF;
1288 --
1289
1290
1291 IF NVL(p_ctr_rdg_rec.reset_reason,FND_API.G_MISS_CHAR) = FND_API.G_MISS_CHAR THEN
1292 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1293 ( p_msg_name => 'CSI_API_CTR_RESET_REASON_MISS',
1294 p_token1_name => 'MODE',
1295 p_token1_val => l_mode
1296 );
1297 END IF;
1298 END IF; -- Reset Mode check
1299 --
1300 -- Adjustment reading is Mandatory for Adjustments
1301 IF NVL(p_ctr_rdg_rec.adjustment_type,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR AND
1302 NVL(p_ctr_rdg_rec.adjustment_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM THEN
1303 csi_ctr_gen_utility_pvt.put_line('Adjustment Reading cannot be Null or Zero for Adjustments...');
1304 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1305 ( p_msg_name => 'CSI_API_CTR_ADJ_RDG_MISS',
1306 p_token1_name => 'MODE',
1307 p_token1_val => l_mode
1308 );
1309 END IF;
1310 --
1311 -- Reverse Validation
1312 IF NVL(p_ctr_rdg_rec.adjustment_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM AND
1313 NVL(p_ctr_rdg_rec.adjustment_type,FND_API.G_MISS_CHAR) = FND_API.G_MISS_CHAR THEN
1314 csi_ctr_gen_utility_pvt.put_line('Adjustment Type is Mandatory for Adjustments...');
1315 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1316 ( p_msg_name => 'CSI_API_CTR_ADJ_TYPE_MISS',
1317 p_token1_name => 'MODE',
1318 p_token1_val => l_mode
1319 );
1320 END IF;
1321 --
1322 IF NVL(p_ctr_rdg_rec.adjustment_reading,FND_API.G_MISS_NUM) <= 0 THEN
1323 csi_ctr_gen_utility_pvt.put_line('Adjustment Reading cannot be Zero or Negative...');
1324 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1325 ( p_msg_name => 'CSI_API_CTR_POSITIVE_ADJ_RDG',
1326 p_token1_name => 'MODE',
1327 p_token1_val => l_mode
1328 );
1329 END IF;
1330 -- Reverse Validations
1331 IF NVL(p_ctr_rdg_rec.reset_counter_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM THEN
1332 IF NVL(p_ctr_rdg_rec.reset_mode,FND_API.G_MISS_CHAR) = FND_API.G_MISS_CHAR THEN
1333 csi_ctr_gen_utility_pvt.put_line('Reset Mode is Mandatory for Resets...');
1334 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1335 ( p_msg_name => 'CSI_API_CTR_RESET_MODE_MISS',
1336 p_token1_name => 'MODE',
1337 p_token1_val => l_mode
1338 );
1339 END IF;
1340 -- Reset Reason is Mandatory
1341 IF NVL(p_ctr_rdg_rec.reset_reason,FND_API.G_MISS_CHAR) = FND_API.G_MISS_CHAR THEN
1342 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1343 ( p_msg_name => 'CSI_API_CTR_RESET_REASON_MISS',
1344 p_token1_name => 'MODE',
1345 p_token1_val => l_mode
1346 );
1347 END IF;
1348 END IF;
1349 -- *
1350 csi_ctr_gen_utility_pvt.put_line('Reset Mode is Mandatory for Resets...'|| p_ctr_rdg_rec.reset_counter_reading );
1351 IF NVL(p_ctr_rdg_rec.reset_reason,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR THEN
1352 IF NVL(p_ctr_rdg_rec.reset_counter_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM THEN
1353 csi_ctr_gen_utility_pvt.put_line('Reset Reading is Mandatory for Resets...');
1354 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1355 ( p_msg_name => 'CSI_API_CTR_RESET_RDG_MISS',
1356 p_token1_name => 'MODE',
1357 p_token1_val => l_mode
1358 );
1359 END IF;
1360 --
1361 IF NVL(p_ctr_rdg_rec.reset_mode,FND_API.G_MISS_CHAR) = FND_API.G_MISS_CHAR THEN
1362 csi_ctr_gen_utility_pvt.put_line('Reset Mode is Mandatory for Resets...');
1363 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1364 ( p_msg_name => 'CSI_API_CTR_RESET_MODE_MISS',
1365 p_token1_name => 'MODE',
1366 p_token1_val => l_mode
1367 );
1368 END IF;
1369 END IF;
1370 --
1371 -- Atleast one reading should be captured.
1372 IF NVL(p_ctr_rdg_rec.counter_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM AND
1373 NVL(p_ctr_rdg_rec.adjustment_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM AND
1374 NVL(p_ctr_rdg_rec.reset_counter_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM THEN
1375 csi_ctr_gen_utility_pvt.put_line('At least one reading should be entered...');
1376 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1377 ( p_msg_name => 'CSI_API_CTR_RDG_MISSING',
1378 p_token1_name => 'MODE',
1379 p_token1_val => l_mode
1380 );
1381 END IF;
1382 --
1383 -- If the Source counter or its object counters have a reading lock date then
1384 -- the reading date cannot be earlier than the lock date (Max of all)
1385 l_rdg_lock_date := NULL;
1386
1387 Begin
1388 select max(reading_lock_date)
1389 into l_rdg_lock_date
1390 from CSI_COUNTER_READING_LOCKS
1391 where counter_id = p_ctr_rdg_rec.counter_id
1392 OR counter_id in (select object_counter_id
1393 from CSI_COUNTER_RELATIONSHIPS
1394 where source_counter_id = p_ctr_rdg_rec.counter_id
1395 and nvl(active_end_date,(p_ctr_rdg_rec.value_timestamp+1)) > p_ctr_rdg_rec.value_timestamp);
1396 End;
1397 --
1398 IF l_rdg_lock_date IS NOT NULL THEN
1399 IF p_ctr_rdg_rec.value_timestamp <= l_rdg_lock_date THEN
1400 csi_ctr_gen_utility_pvt.put_line('Reading Date cannot be earlier than the Reading Lock Date...');
1401 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1402 ( p_msg_name => 'CSI_API_CTR_RDG_DATE_LOCKED',
1403 p_token1_name => 'LOCKED_DATE',
1404 p_token1_val => to_char(l_rdg_lock_date,nvl(fnd_profile.value('ICX_DATE_FORMAT_MASK'),'DD-MON-YYYY HH24:MI:SS')), --fix for bug 5435071
1405 p_token2_name => 'MODE',
1406 p_token2_val => l_mode
1407 );
1408 END IF;
1409 END IF;
1410 -- *
1411 csi_ctr_gen_utility_pvt.put_line('Getting PREV Counter reading' || p_ctr_rdg_rec.value_timestamp );
1412 -- Get the last reading for this counter
1413 OPEN PREV_READING_CUR(p_ctr_rdg_rec.counter_id,p_ctr_rdg_rec.value_timestamp);
1414 FETCH PREV_READING_CUR
1415 INTO l_prev_ctr_reading,
1416 l_prev_net_reading,
1417 l_prev_ltd_reading,
1418 l_prev_value_timestamp,
1419 l_prev_comments;
1420 CLOSE PREV_READING_CUR;
1421
1422 -- *
1423 csi_ctr_gen_utility_pvt.put_line('PREV Counter reading' || l_prev_ctr_reading );
1424
1425
1426 --
1427 -- Check whether this is the first reading
1428 IF l_prev_ctr_reading IS NULL THEN -- First Reading
1429 IF NVL(p_ctr_rdg_rec.adjustment_type,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR OR
1430 NVL(p_ctr_rdg_rec.reset_mode,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR OR
1431 NVL(p_ctr_rdg_rec.automatic_rollover_flag,'N') = 'Y' THEN
1432 csi_ctr_gen_utility_pvt.put_line('First Reading cannot be Adjustment or Reset or Automatic Rollover');
1433 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1434 ( p_msg_name => 'CSI_API_CTR_INVALID_FIRST_RDG',
1435 p_token1_name => 'MODE',
1436 p_token1_val => l_mode
1437 );
1438 END IF;
1439 ELSE
1440 IF NVL(p_ctr_rdg_rec.adjustment_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM THEN
1441 IF p_ctr_rdg_rec.adjustment_reading > l_prev_net_reading THEN
1442 csi_ctr_gen_utility_pvt.put_line('Adjustment Reading cannot be greater than Previous Net Reading');
1443 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1444 ( p_msg_name => 'CSI_API_CTR_INVALID_ADJ_RDG',
1445 p_token1_name => 'PREV_NET',
1446 p_token1_val => to_char(l_prev_net_reading)
1447 );
1448 END IF;
1449 END IF;
1450 END IF;
1451
1452 -- *
1453 csi_ctr_gen_utility_pvt.put_line('Getting LAST Counter reading' || to_char(p_ctr_rdg_rec.value_timestamp,'DD-MON-YYYY HH24:MI:SS'));
1454
1455 csi_ctr_gen_utility_pvt.put_line('next value timestamp before fetch' || l_next_value_timestamp);
1456
1457 -- Get the next reading for this counter
1458 OPEN NEXT_READING_CUR(p_ctr_rdg_rec.counter_id,p_ctr_rdg_rec.value_timestamp);
1459 FETCH NEXT_READING_CUR
1460 INTO l_next_ctr_reading,
1461 l_next_value_timestamp,
1462 l_next_reset_mode,
1463 l_next_comments;
1464 CLOSE NEXT_READING_CUR;
1465
1466 -- *
1467 csi_ctr_gen_utility_pvt.put_line('LAST Counter reading' || l_next_ctr_reading );
1468 csi_ctr_gen_utility_pvt.put_line('LAST Counter reading' || to_char(l_next_value_timestamp,'DD-MON-YYYY HH24:MI:SS') );
1469 csi_ctr_gen_utility_pvt.put_line('Reading Type is' || l_reading_type );
1470 --
1471 --
1472 IF NVL(p_ctr_rdg_rec.automatic_rollover_flag,'N') = 'Y' THEN
1473 IF NVL(l_auto_rollover,'N') <> 'Y' OR
1474 l_rollover_last_rdg IS NULL OR
1475 l_rollover_first_rdg IS NULL THEN
1476 csi_ctr_gen_utility_pvt.put_line('Counter does not have automatic rollover attributes set...');
1477 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1478 ( p_msg_name => 'CSI_API_CTR_ROLLOVER_ATTR_MISS',
1479 p_token1_name => 'MODE',
1480 p_token1_val => l_mode
1481 );
1482 END IF;
1483 END IF;
1484 -- For Change Counters Reset and Automatic rollover are not allowed
1485
1486 IF l_reading_type = 2 THEN
1487 /* IF NVL(p_ctr_rdg_rec.reset_mode,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR THEN
1488 csi_ctr_gen_utility_pvt.put_line('Soft Reset is not allowed for Change Counters..');
1489 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1490 ( p_msg_name => 'CSI_API_NO_RESET_CHG_CTR',
1491 p_token1_name => 'MODE',
1492 p_token1_val => l_mode
1493 );
1494 END IF;
1495 */
1496 --
1497 IF NVL(p_ctr_rdg_rec.automatic_rollover_flag,'N') = 'Y' THEN
1498 csi_ctr_gen_utility_pvt.put_line('Automatic Rollover is not allowed for Change Counters..');
1499 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1500 ( p_msg_name => 'CSI_API_NO_AUTO_CHG_CTR',
1501 p_token1_name => 'MODE',
1502 p_token1_val => l_mode
1503 );
1504 END IF;
1505 --
1506 /* IF NVL(p_ctr_rdg_rec.counter_reading,FND_API.G_MISS_NUM) < 0 THEN
1507 csi_ctr_gen_utility_pvt.put_line('Counter Reading cannot be negative for Change Counters...');
1508 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1509 ( p_msg_name => 'CSI_API_CTR_NEG_RDG',
1510 p_token1_name => 'MODE',
1511 p_token1_val => l_mode
1512 );
1513 END IF
1514 */
1515 END IF;
1516 -- For Bi-Directionsl Counters Adjustments, Reset and Automatic rollover are not allowed
1517 IF l_direction = 'B' THEN
1518 --Commented by Anju for cMRO bug
1519 /* IF NVL(p_ctr_rdg_rec.reset_mode,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR THEN
1520 csi_ctr_gen_utility_pvt.put_line('Reset is not allowed for Bi-directional Counters..');
1521 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1522 ( p_msg_name => 'CSI_API_NO_RESET_BID_CTR',
1523 p_token1_name => 'MODE',
1524 p_token1_val => l_mode
1525 );
1526 END IF;*/
1527
1528 --
1529
1530 csi_ctr_gen_utility_pvt.put_line( 'p_ctr_rdg_rec.reset_mode ' || p_ctr_rdg_rec.reset_mode);
1531 IF NVL(p_ctr_rdg_rec.automatic_rollover_flag,'N') = 'Y' THEN
1532 csi_ctr_gen_utility_pvt.put_line('Automatic Rollover is not allowed for Bi-directional Counters..');
1533 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1534 ( p_msg_name => 'CSI_API_NO_AUTO_BID_CTR',
1535 p_token1_name => 'MODE',
1536 p_token1_val => l_mode
1537 );
1538 END IF;
1539 --
1540
1541 /* IF NVL(p_ctr_rdg_rec.adjustment_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM
1542 THEN
1543 csi_ctr_gen_utility_pvt.put_line('Adjustment Reading is' || p_ctr_rdg_rec.adjustment_reading);
1544 csi_ctr_gen_utility_pvt.put_line('Adjustment is not allowed for Bi-directional Counters..');
1545 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1546 ( p_msg_name => 'CSI_API_NO_ADJ_BID_CTR',
1547 p_token1_name => 'MODE',
1548 p_token1_val => l_mode
1549 );
1550 END IF;*/
1551
1552 END IF;
1553 -- Automatic Rollover cannot be combined with other reading captures.
1554 IF NVL(p_ctr_rdg_rec.automatic_rollover_flag,'N') = 'Y' THEN
1555 IF NVL(p_ctr_rdg_rec.reset_mode,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR OR
1556 NVL(p_ctr_rdg_rec.adjustment_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM THEN
1557 csi_ctr_gen_utility_pvt.put_line('Automatic Rollover cannot be combined with Reset or Adj...');
1558 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_INVALID_AUTO_RDG');
1559 END IF;
1560 END IF;
1561 -- *
1562 csi_ctr_gen_utility_pvt.put_line( '1');
1563 IF l_next_value_timestamp IS NOT NULL THEN
1564 -- *
1565 csi_ctr_gen_utility_pvt.put_line( '2');
1566 csi_ctr_gen_utility_pvt.put_line( 'l_next_value_timestamp' || l_next_value_timestamp);
1567 -- Automatic Rollover Cannot occur inbetween readings
1568 IF NVL(p_ctr_rdg_rec.automatic_rollover_flag,'N') = 'Y' THEN
1569 csi_ctr_gen_utility_pvt.put_line('Next counter reading exists. Cannot Rollover...'); ----- this point
1570
1571 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1572 ( p_msg_name => 'CSI_API_CTR_NEXT_RDG_DT_EXISTS',
1573 p_token1_name => 'NEXT_DATE',
1574 p_token1_val => to_char(l_next_value_timestamp,nvl(fnd_profile.value('ICX_DATE_FORMAT_MASK'),'DD-MON-YYYY HH24:MI:SS'))
1575 );
1576 END IF;
1577 -- Reset cannot happen in between. It has to be at the end
1578 IF NVL(p_ctr_rdg_rec.reset_mode,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR THEN
1579 csi_ctr_gen_utility_pvt.put_line('Next counter reading exists. Cannot Reset in between...');
1580
1581 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1582 ( p_msg_name => 'CSI_API_CTR_NEXT_RDG_DT_EXISTS',
1583 p_token1_name => 'NEXT_DATE',
1584 p_token1_val => to_char(l_next_value_timestamp,nvl(fnd_profile.value('ICX_DATE_FORMAT_MASK'),'DD-MON-YYYY HH24:MI:SS'))
1585 );
1586 END IF;
1587 --
1588 -- Inbetween Adjustments cannot be clubbed with other readings
1589 IF NVL(p_ctr_rdg_rec.adjustment_type,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR OR
1590 NVL(p_ctr_rdg_rec.adjustment_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM THEN
1591 IF NVL(p_ctr_rdg_rec.counter_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM THEN
1592 csi_ctr_gen_utility_pvt.put_line('Between readings adjustments cannot be clubbed with others...');
1593 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1594 ( p_msg_name => 'CSI_API_CTR_ADJ_RDG_ONLY',
1595 p_token1_name => 'NEXT_DATE',
1596 p_token1_val => to_char(l_next_value_timestamp,nvl(fnd_profile.value('ICX_DATE_FORMAT_MASK'),'DD-MON-YYYY HH24:MI:SS'))
1597 );
1598 END IF;
1599 END IF;
1600 END IF; -- Look for Next Value
1601
1602
1603 -- Reset Counter reading cannot be greater than previous counter reading
1604 IF NVL(p_ctr_rdg_rec.reset_mode,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR THEN
1605 IF NVL(p_ctr_rdg_rec.counter_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM THEN
1606 IF l_direction = 'D' THEN
1607 /* Validate that the reset reading is between the rollover if
1608 rollover attributes does exists */
1609 IF nvl(l_auto_rollover,'N') = 'Y' THEN
1610 IF p_ctr_rdg_rec.reset_counter_reading < l_rollover_last_rdg OR
1611 p_ctr_rdg_rec.reset_counter_reading > l_rollover_first_rdg THEN
1612 csi_ctr_gen_utility_pvt.put_line('Reset counter reading not in the range of valid rollover values ...D Dir ');
1613 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1614 ( p_msg_name => 'CSI_API_CTR_DSC_ROLLOVER_RDG',
1615 p_token1_name => 'MODE',
1616 p_token1_val => l_mode
1617 );
1618 END IF;
1619 END IF;
1620
1621
1622 IF p_ctr_rdg_rec.reset_counter_reading < l_prev_ctr_reading THEN
1623 csi_ctr_gen_utility_pvt.put_line('Reset counter reading has to be greater than the previous reading ...D Dir ');
1624 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1625 ( p_msg_name => 'CSI_API_CTR_MORE_RESET_RDG',
1626 p_token1_name => 'PREV_RDG',
1627 p_token1_val => to_char(l_prev_ctr_reading),
1628 p_token2_name => 'MODE',
1629 p_token2_val => l_mode
1630 );
1631 END IF;
1632 ELSIF l_direction = 'A' THEN
1633 IF nvl(l_auto_rollover,'N') = 'Y' THEN
1634 IF p_ctr_rdg_rec.reset_counter_reading > l_rollover_last_rdg OR
1635 p_ctr_rdg_rec.reset_counter_reading < l_rollover_first_rdg THEN
1636
1637 csi_ctr_gen_utility_pvt.put_line('Reset counter reading not in the range of valid rollover values ...A Dir ');
1638 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1639 ( p_msg_name => 'CSI_API_CTR_ASC_ROLLOVER_RDG',
1640 p_token1_name => 'MODE',
1641 p_token1_val => l_mode
1642 );
1643 END IF;
1644 END IF;
1645 IF p_ctr_rdg_rec.reset_counter_reading > l_prev_ctr_reading THEN
1646 csi_ctr_gen_utility_pvt.put_line('Reset counter reading has to be less than the previous reading ... A Dir');
1647 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1648 ( p_msg_name => 'CSI_API_CTR_LESS_RESET_RDG',
1649 p_token1_name => 'PREV_RDG',
1650 p_token1_val => to_char(l_prev_ctr_reading),
1651 p_token2_name => 'MODE',
1652 p_token2_val => l_mode
1653 );
1654 END IF;
1655 END IF;
1656 ELSE
1657 IF l_direction = 'D' THEN
1658 IF p_ctr_rdg_rec.reset_counter_reading < l_prev_ctr_reading THEN
1659 csi_ctr_gen_utility_pvt.put_line('Reset counter reading has to be greater than the previous reading ...D Dir ');
1660 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1661 ( p_msg_name => 'CSI_API_CTR_MORE_RESET_RDG',
1662 p_token1_name => 'PREV_RDG',
1663 p_token1_val => to_char(l_prev_ctr_reading),
1664 p_token2_name => 'MODE',
1665 p_token2_val => l_mode
1666 );
1667 END IF;
1668 /* As in 11.5.10, ensure that Reset of Bidirection counter, reading is less than current reading */
1669 ELSIF l_direction = 'A' THEN
1670 IF p_ctr_rdg_rec.reset_counter_reading > l_prev_ctr_reading THEN
1671 csi_ctr_gen_utility_pvt.put_line('Reset counter reading has to be less than the previous reading ... A Dir');
1672 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1673 ( p_msg_name => 'CSI_API_CTR_LESS_RESET_RDG',
1674 p_token1_name => 'PREV_RDG',
1675 p_token1_val => to_char(l_prev_ctr_reading),
1676 p_token2_name => 'MODE',
1677 p_token2_val => l_mode
1678 );
1679 END IF;
1680 END IF;
1681 END IF;
1682 END IF;
1683 --
1684 -- For Absolute counters check the Counter reading based on the Direction
1685 -- If Reading is captured inbetween then also it should be within prev and next readings
1686 -- If rollover flag is set then current reading can be less than previous reading
1687 IF NVL(p_ctr_rdg_rec.automatic_rollover_flag,'N') <> 'Y' THEN
1688 IF l_reading_type = 1 THEN -- Absolute
1689 -- OR l_reading_type = 2 THEN -- Changed
1690 IF nvl(l_direction,'X') = 'A' THEN
1691 IF NVL(p_ctr_rdg_rec.counter_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM THEN
1692 IF ( (p_ctr_rdg_rec.counter_reading < nvl(l_prev_ctr_reading,p_ctr_rdg_rec.counter_reading)) OR
1693 ( l_next_ctr_reading IS NOT NULL AND
1694 p_ctr_rdg_rec.counter_reading > l_next_ctr_reading) ) THEN
1695 csi_ctr_gen_utility_pvt.put_line('1. Reading should be in increasing order...');
1696 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1697 ( p_msg_name => 'CSI_API_CTR_INV_RDG',
1698 p_token1_name => 'DIRECTION',
1699 -- p_token1_val => l_direction,
1700 p_token1_val => 'an Ascending',
1701 p_token2_name => 'MODE',
1702 p_token2_val => l_mode,
1703 p_token3_name => 'CTR_NAME',
1704 p_token3_val => l_ctr_name
1705 );
1706 END IF;
1707 END IF;
1708 ELSIF nvl(l_direction,'X') = 'D' THEN
1709 IF NVL(p_ctr_rdg_rec.counter_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM THEN
1710 IF ( (p_ctr_rdg_rec.counter_reading > nvl(l_prev_ctr_reading,p_ctr_rdg_rec.counter_reading)) OR
1711 ( l_next_ctr_reading IS NOT NULL AND
1712 p_ctr_rdg_rec.counter_reading < l_next_ctr_reading) ) THEN
1713 csi_ctr_gen_utility_pvt.put_line('2. Reading should be in decreasing order...');
1714 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1715 ( p_msg_name => 'CSI_API_CTR_INV_RDG',
1716 p_token1_name => 'DIRECTION',
1717 -- p_token1_val => l_direction,
1718 p_token1_val => 'a Descending',
1719 p_token2_name => 'MODE',
1720 p_token2_val => l_mode,
1721 p_token3_name => 'CTR_NAME',
1722 p_token3_val => l_ctr_name
1723 );
1724 END IF;
1725 END IF;
1726 END IF;
1727 END IF; -- Reading Type and Direction check
1728 ELSE -- Automatic Rollover
1729 IF nvl(l_direction,'X') = 'A' THEN
1730 IF p_ctr_rdg_rec.counter_reading > l_rollover_last_rdg OR
1731 p_ctr_rdg_rec.counter_reading < l_rollover_first_rdg THEN
1732 csi_ctr_gen_utility_pvt.put_line('Counter Reading has to be within Rollover From-To Rdgs..');
1733 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1734 ( p_msg_name => 'CSI_API_CTR_ASC_ROLLOVER_RDG',
1735 p_token1_name => 'MODE',
1736 p_token1_val => l_mode
1737 );
1738 END IF;
1739 ELSIF nvl(l_direction,'X') = 'D' THEN
1740 IF p_ctr_rdg_rec.counter_reading < l_rollover_last_rdg OR
1741 p_ctr_rdg_rec.counter_reading > l_rollover_first_rdg THEN
1742 csi_ctr_gen_utility_pvt.put_line('Counter Reading has to be within Rollover From-To Rdgs..');
1743 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1744 ( p_msg_name => 'CSI_API_CTR_DSC_ROLLOVER_RDG',
1745 p_token1_name => 'MODE',
1746 p_token1_val => l_mode
1747 );
1748 END IF;
1749 END IF;
1750 END IF; -- Rollover flag check
1751 --
1752 -- If counter reading is not entered then look for adjustments
1753 IF NVL(p_ctr_rdg_rec.counter_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM THEN
1754 IF NVL(p_ctr_rdg_rec.adjustment_type,FND_API.G_MISS_CHAR) <> FND_API.G_MISS_CHAR THEN
1755 IF l_reading_type = 1 THEN
1756 p_ctr_rdg_rec.counter_reading := l_prev_ctr_reading;
1757 ELSE
1758 p_ctr_rdg_rec.counter_reading := 0;
1759 END IF;
1760 END IF;
1761 END IF; -- Null counter reading
1762 --
1763 p_ctr_rdg_rec.object_version_number := 1;
1764 --
1765 -- If counter_reading gets a user entered value or thru' adjustments (Previous value)
1766 -- Insert into CSI_COUNTER_READINGS
1767
1768 csi_ctr_gen_utility_pvt.put_line( 'l_reading_type ' || l_reading_type);
1769 csi_ctr_gen_utility_pvt.put_line( 'p_ctr_rdg_rec.counter_reading ' || p_ctr_rdg_rec.counter_reading);
1770 csi_ctr_gen_utility_pvt.put_line( 'p_ctr_rdg_rec.automatic_rollover_flag ' || p_ctr_rdg_rec.automatic_rollover_flag);
1771 csi_ctr_gen_utility_pvt.put_line( 'p_ctr_rdg_rec.reset_mode ' || p_ctr_rdg_rec.reset_mode);
1772
1773 csi_ctr_gen_utility_pvt.put_line( 'p_ctr_rdg_rec.reset_reason ' || p_ctr_rdg_rec.reset_reason);
1774
1775 csi_ctr_gen_utility_pvt.put_line( 'p_ctr_rdg_rec.reset_counter_reading ' || p_ctr_rdg_rec.reset_counter_reading);
1776
1777 IF NVL(p_ctr_rdg_rec.counter_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM THEN
1778 IF NVL(p_ctr_rdg_rec.reset_counter_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM OR
1779 (NVL(p_ctr_rdg_rec.reset_counter_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM
1780 AND (p_ctr_rdg_rec.counter_reading <> p_ctr_rdg_rec.reset_counter_reading)) THEN
1781 -- check := true;
1782 --csi_ctr_gen_utility_pvt.put_line( 'check' || check);
1783 -- IF (p_ctr_rdg_rec.counter_reading <> p_ctr_rdg_rec.reset_counter_reading) THEN -- for cMRO resetTHEN
1784 IF NVL(p_ctr_rdg_rec.automatic_rollover_flag,'N') <> 'Y' THEN
1785
1786 csi_ctr_gen_utility_pvt.put_line('Calculate Net Reading 1');
1787
1788 Calculate_Net_Reading
1789 ( p_prev_net_rdg => l_prev_net_reading
1790 ,p_prev_ltd_rdg => l_prev_ltd_reading
1791 ,p_curr_rdg => p_ctr_rdg_rec.counter_reading
1792 ,p_prev_rdg => l_prev_ctr_reading
1793 ,p_curr_adj => p_ctr_rdg_rec.adjustment_reading
1794 ,p_rdg_type => l_reading_type
1795 ,p_direction => l_direction
1796 ,px_net_rdg => l_net_reading
1797 ,px_ltd_rdg => l_ltd_reading
1798 ,l_ctr_rdg_rec => p_ctr_rdg_rec -- added 6398254
1799 );
1800
1801 IF l_reading_type = 2 THEN
1802 IF nvl(l_direction,'X') = 'A' THEN
1803 IF NVL(p_ctr_rdg_rec.counter_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM THEN
1804 IF (l_ltd_reading < l_prev_ltd_reading) THEN
1805 csi_ctr_gen_utility_pvt.put_line('3. LTD Reading should be in increasing orde for a CHANGE COUNTER...');
1806 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1807 ( p_msg_name => 'CSI_API_CTR_INV_RDG',
1808 p_token1_name => 'DIRECTION',
1809 -- p_token1_val => l_direction,
1810 p_token1_val => 'an Ascending',
1811 p_token2_name => 'MODE',
1812 p_token2_val => l_mode,
1813 p_token3_name => 'CTR_NAME',
1814 p_token3_val => l_ctr_name
1815 );
1816 END IF;
1817 END IF;
1818 ELSIF nvl(l_direction,'X') = 'D' THEN
1819 IF NVL(p_ctr_rdg_rec.counter_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM THEN
1820 IF (l_ltd_reading > l_prev_ltd_reading) THEN
1821 csi_ctr_gen_utility_pvt.put_line('4. LTD Reading should be in decreasing order for a CHANGE COUNTER...');
1822 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1823 ( p_msg_name => 'CSI_API_CTR_INV_RDG',
1824 p_token1_name => 'DIRECTION',
1825 -- p_token1_val => l_direction,
1826 p_token1_val => 'a Descending',
1827 p_token2_name => 'MODE',
1828 p_token2_val => l_mode,
1829 p_token3_name => 'CTR_NAME',
1830 p_token3_val => l_ctr_name
1831 );
1832 END IF;
1833 END IF;
1834 END IF;
1835 END IF;
1836 ELSE
1837 Calculate_Rollover_Reading
1838 ( p_prev_net_rdg => l_prev_net_reading
1839 ,p_prev_ltd_rdg => l_prev_ltd_reading
1840 ,p_curr_rdg => p_ctr_rdg_rec.counter_reading
1841 ,p_prev_rdg => l_prev_ctr_reading
1842 ,p_rollover_fm => l_rollover_last_rdg
1843 ,p_rollover_to => l_rollover_first_rdg
1844 ,px_net_rdg => l_net_reading
1845 ,px_ltd_rdg => l_ltd_reading
1846 );
1847 END IF; -- automatic_rollover_flag check
1848 -- Need to pass back the Net and LTD Readings
1849 p_ctr_rdg_rec.net_reading := l_net_reading;
1850 p_ctr_rdg_rec.life_to_date_reading := l_ltd_reading;
1851 --
1852 -- Call Table Handler to insert into CSI_COUNTER_READINGS
1853 -- Check and Generate Counter_value_id
1854 IF p_ctr_rdg_rec.counter_value_id IS NULL OR
1855 p_ctr_rdg_rec.counter_value_id = FND_API.G_MISS_NUM THEN
1856 WHILE l_process_flag LOOP
1857 select CSI_COUNTER_READINGS_S.nextval
1858 into p_ctr_rdg_rec.counter_value_id from dual;
1859 IF NOT Counter_Value_Exists(p_ctr_rdg_rec.counter_value_id) THEN
1860 l_process_flag := FALSE;
1861 END IF;
1862 END LOOP;
1863 ELSE
1864 IF Counter_Value_Exists(p_ctr_rdg_rec.counter_value_id) THEN
1865 csi_ctr_gen_utility_pvt.ExitWithErrMsg
1866 ( p_msg_name => 'CSI_API_CTR_VALUE_EXISTS',
1867 p_token1_name => 'CTR_NAME',
1868 p_token1_val => l_ctr_name,
1869 p_token2_name => 'CTR_VALUE_ID',
1870 p_token2_val => to_char(p_ctr_rdg_rec.counter_value_id),
1871 p_token3_name => 'MODE',
1872 p_token3_val => l_mode
1873 );
1874 END IF;
1875 END IF;
1876 --
1877
1878 --
1879 CSI_COUNTER_READINGS_PKG.Insert_Row(
1880 px_COUNTER_VALUE_ID => p_ctr_rdg_rec.counter_value_id
1881 ,p_COUNTER_ID => p_ctr_rdg_rec.counter_id
1882 ,p_VALUE_TIMESTAMP => p_ctr_rdg_rec.value_timestamp
1883 ,p_COUNTER_READING => p_ctr_rdg_rec.counter_reading
1884 ,p_RESET_MODE => p_ctr_rdg_rec.reset_mode -- NULL 6398254
1885 ,p_RESET_REASON => p_ctr_rdg_rec.reset_reason --NULL 6398254
1886 ,p_ADJUSTMENT_TYPE => p_ctr_rdg_rec.adjustment_type
1887 ,p_ADJUSTMENT_READING => p_ctr_rdg_rec.adjustment_reading
1888 ,p_OBJECT_VERSION_NUMBER => p_ctr_rdg_rec.object_version_number
1889 ,p_LAST_UPDATE_DATE => SYSDATE
1890 ,p_LAST_UPDATED_BY => fnd_global.user_id
1891 ,p_CREATION_DATE => SYSDATE
1892 ,p_CREATED_BY => fnd_global.user_id
1893 ,p_LAST_UPDATE_LOGIN => fnd_global.conc_login_id
1894 ,p_ATTRIBUTE1 => p_ctr_rdg_rec.attribute1
1895 ,p_ATTRIBUTE2 => p_ctr_rdg_rec.attribute2
1896 ,p_ATTRIBUTE3 => p_ctr_rdg_rec.attribute3
1897 ,p_ATTRIBUTE4 => p_ctr_rdg_rec.attribute4
1898 ,p_ATTRIBUTE5 => p_ctr_rdg_rec.attribute5
1899 ,p_ATTRIBUTE6 => p_ctr_rdg_rec.attribute6
1900 ,p_ATTRIBUTE7 => p_ctr_rdg_rec.attribute7
1901 ,p_ATTRIBUTE8 => p_ctr_rdg_rec.attribute8
1902 ,p_ATTRIBUTE9 => p_ctr_rdg_rec.attribute9
1903 ,p_ATTRIBUTE10 => p_ctr_rdg_rec.attribute10
1904 ,p_ATTRIBUTE11 => p_ctr_rdg_rec.attribute11
1905 ,p_ATTRIBUTE12 => p_ctr_rdg_rec.attribute12
1906 ,p_ATTRIBUTE13 => p_ctr_rdg_rec.attribute13
1907 ,p_ATTRIBUTE14 => p_ctr_rdg_rec.attribute14
1908 ,p_ATTRIBUTE15 => p_ctr_rdg_rec.attribute15
1909 ,p_ATTRIBUTE16 => p_ctr_rdg_rec.attribute16
1910 ,p_ATTRIBUTE17 => p_ctr_rdg_rec.attribute17
1911 ,p_ATTRIBUTE18 => p_ctr_rdg_rec.attribute18
1912 ,p_ATTRIBUTE19 => p_ctr_rdg_rec.attribute19
1913 ,p_ATTRIBUTE20 => p_ctr_rdg_rec.attribute20
1914 ,p_ATTRIBUTE21 => p_ctr_rdg_rec.attribute21
1915 ,p_ATTRIBUTE22 => p_ctr_rdg_rec.attribute22
1916 ,p_ATTRIBUTE23 => p_ctr_rdg_rec.attribute23
1917 ,p_ATTRIBUTE24 => p_ctr_rdg_rec.attribute24
1918 ,p_ATTRIBUTE25 => p_ctr_rdg_rec.attribute25
1919 ,p_ATTRIBUTE26 => p_ctr_rdg_rec.attribute26
1920 ,p_ATTRIBUTE27 => p_ctr_rdg_rec.attribute27
1921 ,p_ATTRIBUTE28 => p_ctr_rdg_rec.attribute28
1922 ,p_ATTRIBUTE29 => p_ctr_rdg_rec.attribute29
1923 ,p_ATTRIBUTE30 => p_ctr_rdg_rec.attribute30
1924 ,p_ATTRIBUTE_CATEGORY => p_ctr_rdg_rec.attribute_category
1925 ,p_MIGRATED_FLAG => 'N'
1926 ,p_COMMENTS => p_ctr_rdg_rec.comments
1927 ,p_LIFE_TO_DATE_READING => p_ctr_rdg_rec.life_to_date_reading
1928 ,p_TRANSACTION_ID => p_txn_rec.transaction_id
1929 ,p_AUTOMATIC_ROLLOVER_FLAG => p_ctr_rdg_rec.automatic_rollover_flag
1930 ,p_INCLUDE_TARGET_RESETS => NULL
1931 ,p_SOURCE_COUNTER_VALUE_ID => NULL
1932 ,p_NET_READING => p_ctr_rdg_rec.net_reading
1933 ,p_DISABLED_FLAG => 'N'
1934 ,p_SOURCE_CODE => p_ctr_rdg_rec.source_code
1935 ,p_SOURCE_LINE_ID => p_ctr_rdg_rec.source_line_id
1936 ,p_INITIAL_READING_FLAG => p_ctr_rdg_rec.initial_reading_flag
1937 );
1938
1939 --Add call to CSI_COUNTER_PVT.update_ctr_val_max_seq_no
1940 --for bug 7374316
1941 CSI_COUNTER_PVT.update_ctr_val_max_seq_no(
1942 p_api_version => 1.0
1943 ,p_commit => fnd_api.g_false
1944 ,p_init_msg_list => fnd_api.g_true
1945 ,p_validation_level => fnd_api.g_valid_level_full
1946 ,p_counter_id => p_ctr_rdg_rec.counter_id
1947 ,px_ctr_val_max_seq_no => p_ctr_rdg_rec.counter_value_id
1948 ,x_return_status => x_return_status
1949 ,x_msg_count => x_msg_count
1950 ,x_msg_data => x_msg_data
1951 );
1952 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
1953 csi_ctr_gen_utility_pvt.put_line('ERROR FROM CSI_COUNTER_PVT.update_ctr_val_max_seq_no');
1954 l_msg_index := 1;
1955 l_msg_count := x_msg_count;
1956 WHILE l_msg_count > 0 LOOP
1957 x_msg_data := FND_MSG_PUB.GET
1958 ( l_msg_index,
1959 FND_API.G_FALSE
1960 );
1961 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
1962 l_msg_index := l_msg_index + 1;
1963 l_msg_count := l_msg_count - 1;
1964 END LOOP;
1965 RAISE FND_API.G_EXC_ERROR;
1966 END IF;
1967 END IF;
1968 --
1969 BEGIN
1970 select 'Y'
1971 into l_target_ctr_exist
1972 from CSI_COUNTER_RELATIONSHIPS ccr,
1973 CSI_COUNTERS_B ccv,
1974 CSI_COUNTERS_TL cct
1975 where ccr.source_counter_id = p_ctr_rdg_rec.counter_id
1976 and ccr.relationship_type_code = 'CONFIGURATION'
1977 and nvl(ccr.active_start_date,sysdate) <= p_ctr_rdg_rec.value_timestamp
1978 and nvl(ccr.active_end_date,(sysdate+1)) > p_ctr_rdg_rec.value_timestamp
1979 and ccv.counter_id = ccr.object_counter_id
1980 and ccv.counter_id = cct.counter_id
1981 and cct.language = USERENV('LANG');
1982 EXCEPTION
1983 WHEN NO_DATA_FOUND THEN
1984 l_target_ctr_exist := 'N';
1985 WHEN TOO_MANY_ROWS THEN
1986 l_target_ctr_exist := 'Y';
1987 END;
1988
1989 --
1990 IF l_target_ctr_exist = 'Y' THEN
1991 -- Exclude Bi-Directional Counters as Target counters won't be defined for them.
1992 -- Need to Compute Target Counters
1993 -- For this we need to pass the usage of the current counter based on the current reading
1994 -- If Reading type is 'ABSOLUTE' then Usage is (Curr Rdg - Prev Rdg)
1995 -- If Reading type is 'CHANGE' then Usage is (Curr Rdg)
1996 --
1997 l_target_ctr_rec := l_temp_ctr_rdg_rec;
1998 --
1999 l_target_ctr_rec.counter_value_id := p_ctr_rdg_rec.counter_value_id; -- source_counter_value_id
2000 l_target_ctr_rec.counter_id := p_ctr_rdg_rec.counter_id;
2001 l_target_ctr_rec.value_timestamp := p_ctr_rdg_rec.value_timestamp;
2002 l_target_ctr_rec.adjustment_reading := p_ctr_rdg_rec.adjustment_reading;
2003 l_target_ctr_rec.adjustment_type := p_ctr_rdg_rec.adjustment_type;
2004 l_target_ctr_rec.source_code := p_ctr_rdg_rec.source_code;
2005 l_target_ctr_rec.source_line_id := p_ctr_rdg_rec.source_line_id;
2006 l_target_ctr_rec.comments := p_ctr_rdg_rec.comments;
2007 --
2008 IF NVL(p_ctr_rdg_rec.automatic_rollover_flag,'N') = 'Y' THEN
2009 -- For rollover Usage = curr - prev + roll from - roll to
2010 --
2011 -- l_target_ctr_rec.counter_reading := ABS(p_ctr_rdg_rec.counter_reading-nvl(l_prev_ctr_reading,0) + l_rollover_last_rdg - l_rollover_first_rdg);
2012 l_target_ctr_rec.counter_reading := p_ctr_rdg_rec.counter_reading-nvl(l_prev_ctr_reading,0) + l_rollover_last_rdg - l_rollover_first_rdg;
2013 ELSE
2014 IF l_reading_type = 1 THEN
2015 -- l_target_ctr_rec.counter_reading := ABS(p_ctr_rdg_rec.counter_reading - nvl(l_prev_ctr_reading,0));
2016 IF l_direction = 'D' THEN
2017 l_target_ctr_rec.counter_reading := ABS(p_ctr_rdg_rec.counter_reading - nvl(l_prev_ctr_reading,0));
2018 ELSE
2019 l_target_ctr_rec.counter_reading := p_ctr_rdg_rec.counter_reading - nvl(l_prev_ctr_reading,0);
2020 END IF;
2021 ELSIF l_reading_type = 2 THEN
2022 -- l_target_ctr_rec.counter_reading := ABS(p_ctr_rdg_rec.counter_reading);
2023 l_target_ctr_rec.counter_reading := p_ctr_rdg_rec.counter_reading;
2024 END IF;
2025 END IF; -- Rollover flag check
2026 csi_ctr_gen_utility_pvt.put_line('Target counter reading = '||to_char(l_target_ctr_rec.counter_reading));
2027
2028 --
2029 -- Call Compute_Target_Counters
2030 --
2031 csi_ctr_gen_utility_pvt.put_line('Calling Compute_Target_Counters 1...');
2032 Compute_Target_Counters
2033 (
2034 p_api_version => 1.0
2035 ,p_commit => p_commit
2036 ,p_init_msg_list => p_init_msg_list
2037 ,p_validation_level => p_validation_level
2038 ,p_txn_rec => p_txn_rec
2039 ,p_ctr_rdg_rec => l_target_ctr_rec
2040 ,p_mode => 'CREATE'
2041 ,x_return_status => x_return_status
2042 ,x_msg_count => x_msg_count
2043 ,x_msg_data => x_msg_data
2044 );
2045 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
2046 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Compute_Target_Counters API ');
2047 l_msg_index := 1;
2048 l_msg_count := x_msg_count;
2049 WHILE l_msg_count > 0 LOOP
2050 x_msg_data := FND_MSG_PUB.GET
2051 ( l_msg_index,
2052 FND_API.G_FALSE
2053 );
2054 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
2055 l_msg_index := l_msg_index + 1;
2056 l_msg_count := l_msg_count - 1;
2057 END LOOP;
2058 RAISE FND_API.G_EXC_ERROR;
2059 END IF;
2060 END IF; -- l_target_ctr_exist check
2061 --
2062 -- Since Bi-Directional counter readings cannot impact Later readings no need to proceed further.
2063 -- Also re-sets are not allowed for such counters
2064 IF l_direction = 'B' and l_reading_type = 1 THEN
2065 Raise Skip_Process;
2066 END IF;
2067 --
2068 -- Since Automatic rollover has to be the last reading, no need to proceed further
2069 --
2070 IF NVL(p_ctr_rdg_rec.automatic_rollover_flag,'N') = 'Y' THEN
2071 Raise Skip_Process;
2072 END IF;
2073 --
2074 -- Following variables will be set inside the loop
2075 l_previous_rdg := p_ctr_rdg_rec.counter_reading;
2076 l_previous_net := p_ctr_rdg_rec.net_reading;
2077 l_previous_ltd := p_ctr_rdg_rec.life_to_date_reading;
2078
2079 -- For Adjustments or next reading was a reset then
2080 -- adjust the Net Reading of Subsequent readings
2081 -- Re-calculate the formula counters only if the subsequent net reading changes
2082 -- Re-calculate Target counters irrespective of net reading changes. *
2083 IF l_reading_type = 2 OR
2084 (p_ctr_rdg_rec.adjustment_reading IS NOT NULL AND
2085 p_ctr_rdg_rec.adjustment_reading <> FND_API.G_MISS_NUM AND
2086 p_ctr_rdg_rec.adjustment_reading <> 0) OR
2087 NVL(l_next_reset_mode,'X') = 'SOFT' THEN
2088 -- *
2089 csi_ctr_gen_utility_pvt.put_line('Re-calculating target counters');
2090 l_update_loop := TRUE;
2091 FOR later_rdg IN LATER_READINGS_CUR(p_ctr_rdg_rec.counter_id,p_ctr_rdg_rec.value_timestamp)
2092
2093 LOOP
2094
2095 csi_ctr_gen_utility_pvt.put_line('Updating Later Readings for Ctr Value ID : '||to_char(later_rdg.counter_value_id));
2096
2097 IF NVL(later_rdg.reset_mode,'X') = 'SOFT' THEN
2098 csi_ctr_gen_utility_pvt.put_line('SOFT and re-calculating net readings');
2099 UPDATE CSI_COUNTER_READINGS
2100 set net_reading = later_rdg.counter_reading, -- l_previous_net,
2101 life_to_date_reading = l_previous_ltd,
2102 last_update_date = sysdate,
2103 last_updated_by = fnd_global.user_id
2104 where counter_value_id = later_rdg.counter_value_id;
2105 l_previous_net := later_rdg.counter_reading;
2106 l_previous_ltd := l_previous_ltd;
2107 ELSE
2108
2109 Calculate_Net_Reading
2110 ( p_prev_net_rdg => l_previous_net
2111 ,p_prev_ltd_rdg => l_previous_ltd
2112 ,p_curr_rdg => later_rdg.counter_reading
2113 ,p_prev_rdg => l_previous_rdg
2114 ,p_curr_adj => later_rdg.adjustment_reading
2115 ,p_rdg_type => l_reading_type
2116 ,p_direction => l_direction
2117 ,px_net_rdg => l_net_reading
2118 ,px_ltd_rdg => l_ltd_reading
2119 ,l_ctr_rdg_rec => p_ctr_rdg_rec -- added 6398254
2120 );
2121 UPDATE CSI_COUNTER_READINGS
2122 set net_reading = l_net_reading,
2123 life_to_date_reading = l_ltd_reading,
2124 last_update_date = sysdate,
2125 last_updated_by = fnd_global.user_id
2126 where counter_value_id = later_rdg.counter_value_id;
2127 --
2128 l_previous_net := l_net_reading;
2129 l_previous_ltd := l_ltd_reading;
2130 END IF;
2131 --
2132 --
2133 -- Re-calculate Compute Target Counters
2134 -- For Resets which did not include Targets before, no need to Re-compute
2135 --
2136 IF later_rdg.reset_mode IS NULL OR
2137 (later_rdg.reset_mode IS NOT NULL AND NVL(later_rdg.include_target_resets,'N') = 'Y') THEN
2138 l_target_ctr_rec := l_temp_ctr_rdg_rec;
2139 --
2140 l_target_ctr_rec.counter_value_id := later_rdg.counter_value_id; -- source_counter_value_id
2141 l_target_ctr_rec.counter_id := p_ctr_rdg_rec.counter_id;
2142 l_target_ctr_rec.value_timestamp := later_rdg.value_timestamp;
2143 l_target_ctr_rec.adjustment_reading := later_rdg.adjustment_reading;
2144 l_target_ctr_rec.adjustment_type := later_rdg.adjustment_type;
2145 l_target_ctr_rec.comments := later_rdg.comments;
2146 --
2147 IF later_rdg.reset_mode IS NOT NULL AND NVL(later_rdg.include_target_resets,'N') = 'Y' THEN
2148 -- l_target_ctr_rec.counter_reading := ABS(later_rdg.counter_reading);
2149 l_target_ctr_rec.counter_reading := later_rdg.counter_reading;
2150 ELSE
2151 IF l_reading_type = 1 THEN
2152 -- l_target_ctr_rec.counter_reading := ABS(later_rdg.counter_reading - nvl(l_previous_rdg,0));
2153 l_target_ctr_rec.counter_reading := later_rdg.counter_reading - nvl(l_previous_rdg,0);
2154 ELSIF l_reading_type = 2 THEN
2155 -- l_target_ctr_rec.counter_reading := ABS(later_rdg.counter_reading);
2156 l_target_ctr_rec.counter_reading := later_rdg.counter_reading;
2157 END IF;
2158 END IF;
2159 csi_ctr_gen_utility_pvt.put_line('Calling Compute_Target_Counters for Update ...');
2160 Compute_Target_Counters
2161 (
2162 p_api_version => 1.0
2163 ,p_commit => p_commit
2164 ,p_init_msg_list => p_init_msg_list
2165 ,p_validation_level => p_validation_level
2166 ,p_txn_rec => p_txn_rec
2167 ,p_ctr_rdg_rec => l_target_ctr_rec
2168 ,p_mode => 'UPDATE'
2169 ,x_return_status => x_return_status
2170 ,x_msg_count => x_msg_count
2171 ,x_msg_data => x_msg_data
2172 );
2173 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
2174 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Compute_Target_Counters API ');
2175 l_msg_index := 1;
2176 l_msg_count := x_msg_count;
2177 WHILE l_msg_count > 0 LOOP
2178 x_msg_data := FND_MSG_PUB.GET
2179 ( l_msg_index,
2180 FND_API.G_FALSE
2181 );
2182 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
2183 l_msg_index := l_msg_index + 1;
2184 l_msg_count := l_msg_count - 1;
2185 END LOOP;
2186 RAISE FND_API.G_EXC_ERROR;
2187 END IF;
2188 END IF; -- End of Target counter call check
2189 --
2190 l_previous_rdg := later_rdg.counter_reading;
2191 END LOOP; -- Later Readings loop
2192 END IF; -- Condition to loop thru' later readings
2193 --
2194 -- If the above loop was not executed then to re-calculate the Traget counters we loop thru'
2195 -- This is because target counter readings could change even if the net reading did not change.
2196 --
2197 l_previous_rdg := p_ctr_rdg_rec.counter_reading;
2198 --
2199 IF NOT l_update_loop THEN
2200 FOR later_rdg IN LATER_READINGS_CUR(p_ctr_rdg_rec.counter_id,p_ctr_rdg_rec.value_timestamp)
2201 LOOP
2202 csi_ctr_gen_utility_pvt.put_line('6398254: If not update_loop');
2203 -- Re-calculate Compute Target Counters
2204 -- For Resets which did not include Targets before, no need to Re-compute
2205 --
2206 IF later_rdg.reset_mode IS NULL OR
2207 (later_rdg.reset_mode IS NOT NULL AND NVL(later_rdg.include_target_resets,'N') = 'Y') THEN
2208 l_target_ctr_rec := l_temp_ctr_rdg_rec;
2209 --
2210 l_target_ctr_rec.counter_value_id := later_rdg.counter_value_id; -- source_counter_value_id
2211 l_target_ctr_rec.counter_id := p_ctr_rdg_rec.counter_id;
2212 l_target_ctr_rec.value_timestamp := later_rdg.value_timestamp;
2213 l_target_ctr_rec.adjustment_reading := later_rdg.adjustment_reading;
2214 l_target_ctr_rec.adjustment_type := later_rdg.adjustment_type;
2215 l_target_ctr_rec.comments := later_rdg.comments;
2216 --
2217 IF later_rdg.reset_mode IS NOT NULL AND NVL(later_rdg.include_target_resets,'N') = 'Y' THEN
2218 -- l_target_ctr_rec.counter_reading := ABS(later_rdg.counter_reading);
2219 l_target_ctr_rec.counter_reading := later_rdg.counter_reading;
2220 ELSE
2221 IF l_reading_type = 1 THEN
2222 -- l_target_ctr_rec.counter_reading := ABS(later_rdg.counter_reading - nvl(l_previous_rdg,0));
2223 l_target_ctr_rec.counter_reading := later_rdg.counter_reading - nvl(l_previous_rdg,0);
2224 ELSIF l_reading_type = 2 THEN
2225 -- l_target_ctr_rec.counter_reading := ABS(later_rdg.counter_reading);
2226 l_target_ctr_rec.counter_reading := later_rdg.counter_reading;
2227 END IF;
2228 END IF;
2229 csi_ctr_gen_utility_pvt.put_line('Calling Compute_Target_Counters for Update 2...');
2230 Compute_Target_Counters
2231 (
2232 p_api_version => 1.0
2233 ,p_commit => p_commit
2234 ,p_init_msg_list => p_init_msg_list
2235 ,p_validation_level => p_validation_level
2236 ,p_txn_rec => p_txn_rec
2237 ,p_ctr_rdg_rec => l_target_ctr_rec
2238 ,p_mode => 'UPDATE'
2239 ,x_return_status => x_return_status
2240 ,x_msg_count => x_msg_count
2241 ,x_msg_data => x_msg_data
2242 );
2243 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
2244 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Compute_Target_Counters API ');
2245 l_msg_index := 1;
2246 l_msg_count := x_msg_count;
2247 WHILE l_msg_count > 0 LOOP
2248 x_msg_data := FND_MSG_PUB.GET
2249 ( l_msg_index,
2250 FND_API.G_FALSE
2251 );
2252 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
2253 l_msg_index := l_msg_index + 1;
2254 l_msg_count := l_msg_count - 1;
2255 END LOOP;
2256 RAISE FND_API.G_EXC_ERROR;
2257 END IF;
2258 END IF; -- End of Target counter call check
2259 --
2260 l_previous_rdg := later_rdg.counter_reading;
2261 END LOOP;
2262 END IF; -- l_update_loop check
2263 END IF; -- Current counter reading not null check
2264 --
2265 IF NVL(p_ctr_rdg_rec.reset_mode,FND_API.G_MISS_CHAR) = 'SOFT' THEN
2266 -- Introduce a delay. Basically, value_timestamp of reset should be slightly > than the curr Reading
2267 -- For Reset Mode insert a separate record in CSI_COUNTER_READINGS with the Reset counter reading.
2268 -- Net and LTD readings are from the previous counter reading.
2269 -- If only Reset is performed then no need to introduce the delay.
2270 --
2271 l_reset_rdg_rec := l_temp_ctr_rdg_rec;
2272 --
2273
2274 IF NVL(p_ctr_rdg_rec.counter_reading,FND_API.G_MISS_NUM) <> FND_API.G_MISS_NUM
2275 AND (p_ctr_rdg_rec.counter_reading <> p_ctr_rdg_rec.reset_counter_reading) THEN
2276 l_reset_timestamp := p_ctr_rdg_rec.value_timestamp + (1/(24*60*60)); -- Add 1 Sec
2277 ELSE -- Only Reset is performed
2278 l_reset_timestamp := p_ctr_rdg_rec.value_timestamp;
2279 END IF;
2280 --
2281 csi_ctr_gen_utility_pvt.put_line('Reset Timestamp is : '||to_char(l_reset_timestamp,'DD-MON-YYYY HH24:MI:SS'));
2282
2283 --
2284 l_reset_rdg_rec.counter_id := p_ctr_rdg_rec.counter_id;
2285 l_reset_rdg_rec.value_timestamp := l_reset_timestamp;
2286 l_reset_rdg_rec.counter_reading := p_ctr_rdg_rec.reset_counter_reading;
2287 l_reset_rdg_rec.source_code := p_ctr_rdg_rec.source_code;
2288 l_reset_rdg_rec.source_line_id := p_ctr_rdg_rec.source_line_id;
2289 l_reset_rdg_rec.reset_mode := p_ctr_rdg_rec.reset_mode;
2290 l_reset_rdg_rec.reset_reason := p_ctr_rdg_rec.reset_reason;
2291 --
2292 -- If counter reading had been captured along with the reset then net and ltd would take the
2293 -- calculated values stored in p_ctr_rdg_rec. Otherwise, use the previous values.
2294 --
2295 IF NVL(p_ctr_rdg_rec.net_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM THEN
2296 l_reset_rdg_rec.net_reading := p_ctr_rdg_rec.reset_counter_reading;
2297 ELSE
2298 l_reset_rdg_rec.net_reading := p_ctr_rdg_rec.net_reading;
2299 END IF;
2300 IF NVL(p_ctr_rdg_rec.life_to_date_reading,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM THEN
2301 l_reset_rdg_rec.life_to_date_reading := l_prev_ltd_reading;
2302 ELSE
2303 l_reset_rdg_rec.life_to_date_reading := p_ctr_rdg_rec.life_to_date_reading;
2304 END IF;
2305 --
2306 -- Generate the Value_id
2307 l_process_flag := TRUE;
2308 WHILE l_process_flag LOOP
2309 select CSI_COUNTER_READINGS_S.nextval
2310 into l_reset_rdg_rec.counter_value_id from dual;
2311 IF NOT Counter_Value_Exists(l_reset_rdg_rec.counter_value_id) THEN
2312 l_process_flag := FALSE;
2313 END IF;
2314 END LOOP;
2315 --
2316 -- If only Reset is captured then we need to pass the reset counter value_id to p_ctr_rdg_rec
2317 --
2318 IF NVL(p_ctr_rdg_rec.counter_value_id,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM THEN
2319 p_ctr_rdg_rec.counter_value_id := l_reset_rdg_rec.counter_value_id;
2320 END IF;
2321 -- Call the Table Handler to insert the Reset Reading into CSI_COUNTER_READINGS
2322 --
2323 csi_ctr_gen_utility_pvt.put_line('Inserting Reset Record with Ctr Value ID '||to_char(l_reset_rdg_rec.counter_value_id));
2324
2325 --
2326 CSI_COUNTER_READINGS_PKG.Insert_Row(
2327 px_COUNTER_VALUE_ID => l_reset_rdg_rec.counter_value_id
2328 ,p_COUNTER_ID => l_reset_rdg_rec.counter_id
2329 ,p_VALUE_TIMESTAMP => l_reset_rdg_rec.value_timestamp
2330 ,p_COUNTER_READING => l_reset_rdg_rec.counter_reading
2331 ,p_RESET_MODE => l_reset_rdg_rec.reset_mode
2332 ,p_RESET_REASON => l_reset_rdg_rec.reset_reason
2333 ,p_ADJUSTMENT_TYPE => NULL
2334 ,p_ADJUSTMENT_READING => NULL
2335 ,p_OBJECT_VERSION_NUMBER => 1
2336 ,p_LAST_UPDATE_DATE => SYSDATE
2337 ,p_LAST_UPDATED_BY => fnd_global.user_id
2338 ,p_CREATION_DATE => SYSDATE
2339 ,p_CREATED_BY => fnd_global.user_id
2340 ,p_LAST_UPDATE_LOGIN => fnd_global.conc_login_id
2341 ,p_ATTRIBUTE1 => l_reset_rdg_rec.attribute1
2342 ,p_ATTRIBUTE2 => l_reset_rdg_rec.attribute2
2343 ,p_ATTRIBUTE3 => l_reset_rdg_rec.attribute3
2344 ,p_ATTRIBUTE4 => l_reset_rdg_rec.attribute4
2345 ,p_ATTRIBUTE5 => l_reset_rdg_rec.attribute5
2346 ,p_ATTRIBUTE6 => l_reset_rdg_rec.attribute6
2347 ,p_ATTRIBUTE7 => l_reset_rdg_rec.attribute7
2348 ,p_ATTRIBUTE8 => l_reset_rdg_rec.attribute8
2349 ,p_ATTRIBUTE9 => l_reset_rdg_rec.attribute9
2350 ,p_ATTRIBUTE10 => l_reset_rdg_rec.attribute10
2351 ,p_ATTRIBUTE11 => l_reset_rdg_rec.attribute11
2352 ,p_ATTRIBUTE12 => l_reset_rdg_rec.attribute12
2353 ,p_ATTRIBUTE13 => l_reset_rdg_rec.attribute13
2354 ,p_ATTRIBUTE14 => l_reset_rdg_rec.attribute14
2355 ,p_ATTRIBUTE15 => l_reset_rdg_rec.attribute15
2356 ,p_ATTRIBUTE16 => l_reset_rdg_rec.attribute16
2357 ,p_ATTRIBUTE17 => l_reset_rdg_rec.attribute17
2358 ,p_ATTRIBUTE18 => l_reset_rdg_rec.attribute18
2359 ,p_ATTRIBUTE19 => l_reset_rdg_rec.attribute19
2360 ,p_ATTRIBUTE20 => l_reset_rdg_rec.attribute20
2361 ,p_ATTRIBUTE21 => l_reset_rdg_rec.attribute21
2362 ,p_ATTRIBUTE22 => l_reset_rdg_rec.attribute22
2363 ,p_ATTRIBUTE23 => l_reset_rdg_rec.attribute23
2364 ,p_ATTRIBUTE24 => l_reset_rdg_rec.attribute24
2365 ,p_ATTRIBUTE25 => l_reset_rdg_rec.attribute25
2366 ,p_ATTRIBUTE26 => l_reset_rdg_rec.attribute26
2367 ,p_ATTRIBUTE27 => l_reset_rdg_rec.attribute27
2368 ,p_ATTRIBUTE28 => l_reset_rdg_rec.attribute28
2369 ,p_ATTRIBUTE29 => l_reset_rdg_rec.attribute29
2370 ,p_ATTRIBUTE30 => l_reset_rdg_rec.attribute30
2371 ,p_ATTRIBUTE_CATEGORY => l_reset_rdg_rec.attribute_category
2372 ,p_MIGRATED_FLAG => 'N'
2373 ,p_COMMENTS => l_reset_rdg_rec.comments
2374 ,p_LIFE_TO_DATE_READING => l_reset_rdg_rec.life_to_date_reading
2375 ,p_TRANSACTION_ID => p_txn_rec.transaction_id
2376 ,p_AUTOMATIC_ROLLOVER_FLAG => l_reset_rdg_rec.automatic_rollover_flag
2377 ,p_INCLUDE_TARGET_RESETS => p_ctr_rdg_rec.include_target_resets
2378 ,p_SOURCE_COUNTER_VALUE_ID => NULL
2379 ,p_NET_READING => l_reset_rdg_rec.net_reading
2380 ,p_DISABLED_FLAG => 'N'
2381 ,p_SOURCE_CODE => l_reset_rdg_rec.source_code
2382 ,p_SOURCE_LINE_ID => l_reset_rdg_rec.source_line_id
2383 ,p_INITIAL_READING_FLAG => l_reset_rdg_rec.initial_reading_flag
2384 );
2385
2386 --Add call to CSI_COUNTER_PVT.update_ctr_val_max_seq_no
2387 --for bug 7374316
2388 CSI_COUNTER_PVT.update_ctr_val_max_seq_no(
2389 p_api_version => 1.0
2390 ,p_commit => fnd_api.g_false
2391 ,p_init_msg_list => fnd_api.g_true
2392 ,p_validation_level => fnd_api.g_valid_level_full
2393 ,p_counter_id => l_reset_rdg_rec.counter_id
2394 ,px_ctr_val_max_seq_no => l_reset_rdg_rec.counter_value_id
2395 ,x_return_status => x_return_status
2396 ,x_msg_count => x_msg_count
2397 ,x_msg_data => x_msg_data
2398 );
2399 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
2400 csi_ctr_gen_utility_pvt.put_line('ERROR FROM CSI_COUNTER_PVT.update_ctr_val_max_seq_no');
2401 l_msg_index := 1;
2402 l_msg_count := x_msg_count;
2403 WHILE l_msg_count > 0 LOOP
2404 x_msg_data := FND_MSG_PUB.GET
2405 ( l_msg_index,
2406 FND_API.G_FALSE
2407 );
2408 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
2409 l_msg_index := l_msg_index + 1;
2410 l_msg_count := l_msg_count - 1;
2411 END LOOP;
2412 RAISE FND_API.G_EXC_ERROR;
2413 END IF;
2414 -- END IF;
2415 --
2416 --
2417 -- Compute Target counters if Include Target flag is checked
2418 IF NVL(p_ctr_rdg_rec.include_target_resets,'N') = 'Y' THEN
2419 -- Re-calculate Compute Target Counters
2420 l_target_ctr_rec := l_temp_ctr_rdg_rec;
2421 --
2422 l_target_ctr_rec.counter_value_id := l_reset_rdg_rec.counter_value_id; -- source_counter_value_id
2423 l_target_ctr_rec.counter_id := l_reset_rdg_rec.counter_id;
2424 l_target_ctr_rec.value_timestamp := l_reset_rdg_rec.value_timestamp;
2425 l_target_ctr_rec.counter_reading := l_reset_rdg_rec.counter_reading;
2426 l_target_ctr_rec.source_code := l_reset_rdg_rec.source_code;
2427 l_target_ctr_rec.source_line_id := l_reset_rdg_rec.source_line_id;
2428 l_target_ctr_rec.reset_mode := l_reset_rdg_rec.reset_mode;
2429 l_target_ctr_rec.reset_reason := l_reset_rdg_rec.reset_reason;
2430 l_target_ctr_rec.comments := l_reset_rdg_rec.comments;
2431 --
2432 -- added 6398254
2433 csi_ctr_gen_utility_pvt.put_line('6398254: l_reset_rdg_rec.reset_reason' || l_reset_rdg_rec.reset_reason);
2434 -- Call Re-Compute Target Counters
2435 csi_ctr_gen_utility_pvt.put_line('Calling Reset_Target_Counters 1...');
2436 Reset_Target_Counters
2437 (
2438 p_txn_rec => p_txn_rec
2439 ,p_ctr_rdg_rec => l_target_ctr_rec
2440 ,x_return_status => x_return_status
2441 ,x_msg_count => x_msg_count
2442 ,x_msg_data => x_msg_data
2443 );
2444 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
2445 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Reset_Target_Counters API ');
2446 l_msg_index := 1;
2447 l_msg_count := x_msg_count;
2448 WHILE l_msg_count > 0 LOOP
2449 x_msg_data := FND_MSG_PUB.GET
2450 ( l_msg_index,
2451 FND_API.G_FALSE
2452 );
2453 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
2454 l_msg_index := l_msg_index + 1;
2455 l_msg_count := l_msg_count - 1;
2456 END LOOP;
2457 RAISE FND_API.G_EXC_ERROR;
2458 END IF;
2459 END IF; -- Include Target Resets check
2460 --
2461 -- No need to compute Derived Filters for SOFT reset as it has the same net reading
2462 -- as the previous counter reading.
2463 END IF; -- Reset Mode check
2464 --
2465 IF FND_API.to_Boolean(nvl(p_commit,FND_API.G_FALSE)) THEN
2466 COMMIT WORK;
2467 END IF;
2468 --
2469 -- Standard call to get message count and IF count is get message info.
2470 FND_MSG_PUB.Count_And_Get
2471 ( p_count => x_msg_count,
2472 p_data => x_msg_data
2473 );
2474 EXCEPTION
2475 WHEN Skip_Process THEN
2476 x_return_status := FND_API.G_RET_STS_SUCCESS;
2477 FND_MSG_PUB.Count_And_Get
2478 ( p_count => x_msg_count,
2479 p_data => x_msg_data
2480 );
2481 WHEN FND_API.G_EXC_ERROR THEN
2482 x_return_status := FND_API.G_RET_STS_ERROR ;
2483 ROLLBACK TO capture_counter_reading_pvt;
2484 FND_MSG_PUB.Count_And_Get
2485 ( p_count => x_msg_count,
2486 p_data => x_msg_data
2487 );
2488 WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2489 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2490 ROLLBACK TO capture_counter_reading_pvt;
2491 FND_MSG_PUB.Count_And_Get
2492 ( p_count => x_msg_count,
2493 p_data => x_msg_data
2494 );
2495 WHEN OTHERS THEN
2496 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2497 ROLLBACK TO capture_counter_reading_pvt;
2498 IF FND_MSG_PUB.Check_Msg_Level (FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
2499 FND_MSG_PUB.Add_Exc_Msg
2500 ( G_PKG_NAME,
2501 l_api_name
2502 );
2503 END IF;
2504 FND_MSG_PUB.Count_And_Get
2505 ( p_count => x_msg_count,
2506 p_data => x_msg_data
2507 );
2508 END Capture_Counter_Reading;
2509 --
2510 PROCEDURE Compute_Formula_Counters
2511 (
2512 p_api_version IN NUMBER
2513 ,p_commit IN VARCHAR2
2514 ,p_init_msg_list IN VARCHAR2
2515 ,p_validation_level IN NUMBER
2516 ,p_txn_rec IN OUT NOCOPY csi_datastructures_pub.transaction_rec
2517 ,p_ctr_rdg_rec IN csi_ctr_datastructures_pub.counter_readings_rec
2518 ,x_return_status OUT NOCOPY VARCHAR2
2519 ,x_msg_count OUT NOCOPY NUMBER
2520 ,x_msg_data OUT NOCOPY VARCHAR2
2521 )
2522 IS
2523 l_api_name CONSTANT VARCHAR2(30) := 'COMPUTE_FORMULA_COUNTERS';
2524 l_api_version CONSTANT NUMBER := 1.0;
2525 l_msg_data VARCHAR2(2000);
2526 l_msg_index NUMBER;
2527 l_msg_count NUMBER;
2528 l_rel_type VARCHAR2(30) := 'FORMULA';
2529 l_formula_text CSI_COUNTERS_B.formula_text%TYPE;
2530 l_cursor_handle INTEGER; --Dynamic SQL cursor handler
2531 l_n_temp INTEGER;
2532 l_counter_reading NUMBER;
2533 l_bind_var_value NUMBER;
2534 l_bind_var_name VARCHAR2(255);
2535 l_other_src_captured VARCHAR2(1);
2536 l_disabled_flag VARCHAR2(1);
2537 l_exists VARCHAR2(1);
2538 l_ctr_value_id NUMBER;
2539 l_process_flag BOOLEAN;
2540 l_mode VARCHAR2(30);
2541 Process_Next EXCEPTION;
2542 --
2543 TYPE source_ctr_rec IS RECORD
2544 ( source_counter_id NUMBER,
2545 bind_variable_name VARCHAR2(255)
2546 );
2547 TYPE source_ctr_tbl IS TABLE OF source_ctr_rec INDEX BY BINARY_INTEGER;
2548 --
2549 l_src_ctr_tbl source_ctr_tbl;
2550 l_src_count NUMBER := 0;
2551 l_tmp_ctr_value_id NUMBER;
2552 --
2553 CURSOR OBJECT_CTR_CUR(p_src_ctr_id IN NUMBER) IS
2554 select distinct object_counter_id
2555 from csi_counter_relationships
2556 where source_counter_id = p_src_ctr_id
2557 and relationship_type_code = l_rel_type
2558 and nvl(active_end_date,(sysdate+1)) > sysdate;
2559 --
2560 CURSOR SOURCE_CTR_CUR(p_obj_ctr_id IN NUMBER) IS
2561 select source_counter_id,bind_variable_name
2562 from csi_counter_relationships
2563 where object_counter_id = p_obj_ctr_id
2564 and relationship_type_code = l_rel_type
2565 and nvl(active_end_date,(sysdate+1)) > sysdate;
2566 --
2567 CURSOR GET_NET_RDG_CUR(p_counter_id IN NUMBER,p_value_timestamp IN DATE) IS
2568 select net_reading
2569 from CSI_COUNTER_READINGS
2570 where counter_id = p_counter_id
2571 and nvl(disabled_flag,'N') = 'N'
2572 and value_timestamp <= p_value_timestamp
2573 ORDER BY value_timestamp desc,counter_value_id desc;
2574 --
2575 CURSOR LATER_FORMULA_CUR(p_obj_ctr_id IN NUMBER,p_value_timestamp IN DATE) IS
2576 select counter_value_id,value_timestamp
2577 from CSI_COUNTER_READINGS
2578 where counter_id = p_obj_ctr_id
2579 and value_timestamp > p_value_timestamp
2580 and nvl(disabled_flag,'N') = 'N'
2581 ORDER BY value_timestamp desc, counter_value_id desc;
2582 BEGIN
2583 -- Standard Start of API savepoint
2584 SAVEPOINT compute_formula_counters;
2585 -- Standard call to check for call compatibility.
2586 IF NOT FND_API.Compatible_API_Call (l_api_version,
2587 p_api_version,
2588 l_api_name ,
2589 G_PKG_NAME ) THEN
2590 RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
2591 END IF;
2592 -- Initialize message list if p_init_msg_list is set to TRUE.
2593 IF FND_API.to_Boolean(nvl(p_init_msg_list,FND_API.G_FALSE)) THEN
2594 FND_MSG_PUB.initialize;
2595 END IF;
2596 -- Initialize API return status to success
2597 x_return_status := FND_API.G_RET_STS_SUCCESS;
2598
2599 -- Read the debug profiles values in to global variable 7197402
2600 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
2601 --
2602 csi_ctr_gen_utility_pvt.put_line( 'compute_formula_counters' ||'-'||
2603 p_api_version ||'-'||
2604 nvl(p_commit,FND_API.G_FALSE) ||'-'||
2605 nvl(p_init_msg_list,FND_API.G_FALSE) ||'-'||
2606 nvl(p_validation_level,FND_API.G_VALID_LEVEL_FULL) );
2607 --
2608 csi_ctr_gen_utility_pvt.dump_counter_readings_rec(p_ctr_rdg_rec);
2609 --
2610 IF p_txn_rec.transaction_type_id in (88,91,92,94,95) THEN
2611 l_mode := 'Meter';
2612 ELSE
2613 l_mode := 'Counter';
2614 END IF;
2615 --
2616 IF p_ctr_rdg_rec.counter_id IS NULL OR
2617 p_ctr_rdg_rec.counter_id = FND_API.G_MISS_NUM THEN
2618 csi_ctr_gen_utility_pvt.ExitWithErrMsg
2619 ( p_msg_name => 'CSI_API_CTR_INVALID',
2620 p_token1_name => 'MODE',
2621 p_token1_val => l_mode
2622 );
2623 END IF;
2624 --
2625 IF p_ctr_rdg_rec.disabled_flag IS NULL OR
2626 p_ctr_rdg_rec.disabled_flag = FND_API.G_MISS_CHAR THEN
2627 l_disabled_flag := 'N';
2628 ELSE
2629 l_disabled_flag := p_ctr_rdg_rec.disabled_flag;
2630 END IF;
2631 --
2632 FOR obj_cur IN OBJECT_CTR_CUR(p_ctr_rdg_rec.counter_id) LOOP
2633 Begin
2634 l_formula_text := NULL;
2635 Begin
2636 select formula_text
2637 into l_formula_text
2638 from CSI_COUNTERS_B -- Need to be changed
2639 where counter_id = obj_cur.object_counter_id
2640 and nvl(end_date_active,(sysdate+1)) > sysdate;
2641 Exception
2642 when no_data_found then
2643 RAISE Process_Next;
2644 End;
2645 --
2646 l_cursor_handle := dbms_sql.open_cursor;
2647 l_formula_text := 'SELECT '||l_formula_text||' FROM DUAL';
2648 --
2649 Begin
2650 DBMS_SQL.PARSE(l_cursor_handle, l_formula_text, dbms_sql.native);
2651 Exception
2652 when others then
2653 csi_ctr_gen_utility_pvt.ExitWithErrMsg
2654 ( p_msg_name => 'CSI_API_CTR_FORMULA_DEF_INV',
2655 p_token1_name => 'FMLA_TEXT',
2656 p_token1_val => l_formula_text
2657 );
2658 End;
2659 --
2660 DBMS_SQL.DEFINE_COLUMN(l_cursor_handle,1,l_counter_reading);
2661 --
2662 l_src_count := 0;
2663 l_src_ctr_tbl.DELETE;
2664 -- l_src_ctr_bl will be used when we re-calculate the later readings of this formula counter
2665 -- as the set of source counters remain same
2666 --
2667 -- For each source_counter, get the bind_variable_name and the net reading
2668 l_other_src_captured := 'F';
2669 --
2670 FOR sub_cur IN SOURCE_CTR_CUR(obj_cur.object_counter_id) LOOP
2671 -- Check whether the other source counters are read for the same timestamp.
2672 -- If so, then we can't disable the formula counter reading. We use the calculated net rdg.
2673 -- If the other source counters are not read then we can disable the formula counter reading.
2674 IF NVL(p_ctr_rdg_rec.disabled_flag,'N') = 'Y' AND
2675 sub_cur.source_counter_id <> p_ctr_rdg_rec.counter_id AND
2676 l_other_src_captured <> 'T' THEN
2677 Begin
2678 select '1'
2679 into l_exists from dual
2680 where exists (select 'x'
2681 from CSI_COUNTER_READINGS
2682 where counter_id = sub_cur.source_counter_id
2683 and value_timestamp = p_ctr_rdg_rec.value_timestamp
2684 and nvl(disabled_flag,'N') <> 'Y');
2685 l_other_src_captured := 'T';
2686 Exception
2687 when no_data_found then
2688 null;
2689 End;
2690 END IF;
2691 --
2692 l_bind_var_name := ':'||ltrim(sub_cur.bind_variable_name);
2693 l_src_count := l_src_count + 1;
2694 l_src_ctr_tbl(l_src_count).source_counter_id := sub_cur.source_counter_id;
2695 l_src_ctr_tbl(l_src_count).bind_variable_name := sub_cur.bind_variable_name;
2696 --
2697 l_bind_var_value := NULL;
2698 --
2699 OPEN GET_NET_RDG_CUR(sub_cur.source_counter_id,p_ctr_rdg_rec.value_timestamp);
2700 FETCH GET_NET_RDG_CUR INTO l_bind_var_value;
2701 CLOSE GET_NET_RDG_CUR;
2702 DBMS_SQL.BIND_VARIABLE(l_cursor_handle, l_bind_var_name, nvl(l_bind_var_value,0));
2703 END LOOP; -- Sub Cursor
2704 --
2705 l_n_temp := dbms_sql.execute(l_cursor_handle);
2706 --Get the value
2707 IF dbms_sql.fetch_rows(l_cursor_handle) > 0 THEN
2708 dbms_sql.column_value(l_cursor_handle,1,l_counter_reading);
2709 ELSE
2710 l_counter_reading := 0;
2711 END IF;
2712 --Close cursor
2713 DBMS_SQL.close_cursor(l_cursor_handle);
2714 --
2715 -- If the source counter reading is not disabled then we update/insert the row for formula
2716 -- counter.
2717 --
2718 IF NVL(p_ctr_rdg_rec.disabled_flag,'N') <> 'Y' THEN
2719 csi_ctr_gen_utility_pvt.put_line('Trying to Update Object Ctr : '||to_char(obj_cur.object_counter_id));
2720 Update CSI_COUNTER_READINGS
2721 set counter_reading = l_counter_reading,
2722 net_reading = l_counter_reading,
2723 life_to_date_reading = l_counter_reading,
2724 disabled_flag = 'N',
2725 last_update_date = sysdate,
2726 last_updated_by = fnd_global.user_id
2727 where counter_id = obj_cur.object_counter_id
2728 and value_timestamp = p_ctr_rdg_rec.value_timestamp;
2729 --
2730 IF SQL%ROWCOUNT = 0 THEN -- If update was not successfull
2731 -- Generate the Value_id for insert
2732 l_process_flag := TRUE;
2733 WHILE l_process_flag LOOP
2734 select CSI_COUNTER_READINGS_S.nextval
2735 into l_ctr_value_id from dual;
2736 IF NOT Counter_Value_Exists(l_ctr_value_id) THEN
2737 l_process_flag := FALSE;
2738 END IF;
2739 END LOOP;
2740 --
2741 csi_ctr_gen_utility_pvt.put_line('Unable to Update. Inserting Object Ctr : '||to_char(obj_cur.object_counter_id));
2742 -- Call the Table Handler to insert the new reading
2743 CSI_COUNTER_READINGS_PKG.Insert_Row(
2744 px_COUNTER_VALUE_ID => l_ctr_value_id
2745 ,p_COUNTER_ID => obj_cur.object_counter_id
2746 ,p_VALUE_TIMESTAMP => p_ctr_rdg_rec.value_timestamp
2747 ,p_COUNTER_READING => l_counter_reading
2748 ,p_RESET_MODE => NULL
2749 ,p_RESET_REASON => NULL
2750 ,p_ADJUSTMENT_TYPE => NULL
2751 ,p_ADJUSTMENT_READING => NULL
2752 ,p_OBJECT_VERSION_NUMBER => 1
2753 ,p_LAST_UPDATE_DATE => SYSDATE
2754 ,p_LAST_UPDATED_BY => fnd_global.user_id
2755 ,p_CREATION_DATE => SYSDATE
2756 ,p_CREATED_BY => fnd_global.user_id
2757 ,p_LAST_UPDATE_LOGIN => fnd_global.conc_login_id
2758 ,p_ATTRIBUTE1 => NULL
2759 ,p_ATTRIBUTE2 => NULL
2760 ,p_ATTRIBUTE3 => NULL
2761 ,p_ATTRIBUTE4 => NULL
2762 ,p_ATTRIBUTE5 => NULL
2763 ,p_ATTRIBUTE6 => NULL
2764 ,p_ATTRIBUTE7 => NULL
2765 ,p_ATTRIBUTE8 => NULL
2766 ,p_ATTRIBUTE9 => NULL
2767 ,p_ATTRIBUTE10 => NULL
2768 ,p_ATTRIBUTE11 => NULL
2769 ,p_ATTRIBUTE12 => NULL
2770 ,p_ATTRIBUTE13 => NULL
2771 ,p_ATTRIBUTE14 => NULL
2772 ,p_ATTRIBUTE15 => NULL
2773 ,p_ATTRIBUTE16 => NULL
2774 ,p_ATTRIBUTE17 => NULL
2775 ,p_ATTRIBUTE18 => NULL
2776 ,p_ATTRIBUTE19 => NULL
2777 ,p_ATTRIBUTE20 => NULL
2778 ,p_ATTRIBUTE21 => NULL
2779 ,p_ATTRIBUTE22 => NULL
2780 ,p_ATTRIBUTE23 => NULL
2781 ,p_ATTRIBUTE24 => NULL
2782 ,p_ATTRIBUTE25 => NULL
2783 ,p_ATTRIBUTE26 => NULL
2784 ,p_ATTRIBUTE27 => NULL
2785 ,p_ATTRIBUTE28 => NULL
2786 ,p_ATTRIBUTE29 => NULL
2787 ,p_ATTRIBUTE30 => NULL
2788 ,p_ATTRIBUTE_CATEGORY => NULL
2789 ,p_MIGRATED_FLAG => 'N'
2790 ,p_COMMENTS => NULL
2791 ,p_LIFE_TO_DATE_READING => l_counter_reading
2792 ,p_TRANSACTION_ID => p_txn_rec.transaction_id
2793 ,p_AUTOMATIC_ROLLOVER_FLAG => NULL
2794 ,p_INCLUDE_TARGET_RESETS => NULL
2795 ,p_SOURCE_COUNTER_VALUE_ID => NULL
2796 ,p_NET_READING => l_counter_reading
2797 ,p_DISABLED_FLAG => 'N'
2798 ,p_SOURCE_CODE => p_ctr_rdg_rec.source_code
2799 ,p_SOURCE_LINE_ID => p_ctr_rdg_rec.source_line_id
2800 ,p_INITIAL_READING_FLAG => p_ctr_rdg_rec.initial_reading_flag
2801 );
2802
2803 --Add call to CSI_COUNTER_PVT.update_ctr_val_max_seq_no
2804 --for bug 7374316
2805 CSI_COUNTER_PVT.update_ctr_val_max_seq_no(
2806 p_api_version => 1.0
2807 ,p_commit => fnd_api.g_false
2808 ,p_init_msg_list => fnd_api.g_true
2809 ,p_validation_level => fnd_api.g_valid_level_full
2810 ,p_counter_id => obj_cur.object_counter_id
2811 ,px_ctr_val_max_seq_no => l_ctr_value_id
2812 ,x_return_status => x_return_status
2813 ,x_msg_count => x_msg_count
2814 ,x_msg_data => x_msg_data
2815 );
2816 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
2817 csi_ctr_gen_utility_pvt.put_line('ERROR FROM CSI_COUNTER_PVT.update_ctr_val_max_seq_no');
2818 l_msg_index := 1;
2819 l_msg_count := x_msg_count;
2820 WHILE l_msg_count > 0 LOOP
2821 x_msg_data := FND_MSG_PUB.GET
2822 ( l_msg_index,
2823 FND_API.G_FALSE
2824 );
2825 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
2826 l_msg_index := l_msg_index + 1;
2827 l_msg_count := l_msg_count - 1;
2828 END LOOP;
2829 RAISE FND_API.G_EXC_ERROR;
2830 END IF;
2831 ELSE
2832 --Add call to CSI_COUNTER_PVT.update_ctr_val_max_seq_no
2833 --for bug 7374316
2834 l_tmp_ctr_value_id := NULL;
2835 CSI_COUNTER_PVT.update_ctr_val_max_seq_no(
2836 p_api_version => 1.0
2837 ,p_commit => fnd_api.g_false
2838 ,p_init_msg_list => fnd_api.g_true
2839 ,p_validation_level => fnd_api.g_valid_level_full
2840 ,p_counter_id => obj_cur.object_counter_id
2841 ,px_ctr_val_max_seq_no => l_tmp_ctr_value_id
2842 ,x_return_status => x_return_status
2843 ,x_msg_count => x_msg_count
2844 ,x_msg_data => x_msg_data
2845 );
2846 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
2847 csi_ctr_gen_utility_pvt.put_line('ERROR FROM CSI_COUNTER_PVT.update_ctr_val_max_seq_no');
2848 l_msg_index := 1;
2849 l_msg_count := x_msg_count;
2850 WHILE l_msg_count > 0 LOOP
2851 x_msg_data := FND_MSG_PUB.GET
2852 ( l_msg_index,
2853 FND_API.G_FALSE
2854 );
2855 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
2856 l_msg_index := l_msg_index + 1;
2857 l_msg_count := l_msg_count - 1;
2858 END LOOP;
2859 RAISE FND_API.G_EXC_ERROR;
2860 END IF;
2861 END IF;
2862 ELSE -- If source counter is disabled then the corresponding formula counter reading is updated
2863 csi_ctr_gen_utility_pvt.put_line('Disabling Obj Ctr '||to_char(obj_cur.object_counter_id));
2864 Update CSI_COUNTER_READINGS
2865 set counter_reading = l_counter_reading,
2866 net_reading = l_counter_reading,
2867 life_to_date_reading = l_counter_reading,
2868 disabled_flag = decode(l_disabled_flag,'Y',decode(l_other_src_captured,'T','N','Y'),'N'),
2869 last_update_date = sysdate,
2870 last_updated_by = fnd_global.user_id
2871 where counter_id = obj_cur.object_counter_id
2872 and value_timestamp = p_ctr_rdg_rec.value_timestamp;
2873
2874 IF (l_disabled_flag = 'Y') AND (l_other_src_captured <> 'T') THEN
2875 --Add call to CSI_COUNTER_PVT.update_ctr_val_max_seq_no
2876 --for bug 7374316
2877 l_tmp_ctr_value_id := NULL;
2878 CSI_COUNTER_PVT.update_ctr_val_max_seq_no(
2879 p_api_version => 1.0
2880 ,p_commit => fnd_api.g_false
2881 ,p_init_msg_list => fnd_api.g_true
2882 ,p_validation_level => fnd_api.g_valid_level_full
2883 ,p_counter_id => obj_cur.object_counter_id
2884 ,px_ctr_val_max_seq_no => l_tmp_ctr_value_id
2885 ,x_return_status => x_return_status
2886 ,x_msg_count => x_msg_count
2887 ,x_msg_data => x_msg_data
2888 );
2889 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
2890 csi_ctr_gen_utility_pvt.put_line('ERROR FROM CSI_COUNTER_PVT.update_ctr_val_max_seq_no');
2891 l_msg_index := 1;
2892 l_msg_count := x_msg_count;
2893 WHILE l_msg_count > 0 LOOP
2894 x_msg_data := FND_MSG_PUB.GET
2895 ( l_msg_index,
2896 FND_API.G_FALSE
2897 );
2898 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
2899 l_msg_index := l_msg_index + 1;
2900 l_msg_count := l_msg_count - 1;
2901 END LOOP;
2902 RAISE FND_API.G_EXC_ERROR;
2903 END IF;
2904 END IF;
2905 END IF; -- Check for disabled_flag
2906 --
2907 -- Re-compute Later Formula Counter Readings
2908 -- For this Formula counter, pick up the readings later than passed timestamp and re-compute
2909 --
2910 FOR later_rec IN LATER_FORMULA_CUR(obj_cur.object_counter_id,p_ctr_rdg_rec.value_timestamp) LOOP
2911 l_cursor_handle := dbms_sql.open_cursor;
2912 -- Formula Text is reused from the above
2913 -- l_formula_text := 'SELECT '||l_formula_text||' FROM DUAL';
2914 --
2915 Begin
2916 DBMS_SQL.PARSE(l_cursor_handle, l_formula_text, dbms_sql.native);
2917 Exception
2918 when others then
2919 csi_ctr_gen_utility_pvt.ExitWithErrMsg
2920 ( p_msg_name => 'CSI_API_CTR_FORMULA_DEF_INV',
2921 p_token1_name => 'FMLA_TEXT',
2922 p_token1_val => l_formula_text
2923 );
2924 End;
2925 --
2926 DBMS_SQL.DEFINE_COLUMN(l_cursor_handle,1,l_counter_reading);
2927 --
2928 -- Since we already have the list of Source counters for this Object (Formula) we are using it.
2929 IF l_src_ctr_tbl.count > 0 THEN
2930 FOR src_rec in l_src_ctr_tbl.FIRST .. l_src_ctr_tbl.LAST LOOP
2931 l_bind_var_name := ':'||ltrim(l_src_ctr_tbl(src_rec).bind_variable_name);
2932 l_bind_var_value := NULL;
2933 OPEN GET_NET_RDG_CUR(l_src_ctr_tbl(src_rec).source_counter_id,later_rec.value_timestamp);
2934 FETCH GET_NET_RDG_CUR INTO l_bind_var_value;
2935 CLOSE GET_NET_RDG_CUR;
2936 DBMS_SQL.BIND_VARIABLE(l_cursor_handle, l_bind_var_name, nvl(l_bind_var_value,0));
2937 END LOOP;
2938 END IF;
2939 --
2940 l_n_temp := dbms_sql.execute(l_cursor_handle);
2941 --Get the value
2942 IF dbms_sql.fetch_rows(l_cursor_handle) > 0 THEN
2943 dbms_sql.column_value(l_cursor_handle,1,l_counter_reading);
2944 -- Updating Formula Counter
2945 csi_ctr_gen_utility_pvt.put_line('Re-computing later formula Ctr Value ID '||to_char(later_rec.counter_value_id));
2946 Update CSI_COUNTER_READINGS
2947 set counter_reading = l_counter_reading,
2948 net_reading = l_counter_reading,
2949 life_to_date_reading = l_counter_reading,
2950 last_update_date = sysdate,
2951 last_updated_by = fnd_global.user_id
2952 where counter_value_id = later_rec.counter_value_id;
2953 ELSE
2954 l_counter_reading := 0;
2955 END IF;
2956 --Close cursor
2957 DBMS_SQL.close_cursor(l_cursor_handle);
2958 END LOOP; -- Later Formula Readings Loop
2959 Exception
2960 when Process_Next then
2961 null;
2962 End;
2963 END LOOP; -- Obj Cursor
2964 --
2965 IF FND_API.to_Boolean(nvl(p_commit,FND_API.G_FALSE)) THEN
2966 COMMIT WORK;
2967 END IF;
2968 --
2969 -- Standard call to get message count and IF count is get message info.
2970 FND_MSG_PUB.Count_And_Get
2971 ( p_count => x_msg_count,
2972 p_data => x_msg_data
2973 );
2974 EXCEPTION
2975 WHEN FND_API.G_EXC_ERROR THEN
2976 x_return_status := FND_API.G_RET_STS_ERROR ;
2977 ROLLBACK TO compute_formula_counters;
2978 FND_MSG_PUB.Count_And_Get
2979 ( p_count => x_msg_count,
2980 p_data => x_msg_data
2981 );
2982 WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
2983 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2984 ROLLBACK TO compute_formula_counters;
2985 FND_MSG_PUB.Count_And_Get
2986 ( p_count => x_msg_count,
2987 p_data => x_msg_data
2988 );
2989 WHEN OTHERS THEN
2990 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
2991 ROLLBACK TO compute_formula_counters;
2992 IF FND_MSG_PUB.Check_Msg_Level (FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
2993 FND_MSG_PUB.Add_Exc_Msg
2994 ( G_PKG_NAME,
2995 l_api_name
2996 );
2997 END IF;
2998 FND_MSG_PUB.Count_And_Get
2999 ( p_count => x_msg_count,
3000 p_data => x_msg_data
3001 );
3002 END Compute_Formula_Counters;
3003 --
3004 PROCEDURE Compute_Derive_Counters(
3005 P_Api_Version IN NUMBER,
3006 P_Init_Msg_List IN VARCHAR2,
3007 P_Commit IN VARCHAR2,
3008 p_validation_level IN NUMBER,
3009 p_txn_rec IN OUT NOCOPY csi_datastructures_pub.transaction_rec,
3010 p_ctr_rdg_rec IN csi_ctr_datastructures_pub.counter_readings_rec,
3011 p_mode IN VARCHAR2,
3012 X_Return_Status OUT NOCOPY VARCHAR2,
3013 X_Msg_Count OUT NOCOPY NUMBER,
3014 X_Msg_Data OUT NOCOPY VARCHAR2
3015 )
3016 IS
3017 l_api_name CONSTANT VARCHAR2(30) := 'COMPUTE_DERIVE_COUNTERS';
3018 l_msg_index NUMBER;
3019 l_msg_count NUMBER;
3020 -- Start fix for bug 6852415, part 1 of 3
3021 CURSOR base_ctrs IS
3022 SELECT counter_id AS base_ctr_id,
3023 value_timestamp AS base_ctr_timestamp
3024 FROM csi_counter_readings
3025 WHERE counter_value_id = p_ctr_rdg_rec.counter_value_id;
3026 CURSOR ctrs_to_be_calc(base_ctr_id NUMBER, base_ctr_timestamp DATE) IS
3027 SELECT counter_id,
3028 derive_function,
3029 derive_counter_id,
3030 derive_property_id,
3031 filter_reading_count,
3032 filter_type,
3033 filter_time_uom
3034 FROM csi_counters_b
3035 WHERE derive_counter_id = base_ctr_id
3036 AND NVL(start_date_active, base_ctr_timestamp) <= base_ctr_timestamp
3037 AND NVL(end_date_active, (base_ctr_timestamp + 1)) > base_ctr_timestamp;
3038 /*
3039 CURSOR CTRS_TO_BE_CALC IS
3040 SELECT ctr.counter_id, ctr.derive_function,
3041 ctr.derive_counter_id, ctr.derive_property_id,ctr.filter_reading_count,ctr.filter_type,
3042 ctr.filter_time_uom, cv.value_timestamp as new_rdg_dt, cv.counter_id as base_ctr_id
3043 FROM CSI_COUNTERS_B ctr, CSI_COUNTER_READINGS cv
3044 WHERE cv.counter_value_id = p_ctr_rdg_rec.counter_value_id
3045 AND ctr.derive_counter_id = cv.counter_id
3046 AND NVL(ctr.start_date_active,cv.value_timestamp) <= cv.value_timestamp
3047 AND NVL(ctr.end_date_active,(cv.value_timestamp+1)) > cv.value_timestamp;
3048 */
3049 -- End fix for bug 6852415, part 1 of 3
3050 CURSOR DER_FILTERS(b_counter_id IN NUMBER) IS
3051 SELECT filt.counter_property_id, filt.seq_no,filt.left_parent left_paren,
3052 filt.right_parent right_paren, filt.relational_operator,
3053 filt.logical_operator, filt.right_value,
3054 pro.property_data_type
3055 FROM CSI_COUNTER_DERIVED_FILTERS filt, CSI_COUNTER_PROPERTIES_B pro
3056 WHERE filt.counter_id = b_counter_id
3057 AND pro.counter_property_id(+) = filt.counter_property_id;
3058 --
3059 CURSOR GET_TIME_UOM_CUR(p_filter_time_uom IN VARCHAR2) IS
3060 SELECT uom_code
3061 FROM OKC_TIME_CODE_UNITS_V
3062 WHERE uom_code=p_filter_time_uom;
3063 --
3064 l_sqlstr_init VARCHAR2(2000);
3065 l_sqlstr VARCHAR2(2000);
3066 l_sqlwhere VARCHAR2(1000);
3067 l_sqlfrom VARCHAR2(1000);
3068 l_cursor_handle NUMBER;
3069 l_ctr_value NUMBER;
3070 l_n_temp NUMBER;
3071 l_ctr_value_id NUMBER;
3072 l_process_flag BOOLEAN;
3073 l_ctr_in csi_ctr_datastructures_pub.counter_readings_rec;
3074 l_temp_ctr_rdg_rec csi_ctr_datastructures_pub.counter_readings_rec;
3075 --
3076 --variable and arrays for binding dbmssql
3077 TYPE FILTS IS RECORD(
3078 BINDNAME_RIGHTVAL VARCHAR2(240),
3079 BINDVAL_RIGHTVAL VARCHAR2(240),
3080 BINDNAME_CTRPROPID VARCHAR2(240),
3081 BINDVAL_CTRPROPID NUMBER
3082 );
3083 --
3084 TYPE T1 is TABLE OF FILTS index by binary_integer;
3085 T2 T1;
3086 i NUMBER := 1;
3087 lj NUMBER := 1;
3088 --
3089 BINDVAL_DERIVECTRID NUMBER;
3090 --
3091 l_bind_varname VARCHAR2(240);
3092 l_bind_varvalc VARCHAR2(240);
3093 l_bind_varvaln NUMBER;
3094
3095 BEGIN
3096 -- Standard Start of API savepoint
3097 SAVEPOINT compute_derive_counters;
3098 -- Initialize message list if p_init_msg_list is set to TRUE.
3099 IF FND_API.to_Boolean(nvl(p_init_msg_list,FND_API.G_FALSE)) THEN
3100 FND_MSG_PUB.initialize;
3101 END IF;
3102 x_return_status := FND_API.G_RET_STS_SUCCESS;
3103 --
3104
3105 -- Read the debug profiles values in to global variable 7197402
3106 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
3107
3108 csi_ctr_gen_utility_pvt.put_line('Inside Compute_Derive_Counters...');
3109 csi_ctr_gen_utility_pvt.dump_counter_readings_rec(p_ctr_rdg_rec);
3110 --
3111 -- Start fix for bug 6852415, part 2 of 3
3112 FOR base_ctr IN base_ctrs LOOP
3113 FOR ctrs IN ctrs_to_be_calc(base_ctr.base_ctr_id, base_ctr.base_ctr_timestamp) LOOP
3114 -- End fix for bug 6852415, part 2 of 3
3115 IF ctrs.derive_function = 'AVERAGE' AND ctrs.filter_type = 'COUNT' THEN
3116 Declare
3117 n number;
3118 j number := 0;
3119 l_rec_count number;
3120 l_ctr_rdg number;
3121 l_sum_rdg number := 0;
3122 l_avg_rdg number;
3123 l_previous_net number;
3124 --
3125 CURSOR CTR_RDGS(d1_counter_id number) is
3126 SELECT net_reading net_rdg,value_timestamp
3127 FROM CSI_COUNTER_READINGS
3128 WHERE counter_id = d1_counter_id
3129 AND value_timestamp <= p_ctr_rdg_rec.value_timestamp
3130 AND NVL(disabled_flag,'N') = 'N'
3131 order by value_timestamp desc;
3132 --
3133 Begin
3134 -- We need n+1 readings to compute the average where n is the filter count. This is because
3135 -- we don't have the previous net_reading in the same record.
3136 --
3137 IF nvl(ctrs.filter_reading_count,0) <= 0 THEN
3138 csi_ctr_gen_utility_pvt.put_line('Invalid Filter Reading count for the Counter '||
3139 to_char(ctrs.counter_id));
3140 csi_ctr_gen_utility_pvt.ExitWithErrMsg
3141 ( p_msg_name => 'CSI_INVD_FILTER_READING_COUNT',
3142 p_token1_name => 'COUNTER_ID',
3143 p_token1_val => to_char(ctrs.counter_id)
3144 );
3145 END IF;
3146 --
3147 l_rec_count := ctrs.filter_reading_count + 1;
3148 l_previous_net := null;
3149 --
3150 FOR ctr_rdgs_rec in CTR_RDGS(ctrs.derive_counter_id) LOOP
3151 j := j+1;
3152 IF l_previous_net IS NOT NULL THEN -- To skip the first one
3153 l_sum_rdg := l_sum_rdg + ABS((l_previous_net) - (ctr_rdgs_rec.net_rdg));
3154 END IF;
3155 IF j = l_rec_count THEN
3156 l_previous_net := ctr_rdgs_rec.net_rdg; -- will be used if j = 1
3157 exit;
3158 END IF;
3159 l_previous_net := ctr_rdgs_rec.net_rdg;
3160 END LOOP;
3161 --
3162 IF j = 1 THEN -- If only one reading was found
3163 l_sum_rdg := l_previous_net;
3164 ELSIF j < l_rec_count THEN -- Not enough readings found
3165 j := j - 1;
3166 ELSE
3167 j := ctrs.filter_reading_count;
3168 END IF;
3169 --
3170 l_ctr_value := round(nvl(l_sum_rdg,0) / j,2);
3171 --
3172 End; -- 'AVERAGE' and 'COUNT' combination
3173 ELSIF ctrs.derive_function = 'AVERAGE' AND ctrs.filter_type = 'TIME' THEN
3174 Declare
3175 CURSOR GET_TIME_UOM_CUR(p_filter_time_uom IN VARCHAR2) IS
3176 select uom_code
3177 from OKC_TIME_CODE_UNITS_V
3178 where uom_code=p_filter_time_uom;
3179 --
3180 CURSOR GET_FIRST_READING(d3_counter_id IN NUMBER) IS
3181 SELECT net_reading,value_timestamp
3182 FROM CSI_COUNTER_READINGS
3183 WHERE counter_id = d3_counter_id
3184 AND NVL(disabled_flag,'N') = 'N'
3185 order by value_timestamp asc;
3186 --
3187 CURSOR CTR_CUR_RDG IS
3188 SELECT net_reading
3189 FROM CSI_COUNTER_READINGS
3190 WHERE counter_value_id = p_ctr_rdg_rec.counter_value_id;
3191 --
3192 l_time_uom VARCHAR2(10);
3193 l_min_date DATE;
3194 l_first_rdg NUMBER;
3195 l_captured_rdg NUMBER;
3196 l_no_of_days NUMBER;
3197 l_target_qty NUMBER;
3198 l_new_datetime DATE := p_ctr_rdg_rec.value_timestamp;
3199 Begin
3200 OPEN GET_TIME_UOM_CUR(ctrs.filter_time_uom);
3201 FETCH GET_TIME_UOM_CUR INTO l_time_uom;
3202 CLOSE GET_TIME_UOM_CUR;
3203 --
3204 OPEN GET_FIRST_READING(ctrs.derive_counter_id);
3205 FETCH GET_FIRST_READING INTO l_first_rdg,l_min_date;
3206 CLOSE GET_FIRST_READING;
3207 --
3208 OPEN CTR_CUR_RDG;
3209 FETCH CTR_CUR_RDG INTO l_captured_rdg;
3210 CLOSE CTR_CUR_RDG;
3211 --
3212 IF l_time_uom IS NULL THEN
3213 csi_ctr_gen_utility_pvt.ExitWithErrMsg
3214 ( p_msg_name => 'CSI_API_CTR_INVALID_FILT_UOM',
3215 p_token1_name => 'UOM_CODE',
3216 p_token1_val => ctrs.filter_time_uom
3217 );
3218 ELSE
3219 DECLARE
3220 l_source_qty number;
3221 l_period_uom_code varchar2(200);
3222 l_status varchar2(2000);
3223 l_offset number :=0;
3224 BEGIN
3225 l_period_uom_code := 'DAY';
3226 l_source_qty := l_new_datetime - l_min_date;
3227 IF l_source_qty = 0 THEN
3228 l_source_qty := 1;
3229 END IF;
3230
3231 l_target_qty := oks_time_measures_pub.get_target_qty(l_min_date,
3232 l_source_qty,
3233 l_period_uom_code,
3234 ctrs.filter_time_uom,
3235 5);
3236
3237 IF l_target_qty = 0 THEN
3238 l_target_qty := 1;
3239 END IF;
3240 l_ctr_value:=round(( l_captured_rdg-l_first_rdg)/l_target_qty,2) ;
3241 END;
3242 END IF; -- get_time_uom check
3243 End; -- 'AVERAGE' and 'TIME' combination
3244 ELSE
3245 i := 1;
3246 lj := 1;
3247 l_sqlstr_init := 'select '||ctrs.derive_function||'( nvl(net_reading,0) )';
3248 l_sqlstr_init := l_sqlstr_init || ' from CSI_COUNTER_READINGS cv ';
3249 l_sqlstr := ' where counter_value_id in (';
3250 l_sqlstr := l_sqlstr || ' select distinct cv1.counter_value_id from ';
3251 l_sqlfrom := ' CSI_COUNTER_READINGS cv1';
3252 l_sqlwhere := '';
3253 --
3254 FOR filts IN der_filters(ctrs.counter_id) LOOP
3255 l_sqlfrom := l_sqlfrom ||', CSI_CTR_PROPERTY_READINGS pv';
3256 l_sqlfrom := l_sqlfrom ||ltrim(rtrim(filts.seq_no));
3257 l_sqlwhere := l_sqlwhere || nvl(filts.left_paren,' ')||' pv';
3258 l_sqlwhere := l_sqlwhere || ltrim(rtrim(filts.seq_no));
3259 l_sqlwhere := l_sqlwhere || '.property_value ';
3260
3261
3262 l_sqlwhere := l_sqlwhere ||filts.relational_operator;
3263
3264 T2(i).BINDVAL_RIGHTVAL := filts.right_value;
3265 T2(i).BINDNAME_RIGHTVAL := ':x_right_value'||ltrim(rtrim(filts.seq_no));
3266
3267 if filts.property_data_type = 'NUMBER' then
3268 l_sqlwhere := l_sqlwhere || ':x_right_value'||ltrim(rtrim(filts.seq_no));
3269 elsif filts.property_data_type = 'DATE' then
3270 l_sqlwhere := l_sqlwhere || 'to_date( '||':x_right_value'||ltrim(rtrim(filts.seq_no))||','||'''DD-MON-RRRR'''||' )';
3271 else
3272 l_sqlwhere := l_sqlwhere || ':x_right_value'||ltrim(rtrim(filts.seq_no));
3273 end if;
3274
3275
3276 l_sqlwhere := l_sqlwhere || nvl(filts.right_paren,' ');
3277 l_sqlwhere := l_sqlwhere || filts.logical_operator;
3278 l_sqlwhere := l_sqlwhere || ' and pv'||ltrim(rtrim(filts.seq_no)) ;
3279 l_sqlwhere := l_sqlwhere || '.counter_value_id = cv.counter_value_id ';
3280 l_sqlwhere := l_sqlwhere || ' and pv'||ltrim(rtrim(filts.seq_no)) ;
3281 l_sqlwhere := l_sqlwhere || '.counter_property_id = ';
3282
3283 T2(i).BINDVAL_CTRPROPID := filts.counter_property_id;
3284 T2(i).BINDNAME_CTRPROPID := ':x_ctr_prop_id'||ltrim(rtrim(filts.seq_no));
3285 l_sqlwhere := l_sqlwhere ||':x_ctr_prop_id'||ltrim(rtrim(filts.seq_no));
3286
3287 l_sqlwhere := l_sqlwhere || ' and cv.counter_id = ';
3288 l_sqlwhere := l_sqlwhere || ':x_derive_counter_id';
3289 --l_sqlwhere := l_sqlwhere || ctrs.derive_counter_id;
3290 END LOOP;
3291 --
3292 if l_sqlwhere is null then
3293 l_sqlstr := l_sqlstr_init || ' where cv.counter_id = :x_derive_counter_id';
3294 l_cursor_handle := dbms_sql.open_cursor;
3295 DBMS_SQL.PARSE(l_cursor_handle, l_sqlstr, dbms_sql.native);
3296 DBMS_SQL.DEFINE_COLUMN(l_cursor_handle,1,l_ctr_value);
3297 BINDVAL_DERIVECTRID := ctrs.derive_counter_id;
3298 DBMS_SQL.BIND_VARIABLE(l_cursor_handle, ':x_derive_counter_id',BINDVAL_DERIVECTRID);
3299 else
3300 l_sqlstr := l_sqlstr_init||l_sqlstr || l_sqlfrom || ' where '||l_sqlwhere||')';
3301 l_cursor_handle := dbms_sql.open_cursor;
3302 DBMS_SQL.PARSE(l_cursor_handle, l_sqlstr, dbms_sql.native);
3303 DBMS_SQL.DEFINE_COLUMN(l_cursor_handle,1,l_ctr_value);
3304
3305 BINDVAL_DERIVECTRID := ctrs.derive_counter_id;
3306 DBMS_SQL.BIND_VARIABLE(l_cursor_handle, ':x_derive_counter_id',BINDVAL_DERIVECTRID);
3307
3308 while lj < i+1
3309 loop
3310 l_bind_varname := t2(lj).BINDNAME_RIGHTVAL;
3311 l_bind_varvalc := t2(lj).BINDVAL_RIGHTVAL;
3312 DBMS_SQL.BIND_VARIABLE(l_cursor_handle, l_bind_varname, l_bind_varvalc);
3313 l_bind_varname := t2(lj).BINDNAME_CTRPROPID;
3314 l_bind_varvaln := t2(lj).BINDVAL_CTRPROPID;
3315 DBMS_SQL.BIND_VARIABLE(l_cursor_handle, l_bind_varname, l_bind_varvaln);
3316 lj:= lj+1;
3317 end loop;
3318 end if;
3319 --
3320 csi_ctr_gen_utility_pvt.put_line('SQL String is '||l_sqlstr);
3321 l_n_temp := dbms_sql.execute(l_cursor_handle);
3322 IF dbms_sql.fetch_rows(l_cursor_handle) > 0 THEN
3323 dbms_sql.column_value(l_cursor_handle,1,l_ctr_value);
3324 END IF;
3325 DBMS_SQL.close_cursor(l_cursor_handle);
3326 END IF;
3327 --
3328 -- Capture Reading
3329 IF l_ctr_value IS NOT NULL THEN
3330 l_ctr_in := l_temp_ctr_rdg_rec;
3331 --
3332 l_ctr_in.COUNTER_ID := ctrs.counter_id;
3333
3334 -- Pass the reading date of the base counter to the group avg ctr and sysdate for sum and count
3335 --
3336 IF ctrs.derive_function = 'AVERAGE' THEN
3337 l_ctr_in.VALUE_TIMESTAMP := base_ctr.base_ctr_timestamp; -- Modified for bug 6852415
3338 ELSE
3339 l_ctr_in.VALUE_TIMESTAMP := sysdate;
3340 END IF;
3341 --
3342 l_ctr_in.COUNTER_READING := l_ctr_value;
3343 l_ctr_in.source_counter_value_id := p_ctr_rdg_rec.counter_value_id;
3344 l_ctr_in.source_code := p_ctr_rdg_rec.source_code;
3345 l_ctr_in.source_line_id := p_ctr_rdg_rec.source_line_id;
3346 --
3347 IF p_mode = 'UPDATE' THEN
3348 UPDATE CSI_COUNTER_READINGS
3349 set counter_reading = l_ctr_value,
3350 net_reading = l_ctr_value,
3351 life_to_date_reading = l_ctr_value,
3352 last_update_date = sysdate,
3353 last_updated_by = fnd_global.user_id
3354 where counter_id = ctrs.counter_id
3355 and value_timestamp = l_ctr_in.value_timestamp
3356 and source_counter_value_id = l_ctr_in.source_counter_value_id;
3357 ELSIF p_mode = 'CREATE' THEN
3358 -- Generate the Value_id for insert
3359 l_process_flag := TRUE;
3360 WHILE l_process_flag LOOP
3361 select CSI_COUNTER_READINGS_S.nextval
3362 into l_ctr_value_id from dual;
3363 IF NOT Counter_Value_Exists(l_ctr_value_id) THEN
3364 l_process_flag := FALSE;
3365 END IF;
3366 END LOOP;
3367 --
3368 -- Call the Table Handler to insert the new reading
3369 CSI_COUNTER_READINGS_PKG.Insert_Row(
3370 px_COUNTER_VALUE_ID => l_ctr_value_id
3371 ,p_COUNTER_ID => l_ctr_in.counter_id
3372 ,p_VALUE_TIMESTAMP => l_ctr_in.value_timestamp
3373 ,p_COUNTER_READING => l_ctr_value
3374 ,p_RESET_MODE => NULL
3375 ,p_RESET_REASON => NULL
3376 ,p_ADJUSTMENT_TYPE => NULL
3377 ,p_ADJUSTMENT_READING => NULL
3378 ,p_OBJECT_VERSION_NUMBER => 1
3379 ,p_LAST_UPDATE_DATE => SYSDATE
3380 ,p_LAST_UPDATED_BY => fnd_global.user_id
3381 ,p_CREATION_DATE => SYSDATE
3382 ,p_CREATED_BY => fnd_global.user_id
3383 ,p_LAST_UPDATE_LOGIN => fnd_global.conc_login_id
3384 ,p_ATTRIBUTE1 => NULL
3385 ,p_ATTRIBUTE2 => NULL
3386 ,p_ATTRIBUTE3 => NULL
3387 ,p_ATTRIBUTE4 => NULL
3388 ,p_ATTRIBUTE5 => NULL
3389 ,p_ATTRIBUTE6 => NULL
3390 ,p_ATTRIBUTE7 => NULL
3391 ,p_ATTRIBUTE8 => NULL
3392 ,p_ATTRIBUTE9 => NULL
3393 ,p_ATTRIBUTE10 => NULL
3394 ,p_ATTRIBUTE11 => NULL
3395 ,p_ATTRIBUTE12 => NULL
3396 ,p_ATTRIBUTE13 => NULL
3397 ,p_ATTRIBUTE14 => NULL
3398 ,p_ATTRIBUTE15 => NULL
3399 ,p_ATTRIBUTE16 => NULL
3400 ,p_ATTRIBUTE17 => NULL
3401 ,p_ATTRIBUTE18 => NULL
3402 ,p_ATTRIBUTE19 => NULL
3403 ,p_ATTRIBUTE20 => NULL
3404 ,p_ATTRIBUTE21 => NULL
3405 ,p_ATTRIBUTE22 => NULL
3406 ,p_ATTRIBUTE23 => NULL
3407 ,p_ATTRIBUTE24 => NULL
3408 ,p_ATTRIBUTE25 => NULL
3409 ,p_ATTRIBUTE26 => NULL
3410 ,p_ATTRIBUTE27 => NULL
3411 ,p_ATTRIBUTE28 => NULL
3412 ,p_ATTRIBUTE29 => NULL
3413 ,p_ATTRIBUTE30 => NULL
3414 ,p_ATTRIBUTE_CATEGORY => NULL
3415 ,p_MIGRATED_FLAG => 'N'
3416 ,p_COMMENTS => NULL
3417 ,p_LIFE_TO_DATE_READING => l_ctr_value
3418 ,p_TRANSACTION_ID => p_txn_rec.transaction_id
3419 ,p_AUTOMATIC_ROLLOVER_FLAG => NULL
3420 ,p_INCLUDE_TARGET_RESETS => NULL
3421 ,p_SOURCE_COUNTER_VALUE_ID => l_ctr_in.source_counter_value_id
3422 ,p_NET_READING => l_ctr_value
3423 ,p_DISABLED_FLAG => 'N'
3424 ,p_SOURCE_CODE => l_ctr_in.source_code
3425 ,p_SOURCE_LINE_ID => l_ctr_in.source_line_id
3426 ,p_INITIAL_READING_FLAG => l_ctr_in.initial_reading_flag
3427 );
3428
3429 --Add call to CSI_COUNTER_PVT.update_ctr_val_max_seq_no
3430 --for bug 7374316
3431 CSI_COUNTER_PVT.update_ctr_val_max_seq_no(
3432 p_api_version => 1.0
3433 ,p_commit => fnd_api.g_false
3434 ,p_init_msg_list => fnd_api.g_true
3435 ,p_validation_level => fnd_api.g_valid_level_full
3436 ,p_counter_id => l_ctr_in.counter_id
3437 ,px_ctr_val_max_seq_no => l_ctr_value_id
3438 ,x_return_status => x_return_status
3439 ,x_msg_count => x_msg_count
3440 ,x_msg_data => x_msg_data
3441 );
3442 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
3443 csi_ctr_gen_utility_pvt.put_line('ERROR FROM CSI_COUNTER_PVT.update_ctr_val_max_seq_no');
3444 l_msg_index := 1;
3445 l_msg_count := x_msg_count;
3446 WHILE l_msg_count > 0 LOOP
3447 x_msg_data := FND_MSG_PUB.GET
3448 ( l_msg_index,
3449 FND_API.G_FALSE
3450 );
3451 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
3452 l_msg_index := l_msg_index + 1;
3453 l_msg_count := l_msg_count - 1;
3454 END LOOP;
3455 RAISE FND_API.G_EXC_ERROR;
3456 END IF;
3457 END IF; -- p_mode check
3458 ELSE
3459 csi_ctr_gen_utility_pvt.put_line('No derive filters computed for '||to_char(ctrs.counter_id));
3460 END IF; -- l_ctr_value check
3461 END LOOP;
3462 -- Start fix bug 6852415, part 3 of 3
3463 END LOOP;
3464 -- End fix bug 6852415, part 3 of 3
3465 EXCEPTION
3466 WHEN FND_API.G_EXC_ERROR THEN
3467 x_return_status := FND_API.G_RET_STS_ERROR ;
3468 ROLLBACK TO compute_derive_counters;
3469 FND_MSG_PUB.Count_And_Get
3470 ( p_count => x_msg_count,
3471 p_data => x_msg_data
3472 );
3473 WHEN OTHERS THEN
3474 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
3475 ROLLBACK TO compute_derive_counters;
3476 IF FND_MSG_PUB.Check_Msg_Level (FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
3477 FND_MSG_PUB.Add_Exc_Msg
3478 ( G_PKG_NAME,
3479 l_api_name
3480 );
3481 END IF;
3482 FND_MSG_PUB.Count_And_Get
3483 ( p_count => x_msg_count,
3484 p_data => x_msg_data
3485 );
3486 IF DBMS_SQL.IS_OPEN(l_cursor_handle) THEN
3487 DBMS_SQL.CLOSE_cursor(l_cursor_handle);
3488 END IF;
3489 END Compute_Derive_Counters;
3490 --
3491 PROCEDURE Compute_Target_Counters
3492 (
3493 p_api_version IN NUMBER
3494 ,p_commit IN VARCHAR2
3495 ,p_init_msg_list IN VARCHAR2
3496 ,p_validation_level IN NUMBER
3497 ,p_txn_rec IN OUT NOCOPY csi_datastructures_pub.transaction_rec
3498 ,p_ctr_rdg_rec IN csi_ctr_datastructures_pub.counter_readings_rec
3499 ,p_mode IN VARCHAR2
3500 ,x_return_status OUT NOCOPY VARCHAR2
3501 ,x_msg_count OUT NOCOPY NUMBER
3502 ,x_msg_data OUT NOCOPY VARCHAR2
3503 )
3504 IS
3505 l_api_name CONSTANT VARCHAR2(30) := 'COMPUTE_TARGET_COUNTERS';
3506 l_api_version CONSTANT NUMBER := 1.0;
3507 l_msg_data VARCHAR2(2000);
3508 l_msg_index NUMBER;
3509 l_msg_count NUMBER;
3510 l_rel_type VARCHAR2(30) := 'CONFIGURATION';
3511 l_counter_reading NUMBER;
3512 l_prev_ctr_reading NUMBER;
3513 l_prev_net_reading NUMBER;
3514 l_prev_ltd_reading NUMBER;
3515 l_prev_value_timestamp DATE;
3516 l_net_reading NUMBER;
3517 l_ltd_reading NUMBER;
3518 l_ctr_rdg_rec csi_ctr_datastructures_pub.counter_readings_rec;
3519 l_temp_ctr_rdg_rec csi_ctr_datastructures_pub.counter_readings_rec;
3520 l_process_flag BOOLEAN;
3521 l_mode VARCHAR2(30);
3522 Process_next EXCEPTION;
3523 l_instance_id NUMBER;
3524 --
3525 CURSOR OBJECT_CTR_CUR IS
3526 select ccr.object_counter_id,nvl(ccr.factor,1) factor,
3527 ccv.direction,ccv.reading_type, ccv.uom_code object_uom_code,
3528 cct.name object_counter_name
3529 from CSI_COUNTER_RELATIONSHIPS ccr,
3530 CSI_COUNTERS_B ccv,
3531 CSI_COUNTERS_TL cct
3532 where ccr.source_counter_id = p_ctr_rdg_rec.counter_id
3533 and ccr.relationship_type_code = l_rel_type
3534 and nvl(ccr.active_start_date,sysdate) <= p_ctr_rdg_rec.value_timestamp
3535 and nvl(ccr.active_end_date,(sysdate+1)) > p_ctr_rdg_rec.value_timestamp
3536 and ccv.counter_id = ccr.object_counter_id
3537 and ccv.counter_id = cct.counter_id
3538 and cct.language = USERENV('LANG');
3539 --
3540 CURSOR UPD_OBJ_CUR IS
3541 SELECT crg.counter_value_id,crg.value_timestamp,crg.counter_id object_counter_id,
3542 crg.adjustment_reading,crg.counter_reading,nvl(ccr.factor,1) factor,
3543 ccv.direction,ccv.reading_type,crg.reset_mode,
3544 ccv.uom_code object_uom_code, cct.name object_counter_name
3545 from CSI_COUNTER_READINGS crg,
3546 CSI_COUNTER_RELATIONSHIPS ccr,
3547 CSI_COUNTERS_B ccv,
3548 CSI_COUNTERS_TL cct
3549 where crg.source_counter_value_id = p_ctr_rdg_rec.counter_value_id
3550 and ccr.object_counter_id = crg.counter_id
3551 and ccr.source_counter_id = p_ctr_rdg_rec.counter_id
3552 and ccr.relationship_type_code = l_rel_type
3553 and ccv.counter_id = crg.counter_id
3554 and ccv.counter_id = cct.counter_id
3555 and cct.language = USERENV('LANG');
3556 --
3557 CURSOR PREV_READING_CUR(p_counter_id IN NUMBER,p_value_timestamp IN DATE) IS
3558 select counter_reading,net_reading,life_to_date_reading,value_timestamp
3559 from CSI_COUNTER_READINGS
3560 where counter_id = p_counter_id
3561 and nvl(disabled_flag,'N') = 'N'
3562 and value_timestamp < p_value_timestamp
3563 ORDER BY value_timestamp desc,counter_value_id desc;
3564 --
3565 CURSOR GET_UOM_CLASS(p_uom_code VARCHAR2) IS
3566 SELECT uom_class
3567 FROM mtl_units_of_measure
3568 WHERE uom_code = p_uom_code;
3569
3570 l_source_uom_class VARCHAR2(10);
3571 l_object_uom_class VARCHAR2(10);
3572 l_source_uom_code VARCHAR2(3);
3573 l_source_direction VARCHAR2(1);
3574 l_uom_rate NUMBER;
3575 l_src_reading_type VARCHAR2(1);
3576 BEGIN
3577 -- Standard Start of API savepoint
3578 SAVEPOINT compute_target_counters;
3579 -- Standard call to check for call compatibility.
3580 IF NOT FND_API.Compatible_API_Call (l_api_version,
3581 p_api_version,
3582 l_api_name ,
3583 G_PKG_NAME ) THEN
3584 RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
3585 END IF;
3586 -- Initialize message list if p_init_msg_list is set to TRUE.
3587 IF FND_API.to_Boolean(nvl(p_init_msg_list,FND_API.G_FALSE)) THEN
3588 FND_MSG_PUB.initialize;
3589 END IF;
3590 -- Initialize API return status to success
3591 x_return_status := FND_API.G_RET_STS_SUCCESS;
3592 --
3593
3594 -- Read the debug profiles values in to global variable 7197402
3595 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
3596
3597 csi_ctr_gen_utility_pvt.put_line( 'compute_target_counters' ||'-'||
3598 p_api_version ||'-'||
3599 p_mode ||'-'||
3600 nvl(p_commit,FND_API.G_FALSE) ||'-'||
3601 nvl(p_init_msg_list,FND_API.G_FALSE) ||'-'||
3602 nvl(p_validation_level,FND_API.G_VALID_LEVEL_FULL) );
3603 --
3604 csi_ctr_gen_utility_pvt.dump_counter_readings_rec(p_ctr_rdg_rec);
3605 --
3606 IF p_txn_rec.transaction_type_id IN (88,91,92,94,95) THEN
3607 l_mode := 'Meter';
3608 ELSE
3609 l_mode := 'Counter';
3610 END IF;
3611 --
3612 IF p_ctr_rdg_rec.counter_id IS NULL OR
3613 p_ctr_rdg_rec.counter_id = FND_API.G_MISS_NUM THEN
3614 csi_ctr_gen_utility_pvt.ExitWithErrMsg
3615 ( p_msg_name => 'CSI_API_CTR_INVALID',
3616 p_token1_name => 'MODE',
3617 p_token1_val => l_mode
3618 );
3619 END IF;
3620 --
3621 IF p_ctr_rdg_rec.value_timestamp IS NULL OR
3622 p_ctr_rdg_rec.value_timestamp = FND_API.G_MISS_DATE THEN
3623 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_INVALID_RDG_DATE');
3624 END IF;
3625 --
3626 -- Fundamental Assumption is, the direction of All Target counters should be same as the Source Counter
3627 --
3628 IF p_mode = 'UPDATE' THEN
3629 csi_ctr_gen_utility_pvt.put_line(' Compute Target Counters - UPDATE');
3630 FOR obj_cur in UPD_OBJ_CUR LOOP
3631 IF NVL(obj_cur.direction,'X') NOT IN ('A','D','B') THEN
3632 csi_ctr_gen_utility_pvt.put_line('Target Counter has Invalid Direction...');
3633 csi_ctr_gen_utility_pvt.ExitWithErrMsg
3634 ( p_msg_name => 'CSI_API_CTR_INVALID_DIR',
3635 p_token1_name => 'MODE',
3636 p_token1_val => l_mode
3637 );
3638 END IF;
3639 --
3640 BEGIN
3641 SELECT uom_code, direction, reading_type
3642 INTO l_source_uom_code, l_source_direction, l_src_reading_type
3643 FROM csi_counters_b
3644 WHERE counter_id = p_ctr_rdg_rec.counter_id;
3645 EXCEPTION
3646 WHEN OTHERS THEN
3647 NULL;
3648 END;
3649
3650 /* Validate direction */
3651 IF obj_cur.direction = 'B' and l_source_direction <> 'B' THEN
3652 CSI_CTR_GEN_UTILITY_PVT.ExitWithErrMsg('CSI_API_CTR_INV_REL_DIR');
3653 END IF;
3654
3655 IF l_source_direction = 'B' and obj_cur.direction <> 'B' THEN
3656 CSI_CTR_GEN_UTILITY_PVT.ExitWithErrMsg('CSI_API_CTR_INV_REL_DIR');
3657 END IF;
3658
3659 IF obj_cur.object_uom_code <> l_source_uom_code THEN
3660 /* Validate if same UOM class */
3661 OPEN get_uom_class(obj_cur.object_uom_code);
3662 FETCH get_uom_class into l_object_uom_class;
3663
3664 IF get_uom_class%notfound THEN
3665 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_ALL_INVALID_UOM_CODE');
3666 END IF;
3667
3668 IF get_uom_class%ISOPEN THEN
3669 CLOSE get_uom_class;
3670 END IF;
3671
3672 OPEN get_uom_class(l_source_uom_code);
3673 FETCH get_uom_class into l_source_uom_class;
3674
3675 IF get_uom_class%notfound THEN
3676 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_ALL_INVALID_UOM_CODE');
3677 END IF;
3678
3679 IF get_uom_class%ISOPEN THEN
3680 CLOSE get_uom_class;
3681 END IF;
3682
3683 IF l_source_uom_class = l_object_uom_class THEN
3684 /* Do a conversion */
3685 INV_CONVERT.INV_UM_CONVERSION(l_source_uom_code
3686 ,obj_cur.object_uom_code
3687 ,null
3688 ,l_uom_rate);
3689
3690 csi_ctr_gen_utility_pvt.put_line('Object UOM Code = '||obj_cur.object_uom_code);
3691 csi_ctr_gen_utility_pvt.put_line('Source UOM Code = '||l_source_uom_code);
3692 csi_ctr_gen_utility_pvt.put_line('UOM Rate = '||to_char(l_uom_rate));
3693 IF l_uom_rate = -99999 then
3694 csi_ctr_gen_utility_pvt.put_line(' Error during the conversion of UOM');
3695 END IF;
3696 ELSE
3697 l_uom_rate := 1;
3698 END IF;
3699 ELSE
3700 l_uom_rate := 1;
3701 END IF;
3702 --
3703 l_prev_ctr_reading := NULL;
3704 l_prev_net_reading := NULL;
3705 l_prev_ltd_reading := NULL;
3706 l_prev_value_timestamp := NULL;
3707 --
3708 OPEN PREV_READING_CUR(obj_cur.object_counter_id,obj_cur.value_timestamp);
3709 FETCH PREV_READING_CUR
3710 INTO l_prev_ctr_reading,
3711 l_prev_net_reading,
3712 l_prev_ltd_reading,
3713 l_prev_value_timestamp;
3714 CLOSE PREV_READING_CUR;
3715 --
3716 -- p_ctr_rdg_rec.counter_reading contains the Usage from the source counter readings
3717 -- Since there is no change to adjustments, no need to take the passed adjustment.
3718 -- It will be same as the obj_cur.adjustment_reading.
3719
3720 IF obj_cur.reset_mode IS NOT NULL THEN
3721 l_counter_reading := p_ctr_rdg_rec.counter_reading;
3722 ELSE
3723 IF obj_cur.reading_type = 1 THEN
3724 IF l_source_direction = 'A' AND obj_cur.direction = 'D' THEN
3725 IF nvl(l_prev_ctr_reading, 0) = 0 THEN
3726 l_counter_reading := ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor) * -1;
3727 ELSE
3728 IF l_prev_ctr_reading < 0 THEN
3729 l_counter_reading := ((l_prev_ctr_reading * -1) - ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor));
3730 l_counter_reading := l_counter_reading * -1;
3731 ELSE
3732 csi_ctr_gen_utility_pvt.put_line('Source is A, Target is D');
3733 csi_ctr_gen_utility_pvt.put_line('l_prev_ctr_reading = '||to_char(l_prev_ctr_reading));
3734 csi_ctr_gen_utility_pvt.put_line('p_ctr_reading = '||to_char(p_ctr_rdg_rec.counter_reading));
3735 csi_ctr_gen_utility_pvt.put_line('l_uom_rate = '||to_char(l_uom_rate));
3736 csi_ctr_gen_utility_pvt.put_line('factor = '||to_char(obj_cur.factor));
3737
3738 l_counter_reading := nvl(l_prev_ctr_reading,0) - ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
3739 END IF;
3740 END IF;
3741 END IF;
3742
3743 IF l_source_direction = 'D' and obj_cur.direction = 'A' THEN
3744 IF nvl(l_prev_ctr_reading, 0) = 0 THEN
3745 l_counter_reading := ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
3746
3747 IF l_counter_reading < 0 THEN
3748 l_counter_reading := l_counter_reading * -1;
3749 END IF;
3750 ELSE
3751 l_counter_reading := nvl(l_prev_ctr_reading,0) + ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
3752 END IF;
3753 END IF;
3754
3755 IF obj_cur.direction = 'A' and l_source_direction = 'A' THEN
3756 l_counter_reading := nvl(l_prev_ctr_reading,0) + ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
3757 ELSIF obj_cur.direction = 'D' and l_source_direction = 'D' THEN
3758 IF nvl(l_prev_ctr_reading, 0) = 0 THEN
3759 l_counter_reading := ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
3760 ELSE
3761 IF l_prev_ctr_reading < 0 THEN
3762 l_counter_reading := ((l_prev_ctr_reading * -1) - ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor));
3763 l_counter_reading := l_counter_reading * -1;
3764 ELSE
3765 l_counter_reading := nvl(l_prev_ctr_reading,0) - ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
3766 END IF;
3767 END IF;
3768 ELSIF obj_cur.direction = 'B' and l_source_direction = 'B' THEN
3769 l_counter_reading := nvl(l_prev_ctr_reading,0) + ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
3770 END IF;
3771 ELSE
3772 l_counter_reading := (p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor;
3773 END IF;
3774 END IF;
3775
3776 -- Calculate Net and LTD Readings
3777 IF obj_cur.reset_mode IS NULL THEN
3778 Calculate_Net_Reading
3779 ( p_prev_net_rdg => l_prev_net_reading
3780 ,p_prev_ltd_rdg => l_prev_ltd_reading
3781 ,p_curr_rdg => l_counter_reading
3782 ,p_prev_rdg => l_prev_ctr_reading
3783 ,p_curr_adj => obj_cur.adjustment_reading
3784 ,p_rdg_type => obj_cur.reading_type
3785 ,p_direction => obj_cur.direction
3786 ,px_net_rdg => l_net_reading
3787 ,px_ltd_rdg => l_ltd_reading
3788 ,l_ctr_rdg_rec => p_ctr_rdg_rec -- added 6398254
3789 );
3790
3791 csi_ctr_gen_utility_pvt.put_line('Prev net reading = '||to_char(l_prev_net_reading));
3792 csi_ctr_gen_utility_pvt.put_line('Prev ltd reading = '||to_char(l_prev_ltd_reading));
3793 csi_ctr_gen_utility_pvt.put_line('Prev reading = '||to_char(l_prev_ctr_reading));
3794 csi_ctr_gen_utility_pvt.put_line('5. Current reading = '||to_char(l_counter_reading));
3795 IF obj_cur.direction = 'D' THEN
3796 IF l_counter_reading > nvl(l_prev_ctr_reading, l_counter_reading) THEN
3797 csi_ctr_gen_utility_pvt.ExitWithErrMsg
3798 ( p_msg_name => 'CSI_API_CTR_INV_RDG',
3799 p_token1_name => 'DIRECTION',
3800 -- p_token1_val => obj_cur.direction,
3801 p_token1_val => 'a Descending',
3802 p_token2_name => 'MODE',
3803 p_token2_val => l_mode,
3804 p_token3_name => 'CTR_NAME',
3805 p_token3_val => obj_cur.object_counter_name
3806 );
3807 END IF;
3808 ELSIF obj_cur.direction = 'A' THEN
3809 IF l_counter_reading < nvl(l_prev_ctr_reading, l_counter_reading) THEN
3810 csi_ctr_gen_utility_pvt.put_line('6. Current reading ');
3811 csi_ctr_gen_utility_pvt.ExitWithErrMsg
3812 ( p_msg_name => 'CSI_API_CTR_INV_RDG',
3813 p_token1_name => 'DIRECTION',
3814 -- p_token1_val => obj_cur.direction,
3815 p_token1_val => 'an Ascending',
3816 p_token2_name => 'MODE',
3817 p_token2_val => l_mode,
3818 p_token3_name => 'CTR_NAME',
3819 p_token3_val => obj_cur.object_counter_name
3820 );
3821 END IF;
3822 END IF;
3823 ELSE
3824 l_net_reading := l_prev_net_reading;
3825 l_ltd_reading := l_prev_ltd_reading;
3826 END IF;
3827 --
3828 csi_ctr_gen_utility_pvt.put_line('Updating Target Counter Value ID : '||to_char(obj_cur.counter_value_id));
3829
3830 Update CSI_COUNTER_READINGS
3831 set counter_reading = l_counter_reading,
3832 net_reading = l_net_reading,
3833 life_to_date_reading = l_ltd_reading,
3834 last_update_date = sysdate,
3835 last_updated_by = fnd_global.user_id
3836 where counter_value_id = obj_cur.counter_value_id;
3837 END LOOP;
3838 ELSIF p_mode = 'CREATE' THEN
3839 csi_ctr_gen_utility_pvt.put_line(' Compute Target Counters - CREATE');
3840 FOR obj_cur IN OBJECT_CTR_CUR LOOP
3841 Begin
3842 IF NVL(obj_cur.direction,'X') NOT IN ('A','D','B') THEN
3843 csi_ctr_gen_utility_pvt.put_line('Target Counter has Invalid Direction...');
3844 csi_ctr_gen_utility_pvt.ExitWithErrMsg
3845 ( p_msg_name => 'CSI_API_CTR_INVALID_DIR',
3846 p_token1_name => 'MODE',
3847 p_token1_val => l_mode
3848 );
3849 END IF;
3850 --
3851 BEGIN
3852 SELECT uom_code, direction, reading_type
3853 INTO l_source_uom_code, l_source_direction, l_src_reading_type
3854 FROM csi_counters_b
3855 WHERE counter_id = p_ctr_rdg_rec.counter_id;
3856 EXCEPTION
3857 WHEN OTHERS THEN
3858 NULL;
3859 END;
3860
3861 /* Validate direction */
3862 IF obj_cur.direction = 'B' and l_source_direction <> 'B' THEN
3863 CSI_CTR_GEN_UTILITY_PVT.ExitWithErrMsg('CSI_API_CTR_INV_REL_DIR');
3864 END IF;
3865
3866 IF l_source_direction = 'B' and obj_cur.direction <> 'B' THEN
3867 CSI_CTR_GEN_UTILITY_PVT.ExitWithErrMsg('CSI_API_CTR_INV_REL_DIR');
3868 END IF;
3869
3870 IF obj_cur.object_uom_code <> l_source_uom_code THEN
3871 /* Validate if same UOM class */
3872 OPEN get_uom_class(obj_cur.object_uom_code);
3873 FETCH get_uom_class into l_object_uom_class;
3874
3875 IF get_uom_class%notfound THEN
3876 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_ALL_INVALID_UOM_CODE');
3877 END IF;
3878
3879 IF get_uom_class%ISOPEN THEN
3880 CLOSE get_uom_class;
3881 END IF;
3882
3883 OPEN get_uom_class(l_source_uom_code);
3884 FETCH get_uom_class into l_source_uom_class;
3885
3886 IF get_uom_class%notfound THEN
3887 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_ALL_INVALID_UOM_CODE');
3888 END IF;
3889
3890 IF get_uom_class%ISOPEN THEN
3891 CLOSE get_uom_class;
3892 END IF;
3893
3894 IF l_source_uom_class = l_object_uom_class THEN
3895 /* Do a conversion */
3896 INV_CONVERT.INV_UM_CONVERSION(l_source_uom_code
3897 ,obj_cur.object_uom_code
3898 ,null
3899 ,l_uom_rate);
3900
3901 csi_ctr_gen_utility_pvt.put_line('Object UOM Code = '||obj_cur.object_uom_code);
3902 csi_ctr_gen_utility_pvt.put_line('Source UOM Code = '||l_source_uom_code);
3903 csi_ctr_gen_utility_pvt.put_line('UOM Rate = '||to_char(l_uom_rate));
3904 IF l_uom_rate = -99999 then
3905 csi_ctr_gen_utility_pvt.put_line(' Error during the conversion of UOM');
3906 END IF;
3907 ELSE
3908 l_uom_rate := 1;
3909 END IF;
3910 ELSE
3911 l_uom_rate := 1;
3912 END IF;
3913
3914 --
3915 l_ctr_rdg_rec := l_temp_ctr_rdg_rec;
3916 --
3917 l_ctr_rdg_rec.counter_id := obj_cur.object_counter_id;
3918 l_ctr_rdg_rec.value_timestamp := p_ctr_rdg_rec.value_timestamp;
3919 l_ctr_rdg_rec.adjustment_type := p_ctr_rdg_rec.adjustment_type;
3920 l_ctr_rdg_rec.adjustment_reading := p_ctr_rdg_rec.adjustment_reading;
3921 l_ctr_rdg_rec.source_counter_value_id := p_ctr_rdg_rec.counter_value_id;
3922 l_ctr_rdg_rec.source_code := p_ctr_rdg_rec.source_code;
3923 l_ctr_rdg_rec.source_line_id := p_ctr_rdg_rec.source_line_id;
3924 l_ctr_rdg_rec.comments := p_ctr_rdg_rec.comments;
3925 --
3926 -- Get the last reading for this counter
3927 l_prev_ctr_reading := NULL;
3928 l_prev_net_reading := NULL;
3929 l_prev_ltd_reading := NULL;
3930 l_prev_value_timestamp := NULL;
3931 --
3932 OPEN PREV_READING_CUR(obj_cur.object_counter_id,p_ctr_rdg_rec.value_timestamp);
3933 FETCH PREV_READING_CUR
3934 INTO l_prev_ctr_reading,
3935 l_prev_net_reading,
3936 l_prev_ltd_reading,
3937 l_prev_value_timestamp;
3938 CLOSE PREV_READING_CUR;
3939 --
3940 IF l_prev_ctr_reading IS NULL AND
3941 (p_ctr_rdg_rec.adjustment_type IS NOT NULL AND
3942 p_ctr_rdg_rec.adjustment_type <> FND_API.G_MISS_CHAR) THEN
3943 csi_ctr_gen_utility_pvt.put_line('First reading of this Target Counter '||
3944 to_char(obj_cur.object_counter_id)||' cannot be an Adjustment reading. Ingoring it..');
3945 Raise Process_next;
3946 END IF;
3947 --
3948 /* Check if the readings needed to be reverse based on the
3949 source and target direction combination */
3950
3951 csi_ctr_gen_utility_pvt.put_line('Reading Type = '||to_char(obj_cur.reading_type));
3952 csi_ctr_gen_utility_pvt.put_line('Source Direction = '||l_source_direction);
3953 csi_ctr_gen_utility_pvt.put_line('Object Direction = '||obj_cur.direction);
3954 csi_ctr_gen_utility_pvt.put_line('Factor = '||to_char(obj_cur.factor));
3955 csi_ctr_gen_utility_pvt.put_line('UOM Rate = '||to_char(l_uom_rate));
3956 csi_ctr_gen_utility_pvt.put_line('target prev rdg = '||to_char(l_prev_ctr_reading));
3957 csi_ctr_gen_utility_pvt.put_line('source prev rdg = '||to_char(p_ctr_rdg_rec.counter_reading));
3958 IF obj_cur.reading_type = 1 THEN
3959 IF l_source_direction = 'A' AND obj_cur.direction = 'D' THEN
3960 IF nvl(l_prev_ctr_reading, 0) = 0 THEN
3961 l_counter_reading := ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor) * -1;
3962 IF p_ctr_rdg_rec.adjustment_reading is not null and p_ctr_rdg_rec.adjustment_reading <> FND_API.G_MISS_NUM then
3963 l_ctr_rdg_rec.adjustment_reading := ((p_ctr_rdg_rec.adjustment_reading * l_uom_rate) * obj_cur.factor) * -1;
3964 END IF;
3965 ELSE
3966 IF l_prev_ctr_reading < 0 THEN
3967 l_counter_reading := ((l_prev_ctr_reading * -1) - (((p_ctr_rdg_rec.counter_reading * -1) * l_uom_rate) * obj_cur.factor));
3968 l_counter_reading := l_counter_reading * -1;
3969 IF p_ctr_rdg_rec.adjustment_reading is not null and p_ctr_rdg_rec.adjustment_reading <> FND_API.G_MISS_NUM then
3970 l_ctr_rdg_rec.adjustment_reading := (p_ctr_rdg_rec.adjustment_reading * l_uom_rate) * obj_cur.factor;
3971 l_ctr_rdg_rec.adjustment_reading := l_ctr_rdg_rec.adjustment_reading * -1;
3972 END IF;
3973 ELSE
3974 l_counter_reading := nvl(l_prev_ctr_reading,0) - ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
3975 IF p_ctr_rdg_rec.adjustment_reading is not null and p_ctr_rdg_rec.adjustment_reading <> FND_API.G_MISS_NUM then
3976 l_ctr_rdg_rec.adjustment_reading := (p_ctr_rdg_rec.adjustment_reading * l_uom_rate) * obj_cur.factor;
3977 END IF;
3978 END IF;
3979 END IF;
3980 csi_ctr_gen_utility_pvt.put_line('New target reading = '||to_char(l_counter_reading));
3981 END IF;
3982
3983
3984 IF l_source_direction = 'D' and obj_cur.direction = 'A' THEN
3985 IF nvl(l_prev_ctr_reading, 0) = 0 THEN
3986 l_counter_reading := ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
3987
3988 IF l_counter_reading < 0 THEN
3989 l_counter_reading := l_counter_reading * -1;
3990 END IF;
3991
3992 IF p_ctr_rdg_rec.adjustment_reading is not null and p_ctr_rdg_rec.adjustment_reading <> FND_API.G_MISS_NUM then
3993 l_ctr_rdg_rec.adjustment_reading := ((p_ctr_rdg_rec.adjustment_reading * l_uom_rate) * obj_cur.factor);
3994
3995 IF l_ctr_rdg_rec.adjustment_reading < 0 THEN
3996 l_ctr_rdg_rec.adjustment_reading := l_ctr_rdg_rec.adjustment_reading * -1;
3997 END IF;
3998 END IF;
3999 ELSE
4000 l_counter_reading := nvl(l_prev_ctr_reading,0) + ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
4001 IF p_ctr_rdg_rec.adjustment_reading is not null and p_ctr_rdg_rec.adjustment_reading <> FND_API.G_MISS_NUM then
4002 l_ctr_rdg_rec.adjustment_reading := (p_ctr_rdg_rec.adjustment_reading * l_uom_rate) * obj_cur.factor;
4003 END IF;
4004 END IF;
4005 END IF;
4006 csi_ctr_gen_utility_pvt.put_line('New target reading = '||to_char(l_counter_reading));
4007
4008 IF obj_cur.direction = 'A' and l_source_direction = 'A' THEN
4009 l_counter_reading := nvl(l_prev_ctr_reading,0) + ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
4010 IF p_ctr_rdg_rec.adjustment_reading is not null and p_ctr_rdg_rec.adjustment_reading <> FND_API.G_MISS_NUM then
4011 l_ctr_rdg_rec.adjustment_reading := (p_ctr_rdg_rec.adjustment_reading * l_uom_rate) * obj_cur.factor;
4012 END IF;
4013 ELSIF obj_cur.direction = 'D' and l_source_direction = 'D' THEN
4014 IF nvl(l_prev_ctr_reading, 0) = 0 THEN
4015 l_counter_reading := ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
4016 IF p_ctr_rdg_rec.adjustment_reading is not null and p_ctr_rdg_rec.adjustment_reading <> FND_API.G_MISS_NUM then
4017 l_ctr_rdg_rec.adjustment_reading := ((p_ctr_rdg_rec.adjustment_reading * l_uom_rate) * obj_cur.factor);
4018 END IF;
4019 ELSE
4020 IF l_prev_ctr_reading < 0 THEN
4021 l_counter_reading := ((l_prev_ctr_reading * -1) - ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor));
4022 l_counter_reading := l_counter_reading * -1;
4023 IF p_ctr_rdg_rec.adjustment_reading is not null and p_ctr_rdg_rec.adjustment_reading <> FND_API.G_MISS_NUM then
4024 l_ctr_rdg_rec.adjustment_reading := (p_ctr_rdg_rec.adjustment_reading * l_uom_rate) * obj_cur.factor;
4025 l_ctr_rdg_rec.adjustment_reading := l_ctr_rdg_rec.adjustment_reading * -1;
4026 END IF;
4027 ELSE
4028 l_counter_reading := nvl(l_prev_ctr_reading,0) - ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
4029 IF p_ctr_rdg_rec.adjustment_reading is not null then
4030 l_ctr_rdg_rec.adjustment_reading := (p_ctr_rdg_rec.adjustment_reading * l_uom_rate) * obj_cur.factor;
4031 END IF;
4032 END IF;
4033 END IF;
4034 csi_ctr_gen_utility_pvt.put_line('New target reading = '||to_char(l_counter_reading));
4035 ELSIF obj_cur.direction = 'B' and l_source_direction = 'B' THEN
4036 l_counter_reading := nvl(l_prev_ctr_reading,0) + ((p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor);
4037 IF p_ctr_rdg_rec.adjustment_reading is not null and p_ctr_rdg_rec.adjustment_reading <> FND_API.G_MISS_NUM then
4038 l_ctr_rdg_rec.adjustment_reading := (p_ctr_rdg_rec.adjustment_reading * l_uom_rate) * obj_cur.factor;
4039 END IF;
4040 END IF;
4041 ELSE
4042 l_counter_reading := (p_ctr_rdg_rec.counter_reading * l_uom_rate) * obj_cur.factor;
4043 IF p_ctr_rdg_rec.adjustment_reading is not null and p_ctr_rdg_rec.adjustment_reading <> FND_API.G_MISS_NUM then
4044 l_ctr_rdg_rec.adjustment_reading := (p_ctr_rdg_rec.adjustment_reading * l_uom_rate) * obj_cur.factor;
4045 END IF;
4046 END IF;
4047
4048 csi_ctr_gen_utility_pvt.put_line('New target reading = '||to_char(l_counter_reading));
4049 -- Calculate Net and LTD Readings
4050 Calculate_Net_Reading
4051 ( p_prev_net_rdg => l_prev_net_reading
4052 ,p_prev_ltd_rdg => l_prev_ltd_reading
4053 ,p_curr_rdg => l_counter_reading
4054 ,p_prev_rdg => l_prev_ctr_reading
4055 ,p_curr_adj => l_ctr_rdg_rec.adjustment_reading
4056 ,p_rdg_type => obj_cur.reading_type
4057 ,p_direction => obj_cur.direction
4058 ,px_net_rdg => l_net_reading
4059 ,px_ltd_rdg => l_ltd_reading
4060 ,l_ctr_rdg_rec => p_ctr_rdg_rec -- added 6398254
4061 );
4062
4063 csi_ctr_gen_utility_pvt.put_line('Current reading = '||to_char(l_counter_reading));
4064 IF obj_cur.direction = 'D' THEN
4065 IF l_counter_reading > nvl(l_prev_ctr_reading, l_counter_reading) THEN
4066 csi_ctr_gen_utility_pvt.put_line('7. Current reading ');
4067 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4068 ( p_msg_name => 'CSI_API_CTR_INV_RDG',
4069 p_token1_name => 'DIRECTION',
4070 -- p_token1_val => obj_cur.direction,
4071 p_token1_val => 'a Descending',
4072 p_token2_name => 'MODE',
4073 p_token2_val => l_mode,
4074 p_token3_name => 'CTR_NAME',
4075 p_token3_val => obj_cur.object_counter_name
4076 );
4077 END IF;
4078 ELSIF obj_cur.direction = 'A' THEN
4079 IF l_counter_reading < nvl(l_prev_ctr_reading, l_counter_reading) THEN
4080 csi_ctr_gen_utility_pvt.put_line('8. Current reading ');
4081 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4082 ( p_msg_name => 'CSI_API_CTR_INV_RDG',
4083 p_token1_name => 'DIRECTION',
4084 -- p_token1_val => obj_cur.direction,
4085 p_token1_val => 'an Ascending',
4086 p_token2_name => 'MODE',
4087 p_token2_val => l_mode,
4088 p_token3_name => 'CTR_NAME',
4089 p_token3_val => obj_cur.object_counter_name
4090 );
4091 END IF;
4092 END IF;
4093
4094 --
4095 IF p_txn_rec.transaction_type_id in (88,91,92,94,95) THEN
4096 IF p_txn_rec.transaction_type_id = 91 THEN
4097 l_instance_id := p_txn_rec.source_header_ref_id;
4098 ELSE
4099 l_instance_id := null;
4100 END IF;
4101 csi_ctr_gen_utility_pvt.put_line('Calling Insert Meter Log...');
4102 Eam_Asset_Log_Pvt.Insert_Meter_Log
4103 (
4104 P_api_version => 1.0,
4105 P_init_msg_list => fnd_api.g_false,
4106 P_commit => fnd_api.g_false,
4107 P_validation_level => fnd_api.g_valid_level_full,
4108 P_event_date => l_ctr_rdg_rec.value_timestamp,
4109 P_instance_id => l_instance_id,
4110 P_ref_id => l_ctr_rdg_rec.counter_id,
4111 X_return_status => x_return_status,
4112 X_msg_count => x_msg_count,
4113 X_msg_data => x_msg_data
4114 );
4115 -- Since this is only for logging we are ignoring the x_return_status.
4116 -- Just report the API error and proceed.
4117 --
4118 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
4119 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Insert_Meter_Log API ');
4120 l_msg_index := 1;
4121 l_msg_count := x_msg_count;
4122 WHILE l_msg_count > 0 LOOP
4123 x_msg_data := FND_MSG_PUB.GET
4124 ( l_msg_index,
4125 FND_API.G_FALSE
4126 );
4127 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
4128 l_msg_index := l_msg_index + 1;
4129 l_msg_count := l_msg_count - 1;
4130 END LOOP;
4131 -- DO NOT RAISE ERROR
4132 END IF;
4133 END IF; -- EAM Logging Check
4134 --
4135 IF p_txn_rec.transaction_type_id = 92 THEN
4136 csi_ctr_gen_utility_pvt.put_line('Calling Update_Last_Service_Reading_Wo...');
4137 Eam_Meters_Util.Update_Last_Service_Reading_Wo
4138 (
4139 p_wip_entity_id => p_txn_rec.source_header_ref_id,
4140 p_meter_id => l_ctr_rdg_rec.counter_id,
4141 p_meter_reading => l_counter_reading,
4142 p_wo_end_date => l_ctr_rdg_rec.value_timestamp,
4143 X_return_status => x_return_status,
4144 X_msg_count => x_msg_count,
4145 X_msg_data => x_msg_data
4146 );
4147 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
4148 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Update_Last_Service_Reading_Wo API ');
4149 l_msg_index := 1;
4150 l_msg_count := x_msg_count;
4151 WHILE l_msg_count > 0 LOOP
4152 x_msg_data := FND_MSG_PUB.GET
4153 ( l_msg_index,
4154 FND_API.G_FALSE
4155 );
4156 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
4157 l_msg_index := l_msg_index + 1;
4158 l_msg_count := l_msg_count - 1;
4159 END LOOP;
4160 RAISE FND_API.G_EXC_ERROR;
4161 END IF;
4162 END IF; -- Call Update_Last_Service_Reading_WO check
4163
4164 --
4165 -- Generate the Value_id for insert
4166 l_process_flag := TRUE;
4167 WHILE l_process_flag LOOP
4168 select CSI_COUNTER_READINGS_S.nextval
4169 into l_ctr_rdg_rec.counter_value_id from dual;
4170 IF NOT Counter_Value_Exists(l_ctr_rdg_rec.counter_value_id) THEN
4171 l_process_flag := FALSE;
4172 END IF;
4173 END LOOP;
4174 --
4175 csi_ctr_gen_utility_pvt.put_line('Inserting Target Counter ID : '||to_char(l_ctr_rdg_rec.counter_id));
4176 -- Call the Table Handler to insert into CSI_COUNTER_READINGS
4177 CSI_COUNTER_READINGS_PKG.Insert_Row(
4178 px_COUNTER_VALUE_ID => l_ctr_rdg_rec.counter_value_id
4179 ,p_COUNTER_ID => l_ctr_rdg_rec.counter_id
4180 ,p_VALUE_TIMESTAMP => l_ctr_rdg_rec.value_timestamp
4181 ,p_COUNTER_READING => l_counter_reading
4182 ,p_RESET_MODE => p_ctr_rdg_rec.reset_mode -- NULL 6398254
4183 ,p_RESET_REASON => p_ctr_rdg_rec.reset_reason -- NULL 6398254
4184 ,p_ADJUSTMENT_TYPE => l_ctr_rdg_rec.adjustment_type
4185 ,p_ADJUSTMENT_READING => l_ctr_rdg_rec.adjustment_reading
4186 ,p_OBJECT_VERSION_NUMBER => 1
4187 ,p_LAST_UPDATE_DATE => SYSDATE
4188 ,p_LAST_UPDATED_BY => fnd_global.user_id
4189 ,p_CREATION_DATE => SYSDATE
4190 ,p_CREATED_BY => fnd_global.user_id
4191 ,p_LAST_UPDATE_LOGIN => fnd_global.conc_login_id
4192 ,p_ATTRIBUTE1 => l_ctr_rdg_rec.attribute1
4193 ,p_ATTRIBUTE2 => l_ctr_rdg_rec.attribute2
4194 ,p_ATTRIBUTE3 => l_ctr_rdg_rec.attribute3
4195 ,p_ATTRIBUTE4 => l_ctr_rdg_rec.attribute4
4196 ,p_ATTRIBUTE5 => l_ctr_rdg_rec.attribute5
4197 ,p_ATTRIBUTE6 => l_ctr_rdg_rec.attribute6
4198 ,p_ATTRIBUTE7 => l_ctr_rdg_rec.attribute7
4199 ,p_ATTRIBUTE8 => l_ctr_rdg_rec.attribute8
4200 ,p_ATTRIBUTE9 => l_ctr_rdg_rec.attribute9
4201 ,p_ATTRIBUTE10 => l_ctr_rdg_rec.attribute10
4202 ,p_ATTRIBUTE11 => l_ctr_rdg_rec.attribute11
4203 ,p_ATTRIBUTE12 => l_ctr_rdg_rec.attribute12
4204 ,p_ATTRIBUTE13 => l_ctr_rdg_rec.attribute13
4205 ,p_ATTRIBUTE14 => l_ctr_rdg_rec.attribute14
4206 ,p_ATTRIBUTE15 => l_ctr_rdg_rec.attribute15
4207 ,p_ATTRIBUTE16 => l_ctr_rdg_rec.attribute16
4208 ,p_ATTRIBUTE17 => l_ctr_rdg_rec.attribute17
4209 ,p_ATTRIBUTE18 => l_ctr_rdg_rec.attribute18
4210 ,p_ATTRIBUTE19 => l_ctr_rdg_rec.attribute19
4211 ,p_ATTRIBUTE20 => l_ctr_rdg_rec.attribute20
4212 ,p_ATTRIBUTE21 => l_ctr_rdg_rec.attribute21
4213 ,p_ATTRIBUTE22 => l_ctr_rdg_rec.attribute22
4214 ,p_ATTRIBUTE23 => l_ctr_rdg_rec.attribute23
4215 ,p_ATTRIBUTE24 => l_ctr_rdg_rec.attribute24
4216 ,p_ATTRIBUTE25 => l_ctr_rdg_rec.attribute25
4217 ,p_ATTRIBUTE26 => l_ctr_rdg_rec.attribute26
4218 ,p_ATTRIBUTE27 => l_ctr_rdg_rec.attribute27
4219 ,p_ATTRIBUTE28 => l_ctr_rdg_rec.attribute28
4220 ,p_ATTRIBUTE29 => l_ctr_rdg_rec.attribute29
4221 ,p_ATTRIBUTE30 => l_ctr_rdg_rec.attribute30
4222 ,p_ATTRIBUTE_CATEGORY => l_ctr_rdg_rec.attribute_category
4223 ,p_MIGRATED_FLAG => 'N'
4224 ,p_COMMENTS => l_ctr_rdg_rec.comments
4225 ,p_LIFE_TO_DATE_READING => l_ltd_reading
4226 ,p_TRANSACTION_ID => p_txn_rec.transaction_id
4227 ,p_AUTOMATIC_ROLLOVER_FLAG => l_ctr_rdg_rec.automatic_rollover_flag
4228 ,p_INCLUDE_TARGET_RESETS => l_ctr_rdg_rec.include_target_resets
4229 ,p_SOURCE_COUNTER_VALUE_ID => l_ctr_rdg_rec.source_counter_value_id
4230 ,p_NET_READING => l_net_reading
4231 ,p_DISABLED_FLAG => 'N'
4232 ,p_SOURCE_CODE => l_ctr_rdg_rec.source_code
4233 ,p_SOURCE_LINE_ID => l_ctr_rdg_rec.source_line_id
4234 ,p_INITIAL_READING_FLAG => l_ctr_rdg_rec.initial_reading_flag
4235 );
4236
4237 --Add call to CSI_COUNTER_PVT.update_ctr_val_max_seq_no
4238 --for bug 7374316
4239 CSI_COUNTER_PVT.update_ctr_val_max_seq_no(
4240 p_api_version => 1.0
4241 ,p_commit => fnd_api.g_false
4242 ,p_init_msg_list => fnd_api.g_true
4243 ,p_validation_level => fnd_api.g_valid_level_full
4244 ,p_counter_id => l_ctr_rdg_rec.counter_id
4245 ,px_ctr_val_max_seq_no => l_ctr_rdg_rec.counter_value_id
4246 ,x_return_status => x_return_status
4247 ,x_msg_count => x_msg_count
4248 ,x_msg_data => x_msg_data
4249 );
4250 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
4251 csi_ctr_gen_utility_pvt.put_line('ERROR FROM CSI_COUNTER_PVT.update_ctr_val_max_seq_no');
4252 l_msg_index := 1;
4253 l_msg_count := x_msg_count;
4254 WHILE l_msg_count > 0 LOOP
4255 x_msg_data := FND_MSG_PUB.GET
4256 ( l_msg_index,
4257 FND_API.G_FALSE
4258 );
4259 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
4260 l_msg_index := l_msg_index + 1;
4261 l_msg_count := l_msg_count - 1;
4262 END LOOP;
4263 RAISE FND_API.G_EXC_ERROR;
4264 END IF;
4265 Exception
4266 when Process_next then
4267 null;
4268 End;
4269 END LOOP; -- Obj Cursor
4270 END IF; -- p_mode check
4271 --
4272 IF FND_API.to_Boolean(nvl(p_commit,FND_API.G_FALSE)) THEN
4273 COMMIT WORK;
4274 END IF;
4275 --
4276 -- Standard call to get message count and IF count is get message info.
4277 FND_MSG_PUB.Count_And_Get
4278 ( p_count => x_msg_count,
4279 p_data => x_msg_data
4280 );
4281 EXCEPTION
4282 WHEN FND_API.G_EXC_ERROR THEN
4283 x_return_status := FND_API.G_RET_STS_ERROR ;
4284 ROLLBACK TO compute_target_counters;
4285 FND_MSG_PUB.Count_And_Get
4286 ( p_count => x_msg_count,
4287 p_data => x_msg_data
4288 );
4289 WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
4290 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4291 ROLLBACK TO compute_target_counters;
4292 FND_MSG_PUB.Count_And_Get
4293 ( p_count => x_msg_count,
4294 p_data => x_msg_data
4295 );
4296 WHEN OTHERS THEN
4297 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
4298 ROLLBACK TO compute_target_counters;
4299 IF FND_MSG_PUB.Check_Msg_Level (FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
4300 FND_MSG_PUB.Add_Exc_Msg
4301 ( G_PKG_NAME,
4302 l_api_name
4303 );
4304 END IF;
4305 FND_MSG_PUB.Count_And_Get
4306 ( p_count => x_msg_count,
4307 p_data => x_msg_data
4308 );
4309 END Compute_Target_Counters;
4310 --
4311 /*----------------------------------------------------*/
4312 /* procedure name: Update_Counter_Reading */
4313 /* description : procedure used to */
4314 /* disable counter readings */
4315 /*----------------------------------------------------*/
4316
4317 PROCEDURE Update_Counter_Reading
4318 (
4319 p_api_version IN NUMBER
4320 ,p_commit IN VARCHAR2
4321 ,p_init_msg_list IN VARCHAR2
4322 ,p_validation_level IN NUMBER
4323 ,p_ctr_rdg_rec IN OUT NOCOPY csi_ctr_datastructures_pub.counter_readings_rec
4324 ,x_return_status OUT NOCOPY VARCHAR2
4325 ,x_msg_count OUT NOCOPY NUMBER
4326 ,x_msg_data OUT NOCOPY VARCHAR2
4327 )
4328 IS
4329 l_api_name CONSTANT VARCHAR2(30) := 'UPDATE_COUNTER_READING_PVT';
4330 l_api_version CONSTANT NUMBER := 1.0;
4331 l_msg_data VARCHAR2(2000);
4332 l_msg_index NUMBER;
4333 l_msg_count NUMBER;
4334 l_prev_ctr_reading NUMBER;
4335 l_prev_net_reading NUMBER;
4336 l_prev_ltd_reading NUMBER;
4337 l_prev_value_timestamp DATE;
4338 l_next_ctr_reading NUMBER;
4339 l_next_value_timestamp DATE;
4340 l_next_reset_mode VARCHAR2(30);
4341 l_next_adj_type VARCHAR2(30);
4342 l_next_auto_rollover VARCHAR2(1);
4343 l_later_ctr_reading NUMBER;
4344 l_adj_ctr NUMBER;
4345 l_ctr_name VARCHAR2(50);
4346 l_ctr_type VARCHAR2(30);
4347 l_rollover_last_rdg NUMBER;
4348 l_rollover_first_rdg NUMBER;
4349 l_direction VARCHAR2(1);
4350 l_reading_type NUMBER;
4351 l_auto_rollover VARCHAR2(1);
4352 l_net_reading NUMBER;
4353 l_ltd_reading NUMBER;
4354 l_previous_rdg NUMBER;
4355 l_upd_previous_rdg NUMBER;
4356 l_previous_net NUMBER;
4357 l_previous_ltd NUMBER;
4358 l_process_flag BOOLEAN := TRUE;
4359 l_seq_num NUMBER;
4360 l_rdg_lock_date DATE;
4361 l_target_ctr_rec csi_ctr_datastructures_pub.counter_readings_rec;
4362 l_temp_ctr_rdg_rec csi_ctr_datastructures_pub.counter_readings_rec;
4363 l_exists VARCHAR2(1);
4364 l_update_loop BOOLEAN := FALSE;
4365 l_upd_fl_rdg_rec csi_ctr_datastructures_pub.counter_readings_rec;
4366 l_derive_ctr_rec csi_ctr_datastructures_pub.counter_readings_rec;
4367 l_txn_rec csi_datastructures_pub.transaction_rec;
4368 l_mode VARCHAR2(30);
4369 l_txn_type_id NUMBER;
4370 l_ctr_val_max_seq_no NUMBER;
4371 --
4372 CURSOR CURRENT_READING_CUR(p_counter_value_id IN NUMBER) IS
4373 select * from
4374 CSI_COUNTER_READINGS
4375 where counter_value_id = p_counter_value_id;
4376 --
4377 l_curr_ctr_rdg_rec CURRENT_READING_CUR%rowtype;
4378 --
4379 CURSOR PREV_READING_CUR(p_counter_id IN NUMBER,p_value_timestamp IN DATE) IS
4380 select counter_reading,net_reading,life_to_date_reading,value_timestamp
4381 from CSI_COUNTER_READINGS
4382 where counter_id = p_counter_id
4383 and nvl(disabled_flag,'N') = 'N'
4384 and value_timestamp < p_value_timestamp
4385 ORDER BY value_timestamp desc,counter_value_id desc;
4386 --
4387 CURSOR NEXT_READING_CUR(p_counter_id IN NUMBER,p_value_timestamp IN DATE) IS
4388 select counter_reading,value_timestamp,reset_mode,
4389 adjustment_type,automatic_rollover_flag
4390 from CSI_COUNTER_READINGS
4391 where counter_id = p_counter_id
4392 and nvl(disabled_flag,'N') = 'N'
4393 and value_timestamp > p_value_timestamp
4394 ORDER BY value_timestamp asc,counter_value_id asc;
4395 --
4396 CURSOR LATER_READINGS_CUR(p_counter_id IN NUMBER,p_value_timestamp IN DATE) IS
4397 select counter_value_id,counter_reading,net_reading,value_timestamp,adjustment_reading
4398 ,reset_mode,adjustment_type,include_target_resets
4399 from CSI_COUNTER_READINGS
4400 where counter_id = p_counter_id
4401 and nvl(disabled_flag,'N') = 'N'
4402 and value_timestamp > p_value_timestamp
4403 ORDER BY value_timestamp asc, counter_value_id asc;
4404 --
4405 BEGIN
4406 -- Standard Start of API savepoint
4407 SAVEPOINT update_counter_reading_pvt;
4408 -- Standard call to check for call compatibility.
4409 IF NOT FND_API.Compatible_API_Call (l_api_version,
4410 p_api_version,
4411 l_api_name ,
4412 G_PKG_NAME ) THEN
4413 RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
4414 END IF;
4415 -- Initialize message list if p_init_msg_list is set to TRUE.
4416 IF FND_API.to_Boolean(nvl(p_init_msg_list,FND_API.G_FALSE)) THEN
4417 FND_MSG_PUB.initialize;
4418 END IF;
4419 -- Initialize API return status to success
4420 x_return_status := FND_API.G_RET_STS_SUCCESS;
4421 --
4422
4423 -- Read the debug profiles values in to global variable 7197402
4424 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
4425
4426 csi_ctr_gen_utility_pvt.put_line( 'update_counter_reading_pvt' ||'-'||
4427 p_api_version ||'-'||
4428 nvl(p_commit,FND_API.G_FALSE) ||'-'||
4429 nvl(p_init_msg_list,FND_API.G_FALSE) ||'-'||
4430 nvl(p_validation_level,FND_API.G_VALID_LEVEL_FULL) );
4431 --
4432 IF NVL(p_ctr_rdg_rec.counter_value_id,FND_API.G_MISS_NUM) = FND_API.G_MISS_NUM THEN
4433 csi_ctr_gen_utility_pvt.put_line('Invalid Counter Value ID...');
4434 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_VALUE_ID_MISS');
4435 ELSE
4436 OPEN CURRENT_READING_CUR(p_ctr_rdg_rec.counter_value_id);
4437 FETCH CURRENT_READING_CUR INTO l_curr_ctr_rdg_rec;
4438 CLOSE CURRENT_READING_CUR;
4439 --
4440 IF l_curr_ctr_rdg_rec.counter_value_id IS NULL THEN
4441 csi_ctr_gen_utility_pvt.put_line('Invalid Counter Value ID...');
4442 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_VALUE_ID_MISS');
4443 END IF;
4444 --
4445 Begin
4446 select transaction_type_id
4447 into l_txn_type_id
4448 from csi_transactions
4449 where transaction_id = l_curr_ctr_rdg_rec.transaction_id;
4450 Exception
4451 when no_data_found then
4452 l_txn_type_id := -1;
4453 End;
4454 --
4455 IF l_txn_type_id IN (88,91,92,94,95) THEN
4456 l_mode := 'Meter';
4457 ELSE
4458 l_mode := 'Counter';
4459 END IF;
4460 --
4461 IF l_curr_ctr_rdg_rec.object_version_number <> NVL(p_ctr_rdg_rec.object_version_number,0) THEN
4462 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4463 ( p_msg_name => 'CSI_API_CTR_OBJ_VER_MISMATCH',
4464 p_token1_name => 'MODE',
4465 p_token1_val => l_mode
4466 );
4467 END IF;
4468 --
4469 IF NVL(l_curr_ctr_rdg_rec.disabled_flag,'N') = 'Y' THEN
4470 csi_ctr_gen_utility_pvt.put_line('Counter Reading is already disabled...');
4471 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4472 ( p_msg_name => 'CSI_API_CTR_DISABLED_RDG',
4473 p_token1_name => 'MODE',
4474 p_token1_val => l_mode
4475 );
4476 END IF;
4477 END IF;
4478 --
4479 IF p_ctr_rdg_rec.counter_id IS NOT NULL AND
4480 p_ctr_rdg_rec.counter_id <> l_curr_ctr_rdg_rec.counter_id THEN
4481 csi_ctr_gen_utility_pvt.put_line('Cannot Update Counter ID...');
4482 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4483 ( p_msg_name => 'CSI_API_CTR_UPD_COUNTER_ID',
4484 p_token1_name => 'MODE',
4485 p_token1_val => l_mode
4486 );
4487 ELSE
4488 -- Get the counter definition
4489 Begin
4490 select name,counter_type,rollover_last_reading,
4491 rollover_first_reading,direction,reading_type,
4492 automatic_rollover
4493 into l_ctr_name,l_ctr_type,l_rollover_last_rdg,l_rollover_first_rdg,
4494 l_direction,l_reading_type,l_auto_rollover
4495 from CSI_COUNTERS_VL
4496 where counter_id = l_curr_ctr_rdg_rec.counter_id
4497 and nvl(end_date_active,(sysdate+1)) > sysdate;
4498 Exception
4499 when no_data_found then
4500 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4501 ( p_msg_name => 'CSI_API_CTR_INVALID',
4502 p_token1_name => 'MODE',
4503 p_token1_val => l_mode
4504 );
4505 End;
4506 END IF;
4507 --
4508 IF nvl(p_ctr_rdg_rec.disabled_flag,'N') <> 'Y' THEN
4509 csi_ctr_gen_utility_pvt.put_line('Disabled flag is not set...');
4510 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_INV_DISABLED_FLAG');
4511 END IF;
4512 --
4513 IF NVL(l_direction,'X') NOT IN ('A','D','B') THEN
4514 csi_ctr_gen_utility_pvt.put_line('This counter has an Invalid Direction...');
4515 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4516 ( p_msg_name => 'CSI_API_CTR_INVALID_DIR',
4517 p_token1_name => 'MODE',
4518 p_token1_val => l_mode
4519 );
4520 END IF;
4521 --
4522 IF l_curr_ctr_rdg_rec.reset_mode IS NOT NULL THEN
4523 /* Check if there are readings after the reset */
4524 OPEN NEXT_READING_CUR(l_curr_ctr_rdg_rec.counter_id,
4525 l_curr_ctr_rdg_rec.value_timestamp);
4526 FETCH NEXT_READING_CUR
4527 INTO l_next_ctr_reading,
4528 l_next_value_timestamp,
4529 l_next_reset_mode,
4530 l_next_adj_type,
4531 l_next_auto_rollover;
4532 CLOSE NEXT_READING_CUR;
4533
4534 IF l_next_ctr_reading IS NOT NULL THEN
4535 /* End of checking */
4536 csi_ctr_gen_utility_pvt.put_line('Cannot Disable Reset Reading...');
4537 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4538 ( p_msg_name => 'CSI_API_CTR_DISABLE_RESET',
4539 p_token1_name => 'MODE',
4540 p_token1_val => l_mode
4541 );
4542 END IF;
4543 END IF;
4544 --
4545 IF NVL(l_curr_ctr_rdg_rec.automatic_rollover_flag,'N') = 'Y' THEN
4546 csi_ctr_gen_utility_pvt.put_line('Cannot Disable Automatic Rollover Reading...');
4547 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4548 ( p_msg_name => 'CSI_API_CTR_DISABLE_ROLLOVER',
4549 p_token1_name => 'MODE',
4550 p_token1_val => l_mode
4551 );
4552 END IF;
4553 --
4554 -- Cannot Disable Target Counters as they are driven by source counters
4555 IF Is_Target_Counter(l_curr_ctr_rdg_rec.counter_id) THEN
4556 csi_ctr_gen_utility_pvt.put_line('Cannot Disable Target Counter...');
4557 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4558 ( p_msg_name => 'CSI_API_CTR_DISABLE_TARGET',
4559 p_token1_name => 'MODE',
4560 p_token1_val => l_mode
4561 );
4562 END IF;
4563 --
4564 -- Cannot Disable Formula Counters Readings
4565 IF Is_Formula_Counter(l_curr_ctr_rdg_rec.counter_id) THEN
4566 csi_ctr_gen_utility_pvt.put_line('Cannot Disable Formula Counter...');
4567 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4568 ( p_msg_name => 'CSI_API_CTR_DISABLE_FORMULA',
4569 p_token1_name => 'MODE',
4570 p_token1_val => l_mode
4571 );
4572 END IF;
4573 --
4574 IF p_ctr_rdg_rec.value_timestamp IS NOT NULL AND
4575 p_ctr_rdg_rec.value_timestamp <> l_curr_ctr_rdg_rec.value_timestamp THEN
4576 csi_ctr_gen_utility_pvt.put_line('Cannot Update Value Timestamp...');
4577 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4578 ( p_msg_name => 'CSI_API_CTR_UPD_READING_DATE',
4579 p_token1_name => 'MODE',
4580 p_token1_val => l_mode
4581 );
4582 END IF;
4583 --
4584 IF p_ctr_rdg_rec.counter_reading IS NOT NULL AND
4585 p_ctr_rdg_rec.counter_reading <> NVL(l_curr_ctr_rdg_rec.counter_reading,0) THEN
4586 csi_ctr_gen_utility_pvt.put_line('Cannot Update Counter Reading...');
4587 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4588 ( p_msg_name => 'CSI_API_CTR_UPD_CTR_READING',
4589 p_token1_name => 'MODE',
4590 p_token1_val => l_mode
4591 );
4592 END IF;
4593 --
4594 IF p_ctr_rdg_rec.adjustment_type IS NOT NULL AND
4595 p_ctr_rdg_rec.adjustment_type <> NVL(l_curr_ctr_rdg_rec.adjustment_type,'$#$') THEN
4596 csi_ctr_gen_utility_pvt.put_line('Cannot Update Adjustment Type...');
4597 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4598 ( p_msg_name => 'CSI_API_CTR_UPD_ADJ_TYPE',
4599 p_token1_name => 'MODE',
4600 p_token1_val => l_mode
4601 );
4602 END IF;
4603 --
4604 IF p_ctr_rdg_rec.adjustment_reading IS NOT NULL AND
4605 p_ctr_rdg_rec.adjustment_reading <> NVL(l_curr_ctr_rdg_rec.adjustment_reading,0) THEN
4606 csi_ctr_gen_utility_pvt.put_line('Cannot Update Adjustment Reading...');
4607 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_UPD_ADJ_RDG');
4608 END IF;
4609 --
4610 -- If the Source counter or its object counters have a reading lock date then
4611 -- the reading date cannot be earlier than the lock date (Max of all)
4612 l_rdg_lock_date := NULL;
4613 Begin
4614 select max(reading_lock_date)
4615 into l_rdg_lock_date
4616 from CSI_COUNTER_READING_LOCKS
4617 where counter_id = l_curr_ctr_rdg_rec.counter_id
4618 OR counter_id in (select object_counter_id
4619 from CSI_COUNTER_RELATIONSHIPS
4620 where source_counter_id = l_curr_ctr_rdg_rec.counter_id
4621 and nvl(active_end_date,(l_curr_ctr_rdg_rec.value_timestamp+1)) > l_curr_ctr_rdg_rec.value_timestamp);
4622 End;
4623 --
4624 IF l_rdg_lock_date IS NOT NULL THEN
4625 IF l_curr_ctr_rdg_rec.value_timestamp <= l_rdg_lock_date THEN
4626 csi_ctr_gen_utility_pvt.put_line('Reading Date cannot be earlier than the Reading Lock Date...');
4627 csi_ctr_gen_utility_pvt.ExitWithErrMsg
4628 ( p_msg_name => 'CSI_API_CTR_RDG_DATE_LOCKED',
4629 p_token1_name => 'LOCKED_DATE',
4630 p_token1_val => to_char(l_rdg_lock_date,nvl(fnd_profile.value('ICX_DATE_FORMAT_MASK'),'DD-MON-YYYY HH24:MI:SS')), --fix for bug 5435071
4631 p_token2_name => 'MODE',
4632 p_token2_val => l_mode
4633 );
4634 END IF;
4635 END IF;
4636 --
4637 -- Get the last reading for this counter
4638 OPEN PREV_READING_CUR(l_curr_ctr_rdg_rec.counter_id,l_curr_ctr_rdg_rec.value_timestamp);
4639 FETCH PREV_READING_CUR
4640 INTO l_prev_ctr_reading,
4641 l_prev_net_reading,
4642 l_prev_ltd_reading,
4643 l_prev_value_timestamp;
4644 CLOSE PREV_READING_CUR;
4645 --
4646 -- Get the next reading for this counter
4647 OPEN NEXT_READING_CUR(l_curr_ctr_rdg_rec.counter_id,l_curr_ctr_rdg_rec.value_timestamp);
4648 FETCH NEXT_READING_CUR
4649 INTO l_next_ctr_reading,
4650 l_next_value_timestamp,
4651 l_next_reset_mode,
4652 l_next_adj_type,
4653 l_next_auto_rollover;
4654 CLOSE NEXT_READING_CUR;
4655 --
4656 IF l_prev_ctr_reading IS NULL AND
4657 l_next_reset_mode IS NOT NULL THEN
4658 csi_ctr_gen_utility_pvt.put_line('Next Reading is a Reset. Disabling the current reading will cause the Reset Reading to be the first reading.');
4659 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_NEXT_RESET_RDG');
4660 END IF;
4661 --
4662 IF l_prev_ctr_reading IS NULL AND
4663 l_next_adj_type IS NOT NULL THEN
4664 csi_ctr_gen_utility_pvt.put_line('Next Reading is a Adjustment. Disabling the current reading will cause the Adjustment Reading to be the first reading.');
4665 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_NEXT_ADJ_RDG');
4666 END IF;
4667 --
4668 IF l_prev_ctr_reading IS NULL AND
4669 nvl(l_next_auto_rollover,'N') = 'Y' THEN
4670 csi_ctr_gen_utility_pvt.put_line('Next Reading is an Automatic Rollover. Disabling the current reading will cause the Automatic Rollover Reading to be the first reading.');
4671 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_NEXT_AUTO_RDG');
4672 END IF;
4673 --
4674 p_ctr_rdg_rec.object_version_number := l_curr_ctr_rdg_rec.object_version_number + 1;
4675 --
4676 -- Below two assignments are required by Update public API to call OKC Assembler
4677 p_ctr_rdg_rec.counter_id := l_curr_ctr_rdg_rec.counter_id;
4678 p_ctr_rdg_rec.value_timestamp := l_curr_ctr_rdg_rec.value_timestamp;
4679 --
4680 -- Call Table Handler to Update CSI_COUNTER_READINGS
4681 csi_ctr_gen_utility_pvt.put_line('Calling Update Row to Disable the Reading...');
4682 CSI_COUNTER_READINGS_PKG.Update_Row(
4683 p_COUNTER_VALUE_ID => p_ctr_rdg_rec.counter_value_id
4684 ,p_COUNTER_ID => NULL
4685 ,p_VALUE_TIMESTAMP => NULL
4686 ,p_COUNTER_READING => NULL
4687 ,p_RESET_MODE => NULL
4688 ,p_RESET_REASON => p_ctr_rdg_rec.reset_reason -- NULL 6398254
4689 ,p_ADJUSTMENT_TYPE => NULL
4690 ,p_ADJUSTMENT_READING => NULL
4691 ,p_OBJECT_VERSION_NUMBER => p_ctr_rdg_rec.object_version_number
4692 ,p_LAST_UPDATE_DATE => SYSDATE
4693 ,p_LAST_UPDATED_BY => fnd_global.user_id
4694 ,p_CREATION_DATE => NULL
4695 ,p_CREATED_BY => NULL
4696 ,p_LAST_UPDATE_LOGIN => fnd_global.conc_login_id
4697 ,p_ATTRIBUTE1 => NULL
4698 ,p_ATTRIBUTE2 => NULL
4699 ,p_ATTRIBUTE3 => NULL
4700 ,p_ATTRIBUTE4 => NULL
4701 ,p_ATTRIBUTE5 => NULL
4702 ,p_ATTRIBUTE6 => NULL
4703 ,p_ATTRIBUTE7 => NULL
4704 ,p_ATTRIBUTE8 => NULL
4705 ,p_ATTRIBUTE9 => NULL
4706 ,p_ATTRIBUTE10 => NULL
4707 ,p_ATTRIBUTE11 => NULL
4708 ,p_ATTRIBUTE12 => NULL
4709 ,p_ATTRIBUTE13 => NULL
4710 ,p_ATTRIBUTE14 => NULL
4711 ,p_ATTRIBUTE15 => NULL
4712 ,p_ATTRIBUTE16 => NULL
4713 ,p_ATTRIBUTE17 => NULL
4714 ,p_ATTRIBUTE18 => NULL
4715 ,p_ATTRIBUTE19 => NULL
4716 ,p_ATTRIBUTE20 => NULL
4717 ,p_ATTRIBUTE21 => NULL
4718 ,p_ATTRIBUTE22 => NULL
4719 ,p_ATTRIBUTE23 => NULL
4720 ,p_ATTRIBUTE24 => NULL
4721 ,p_ATTRIBUTE25 => NULL
4722 ,p_ATTRIBUTE26 => NULL
4723 ,p_ATTRIBUTE27 => NULL
4724 ,p_ATTRIBUTE28 => NULL
4725 ,p_ATTRIBUTE29 => NULL
4726 ,p_ATTRIBUTE30 => NULL
4727 ,p_ATTRIBUTE_CATEGORY => NULL
4728 ,p_MIGRATED_FLAG => NULL
4729 ,p_COMMENTS => NULL
4730 ,p_LIFE_TO_DATE_READING => NULL
4731 ,p_TRANSACTION_ID => NULL
4732 ,p_AUTOMATIC_ROLLOVER_FLAG => NULL
4733 ,p_INCLUDE_TARGET_RESETS => NULL
4734 ,p_SOURCE_COUNTER_VALUE_ID => NULL
4735 ,p_NET_READING => NULL
4736 ,p_DISABLED_FLAG => p_ctr_rdg_rec.disabled_flag
4737 ,p_SOURCE_CODE => NULL
4738 ,p_SOURCE_LINE_ID => NULL
4739 ,p_INITIAL_READING_FLAG => NULL
4740 );
4741
4742 IF p_ctr_rdg_rec.disabled_flag = 'Y' THEN
4743 l_ctr_val_max_seq_no := NULL;
4744 --Add call to CSI_COUNTER_PVT.update_ctr_val_max_seq_no
4745 --for bug 7374316
4746 CSI_COUNTER_PVT.update_ctr_val_max_seq_no(
4747 p_api_version => 1.0
4748 ,p_commit => fnd_api.g_false
4749 ,p_init_msg_list => fnd_api.g_true
4750 ,p_validation_level => fnd_api.g_valid_level_full
4751 ,p_counter_id => p_ctr_rdg_rec.counter_id
4752 ,px_ctr_val_max_seq_no => l_ctr_val_max_seq_no
4753 ,x_return_status => x_return_status
4754 ,x_msg_count => x_msg_count
4755 ,x_msg_data => x_msg_data
4756 );
4757
4758 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
4759 l_msg_index := 1;
4760 l_msg_count := x_msg_count;
4761 WHILE l_msg_count > 0 LOOP
4762 x_msg_data := FND_MSG_PUB.GET
4763 (l_msg_index,
4764 FND_API.G_FALSE
4765 );
4766 csi_ctr_gen_utility_pvt.put_line('ERROR FROM CSI_COUNTER_PVT.update_ctr_val_max_seq_no');
4767 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
4768 l_msg_index := l_msg_index + 1;
4769 l_msg_count := l_msg_count - 1;
4770 END LOOP;
4771 RAISE FND_API.G_EXC_ERROR;
4772 END IF;
4773 END IF;
4774 --
4775 Disable_Target_Derive_Rdg
4776 ( p_src_counter_value_id => p_ctr_rdg_rec.counter_value_id,
4777 x_return_status => x_return_status
4778 );
4779 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
4780 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Disable_Target_Derive_Rdg API ');
4781 RAISE FND_API.G_EXC_ERROR;
4782 END IF;
4783 --
4784 -- Following variables will be set inside the loop
4785 l_previous_rdg := l_prev_ctr_reading;
4786 l_upd_previous_rdg := l_prev_ctr_reading;
4787 l_previous_net := l_prev_net_reading;
4788 l_previous_ltd := l_prev_ltd_reading;
4789 --
4790 -- For Adjustments or next reading was a reset then
4791 -- adjust the Net Reading of Subsequent readings.
4792 -- Re-calculate Target counters irrespective of net reading changes.
4793
4794 --Modified if condition for bug 7589871, to allow later reading to be updated for Changed Fluctuating counter
4795 IF (l_direction <> 'B') OR (l_direction = 'B' AND l_reading_type = 2) THEN
4796 IF l_reading_type = 2 OR
4797 l_curr_ctr_rdg_rec.adjustment_reading IS NOT NULL OR
4798 l_next_adj_type IS NOT NULL OR
4799 NVL(l_next_reset_mode,'X') = 'SOFT' THEN
4800 l_update_loop := TRUE;
4801 l_adj_ctr := 0;
4802 csi_ctr_gen_utility_pvt.put_line('Updating Later Readings for Ctr ID '||to_char(l_curr_ctr_rdg_rec.counter_id));
4803 FOR later_rdg IN LATER_READINGS_CUR(l_curr_ctr_rdg_rec.counter_id
4804 ,l_curr_ctr_rdg_rec.value_timestamp)
4805 LOOP
4806 l_adj_ctr := l_adj_ctr + 1;
4807 --
4808 -- If the immediate reading after the current disabled rdg is an Adjustment then
4809 -- we need to update the counter reading of that adjustment, provided it took the same disabled
4810 -- counter reading. If a counter rdg was also captured as the part of adjustment then
4811 -- no need to update the counter reading. Just retain the same and pass it to Net rdg calculation.
4812 -- It will come back with the same values.
4813 --
4814 -- Above statements are true only for Absolute counters since we take the usage for Change counters
4815 --
4816 -- l_previous_rdg always takes the un-updated counter reading from the cursor
4817 -- l_upd_previous_rdg takes the updated value which will be used to compute the usage for Targets
4818 -- l_prev_ctr_reading is read outside the loop and never change. Used only for the first record
4819 -- in the following Loop.
4820 --
4821 IF later_rdg.adjustment_type IS NOT NULL AND
4822 l_reading_type = 1 THEN
4823 IF l_adj_ctr = 1 THEN -- First record of Later Readings (Immediate record after disabled rdg)
4824 -- Checking whether it took the same rdg as the disabled one.
4825 IF later_rdg.counter_reading = l_curr_ctr_rdg_rec.counter_reading THEN
4826 l_later_ctr_reading := l_prev_ctr_reading; -- The one before disable rdg
4827 ELSE -- Retain the counter reading
4828 l_later_ctr_reading := later_rdg.counter_reading;
4829 END IF;
4830 ELSE
4831 IF later_rdg.counter_reading <> l_previous_rdg THEN
4832 l_later_ctr_reading := later_rdg.counter_reading;
4833 -- ELSE part is basically retaining the l_later_ctr_reading derived in Previous iteration
4834 END IF;
4835 END IF;
4836 ELSE
4837 l_later_ctr_reading := later_rdg.counter_reading;
4838 END IF;
4839 --
4840 csi_ctr_gen_utility_pvt.put_line('Updating Counter Value ID '||to_char(later_rdg.counter_value_id));
4841 IF NVL(later_rdg.reset_mode,'X') = 'SOFT' THEN
4842 UPDATE CSI_COUNTER_READINGS
4843 set net_reading = l_previous_net,
4844 life_to_date_reading = l_previous_ltd,
4845 last_update_date = sysdate,
4846 last_updated_by = fnd_global.user_id
4847 where counter_value_id = later_rdg.counter_value_id;
4848 ELSE
4849 Calculate_Net_Reading
4850 ( p_prev_net_rdg => l_previous_net
4851 ,p_prev_ltd_rdg => l_previous_ltd
4852 ,p_curr_rdg => l_later_ctr_reading -- later_rdg.counter_reading
4853 ,p_prev_rdg => l_upd_previous_rdg -- l_previous_rdg
4854 ,p_curr_adj => later_rdg.adjustment_reading
4855 ,p_rdg_type => l_reading_type
4856 ,p_direction => l_direction
4857 ,px_net_rdg => l_net_reading
4858 ,px_ltd_rdg => l_ltd_reading
4859 ,l_ctr_rdg_rec => p_ctr_rdg_rec -- added 6398254
4860 );
4861 UPDATE CSI_COUNTER_READINGS
4862 set counter_reading = l_later_ctr_reading,
4863 net_reading = l_net_reading,
4864 life_to_date_reading = l_ltd_reading,
4865 last_update_date = sysdate,
4866 last_updated_by = fnd_global.user_id
4867 where counter_value_id = later_rdg.counter_value_id;
4868 --
4869 l_previous_net := l_net_reading;
4870 l_previous_ltd := l_ltd_reading;
4871 END IF;
4872 --
4873 --
4874 -- Re-calculate Compute Target Counters
4875 -- For Resets which did not include Targets before, no need to Re-compute
4876 --
4877 IF later_rdg.reset_mode IS NULL OR
4878 (later_rdg.reset_mode IS NOT NULL AND NVL(later_rdg.include_target_resets,'N') = 'Y') THEN
4879 l_target_ctr_rec := l_temp_ctr_rdg_rec;
4880 --
4881 l_target_ctr_rec.counter_value_id := later_rdg.counter_value_id; -- source_counter_value_id
4882 l_target_ctr_rec.counter_id := l_curr_ctr_rdg_rec.counter_id;
4883 l_target_ctr_rec.value_timestamp := later_rdg.value_timestamp;
4884 l_target_ctr_rec.adjustment_reading := later_rdg.adjustment_reading;
4885 l_target_ctr_rec.adjustment_type := later_rdg.adjustment_type;
4886 --
4887 -- Used l_later_ctr_reading instead of later_rdg.counter_reading
4888 --
4889 IF later_rdg.reset_mode IS NOT NULL AND NVL(later_rdg.include_target_resets,'N') = 'Y' THEN
4890 -- l_target_ctr_rec.counter_reading := ABS(later_rdg.counter_reading);
4891 l_target_ctr_rec.counter_reading := later_rdg.counter_reading;
4892 ELSE
4893 IF l_reading_type = 1 THEN
4894 -- l_target_ctr_rec.counter_reading := ABS(l_later_ctr_reading - nvl(l_upd_previous_rdg,0));
4895 l_target_ctr_rec.counter_reading := l_later_ctr_reading - nvl(l_upd_previous_rdg,0);
4896 ELSIF l_reading_type = 2 THEN
4897 -- l_target_ctr_rec.counter_reading := ABS(l_later_ctr_reading);
4898 l_target_ctr_rec.counter_reading := l_later_ctr_reading;
4899 END IF;
4900 END IF;
4901 --
4902 csi_ctr_gen_utility_pvt.put_line('Calling Compute_Target_Counters for Update...');
4903 Compute_Target_Counters
4904 (
4905 p_api_version => 1.0
4906 ,p_commit => p_commit
4907 ,p_init_msg_list => p_init_msg_list
4908 ,p_validation_level => p_validation_level
4909 ,p_txn_rec => l_txn_rec
4910 ,p_ctr_rdg_rec => l_target_ctr_rec
4911 ,p_mode => 'UPDATE'
4912 ,x_return_status => x_return_status
4913 ,x_msg_count => x_msg_count
4914 ,x_msg_data => x_msg_data
4915 );
4916 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
4917 l_msg_index := 1;
4918 l_msg_count := x_msg_count;
4919 WHILE l_msg_count > 0 LOOP
4920 x_msg_data := FND_MSG_PUB.GET
4921 ( l_msg_index,
4922 FND_API.G_FALSE
4923 );
4924 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Compute_Target_Counters API ');
4925 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
4926 l_msg_index := l_msg_index + 1;
4927 l_msg_count := l_msg_count - 1;
4928 END LOOP;
4929 RAISE FND_API.G_EXC_ERROR;
4930 END IF;
4931 END IF; -- Target Counter call check
4932 --
4933 -- Re-compute Derive comunters.
4934 -- No need for SOFT reset as we would not have created it before.
4935 --
4936 IF NVL(later_rdg.reset_mode,'$#$') <> 'SOFT' THEN
4937 l_derive_ctr_rec := l_temp_ctr_rdg_rec;
4938 --
4939 l_derive_ctr_rec.counter_value_id := later_rdg.counter_value_id; -- source_counter_value_id
4940 l_derive_ctr_rec.counter_id := l_curr_ctr_rdg_rec.counter_id;
4941 l_derive_ctr_rec.value_timestamp := later_rdg.value_timestamp;
4942 --
4943 -- Compute Derive Counters
4944 csi_ctr_gen_utility_pvt.put_line('Calling Compute_Derive_Counters for Update...');
4945 Compute_Derive_Counters
4946 (
4947 p_api_version => 1.0
4948 ,p_commit => p_commit
4949 ,p_init_msg_list => p_init_msg_list
4950 ,p_validation_level => p_validation_level
4951 ,p_txn_rec => l_txn_rec
4952 ,p_ctr_rdg_rec => l_derive_ctr_rec
4953 ,p_mode => 'UPDATE'
4954 ,x_return_status => x_return_status
4955 ,x_msg_count => x_msg_count
4956 ,x_msg_data => x_msg_data
4957 );
4958 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
4959 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Compute_Derive_Counters API ');
4960 l_msg_index := 1;
4961 l_msg_count := x_msg_count;
4962 WHILE l_msg_count > 0 LOOP
4963 x_msg_data := FND_MSG_PUB.GET
4964 ( l_msg_index,
4965 FND_API.G_FALSE
4966 );
4967 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
4968 l_msg_index := l_msg_index + 1;
4969 l_msg_count := l_msg_count - 1;
4970 END LOOP;
4971 RAISE FND_API.G_EXC_ERROR;
4972 END IF;
4973 END IF; -- Derive Counters call check
4974 --
4975 l_previous_rdg := later_rdg.counter_reading;
4976 l_upd_previous_rdg := l_later_ctr_reading;
4977 END LOOP; -- Later Readings loop
4978 END IF; -- Condition to loop thru' later readings
4979 --
4980 -- If the above loop was not executed then to re-calculate the Traget counters we loop thru'
4981 -- This is because target counter readings could change even if the net reading did not change.
4982 --
4983 l_previous_rdg := l_prev_ctr_reading; -- Assigning it to Rdg before Disable Rdg (Just in case...)
4984 --
4985 IF NOT l_update_loop THEN
4986 FOR later_rdg IN LATER_READINGS_CUR(l_curr_ctr_rdg_rec.counter_id,
4987 l_curr_ctr_rdg_rec.value_timestamp)
4988 LOOP
4989 -- Re-calculate Compute Target Counters
4990 -- For Resets which did not include Targets before, no need to Re-compute
4991 --
4992 IF later_rdg.reset_mode IS NULL OR
4993 (later_rdg.reset_mode IS NOT NULL AND NVL(later_rdg.include_target_resets,'N') = 'Y') THEN
4994 l_target_ctr_rec := l_temp_ctr_rdg_rec;
4995 --
4996 l_target_ctr_rec.counter_value_id := later_rdg.counter_value_id; -- source_counter_value_id
4997 l_target_ctr_rec.counter_id := l_curr_ctr_rdg_rec.counter_id;
4998 l_target_ctr_rec.value_timestamp := later_rdg.value_timestamp;
4999 l_target_ctr_rec.adjustment_reading := later_rdg.adjustment_reading;
5000 l_target_ctr_rec.adjustment_type := later_rdg.adjustment_type;
5001 --
5002 IF later_rdg.reset_mode IS NOT NULL AND NVL(later_rdg.include_target_resets,'N') = 'Y' THEN
5003 -- l_target_ctr_rec.counter_reading := ABS(later_rdg.counter_reading);
5004 l_target_ctr_rec.counter_reading := later_rdg.counter_reading;
5005 ELSE
5006 IF l_reading_type = 1 THEN
5007 -- l_target_ctr_rec.counter_reading := ABS(later_rdg.counter_reading - nvl(l_previous_rdg,0));
5008 l_target_ctr_rec.counter_reading := later_rdg.counter_reading - nvl(l_previous_rdg,0);
5009 ELSIF l_reading_type = 2 THEN
5010 -- l_target_ctr_rec.counter_reading := ABS(later_rdg.counter_reading);
5011 l_target_ctr_rec.counter_reading := later_rdg.counter_reading;
5012 END IF;
5013 END IF;
5014 --
5015 -- Call Compute Target Counters
5016 csi_ctr_gen_utility_pvt.put_line('Calling Compute_Target_Counters for Update...');
5017 Compute_Target_Counters
5018 (
5019 p_api_version => 1.0
5020 ,p_commit => p_commit
5021 ,p_init_msg_list => p_init_msg_list
5022 ,p_validation_level => p_validation_level
5023 ,p_txn_rec => l_txn_rec
5024 ,p_ctr_rdg_rec => l_target_ctr_rec
5025 ,p_mode => 'UPDATE'
5026 ,x_return_status => x_return_status
5027 ,x_msg_count => x_msg_count
5028 ,x_msg_data => x_msg_data
5029 );
5030 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
5031 l_msg_index := 1;
5032 l_msg_count := x_msg_count;
5033 WHILE l_msg_count > 0 LOOP
5034 x_msg_data := FND_MSG_PUB.GET
5035 ( l_msg_index,
5036 FND_API.G_FALSE
5037 );
5038 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Compute_Target_Counters API ');
5039 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
5040 l_msg_index := l_msg_index + 1;
5041 l_msg_count := l_msg_count - 1;
5042 END LOOP;
5043 RAISE FND_API.G_EXC_ERROR;
5044 END IF;
5045 END IF; -- Target counter call check
5046 --
5047 -- Re-Compute Derive Counters
5048 -- No need for SOFT reset as we would not have created it before.
5049 IF NVL(later_rdg.reset_mode,'$#$') <> 'SOFT' THEN
5050 l_derive_ctr_rec := l_temp_ctr_rdg_rec;
5051 --
5052 l_derive_ctr_rec.counter_value_id := later_rdg.counter_value_id; -- source_counter_value_id
5053 l_derive_ctr_rec.counter_id := l_curr_ctr_rdg_rec.counter_id;
5054 l_derive_ctr_rec.value_timestamp := later_rdg.value_timestamp;
5055 --
5056 csi_ctr_gen_utility_pvt.put_line('Calling Compute_Derive_Counters for Update...');
5057 Compute_Derive_Counters
5058 (
5059 p_api_version => 1.0
5060 ,p_commit => p_commit
5061 ,p_init_msg_list => p_init_msg_list
5062 ,p_validation_level => p_validation_level
5063 ,p_txn_rec => l_txn_rec
5064 ,p_ctr_rdg_rec => l_derive_ctr_rec
5065 ,p_mode => 'UPDATE'
5066 ,x_return_status => x_return_status
5067 ,x_msg_count => x_msg_count
5068 ,x_msg_data => x_msg_data
5069 );
5070 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
5071 l_msg_index := 1;
5072 l_msg_count := x_msg_count;
5073 WHILE l_msg_count > 0 LOOP
5074 x_msg_data := FND_MSG_PUB.GET
5075 ( l_msg_index,
5076 FND_API.G_FALSE
5077 );
5078 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Compute_Derive_Counters API ');
5079 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
5080 l_msg_index := l_msg_index + 1;
5081 l_msg_count := l_msg_count - 1;
5082 END LOOP;
5083 RAISE FND_API.G_EXC_ERROR;
5084 END IF;
5085 END IF; -- Derive counters call check
5086 --
5087 l_previous_rdg := later_rdg.counter_reading;
5088 END LOOP;
5089 END IF; -- l_update_loop check
5090 ELSE
5091 -- For Bi-directional counters just Re-compute the Derived filters for Later readings
5092 FOR later_rdg IN LATER_READINGS_CUR(l_curr_ctr_rdg_rec.counter_id,
5093 l_curr_ctr_rdg_rec.value_timestamp)
5094 LOOP
5095 -- Re-Compute Derive Counters
5096 -- No need for SOFT reset as we would not have created it before.
5097 IF NVL(later_rdg.reset_mode,'$#$') <> 'SOFT' THEN
5098 l_derive_ctr_rec := l_temp_ctr_rdg_rec;
5099 --
5100 l_derive_ctr_rec.counter_value_id := later_rdg.counter_value_id; -- source_counter_value_id
5101 l_derive_ctr_rec.counter_id := l_curr_ctr_rdg_rec.counter_id;
5102 l_derive_ctr_rec.value_timestamp := later_rdg.value_timestamp;
5103 --
5104 csi_ctr_gen_utility_pvt.put_line('Calling Compute_Derive_Counters for Update...');
5105 Compute_Derive_Counters
5106 (
5107 p_api_version => 1.0
5108 ,p_commit => p_commit
5109 ,p_init_msg_list => p_init_msg_list
5110 ,p_validation_level => p_validation_level
5111 ,p_txn_rec => l_txn_rec
5112 ,p_ctr_rdg_rec => l_derive_ctr_rec
5113 ,p_mode => 'UPDATE'
5114 ,x_return_status => x_return_status
5115 ,x_msg_count => x_msg_count
5116 ,x_msg_data => x_msg_data
5117 );
5118 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
5119 l_msg_index := 1;
5120 l_msg_count := x_msg_count;
5121 WHILE l_msg_count > 0 LOOP
5122 x_msg_data := FND_MSG_PUB.GET
5123 ( l_msg_index,
5124 FND_API.G_FALSE
5125 );
5126 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Compute_Derive_Counters API ');
5127 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
5128 l_msg_index := l_msg_index + 1;
5129 l_msg_count := l_msg_count - 1;
5130 END LOOP;
5131 RAISE FND_API.G_EXC_ERROR;
5132 END IF;
5133 END IF; -- Derive counters call check
5134 END LOOP;
5135 END IF; -- l_direction check
5136 --
5137 l_upd_fl_rdg_rec.counter_id := l_curr_ctr_rdg_rec.counter_id;
5138 l_upd_fl_rdg_rec.value_timestamp := l_curr_ctr_rdg_rec.value_timestamp;
5139 l_upd_fl_rdg_rec.disabled_flag := 'Y';
5140 --
5141 -- Call Compute Formula
5142 csi_ctr_gen_utility_pvt.put_line('Calling Compute_Formula_Counters for Update...');
5143 Compute_Formula_Counters
5144 (
5145 p_api_version => 1.0
5146 ,p_commit => p_commit
5147 ,p_init_msg_list => p_init_msg_list
5148 ,p_validation_level => p_validation_level
5149 ,p_txn_rec => l_txn_rec
5150 ,p_ctr_rdg_rec => l_upd_fl_rdg_rec
5151 ,x_return_status => x_return_status
5152 ,x_msg_count => x_msg_count
5153 ,x_msg_data => x_msg_data
5154 );
5155 IF NOT(x_return_status = FND_API.G_RET_STS_SUCCESS) THEN
5156 csi_ctr_gen_utility_pvt.put_line('Error from Compute_Formula_Counters API...');
5157 l_msg_index := 1;
5158 l_msg_count := x_msg_count;
5159 WHILE l_msg_count > 0 LOOP
5160 x_msg_data := FND_MSG_PUB.GET
5161 ( l_msg_index,
5162 FND_API.G_FALSE
5163 );
5164 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Compute_Formula_Counters API ');
5165 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
5166 l_msg_index := l_msg_index + 1;
5167 l_msg_count := l_msg_count - 1;
5168 END LOOP;
5169 RAISE FND_API.G_EXC_ERROR;
5170 END IF;
5171 --
5172 IF FND_API.to_Boolean(nvl(p_commit,FND_API.G_FALSE)) THEN
5173 COMMIT WORK;
5174 END IF;
5175 --
5176 -- Standard call to get message count and IF count is get message info.
5177 FND_MSG_PUB.Count_And_Get
5178 ( p_count => x_msg_count,
5179 p_data => x_msg_data
5180 );
5181 EXCEPTION
5182 WHEN FND_API.G_EXC_ERROR THEN
5183 x_return_status := FND_API.G_RET_STS_ERROR ;
5184 ROLLBACK TO update_counter_reading_pvt;
5185 FND_MSG_PUB.Count_And_Get
5186 ( p_count => x_msg_count,
5187 p_data => x_msg_data
5188 );
5189 WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5190 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5191 ROLLBACK TO update_counter_reading_pvt;
5192 FND_MSG_PUB.Count_And_Get
5193 ( p_count => x_msg_count,
5194 p_data => x_msg_data
5195 );
5196 WHEN OTHERS THEN
5197 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5198 ROLLBACK TO update_counter_reading_pvt;
5199 IF FND_MSG_PUB.Check_Msg_Level (FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
5200 FND_MSG_PUB.Add_Exc_Msg
5201 ( G_PKG_NAME,
5202 l_api_name
5203 );
5204 END IF;
5205 FND_MSG_PUB.Count_And_Get
5206 ( p_count => x_msg_count,
5207 p_data => x_msg_data
5208 );
5209 END Update_Counter_Reading;
5210 --
5211 PROCEDURE Capture_Ctr_Property_Reading
5212 (
5213 p_api_version IN NUMBER
5214 ,p_commit IN VARCHAR2
5215 ,p_init_msg_list IN VARCHAR2
5216 ,p_validation_level IN NUMBER
5217 ,p_ctr_prop_rdg_rec IN OUT NOCOPY csi_ctr_datastructures_pub.ctr_property_readings_rec
5218 ,x_return_status OUT NOCOPY VARCHAR2
5219 ,x_msg_count OUT NOCOPY NUMBER
5220 ,x_msg_data OUT NOCOPY VARCHAR2
5221 )
5222 IS
5223 l_api_name CONSTANT VARCHAR2(30) := 'CAPTURE_CTR_PROPERTY_READING';
5224 l_api_version CONSTANT NUMBER := 1.0;
5225 l_msg_data VARCHAR2(2000);
5226 l_msg_index NUMBER;
5227 l_msg_count NUMBER;
5228 l_pval VARCHAR2(1) := 'F';
5229 l_prop_lov_type VARCHAR2(30);
5230 l_property_type VARCHAR2(30);
5231 l_is_nullable VARCHAR2(30);
5232 l_n_temp NUMBER;
5233 l_d_temp DATE;
5234 l_process_flag BOOLEAN := TRUE;
5235 --
5236 CURSOR PROP_LOV_CUR(p_prop_id IN NUMBER) IS
5237 select lookup_code,meaning --Meaning added for bug #6904836
5238 from CSI_LOOKUPS
5239 where lookup_type = (select property_lov_type
5240 from CSI_COUNTER_PROPERTIES_B
5241 where counter_property_id = p_prop_id);
5242 BEGIN
5243 -- Standard Start of API savepoint
5244 SAVEPOINT capture_ctr_property_reading;
5245 -- Standard call to check for call compatibility.
5246 IF NOT FND_API.Compatible_API_Call (l_api_version,
5247 p_api_version,
5248 l_api_name ,
5249 G_PKG_NAME ) THEN
5250 RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
5251 END IF;
5252 -- Initialize message list if p_init_msg_list is set to TRUE.
5253 IF FND_API.to_Boolean(nvl(p_init_msg_list,FND_API.G_FALSE)) THEN
5254 FND_MSG_PUB.initialize;
5255 END IF;
5256 -- Initialize API return status to success
5257 x_return_status := FND_API.G_RET_STS_SUCCESS;
5258 --
5259
5260 -- Read the debug profiles values in to global variable 7197402
5261 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
5262
5263 csi_ctr_gen_utility_pvt.put_line( 'capture_ctr_property_reading' ||'-'||
5264 p_api_version ||'-'||
5265 nvl(p_commit,FND_API.G_FALSE) ||'-'||
5266 nvl(p_init_msg_list,FND_API.G_FALSE) ||'-'||
5267 nvl(p_validation_level,FND_API.G_VALID_LEVEL_FULL) );
5268 --
5269 IF p_ctr_prop_rdg_rec.counter_value_id IS NULL OR
5270 p_ctr_prop_rdg_rec.counter_value_id = FND_API.G_MISS_NUM THEN
5271 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_VALUE_ID_MISS');
5272 END IF;
5273 --
5274 IF p_ctr_prop_rdg_rec.counter_property_id IS NULL OR
5275 p_ctr_prop_rdg_rec.counter_property_id = FND_API.G_MISS_NUM THEN
5276 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_PROP_INVALID');
5277 END IF;
5278 --
5279 IF p_ctr_prop_rdg_rec.value_timestamp IS NULL OR
5280 p_ctr_prop_rdg_rec.value_timestamp = FND_API.G_MISS_DATE THEN
5281 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_INVALID_RDG_DATE');
5282 END IF;
5283 --
5284 Begin
5285 select property_lov_type,property_data_type,is_nullable
5286 into l_prop_lov_type,l_property_type, l_is_nullable
5287 from CSI_COUNTER_PROPERTIES_B
5288 where counter_property_id = p_ctr_prop_rdg_rec.counter_property_id
5289 and nvl(end_date_active,(sysdate+1)) > sysdate;
5290 Exception
5291 when no_data_found then
5292 csi_ctr_gen_utility_pvt.put_line('Counter Property is Invalid or Expired...');
5293 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_PROP_INVALID');
5294 End;
5295 --
5296 IF l_is_nullable <> 'Y' THEN
5297 IF p_ctr_prop_rdg_rec.property_value IS NULL OR
5298 p_ctr_prop_rdg_rec.property_value = FND_API.G_MISS_CHAR THEN
5299 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_PROP_VALUE_MISSING');
5300 END IF;
5301 END IF;
5302 --
5303 IF NOT Valid_Ctr_Property_ID
5304 (p_ctr_value_id => p_ctr_prop_rdg_rec.counter_value_id
5305 ,p_ctr_prop_id => p_ctr_prop_rdg_rec.counter_property_id) THEN
5306 -- Property does not belong to the captured counter
5307 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_PROP_INVALID');
5308 END IF;
5309 --
5310 IF Has_Property_Value(p_counter_property_id => p_ctr_prop_rdg_rec.counter_property_id,
5311 p_counter_value_id => p_ctr_prop_rdg_rec.counter_value_id) = 'T' THEN
5312 -- Property value already exists
5313 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_PROP_VALUE_EXISTS');
5314 END IF;
5315 --
5316 IF l_is_nullable <> 'Y' THEN
5317 IF l_prop_lov_type IS NOT NULL THEN
5318 FOR prop_rec in PROP_LOV_CUR(p_ctr_prop_rdg_rec.counter_property_id) LOOP
5319 IF RTRIM(p_ctr_prop_rdg_rec.PROPERTY_VALUE) = RTRIM(prop_rec.lookup_code) OR
5320 RTRIM(p_ctr_prop_rdg_rec.PROPERTY_VALUE) = RTRIM(prop_rec.meaning) THEN --Condition added for bug #6904836
5321 l_pval := 'T';
5322 END IF;
5323 END LOOP;
5324 ELSE -- LOV Type Not defined
5325 l_pval := 'T';
5326 END IF;
5327 --
5328 IF l_pval = 'F' THEN
5329 csi_ctr_gen_utility_pvt.put_line('Property Value does not match with Property LOV Type...');
5330 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_PROP_LOV_MISMATCH');
5331 END IF;
5332 --
5333 /***********************************************
5334 *Check if value is valid for property data type
5335 ***********************************************/
5336 IF l_property_type = 'NUMBER' THEN
5337 BEGIN
5338 l_n_temp := TO_NUMBER(p_ctr_prop_rdg_rec.PROPERTY_VALUE);
5339 EXCEPTION
5340 WHEN OTHERS THEN
5341 IF (SQLCODE = -6502) THEN
5342 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_PROP_DATA_MISMATCH');
5343 ELSE
5344 RAISE;
5345 END IF;
5346 END;
5347 ELSIF l_property_type = 'CHAR' then
5348 null;
5349 ELSIF l_property_type = 'DATE' then
5350 BEGIN
5351 l_d_temp := to_date(p_ctr_prop_rdg_rec.PROPERTY_VALUE,'MM-DD-YYYY');
5352 EXCEPTION
5353 WHEN OTHERS THEN
5354 IF (SQLCODE BETWEEN -1899 AND -1800) THEN
5355 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_PROP_DATA_MISMATCH');
5356 ELSE
5357 RAISE;
5358 END IF;
5359 END;
5360 ELSE
5361 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_PROP_DATA_MISMATCH');
5362 END IF;
5363
5364 END IF;
5365 --
5366 -- Generate Counter_Prop_Value_id
5367 IF p_ctr_prop_rdg_rec.counter_prop_value_id IS NULL OR
5368 p_ctr_prop_rdg_rec.counter_prop_value_id = FND_API.G_MISS_NUM THEN
5369 WHILE l_process_flag LOOP
5370 select CSI_CTR_PROPERTY_READINGS_S.nextval
5371 into p_ctr_prop_rdg_rec.counter_prop_value_id from dual;
5372 IF NOT Counter_Prop_Value_Exists(p_ctr_prop_rdg_rec.counter_prop_value_id) THEN
5373 l_process_flag := FALSE;
5374 END IF;
5375 END LOOP;
5376 ELSE
5377 IF Counter_Prop_Value_Exists(p_ctr_prop_rdg_rec.counter_prop_value_id) THEN
5378 csi_ctr_gen_utility_pvt.ExitWithErrMsg
5379 ( p_msg_name => 'CSI_API_CTR_PROP_VALUE_EXISTS',
5380 p_token1_name => 'PROP_VALUE_ID',
5381 p_token1_val => to_char(p_ctr_prop_rdg_rec.counter_prop_value_id)
5382 );
5383 END IF;
5384 END IF;
5385 --
5386 p_ctr_prop_rdg_rec.object_version_number := 1;
5387 --
5388 CSI_CTR_PROPERTY_READING_PKG.Insert_Row(
5389 px_COUNTER_PROP_VALUE_ID => p_ctr_prop_rdg_rec.counter_prop_value_id
5390 ,p_COUNTER_VALUE_ID => p_ctr_prop_rdg_rec.counter_value_id
5391 ,p_COUNTER_PROPERTY_ID => p_ctr_prop_rdg_rec.counter_property_id
5392 ,p_PROPERTY_VALUE => p_ctr_prop_rdg_rec.property_value
5393 ,p_VALUE_TIMESTAMP => p_ctr_prop_rdg_rec.value_timestamp
5394 ,p_OBJECT_VERSION_NUMBER => p_ctr_prop_rdg_rec.object_version_number
5395 ,p_LAST_UPDATE_DATE => SYSDATE
5396 ,p_LAST_UPDATED_BY => fnd_global.user_id
5397 ,p_CREATION_DATE => SYSDATE
5398 ,p_CREATED_BY => fnd_global.user_id
5399 ,p_LAST_UPDATE_LOGIN => fnd_global.conc_login_id
5400 ,p_ATTRIBUTE1 => p_ctr_prop_rdg_rec.attribute1
5401 ,p_ATTRIBUTE2 => p_ctr_prop_rdg_rec.attribute2
5402 ,p_ATTRIBUTE3 => p_ctr_prop_rdg_rec.attribute3
5403 ,p_ATTRIBUTE4 => p_ctr_prop_rdg_rec.attribute4
5404 ,p_ATTRIBUTE5 => p_ctr_prop_rdg_rec.attribute5
5405 ,p_ATTRIBUTE6 => p_ctr_prop_rdg_rec.attribute6
5406 ,p_ATTRIBUTE7 => p_ctr_prop_rdg_rec.attribute7
5407 ,p_ATTRIBUTE8 => p_ctr_prop_rdg_rec.attribute8
5408 ,p_ATTRIBUTE9 => p_ctr_prop_rdg_rec.attribute9
5409 ,p_ATTRIBUTE10 => p_ctr_prop_rdg_rec.attribute10
5410 ,p_ATTRIBUTE11 => p_ctr_prop_rdg_rec.attribute11
5411 ,p_ATTRIBUTE12 => p_ctr_prop_rdg_rec.attribute12
5412 ,p_ATTRIBUTE13 => p_ctr_prop_rdg_rec.attribute13
5413 ,p_ATTRIBUTE14 => p_ctr_prop_rdg_rec.attribute14
5414 ,p_ATTRIBUTE15 => p_ctr_prop_rdg_rec.attribute15
5415 ,p_ATTRIBUTE_CATEGORY => p_ctr_prop_rdg_rec.attribute_category
5416 ,p_MIGRATED_FLAG => 'N'
5417 );
5418 --
5419 IF FND_API.to_Boolean(nvl(p_commit,FND_API.G_FALSE)) THEN
5420 COMMIT WORK;
5421 END IF;
5422 --
5423 -- Standard call to get message count and IF count is get message info.
5424 FND_MSG_PUB.Count_And_Get
5425 ( p_count => x_msg_count,
5426 p_data => x_msg_data
5427 );
5428 EXCEPTION
5429 WHEN FND_API.G_EXC_ERROR THEN
5430 x_return_status := FND_API.G_RET_STS_ERROR ;
5431 ROLLBACK TO capture_ctr_property_reading;
5432 FND_MSG_PUB.Count_And_Get
5433 ( p_count => x_msg_count,
5434 p_data => x_msg_data
5435 );
5436 WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5437 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5438 ROLLBACK TO capture_ctr_property_reading;
5439 FND_MSG_PUB.Count_And_Get
5440 ( p_count => x_msg_count,
5441 p_data => x_msg_data
5442 );
5443 WHEN OTHERS THEN
5444 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5445 ROLLBACK TO capture_ctr_property_reading;
5446 IF FND_MSG_PUB.Check_Msg_Level (FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
5447 FND_MSG_PUB.Add_Exc_Msg
5448 ( G_PKG_NAME,
5449 l_api_name
5450 );
5451 END IF;
5452 FND_MSG_PUB.Count_And_Get
5453 ( p_count => x_msg_count,
5454 p_data => x_msg_data
5455 );
5456 END Capture_Ctr_Property_Reading;
5457 --
5458 FUNCTION Est_daily_avg(
5459 p_start_date IN DATE,
5460 p_start_reading IN NUMBER,
5461 p_end_date IN DATE,
5462 p_end_reading IN NUMBER
5463 ) RETURN NUMBER IS
5464 l_daily_avg NUMBER;
5465 BEGIN
5466 l_daily_avg := (p_end_reading-p_start_reading)/(trunc(p_end_date)-trunc(p_start_date));
5467 RETURN (l_daily_avg);
5468 END;
5469 --
5470 PROCEDURE ESTIMATE_START_READINGS(
5471 P_api_version IN NUMBER,
5472 P_Init_Msg_List IN VARCHAR2,
5473 P_Commit IN VARCHAR2,
5474 p_validation_level IN NUMBER,
5475 p_counter_id IN NUMBER,
5476 p_default_value IN NUMBER,
5477 p_calculation_start_date IN DATE,
5478 x_calc_start_reading OUT NOCOPY NUMBER,
5479 X_Return_Status OUT NOCOPY VARCHAR2,
5480 X_Msg_Count OUT NOCOPY NUMBER,
5481 X_Msg_Data OUT NOCOPY VARCHAR2
5482 )
5483 IS
5484 CURSOR PRIOR_RDG_VALUES(b_counter_id NUMBER, b_rdg_date DATE) IS
5485 select b.net_reading "prev_reading",b.value_timestamp "prev_rdg_date"
5486 from CSI_COUNTER_READINGS b
5487 where b.counter_id = b_counter_id
5488 and b.value_timestamp < b_rdg_date
5489 and nvl(b.disabled_flag,'N') = 'N'
5490 order by b.value_timestamp desc;
5491 --
5492 l_prev_reading NUMBER;
5493 l_prev_value_timestamp DATE;
5494 --
5495 CURSOR POST_RDG_VALUES(b_counter_id NUMBER, b_rdg_date DATE) IS
5496 select b.net_reading "post_reading",b.value_timestamp "post_rdg_date"
5497 from CSI_COUNTER_READINGS b
5498 where b.counter_id = b_counter_id
5499 and b.value_timestamp > b_rdg_date
5500 and nvl(b.disabled_flag,'N') = 'N'
5501 order by b.value_timestamp asc;
5502 --
5503 l_post_reading NUMBER;
5504 l_post_value_timestamp DATE;
5505 --
5506 CURSOR PASSED_DT_RDG_VALUES(b_counter_id NUMBER, b_rdg_date DATE) IS
5507 select b.net_reading "passed_dt_reading", b.value_timestamp "passed_rdg_date"
5508 from CSI_COUNTER_READINGS b
5509 where b.counter_id = b_counter_id
5510 and nvl(b.disabled_flag,'N') = 'N'
5511 and trunc(b.value_timestamp) = trunc(b_rdg_date)
5512 order by b.value_timestamp desc;
5513 --
5514 l_passed_dt_reading NUMBER;
5515 l_passed_rdg_date DATE;
5516 --
5517 CURSOR FIRST_RDG_VALUES(b_counter_id NUMBER) IS
5518 select b.net_reading "first_reading",b.value_timestamp "first_rdg_date"
5519 from CSI_COUNTER_READINGS b
5520 where b.counter_id = b_counter_id
5521 and nvl(b.disabled_flag,'N') = 'N'
5522 order by b.value_timestamp asc;
5523 --
5524 l_first_reading NUMBER;
5525 l_first_rdg_date DATE;
5526 --
5527 CURSOR CTR_START_DATE(b_counter_id NUMBER) IS
5528 select nvl(start_date_active,creation_date) "ctr_start_date"
5529 from CSI_COUNTERS_B
5530 where counter_id = b_counter_id;
5531
5532 CURSOR CTR_DIRECTION(b_counter_id NUMBER) IS
5533 select direction
5534 from CSI_COUNTERS_B
5535 where counter_id = b_counter_id;
5536 --
5537 l_ctr_direction VARCHAR2(1);
5538 --
5539 l_api_name CONSTANT VARCHAR2(30) := 'ESTIMATE_START_READINGS';
5540 l_api_version CONSTANT NUMBER := 1.0;
5541 l_calculation_start_rdg NUMBER;
5542 l_calculation_start_dt DATE;
5543 l_calc_daily_avg NUMBER;
5544 l_calc_usage NUMBER;
5545 l_calc_start_rdg NUMBER;
5546 BEGIN
5547 SAVEPOINT ESTIMATE_START_READINGS;
5548 -- Initialize message list if p_init_msg_list is set to TRUE.
5549 IF FND_API.to_Boolean( p_init_msg_list ) THEN
5550 FND_MSG_PUB.initialize;
5551 END IF;
5552 -- Initialize API return status to SUCCESS
5553 x_return_status := FND_API.G_RET_STS_SUCCESS;
5554 --
5555
5556 -- Read the debug profiles values in to global variable 7197402
5557 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
5558
5559 csi_ctr_gen_utility_pvt.put_line( 'Inside Estimate_Start_Readings...');
5560 --
5561 -- fetch the reading of the passed avg calculation start date
5562 OPEN PASSED_DT_RDG_VALUES(p_counter_id, p_calculation_start_date);
5563 FETCH PASSED_DT_RDG_VALUES
5564 INTO l_calculation_start_rdg,l_calculation_start_dt;
5565 CLOSE PASSED_DT_RDG_VALUES;
5566 -- if no actual reading on passed avg calc start dt then compute the reading.
5567 IF l_calculation_start_rdg is NULL THEN
5568 OPEN PRIOR_RDG_VALUES(p_counter_id,p_calculation_start_date);
5569 FETCH PRIOR_RDG_VALUES
5570 INTO l_prev_reading,l_prev_value_timestamp;
5571 CLOSE PRIOR_RDG_VALUES;
5572 --
5573 IF l_prev_reading IS NOT NULL THEN
5574 OPEN POST_RDG_VALUES(p_counter_id,p_calculation_start_date);
5575 FETCH POST_RDG_VALUES
5576 INTO l_post_reading,l_post_value_timestamp;
5577 CLOSE POST_RDG_VALUES;
5578 --
5579 IF l_post_reading IS NOT NULL THEN
5580 l_calc_daily_avg := Est_daily_avg(l_prev_value_timestamp,l_prev_reading,l_post_value_timestamp,l_post_reading);
5581 l_calc_usage := (trunc(p_calculation_start_date) - trunc(l_prev_value_timestamp))*l_calc_daily_avg;
5582 l_calc_start_rdg := l_prev_reading + l_calc_usage;
5583 ELSE --l_post_reading is null
5584 OPEN FIRST_RDG_VALUES(p_counter_id);
5585 FETCH FIRST_RDG_VALUES
5586 INTO l_first_reading,l_first_rdg_date;
5587 CLOSE FIRST_RDG_VALUES;
5588 --
5589 IF (trunc(l_first_rdg_date) = trunc(l_prev_value_timestamp)) THEN
5590 IF p_default_Value IS NULL THEN
5591 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_EST_DEF_VAL_NULL');
5592 END IF;
5593 --
5594 l_calc_start_rdg := (trunc(p_calculation_start_date) - trunc(l_first_rdg_date)) * p_default_Value;
5595 -- get the next reading after the period start date to check for erroneous readings
5596 -- For Descending counter
5597 OPEN CTR_DIRECTION(p_counter_id);
5598 FETCH CTR_DIRECTION
5599 INTO l_ctr_direction;
5600 CLOSE CTR_DIRECTION;
5601 --
5602 IF nvl(l_ctr_direction,'X') = 'D' THEN
5603 l_calc_start_rdg := l_first_reading - l_calc_start_rdg;
5604 ELSIF nvl(l_ctr_direction,'X') = 'A' THEN
5605 l_calc_start_rdg := l_first_reading + l_calc_start_rdg;
5606 END IF;
5607 ELSE
5608 l_calc_daily_avg := Est_daily_avg(l_first_rdg_date,l_first_reading,l_prev_value_timestamp,l_prev_reading);
5609 l_calc_usage := (trunc(p_calculation_start_date) - trunc(l_prev_value_timestamp))*l_calc_daily_avg;
5610 l_calc_start_rdg := l_prev_reading + l_calc_usage;
5611 END IF;
5612 END IF; --l_post_reading not null
5613 ELSE --prev reading is null
5614 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_NO_RDG_PR_CAL_STDT');
5615 END IF; --l_prev_reading not null
5616 --
5617 x_calc_start_reading := round(l_calc_start_rdg);
5618 --
5619 ELSE --_calculation_start_rdg not null
5620 x_calc_start_reading := round(l_calculation_start_rdg);
5621 END IF; --l_calculation_start_rdg null
5622 --
5623 IF FND_API.to_Boolean(nvl(p_commit,FND_API.G_FALSE)) THEN
5624 COMMIT WORK;
5625 END IF;
5626 --
5627 -- Standard call to get message count and IF count is get message info.
5628 FND_MSG_PUB.Count_And_Get
5629 ( p_count => x_msg_count,
5630 p_data => x_msg_data
5631 );
5632
5633 EXCEPTION
5634 WHEN FND_API.G_EXC_ERROR THEN
5635 ROLLBACK TO ESTIMATE_START_READINGS;
5636 x_return_status := FND_API.G_RET_STS_ERROR ;
5637 FND_MSG_PUB.Count_And_Get
5638 (p_count => x_msg_count,
5639 p_data => x_msg_data
5640 );
5641 WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5642 ROLLBACK TO ESTIMATE_START_READINGS;
5643 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5644 FND_MSG_PUB.Count_And_Get
5645 (
5646 p_count => x_msg_count,
5647 p_data => x_msg_data
5648 );
5649 WHEN OTHERS THEN
5650 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5651 ROLLBACK TO ESTIMATE_START_READINGS;
5652 IF FND_MSG_PUB.Check_Msg_Level (FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
5653 FND_MSG_PUB.Add_Exc_Msg
5654 ( G_PKG_NAME,
5655 l_api_name
5656 );
5657 END IF;
5658 FND_MSG_PUB.Count_And_Get
5659 ( p_count => x_msg_count,
5660 p_data => x_msg_data
5661 );
5662 END ESTIMATE_START_READINGS;
5663 --
5664 PROCEDURE EST_PERIOD_START_READINGS(
5665 P_api_version IN NUMBER,
5666 P_Init_Msg_List IN VARCHAR2,
5667 P_Commit IN VARCHAR2,
5668 p_validation_level IN NUMBER,
5669 p_counter_id IN NUMBER,
5670 p_default_value IN NUMBER,
5671 p_avg_calculation_start_date IN DATE,
5672 p_calculation_start_date IN DATE,
5673 x_calc_start_reading OUT NOCOPY NUMBER,
5674 X_Return_Status OUT NOCOPY VARCHAR2,
5675 X_Msg_Count OUT NOCOPY NUMBER,
5676 X_Msg_Data OUT NOCOPY VARCHAR2
5677 )
5678 IS
5679 l_api_name CONSTANT VARCHAR2(30) := 'EST_PERIOD_START_READINGS';
5680 l_api_version CONSTANT NUMBER := 1.0;
5681 l_msg_data VARCHAR2(2000);
5682 l_msg_index NUMBER;
5683 l_msg_count NUMBER;
5684 --
5685 CURSOR PRIOR_RDG_VALUES(b_counter_id NUMBER, b_rdg_date DATE) IS
5686 select b.net_reading "prev_reading",b.value_timestamp "prev_rdg_date"
5687 from CSI_COUNTER_READINGS b
5688 where b.counter_id = b_counter_id
5689 and b.value_timestamp < b_rdg_date
5690 and nvl(b.disabled_flag,'N') = 'N'
5691 order by b.value_timestamp desc;
5692
5693 l_prev_reading NUMBER;
5694 l_prev_value_timestamp DATE;
5695
5696 CURSOR POST_RDG_VALUES(b_counter_id NUMBER, b_rdg_date DATE) IS
5697 select b.net_reading "post_reading",b.value_timestamp "post_rdg_date"
5698 from CSI_COUNTER_READINGS b
5699 where b.counter_id = b_counter_id
5700 and b.value_timestamp > b_rdg_date
5701 and nvl(b.disabled_flag,'N') = 'N'
5702 order by b.value_timestamp asc;
5703
5704 l_post_reading NUMBER;
5705 l_post_value_timestamp DATE;
5706
5707 CURSOR PASSED_DT_RDG_VALUES(b_counter_id NUMBER, b_rdg_date DATE) IS
5708 select b.net_reading "passed_dt_reading", b.value_timestamp "passed_rdg_date"
5709 from CSI_COUNTER_READINGS b
5710 where b.counter_id = b_counter_id
5711 and nvl(b.disabled_flag,'N') = 'N'
5712 and trunc(b.value_timestamp) = trunc(b_rdg_date)
5713 order by b.value_timestamp desc;
5714
5715 l_passed_dt_reading NUMBER;
5716 l_passed_rdg_date DATE;
5717
5718 CURSOR first_rdg_values(b_counter_id NUMBER) IS
5719 select b.net_reading "first_reading",b.value_timestamp "first_rdg_date"
5720 from CSI_COUNTER_READINGS b
5721 where b.counter_id = b_counter_id
5722 and nvl(b.disabled_flag,'N') = 'N'
5723 order by b.value_timestamp asc;
5724
5725 l_first_reading NUMBER;
5726 l_first_rdg_date DATE;
5727
5728 CURSOR ctr_start_date(b_counter_id NUMBER) IS
5729 select nvl(start_date_active,creation_date) "ctr_start_date"
5730 from CSI_COUNTERS_B
5731 where counter_id = b_counter_id;
5732
5733 CURSOR CTR_DIRECTION(b_counter_id NUMBER) IS
5734 select direction
5735 from CSI_COUNTERS_B
5736 where counter_id = b_counter_id;
5737
5738 l_ctr_direction VARCHAR2(1);
5739
5740 l_calculation_start_rdg NUMBER;
5741 l_calculation_start_dt DATE;
5742 l_calc_daily_avg NUMBER;
5743 l_calc_usage NUMBER;
5744 l_calc_start_rdg NUMBER;
5745
5746 l_avg_calc_start_rdg NUMBER;
5747 BEGIN
5748 SAVEPOINT EST_PERIOD_START_READINGS;
5749 -- Initialize message list if p_init_msg_list is set to TRUE.
5750 IF FND_API.to_Boolean( p_init_msg_list ) THEN
5751 FND_MSG_PUB.initialize;
5752 END IF;
5753 -- Initialize API return status to SUCCESS
5754 x_return_status := FND_API.G_RET_STS_SUCCESS;
5755 --
5756 -- Read the debug profiles values in to global variable 7197402
5757 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
5758
5759 csi_ctr_gen_utility_pvt.put_line( 'Inside Est_Period_Start_Readings...');
5760 --
5761 IF FND_API.to_Boolean(nvl(p_commit,FND_API.G_FALSE)) THEN
5762 COMMIT WORK;
5763 END IF;
5764 --
5765 -- fetch the reading of the passed avg calculation start date
5766 OPEN PASSED_DT_RDG_VALUES(p_counter_id, p_calculation_start_date);
5767 FETCH PASSED_DT_RDG_VALUES
5768 INTO l_calculation_start_rdg,l_calculation_start_dt;
5769 CLOSE PASSED_DT_RDG_VALUES;
5770 -- if no actual reading on passed avg calc start dt then compute the reading.
5771 IF l_calculation_start_rdg is NULL THEN
5772 IF p_avg_calculation_start_date IS NULL THEN
5773 OPEN PRIOR_RDG_VALUES(p_counter_id,p_calculation_start_date);
5774 FETCH PRIOR_RDG_VALUES INTO l_prev_reading,l_prev_value_timestamp;
5775 CLOSE PRIOR_RDG_VALUES;
5776 --
5777 IF l_prev_reading IS NOT NULL THEN
5778 OPEN POST_RDG_VALUES(p_counter_id,p_calculation_start_date);
5779 FETCH POST_RDG_VALUES INTO l_post_reading,l_post_value_timestamp;
5780 CLOSE POST_RDG_VALUES;
5781 --
5782 IF l_post_reading IS NOT NULL THEN
5783 l_calc_daily_avg := Est_daily_avg(l_prev_value_timestamp,l_prev_reading,l_post_value_timestamp,l_post_reading);
5784 l_calc_usage := (trunc(p_calculation_start_date) - trunc(l_prev_value_timestamp))*l_calc_daily_avg;
5785 l_calc_start_rdg := l_prev_reading + l_calc_usage;
5786 ELSE --l_post_reading is null
5787 OPEN FIRST_RDG_VALUES(p_counter_id);
5788 FETCH FIRST_RDG_VALUES
5789 INTO l_first_reading,l_first_rdg_date;
5790 CLOSE FIRST_RDG_VALUES;
5791 --
5792 IF (trunc(l_first_rdg_date) = trunc(l_prev_value_timestamp)) THEN
5793 IF p_default_Value IS NULL THEN
5794 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_EST_DEF_VAL_NULL');
5795 END IF;
5796 l_calc_start_rdg := (trunc(p_calculation_start_date) - trunc(l_first_rdg_date)) * p_default_Value;
5797 OPEN CTR_DIRECTION(p_counter_id);
5798 FETCH CTR_DIRECTION
5799 INTO l_ctr_direction;
5800 CLOSE CTR_DIRECTION;
5801 --
5802 IF nvl(l_ctr_direction,'X') = 'D' THEN
5803 l_calc_start_rdg := l_first_reading - l_calc_start_rdg;
5804 ELSIF nvl(l_ctr_direction,'X') = 'A' THEN
5805 l_calc_start_rdg := l_first_reading + l_calc_start_rdg;
5806 END IF;
5807 ELSE
5808 l_calc_daily_avg := Est_daily_avg(l_first_rdg_date,l_first_reading,l_prev_value_timestamp,l_prev_reading);
5809 l_calc_usage := (trunc(p_calculation_start_date) - trunc(l_prev_value_timestamp))*l_calc_daily_avg;
5810 l_calc_start_rdg := l_prev_reading + l_calc_usage;
5811 END IF;
5812 END IF; --l_post_reading not null
5813 ELSE --prev reading is null
5814 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_NO_RDG_PR_PRD_STDT');
5815 END IF; --l_prev_reading not null
5816 ELSE --p avg calculation start date is not null
5817 -- get the avg calculation start reading.
5818 csi_ctr_gen_utility_pvt.put_line('Calling Estimate_Start_Readings...');
5819 ESTIMATE_START_READINGS(
5820 P_api_version => 1.0,
5821 P_Init_Msg_List => P_Init_Msg_List,
5822 P_Commit => P_Commit,
5823 p_validation_level => p_validation_level,
5824 p_counter_id => p_counter_id,
5825 p_default_value => p_default_value,
5826 p_calculation_start_date => p_avg_calculation_start_date,
5827 x_calc_start_reading => l_avg_calc_start_rdg,
5828 X_Return_Status => X_Return_Status,
5829 X_Msg_Count => X_Msg_Count,
5830 X_Msg_Data => X_Msg_Data
5831 );
5832 IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
5833 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Estimate_Start_Readings API ');
5834 l_msg_index := 1;
5835 l_msg_count := x_msg_count;
5836 WHILE l_msg_count > 0 LOOP
5837 x_msg_data := FND_MSG_PUB.GET
5838 ( l_msg_index,
5839 FND_API.G_FALSE
5840 );
5841 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
5842 l_msg_index := l_msg_index + 1;
5843 l_msg_count := l_msg_count - 1;
5844 END LOOP;
5845 RAISE FND_API.G_EXC_ERROR;
5846 END IF;
5847 --
5848 OPEN PRIOR_RDG_VALUES(p_counter_id,p_calculation_start_date);
5849 FETCH PRIOR_RDG_VALUES
5850 INTO l_prev_reading,l_prev_value_timestamp;
5851 CLOSE PRIOR_RDG_VALUES;
5852 --
5853 IF l_prev_reading IS NOT NULL THEN
5854 OPEN POST_RDG_VALUES(p_counter_id,p_calculation_start_date);
5855 FETCH POST_RDG_VALUES
5856 INTO l_post_reading,l_post_value_timestamp;
5857 CLOSE POST_RDG_VALUES;
5858 --
5859 IF l_post_reading IS NOT NULL THEN
5860 l_calc_daily_avg := Est_daily_avg(l_prev_value_timestamp,l_prev_reading,l_post_value_timestamp,l_post_reading);
5861 l_calc_usage := (trunc(p_calculation_start_date) - trunc(l_prev_value_timestamp))*l_calc_daily_avg;
5862 l_calc_start_rdg := l_prev_reading + l_calc_usage;
5863 ELSE --l_post_reading is null
5864 IF trunc(l_prev_value_timestamp) > trunc(p_avg_calculation_start_date) THEN
5865 l_calc_daily_avg := Est_daily_avg(p_avg_calculation_start_date,l_avg_calc_start_rdg,l_prev_value_timestamp,l_prev_reading);
5866 l_calc_usage := (trunc(p_calculation_start_date) - trunc(l_prev_value_timestamp)) * l_calc_daily_avg;
5867 l_calc_start_rdg := l_prev_reading + l_calc_usage;
5868 ELSE
5869 IF p_default_Value IS NULL THEN
5870 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_EST_DEF_VAL_NULL');
5871 END IF;
5872 l_calc_start_rdg := (trunc(p_calculation_start_date) - trunc(p_avg_calculation_start_date)) * p_default_Value;
5873 OPEN CTR_DIRECTION(p_counter_id);
5874 FETCH CTR_DIRECTION INTO l_ctr_direction;
5875 CLOSE CTR_DIRECTION;
5876 --
5877 IF nvl(l_ctr_direction,'X') = 'D' THEN
5878 l_calc_start_rdg := l_avg_calc_start_rdg - l_calc_start_rdg;
5879 ELSIF nvl(l_ctr_direction,'X') = 'A' THEN
5880 l_calc_start_rdg := l_avg_calc_start_rdg + l_calc_start_rdg;
5881 END IF;
5882 END IF;
5883 END IF; --l_post_reading not null
5884 ELSE --prev reading is null
5885 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_NO_RDG_PR_PRD_STDT');
5886 END IF; --l_prev_reading not null
5887 END IF; -- p avg calculation start date is null
5888 --
5889 x_calc_start_reading := round(l_calc_start_rdg);
5890 --
5891 ELSE --l_calculation_start_rdg not null
5892 x_calc_start_reading := round(l_calculation_start_rdg);
5893 END IF; --l_calculation_start_rdg null
5894 --
5895 -- Standard call to get message count and IF count is get message info.
5896 FND_MSG_PUB.Count_And_Get
5897 ( p_count => x_msg_count,
5898 p_data => x_msg_data
5899 );
5900
5901 EXCEPTION
5902 WHEN FND_API.G_EXC_ERROR THEN
5903 ROLLBACK TO EST_PERIOD_START_READINGS;
5904 x_return_status := FND_API.G_RET_STS_ERROR ;
5905 FND_MSG_PUB.Count_And_Get
5906 (p_count => x_msg_count,
5907 p_data => x_msg_data
5908 );
5909 WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
5910 ROLLBACK TO EST_PERIOD_START_READINGS;
5911 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5912 FND_MSG_PUB.Count_And_Get
5913 (
5914 p_count => x_msg_count,
5915 p_data => x_msg_data
5916 );
5917 WHEN OTHERS THEN
5918 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
5919 ROLLBACK TO EST_PERIOD_START_READINGS;
5920 IF FND_MSG_PUB.Check_Msg_Level (FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
5921 FND_MSG_PUB.Add_Exc_Msg
5922 ( G_PKG_NAME,
5923 l_api_name
5924 );
5925 END IF;
5926 FND_MSG_PUB.Count_And_Get
5927 ( p_count => x_msg_count,
5928 p_data => x_msg_data
5929 );
5930 END EST_PERIOD_START_READINGS;
5931 --
5932 PROCEDURE ESTIMATE_USAGE(
5933 P_api_version IN NUMBER,
5934 P_Init_Msg_List IN VARCHAR2,
5935 P_Commit IN VARCHAR2,
5936 p_validation_level IN NUMBER,
5937 p_counter_id IN NUMBER,
5938 p_usage_markup IN NUMBER,
5939 p_default_value IN NUMBER,
5940 p_estimation_avg_type IN VARCHAR2,
5941 p_estimation_period_start_date IN DATE,
5942 p_estimation_period_end_date IN DATE,
5943 p_avg_calculation_start_date IN DATE,
5944 p_number_of_readings IN NUMBER,
5945 x_estimated_usage_qty OUT NOCOPY NUMBER,
5946 x_estimated_meter_reading OUT NOCOPY NUMBER,
5947 x_estimated_period_start_rdg OUT NOCOPY NUMBER,
5948 X_Return_Status OUT NOCOPY VARCHAR2,
5949 X_Msg_Count OUT NOCOPY NUMBER,
5950 X_Msg_Data OUT NOCOPY VARCHAR2
5951 )
5952 IS
5953 l_api_name CONSTANT VARCHAR2(30) := 'ESTIMATE_USAGE';
5954 l_api_version CONSTANT NUMBER := 1.0;
5955 l_msg_data VARCHAR2(2000);
5956 l_msg_index NUMBER;
5957 l_msg_count NUMBER;
5958 --
5959 CURSOR PRIOR_RDG_VALUES(b_counter_id NUMBER, b_rdg_date DATE) IS
5960 select b.net_reading "prev_reading",b.value_timestamp "prev_rdg_date"
5961 from CSI_COUNTER_READINGS b
5962 where b.counter_id = b_counter_id
5963 and b.value_timestamp < b_rdg_date
5964 and nvl(b.disabled_flag,'N') = 'N'
5965 order by b.value_timestamp desc;
5966 --
5967 l_prev_reading NUMBER;
5968 l_prev_value_timestamp DATE;
5969 --
5970 CURSOR POST_RDG_VALUES(b_counter_id NUMBER, b_rdg_date DATE) IS
5971 select b.net_reading "post_reading",b.value_timestamp "post_rdg_date"
5972 from CSI_COUNTER_READINGS b
5973 where b.counter_id = b_counter_id
5974 and b.value_timestamp > b_rdg_date
5975 and nvl(b.disabled_flag,'N') = 'N'
5976 order by b.value_timestamp asc;
5977 --
5978 l_post_reading NUMBER;
5979 l_post_value_timestamp DATE;
5980
5981 CURSOR PASSED_DT_RDG_VALUES(b_counter_id NUMBER, b_rdg_date DATE) IS
5982 select b.net_reading "passed_dt_reading", b.value_timestamp "passed_rdg_date"
5983 from CSI_COUNTER_READINGS b
5984 where b.counter_id = b_counter_id
5985 and nvl(b.disabled_flag,'N') = 'N'
5986 and trunc(b.value_timestamp) = trunc(b_rdg_date)
5987 order by b.value_timestamp desc;
5988 --
5989 l_passed_dt_reading NUMBER;
5990 l_passed_rdg_date DATE;
5991
5992 CURSOR first_rdg_values(b_counter_id NUMBER) IS
5993 select b.net_reading "first_reading",b.value_timestamp "first_rdg_date"
5994 from CSI_COUNTER_READINGS b
5995 where b.counter_id = b_counter_id
5996 and nvl(b.disabled_flag,'N') = 'N'
5997 order by b.value_timestamp asc;
5998 --
5999 l_first_reading NUMBER;
6000 l_first_rdg_date DATE;
6001
6002 CURSOR ctr_start_date(b_counter_id NUMBER) IS
6003 select nvl(start_date_active,creation_date) "ctr_start_date"
6004 from CSI_COUNTERS_B
6005 where counter_id = b_counter_id;
6006 --
6007 CURSOR CTR_DIRECTION(b_counter_id NUMBER) IS
6008 select direction
6009 from CSI_COUNTERS_B
6010 where counter_id = b_counter_id;
6011 --
6012 l_ctr_direction VARCHAR2(1);
6013 --
6014 l_avg_calc_start_reading NUMBER;
6015 l_period_start_reading NUMBER;
6016
6017 l_daily_avg_for_est NUMBER;
6018 l_usage_for_est NUMBER;
6019 l_estimated_meter_rdg NUMBER;
6020 l_estimated_usage NUMBER;
6021
6022 l_num_ctr_rdg number;
6023 l_num_value_timestamp DATE;
6024
6025 lp_period_start_reading number;
6026 lprdst_num_ctr_rdg number;
6027 lprdst_num_value_timestamp date;
6028 BEGIN
6029 SAVEPOINT ESTIMATE_USAGE;
6030 -- Initialize message list if p_init_msg_list is set to TRUE.
6031 IF FND_API.to_Boolean( p_init_msg_list ) THEN
6032 FND_MSG_PUB.initialize;
6033 END IF;
6034 -- Initialize API return status to SUCCESS
6035 x_return_status := FND_API.G_RET_STS_SUCCESS;
6036 --
6037
6038 -- Read the debug profiles values in to global variable 7197402
6039 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
6040
6041 csi_ctr_gen_utility_pvt.put_line( 'Inside Estimate_Usage...');
6042 --
6043 IF p_avg_calculation_start_date IS NOT NULL THEN
6044 csi_ctr_gen_utility_pvt.put_line('Calling Estimate_Start_Readings...');
6045 ESTIMATE_START_READINGS(
6046 P_api_version => 1.0,
6047 P_Init_Msg_List => P_Init_Msg_List,
6048 P_Commit => P_Commit,
6049 p_validation_level => p_validation_level,
6050 p_counter_id => p_counter_id,
6051 p_default_value => p_default_value,
6052 p_calculation_start_date => p_avg_calculation_start_date,
6053 x_calc_start_reading => l_avg_calc_start_reading,
6054 X_Return_Status => X_Return_Status,
6055 X_Msg_Count => X_Msg_Count,
6056 X_Msg_Data => X_Msg_Data
6057 );
6058 IF x_return_status<>FND_API.G_RET_STS_SUCCESS THEN
6059 l_msg_index := 1;
6060 l_msg_count := x_msg_count;
6061 WHILE l_msg_count > 0 LOOP
6062 x_msg_data := FND_MSG_PUB.GET
6063 ( l_msg_index,
6064 FND_API.G_FALSE
6065 );
6066 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Estimate_Start_Readings API ');
6067 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
6068 l_msg_index := l_msg_index + 1;
6069 l_msg_count := l_msg_count - 1;
6070 END LOOP;
6071 RAISE FND_API.G_EXC_ERROR;
6072 END IF;
6073 END IF;
6074
6075 IF p_estimation_period_start_date IS NOT NULL THEN
6076 csi_ctr_gen_utility_pvt.put_line('Calling Est_Period_Start_Readings...');
6077 EST_PERIOD_START_READINGS(
6078 P_api_version => 1.0,
6079 P_Init_Msg_List => P_Init_Msg_List,
6080 P_Commit => P_Commit,
6081 p_validation_level => p_validation_level,
6082 p_counter_id => p_counter_id,
6083 p_default_value => p_default_value,
6084 p_avg_calculation_start_date => p_avg_calculation_start_date,
6085 p_calculation_start_date => p_estimation_period_start_date,
6086 x_calc_start_reading => l_period_start_reading,
6087 X_Return_Status => X_Return_Status,
6088 X_Msg_Count => X_Msg_Count,
6089 X_Msg_Data => X_Msg_Data
6090 );
6091 IF x_return_status<>FND_API.G_RET_STS_SUCCESS THEN
6092 l_msg_index := 1;
6093 l_msg_count := x_msg_count;
6094 WHILE l_msg_count > 0 LOOP
6095 x_msg_data := FND_MSG_PUB.GET
6096 ( l_msg_index,
6097 FND_API.G_FALSE
6098 );
6099 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Est_Period_Start_Readings API ');
6100 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
6101 l_msg_index := l_msg_index + 1;
6102 l_msg_count := l_msg_count - 1;
6103 END LOOP;
6104 RAISE FND_API.G_EXC_ERROR;
6105 END IF;
6106 END IF;
6107 -- estimation usage calculation
6108 -- fetch the reading of the passed estimation period end date
6109 OPEN PASSED_DT_RDG_VALUES(p_counter_id, p_estimation_period_end_date);
6110 FETCH PASSED_DT_RDG_VALUES
6111 INTO l_estimated_meter_rdg,l_passed_rdg_date;
6112 CLOSE PASSED_DT_RDG_VALUES;
6113 -- if no actual reading on passed estimation period end dt then compute the reading.
6114 IF l_estimated_meter_rdg is NULL THEN
6115 IF p_avg_calculation_start_date IS NOT NULL THEN
6116 OPEN PRIOR_RDG_VALUES(p_counter_id, p_estimation_period_end_date);
6117 FETCH PRIOR_RDG_VALUES
6118 INTO l_prev_reading,l_prev_value_timestamp;
6119 CLOSE PRIOR_RDG_VALUES;
6120 --
6121 IF l_prev_reading IS NOT NULL THEN
6122 OPEN POST_RDG_VALUES(p_counter_id,p_estimation_period_end_date);
6123 FETCH POST_RDG_VALUES
6124 INTO l_post_reading,l_post_value_timestamp;
6125 CLOSE POST_RDG_VALUES;
6126 --
6127 IF l_post_reading IS NOT NULL THEN
6128 l_daily_avg_for_est := Est_daily_avg(l_prev_value_timestamp,l_prev_reading,l_post_value_timestamp,l_post_reading);
6129 l_usage_for_est := (trunc(p_estimation_period_end_date) - trunc(l_prev_value_timestamp)) * l_daily_avg_for_est;
6130 l_usage_for_est := l_usage_for_est + ((nvl(p_usage_markup,0)/100) * (l_usage_for_est));
6131 l_estimated_meter_rdg := l_prev_reading + l_usage_for_est;
6132 IF p_estimation_period_start_date IS NOT NULL THEN
6133 l_estimated_usage := l_estimated_meter_rdg - l_period_start_reading;
6134 END IF;
6135 ELSE --l_post_reading is null
6136 IF trunc(l_prev_value_timestamp) > trunc(p_avg_calculation_start_date) THEN
6137 l_daily_avg_for_est := Est_daily_avg(p_avg_calculation_start_date,l_avg_calc_start_reading,l_prev_value_timestamp,l_prev_reading);
6138 l_usage_for_est := (trunc(p_estimation_period_end_date) - trunc(l_prev_value_timestamp)) * l_daily_avg_for_est;
6139 l_usage_for_est := l_usage_for_est + ((nvl(p_usage_markup,0)/100) * (l_usage_for_est));
6140 l_estimated_meter_rdg := l_prev_reading + l_usage_for_est;
6141 IF p_estimation_period_start_date IS NOT NULL THEN
6142 l_estimated_usage := l_estimated_meter_rdg - l_period_start_reading;
6143 END IF;
6144 ELSE
6145 IF p_default_Value IS NULL THEN
6146 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_EST_DEF_VAL_NULL');
6147 END IF;
6148 l_estimated_meter_rdg := (trunc(p_estimation_period_end_date) - trunc(p_avg_calculation_start_date)) * p_default_Value;
6149 l_estimated_meter_rdg := l_estimated_meter_rdg + ((nvl(p_usage_markup,0)/100) * (l_estimated_meter_rdg));
6150 -- get the next reading after the period start date to check for erroneous readings
6151 OPEN CTR_DIRECTION(p_counter_id);
6152 FETCH CTR_DIRECTION
6153 INTO l_ctr_direction;
6154 CLOSE CTR_DIRECTION;
6155 --
6156 IF nvl(l_ctr_direction,'X') = 'D' THEN
6157 l_estimated_meter_rdg := l_avg_calc_start_reading - l_estimated_meter_rdg;
6158 ELSIF nvl(l_ctr_direction,'X') = 'A' THEN
6159 l_estimated_meter_rdg := l_avg_calc_start_reading + l_estimated_meter_rdg;
6160 END IF;
6161 --
6162 IF p_estimation_period_start_date IS NOT NULL THEN
6163 l_estimated_usage := l_estimated_meter_rdg - l_period_start_reading;
6164 END IF;
6165 END IF; --l_prev_value_timestamp>p_avg_calculation_start_date
6166 END IF; --l_post_reading not null
6167 ELSE --l_prev_reading is null
6168 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_NO_RDG_PR_PRD_ENDT');
6169 END IF; --l_prev_reading not null
6170 ELSIF P_number_of_readings is not null then -- p_number of rdgs not null
6171 Declare
6172 n number;
6173 j number := 0;
6174 l_min_seqno number;
6175 CURSOR CTR_RDGS(d1_counter_id number, b_prd_rdg_date DATE) IS
6176 select cval.net_reading AS NET_RDG, cval.value_timestamp
6177 from CSI_COUNTER_READINGS cval
6178 where cval.counter_id = d1_counter_id
6179 and cval.value_timestamp < b_prd_rdg_date
6180 and nvl(cval.disabled_flag,'N') = 'N'
6181 order by cval.value_timestamp desc;
6182 --for prd start reading
6183 n1 number;
6184 j1 number := 0;
6185 Begin
6186 -- estimation start meter reading.
6187 IF p_estimation_period_start_date IS NOT NULL THEN
6188 FOR prd_st_ctr_rdgs_rec in CTR_RDGS(p_counter_id,p_estimation_period_start_date) LOOP
6189 j1 := j1+1;
6190 lprdst_num_ctr_rdg := nvl(prd_st_ctr_rdgs_rec.net_rdg,0);
6191 lprdst_num_value_timestamp := prd_st_ctr_rdgs_rec.value_timestamp;
6192 IF j1 = p_number_of_readings then
6193 exit;
6194 END IF;
6195 END LOOP;
6196 --
6197 IF J1 < 2 THEN
6198 lprdst_num_ctr_rdg := null;
6199 csi_ctr_gen_utility_pvt.ExitWithErrMsg
6200 ( p_msg_name => 'CSI_API_CTR_INVD_NUM_OF_RDGS',
6201 p_token1_name => 'P_NUMBER_OF_READINGS',
6202 p_token1_val => to_char(p_number_of_readings)
6203 );
6204 ELSE
6205 OPEN PRIOR_RDG_VALUES(p_counter_id, p_estimation_period_start_date);
6206 FETCH PRIOR_RDG_VALUES
6207 INTO l_prev_reading,l_prev_value_timestamp;
6208 CLOSE PRIOR_RDG_VALUES;
6209 --
6210 IF l_prev_reading IS NOT NULL THEN
6211 l_daily_avg_for_est := Est_daily_avg(lprdst_num_value_timestamp,lprdst_num_ctr_rdg,l_prev_value_timestamp,l_prev_reading);
6212 l_usage_for_est := (trunc(p_estimation_period_start_date) - trunc(l_prev_value_timestamp)) * l_daily_avg_for_est;
6213 lp_period_start_reading := l_prev_reading + l_usage_for_est;
6214 l_period_start_reading := round(lp_period_start_reading);
6215 ELSE
6216 csi_ctr_gen_utility_pvt.ExitWithErrMsg
6217 ( p_msg_name => 'CSI_API_CTR_INVD_NUM_OF_RDGS',
6218 p_token1_name => 'P_NUMBER_OF_READINGS',
6219 p_token1_val => to_char(p_number_of_readings)
6220 );
6221 END IF;
6222 END IF;
6223 END IF;
6224 --
6225 l_prev_reading := null;
6226 l_prev_value_timestamp := null;
6227 l_daily_avg_for_est := null;
6228 l_usage_for_est := null;
6229 --estimation end meter reading.
6230 FOR ctr_rdgs_rec in CTR_RDGS(p_counter_id, p_estimation_period_end_date) LOOP
6231 j:=j+1;
6232 l_num_ctr_rdg := nvl(ctr_rdgs_rec.net_rdg,0);
6233 l_num_value_timestamp := ctr_rdgs_rec.value_timestamp;
6234 IF j = p_number_of_readings then
6235 exit;
6236 END IF;
6237 END LOOP;
6238 --
6239 IF J < 2 THEN --J <> p_number_of_readings then
6240 l_num_ctr_rdg := null;
6241 csi_ctr_gen_utility_pvt.ExitWithErrMsg
6242 ( p_msg_name => 'CSI_API_CTR_INVD_NUM_OF_RDGS',
6243 p_token1_name => 'P_NUMBER_OF_READINGS',
6244 p_token1_val => to_char(p_number_of_readings)
6245 );
6246 END IF;
6247 End;
6248 --
6249 OPEN PRIOR_RDG_VALUES(p_counter_id, p_estimation_period_end_date);
6250 FETCH PRIOR_RDG_VALUES INTO l_prev_reading,l_prev_value_timestamp;
6251 CLOSE PRIOR_RDG_VALUES;
6252 IF l_prev_reading IS NOT NULL THEN
6253 l_daily_avg_for_est := Est_daily_avg(l_num_value_timestamp,l_num_ctr_rdg,l_prev_value_timestamp,l_prev_reading);
6254 l_usage_for_est := (trunc(p_estimation_period_end_date) - trunc(l_prev_value_timestamp)) * l_daily_avg_for_est;
6255 l_usage_for_est := l_usage_for_est + ((nvl(p_usage_markup,0)/100) * (l_usage_for_est));
6256 l_estimated_meter_rdg := l_prev_reading + l_usage_for_est;
6257 IF p_estimation_period_start_date IS NOT NULL THEN
6258 l_estimated_usage := l_estimated_meter_rdg - lp_period_start_reading;
6259 END IF;
6260 ELSE
6261 csi_ctr_gen_utility_pvt.ExitWithErrMsg
6262 ( p_msg_name => 'CSI_API_CTR_INVD_NUM_OF_RDGS',
6263 p_token1_name => 'P_NUMBER_OF_READINGS',
6264 p_token1_val => to_char(p_number_of_readings)
6265 );
6266 END IF;
6267 ELSIF p_avg_calculation_start_date IS NULL and P_number_of_readings IS NULL THEN
6268 OPEN PRIOR_RDG_VALUES(p_counter_id, p_estimation_period_end_date);
6269 FETCH PRIOR_RDG_VALUES
6270 INTO l_prev_reading,l_prev_value_timestamp;
6271 CLOSE PRIOR_RDG_VALUES;
6272 --
6273 IF l_prev_reading IS NOT NULL THEN
6274 OPEN POST_RDG_VALUES(p_counter_id,p_estimation_period_end_date);
6275 FETCH POST_RDG_VALUES
6276 INTO l_post_reading,l_post_value_timestamp;
6277 CLOSE POST_RDG_VALUES;
6278 --
6279 IF l_post_reading IS NOT NULL THEN
6280 l_daily_avg_for_est := Est_daily_avg(l_prev_value_timestamp,l_prev_reading,l_post_value_timestamp,l_post_reading);
6281 l_usage_for_est := (trunc(p_estimation_period_end_date) - trunc(l_prev_value_timestamp)) * l_daily_avg_for_est;
6282 l_usage_for_est := l_usage_for_est + ((nvl(p_usage_markup,0)/100) * (l_usage_for_est));
6283 l_estimated_meter_rdg := l_prev_reading + l_usage_for_est;
6284 IF p_estimation_period_start_date IS NOT NULL THEN
6285 l_estimated_usage := l_estimated_meter_rdg - l_period_start_reading;
6286 END IF;
6287 ELSE --l_post_reading is null
6288 OPEN FIRST_RDG_VALUES(p_counter_id);
6289 FETCH FIRST_RDG_VALUES
6290 INTO l_first_reading,l_first_rdg_date;
6291 CLOSE FIRST_RDG_VALUES;
6292 --
6293 IF trunc(l_prev_value_timestamp) = trunc(l_first_rdg_date) THEN
6294 IF p_default_Value IS NULL THEN
6295 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_EST_DEF_VAL_NULL');
6296 END IF;
6297 l_estimated_meter_rdg := (trunc(p_estimation_period_end_date) - trunc(l_first_rdg_date)) * p_default_Value;
6298 l_estimated_meter_rdg := l_estimated_meter_rdg + ((nvl(p_usage_markup,0)/100) * (l_estimated_meter_rdg));
6299 OPEN CTR_DIRECTION(p_counter_id);
6300 FETCH CTR_DIRECTION
6301 INTO l_ctr_direction;
6302 CLOSE CTR_DIRECTION;
6303 --
6304 IF nvl(l_ctr_direction,'X') = 'D' THEN
6305 l_estimated_meter_rdg := l_first_reading - l_estimated_meter_rdg;
6306 ELSIF nvl(l_ctr_direction,'X') = 'A' THEN
6307 l_estimated_meter_rdg := l_first_reading + l_estimated_meter_rdg;
6308 END IF;
6309 IF p_estimation_period_start_date IS NOT NULL THEN
6310 l_estimated_usage := l_estimated_meter_rdg - l_period_start_reading;
6311 END IF;
6312 ELSE
6313 l_daily_avg_for_est := Est_daily_avg(l_first_rdg_date,l_first_reading,l_prev_value_timestamp,l_prev_reading);
6314 l_usage_for_est := (trunc(p_estimation_period_end_date) - trunc(l_prev_value_timestamp)) * l_daily_avg_for_est;
6315 l_usage_for_est := l_usage_for_est + ((nvl(p_usage_markup,0)/100) * (l_usage_for_est));
6316 l_estimated_meter_rdg := l_prev_reading + l_usage_for_est;
6317 IF p_estimation_period_start_date IS NOT NULL THEN
6318 l_estimated_usage := l_estimated_meter_rdg - l_period_start_reading;
6319 END IF;
6320 END IF;
6321 END IF; --l_post_reading not null
6322 ELSE --l_prev_reading is null
6323 --error out - not enough readings to calculate the estimation
6324 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_NO_RDG_PR_PRD_ENDT');
6325 END IF;
6326 END IF; --p_avg_calculation_start_date not null
6327 ELSE --l_estimated_meter_rdg is NOT NULL
6328 IF p_estimation_period_start_date IS NOT NULL THEN
6329 l_estimated_usage := l_estimated_meter_rdg - l_period_start_reading;
6330 END IF;
6331 END IF; -- l_estimated_meter_rdg is NULL
6332 --
6333 x_estimated_meter_reading := round(l_estimated_meter_rdg);
6334 x_estimated_usage_qty := abs(round(l_estimated_usage));
6335 x_estimated_period_start_rdg := l_period_start_reading;
6336 --
6337 IF FND_API.to_Boolean(nvl(p_commit,FND_API.G_FALSE)) THEN
6338 COMMIT WORK;
6339 END IF;
6340 --
6341 -- Standard call to get message count and IF count is get message info.
6342 FND_MSG_PUB.Count_And_Get
6343 ( p_count => x_msg_count,
6344 p_data => x_msg_data
6345 );
6346
6347 EXCEPTION
6348 WHEN FND_API.G_EXC_ERROR THEN
6349 ROLLBACK TO ESTIMATE_USAGE;
6350 x_return_status := FND_API.G_RET_STS_ERROR ;
6351 FND_MSG_PUB.Count_And_Get
6352 (p_count => x_msg_count,
6353 p_data => x_msg_data
6354 );
6355 WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6356 ROLLBACK TO ESTIMATE_USAGE;
6357 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6358 FND_MSG_PUB.Count_And_Get
6359 (
6360 p_count => x_msg_count,
6361 p_data => x_msg_data
6362 );
6363 WHEN OTHERS THEN
6364 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6365 ROLLBACK TO ESTIMATE_USAGE;
6366 IF FND_MSG_PUB.Check_Msg_Level (FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
6367 FND_MSG_PUB.Add_Exc_Msg
6368 ( G_PKG_NAME,
6369 l_api_name
6370 );
6371 END IF;
6372 FND_MSG_PUB.Count_And_Get
6373 ( p_count => x_msg_count,
6374 p_data => x_msg_data
6375 );
6376 END ESTIMATE_USAGE;
6377 --
6378 PROCEDURE ESTIMATE_COUNTER_READING(
6379 P_api_version IN NUMBER,
6380 P_Init_Msg_List IN VARCHAR2,
6381 P_Commit IN VARCHAR2,
6382 p_validation_level IN NUMBER,
6383 p_counter_id IN NUMBER,
6384 p_estimation_period_start_date IN DATE,
6385 p_estimation_period_end_date IN DATE,
6386 p_avg_calculation_start_date IN DATE,
6387 p_number_of_readings IN NUMBER,
6388 x_estimated_usage_qty OUT NOCOPY NUMBER,
6389 x_estimated_meter_reading OUT NOCOPY NUMBER,
6390 x_estimated_period_start_rdg OUT NOCOPY NUMBER,
6391 X_Return_Status OUT NOCOPY VARCHAR2,
6392 X_Msg_Count OUT NOCOPY NUMBER,
6393 X_Msg_Data OUT NOCOPY VARCHAR2
6394 )
6395 IS
6396 l_api_name CONSTANT VARCHAR2(30) := 'ESTIMATE_COUNTER_READING';
6397 l_api_version CONSTANT NUMBER := 1.0;
6398 l_msg_data VARCHAR2(2000);
6399 l_msg_index NUMBER;
6400 l_msg_count NUMBER;
6401 l_estimated_rdg_id NUMBER;
6402 l_process_flag BOOLEAN := TRUE;
6403 --
6404 CURSOR CTREST_REC IS
6405 select group_id counter_group_id,estimation_id
6406 from CSI_COUNTERS_B
6407 where counter_id = p_counter_id;
6408 --
6409 l_counter_group_id NUMBER;
6410 l_estimation_id NUMBER;
6411 --
6412 CURSOR EST_REC(b_estimation_id NUMBER) IS
6413 select name, estimation_type, fixed_value, usage_markup,
6414 default_value, estimation_avg_type
6415 from CSI_CTR_ESTIMATE_METHODS_VL
6416 where estimation_id = b_estimation_id;
6417 --
6418 l_est_rec est_rec%rowtype;
6419 --
6420 CURSOR REF_COUNTER(b_counter_group_id NUMBER,b_counter_id NUMBER) IS
6421 select counter_id
6422 from CSI_COUNTERS_B -- Need to change
6423 where group_id = b_counter_group_id
6424 and created_from_counter_tmpl_id =b_counter_id;
6425 --
6426 l_ref_counter_id NUMBER;
6427 --
6428 l_dummy VARCHAR2(1);
6429 l_estimation_period_start_date DATE;
6430 --
6431 -- cursor to fetch the captured reading of the period end date if exists.
6432 CURSOR EST_DT_RDG_VALUES(b_counter_id NUMBER, b_rdg_date DATE) IS
6433 select b.net_reading "passed_dt_reading", b.value_timestamp "passed_rdg_date"
6434 from CSI_COUNTER_READINGS b
6435 where b.counter_id = b_counter_id
6436 and nvl(b.disabled_flag,'N') = 'N'
6437 and trunc(b.value_timestamp) = trunc(b_rdg_date)
6438 order by b.value_timestamp desc;
6439 --
6440 l_est_dt_reading NUMBER;
6441 l_est_rdg_date DATE;
6442
6443 -- cursor to check whether any counter readings exist
6444 CURSOR CTR_RDGS_EXIST(b_counter_id NUMBER) IS
6445 select counter_value_id
6446 FROM CSI_COUNTER_READINGS
6447 WHERE counter_id = b_counter_id
6448 and nvl(disabled_flag,'N') = 'N';
6449 --
6450 l_ctr_val_id NUMBER;
6451 BEGIN
6452 SAVEPOINT ESTIMATE_COUNTER_READING;
6453 -- Initialize message list if p_init_msg_list is set to TRUE.
6454 IF FND_API.to_Boolean( p_init_msg_list ) THEN
6455 FND_MSG_PUB.initialize;
6456 END IF;
6457 -- Initialize API return status to SUCCESS
6458 x_return_status := FND_API.G_RET_STS_SUCCESS;
6459 --
6460 -- Read the debug profiles values in to global variable 7197402
6461 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
6462
6463 csi_ctr_gen_utility_pvt.put_line( 'Inside Estimate_Counter_Reading...');
6464 --
6465 -- Standard call to check for call compatibility.
6466 IF NOT FND_API.Compatible_API_Call (l_api_version,
6467 p_api_version,
6468 l_api_name ,
6469 G_PKG_NAME ) THEN
6470 RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
6471 END IF;
6472 --
6473 IF p_counter_id IS NULL or p_estimation_period_end_date IS NULL THEN
6474 csi_ctr_gen_utility_pvt.ExitWithErrMsg
6475 ( p_msg_name => 'CSI_API_CTR_CTRID_PRD_ENDDT',
6476 p_token1_name => 'P_COUNTER_ID',
6477 p_token1_val => to_char(p_counter_id),
6478 p_token2_name => 'P_ESTIMATION_PERIOD_END_DATE',
6479 p_token2_val => to_char(p_estimation_period_end_date,nvl(fnd_profile.value('ICX_DATE_FORMAT_MASK'),'DD-MON-YYYY HH24:MI:SS'))
6480 );
6481 END IF;
6482 IF p_avg_calculation_start_date IS NOT NULL and p_number_of_readings IS NOT NULL THEN
6483 csi_ctr_gen_utility_pvt.ExitWithErrMsg
6484 ( p_msg_name => 'CSI_API_CTR_CAL_STDT_NUM_RDGS',
6485 p_token1_name => 'P_AVG_CALCULATION_START_DATE',
6486 p_token1_val => to_char(p_avg_calculation_start_date,nvl(fnd_profile.value('ICX_DATE_FORMAT_MASK'),'DD-MON-YYYY HH24:MI:SS')),
6487 p_token2_name => 'P_NUMBER_OF_READINGS',
6488 p_token2_val => to_char(p_number_of_readings)
6489 );
6490 END IF;
6491
6492 IF NOT trunc(p_estimation_period_start_date) <= trunc(p_estimation_period_end_date) THEN
6493 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_INV_PRD_ST_END_DT');
6494 END IF;
6495
6496 IF NOT trunc(p_avg_calculation_start_date) < trunc(p_estimation_period_start_date) THEN
6497 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_CAL_STDT_PRD_STDT');
6498 END IF;
6499
6500 IF NOT trunc(p_avg_calculation_start_date) < trunc(p_estimation_period_end_date) THEN
6501 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_CAL_STDT_PRD_ENDDT');
6502 END IF;
6503 --
6504 BEGIN
6505 select 'X' into l_dummy
6506 from CSI_COUNTERS_B
6507 where counter_id = p_Counter_id;
6508 EXCEPTION
6509 when no_data_found then
6510 csi_ctr_gen_utility_pvt.ExitWithErrMsg
6511 ( p_msg_name => 'CSI_API_CTR_INVALID',
6512 p_token1_name => 'MODE',
6513 p_token1_val => 'Counter'
6514 );
6515 END;
6516 --
6517 OPEN CTREST_REC;
6518 FETCH CTREST_REC
6519 INTO l_counter_group_id,l_estimation_id;
6520 CLOSE CTREST_REC;
6521 --
6522 OPEN EST_REC(l_estimation_id);
6523 FETCH EST_REC INTO l_est_rec;
6524 CLOSE EST_REC;
6525 --
6526 IF p_estimation_period_start_date IS NOT NULL THEN
6527 l_estimation_period_start_date := p_estimation_period_start_date -1;
6528 END IF;
6529
6530 IF l_est_rec.estimation_type in ('FIXED','USAGE') THEN
6531 -- if no counter reading exists then exit the estimation routine
6532 OPEN CTR_RDGS_EXIST(p_counter_id);
6533 FETCH CTR_RDGS_EXIST into l_ctr_val_id;
6534 CLOSE CTR_RDGS_EXIST;
6535 IF l_ctr_val_id IS NULL THEN
6536 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_NO_RDGS_EXIST');
6537 END IF;
6538 END IF;
6539
6540 IF l_est_rec.estimation_type = 'FIXED' THEN
6541 /********************
6542 Compute Fixed Value Estimation
6543 ********************/
6544 csi_ctr_gen_utility_pvt.put_line('Calling Estimate_fixed_values...');
6545 --
6546 Estimate_fixed_values(
6547 P_api_version => 1.0,
6548 P_Init_Msg_List => P_Init_Msg_List,
6549 P_Commit => P_Commit,
6550 p_validation_level => p_validation_level,
6551 p_counter_id => p_counter_id,
6552 p_fixed_value => l_est_rec.fixed_value,
6553 p_default_value => l_est_rec.default_value,
6554 p_estimation_period_start_date => l_estimation_period_start_date,
6555 p_estimation_period_end_date => p_estimation_period_end_date,
6556 x_estimated_meter_reading => x_estimated_meter_reading,
6557 x_estimated_usage_qty => x_estimated_usage_qty,
6558 x_estimated_period_start_rdg => x_estimated_period_start_rdg,
6559 X_Return_Status => X_Return_Status,
6560 X_Msg_Count => X_Msg_Count,
6561 X_Msg_Data => X_Msg_Data
6562 );
6563 IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
6564 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Estimate_fixed_values API ');
6565 l_msg_index := 1;
6566 l_msg_count := x_msg_count;
6567 WHILE l_msg_count > 0 LOOP
6568 x_msg_data := FND_MSG_PUB.GET
6569 ( l_msg_index,
6570 FND_API.G_FALSE
6571 );
6572 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
6573 l_msg_index := l_msg_index + 1;
6574 l_msg_count := l_msg_count - 1;
6575 END LOOP;
6576 RAISE FND_API.G_EXC_ERROR;
6577 END IF;
6578
6579 ELSIF l_est_rec.estimation_type = 'USAGE' THEN
6580 /********************
6581 Compute Usage of direct counter Estimation
6582 *******************/
6583 csi_ctr_gen_utility_pvt.put_line('Calling Estimate_Usage...');
6584 Estimate_Usage(
6585 P_api_version => 1.0,
6586 P_Init_Msg_List => P_Init_Msg_List,
6587 P_Commit => P_Commit,
6588 p_validation_level => p_validation_level,
6589 p_counter_id => p_counter_id,
6590 p_usage_markup => l_est_rec.usage_markup,
6591 p_default_value => l_est_rec.default_value,
6592 p_estimation_avg_type => l_est_rec.estimation_avg_type,
6593 p_estimation_period_start_date => l_estimation_period_start_date,
6594 p_estimation_period_end_date => p_estimation_period_end_date,
6595 p_avg_calculation_start_date => p_avg_calculation_start_date,
6596 p_number_of_readings => p_number_of_readings,
6597 x_estimated_usage_qty => x_estimated_usage_qty,
6598 x_estimated_meter_reading => x_estimated_meter_reading,
6599 x_estimated_period_start_rdg => x_estimated_period_start_rdg,
6600 X_Return_Status => X_Return_Status,
6601 X_Msg_Count => X_Msg_Count,
6602 X_Msg_Data => X_Msg_Data
6603 );
6604 IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
6605 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Estimate_Usage API ');
6606 l_msg_index := 1;
6607 l_msg_count := x_msg_count;
6608 WHILE l_msg_count > 0 LOOP
6609 x_msg_data := FND_MSG_PUB.GET
6610 ( l_msg_index,
6611 FND_API.G_FALSE
6612 );
6613 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
6614 l_msg_index := l_msg_index + 1;
6615 l_msg_count := l_msg_count - 1;
6616 END LOOP;
6617 RAISE FND_API.G_EXC_ERROR;
6618 END IF;
6619 ELSIF l_est_rec.estimation_type = 'REFCTR' THEN
6620 /********************
6621 Compute Usage of indirect counter Estimation
6622 *******************/
6623
6624 OPEN REF_COUNTER(l_counter_group_id,p_counter_id);
6625 FETCH REF_COUNTER INTO l_ref_counter_id;
6626 CLOSE REF_COUNTER;
6627 -- if no counter readings exist for the counter then exit.
6628 OPEN CTR_RDGS_EXIST(l_ref_counter_id);
6629 FETCH CTR_RDGS_EXIST into l_ctr_val_id;
6630 close CTR_RDGS_EXIST;
6631 --
6632 IF l_ctr_val_id IS NULL THEN
6633 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_NO_RDGS_EXIST');
6634 END IF;
6635
6636 Estimate_Usage(
6637 P_api_version => 1.0,
6638 P_Init_Msg_List => P_Init_Msg_List,
6639 P_Commit => P_Commit,
6640 p_validation_level => p_validation_level,
6641 p_counter_id => l_ref_counter_id,
6642 p_usage_markup => l_est_rec.usage_markup,
6643 p_default_value => l_est_rec.default_value,
6644 p_estimation_avg_type => l_est_rec.estimation_avg_type,
6645 p_estimation_period_start_date => l_estimation_period_start_date,
6646 p_estimation_period_end_date => p_estimation_period_end_date,
6647 p_avg_calculation_start_date => p_avg_calculation_start_date,
6648 p_number_of_readings => p_number_of_readings,
6649 x_estimated_usage_qty => x_estimated_usage_qty,
6650 x_estimated_meter_reading => x_estimated_meter_reading,
6651 x_estimated_period_start_rdg => x_estimated_period_start_rdg,
6652 X_Return_Status => X_Return_Status,
6653 X_Msg_Count => X_Msg_Count,
6654 X_Msg_Data => X_Msg_Data
6655 );
6656 IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
6657 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Estimate_Usage API ');
6658 l_msg_index := 1;
6659 l_msg_count := x_msg_count;
6660 WHILE l_msg_count > 0 LOOP
6661 x_msg_data := FND_MSG_PUB.GET
6662 ( l_msg_index,
6663 FND_API.G_FALSE
6664 );
6665 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
6666 l_msg_index := l_msg_index + 1;
6667 l_msg_count := l_msg_count - 1;
6668 END LOOP;
6669 RAISE FND_API.G_EXC_ERROR;
6670 END IF;
6671 END IF;
6672 --
6673 -- Generate the Value_id for insert
6674 l_process_flag := TRUE;
6675 WHILE l_process_flag LOOP
6676 select CSI_CTR_ESTIMATED_READINGS_S.nextval
6677 into l_estimated_rdg_id from dual;
6678 IF NOT Estimated_Rdg_ID_Exists(l_estimated_rdg_id) THEN
6679 l_process_flag := FALSE;
6680 END IF;
6681 END LOOP;
6682 --
6683 CSI_CTR_ESTIMATED_READINGS_PKG.Insert_Row
6684 (
6685 px_ESTIMATED_READING_ID => l_estimated_rdg_id
6686 ,p_COUNTER_ID => p_counter_id
6687 ,p_ESTIMATION_ID => l_estimation_id
6688 ,p_VALUE_TIMESTAMP => SYSDATE
6689 ,p_ESTIMATED_METER_READING => x_estimated_meter_reading
6690 ,p_NUM_OF_READINGS => p_number_of_readings
6691 ,p_PERIOD_START_DATE => p_estimation_period_start_date
6692 ,p_PERIOD_END_DATE => p_estimation_period_end_date
6693 ,p_AVG_CALCULATION_START_DATE => p_avg_calculation_start_date
6694 ,p_ESTIMATED_USAGE => x_estimated_usage_qty
6695 ,p_ATTRIBUTE1 => NULL
6696 ,p_ATTRIBUTE2 => NULL
6697 ,p_ATTRIBUTE3 => NULL
6698 ,p_ATTRIBUTE4 => NULL
6699 ,p_ATTRIBUTE5 => NULL
6700 ,p_ATTRIBUTE6 => NULL
6701 ,p_ATTRIBUTE7 => NULL
6702 ,p_ATTRIBUTE8 => NULL
6703 ,p_ATTRIBUTE9 => NULL
6704 ,p_ATTRIBUTE10 => NULL
6705 ,p_ATTRIBUTE11 => NULL
6706 ,p_ATTRIBUTE12 => NULL
6707 ,p_ATTRIBUTE13 => NULL
6708 ,p_ATTRIBUTE14 => NULL
6709 ,p_ATTRIBUTE15 => NULL
6710 ,p_ATTRIBUTE_CATEGORY => NULL
6711 ,p_LAST_UPDATE_DATE => SYSDATE
6712 ,p_LAST_UPDATED_BY => fnd_global.user_id
6713 ,p_LAST_UPDATE_LOGIN => fnd_global.conc_login_id
6714 ,p_CREATION_DATE => SYSDATE
6715 ,p_CREATED_BY => fnd_global.user_id
6716 ,p_OBJECT_VERSION_NUMBER => 1
6717 ,p_MIGRATED_FLAG => 'N'
6718 );
6719 --
6720 IF FND_API.to_Boolean(nvl(p_commit,FND_API.G_FALSE)) THEN
6721 COMMIT WORK;
6722 END IF;
6723 --
6724 -- Standard call to get message count and IF count is get message info.
6725 FND_MSG_PUB.Count_And_Get
6726 ( p_count => x_msg_count,
6727 p_data => x_msg_data
6728 );
6729
6730 EXCEPTION
6731 WHEN FND_API.G_EXC_ERROR THEN
6732 ROLLBACK TO ESTIMATE_COUNTER_READING;
6733 x_return_status := FND_API.G_RET_STS_ERROR ;
6734 FND_MSG_PUB.Count_And_Get
6735 (p_count => x_msg_count,
6736 p_data => x_msg_data
6737 );
6738 WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6739 ROLLBACK TO ESTIMATE_COUNTER_READING;
6740 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6741 FND_MSG_PUB.Count_And_Get
6742 (
6743 p_count => x_msg_count,
6744 p_data => x_msg_data
6745 );
6746 WHEN OTHERS THEN
6747 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6748 ROLLBACK TO ESTIMATE_COUNTER_READING;
6749 IF FND_MSG_PUB.Check_Msg_Level (FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
6750 FND_MSG_PUB.Add_Exc_Msg
6751 ( G_PKG_NAME,
6752 l_api_name
6753 );
6754 END IF;
6755 FND_MSG_PUB.Count_And_Get
6756 ( p_count => x_msg_count,
6757 p_data => x_msg_data
6758 );
6759 END ESTIMATE_COUNTER_READING;
6760 --
6761 PROCEDURE ESTIMATE_FIXED_VALUES(
6762 P_api_version IN NUMBER,
6763 P_Init_Msg_List IN VARCHAR2,
6764 P_Commit IN VARCHAR2,
6765 p_validation_level IN NUMBER,
6766 p_counter_id IN NUMBER,
6767 p_fixed_value IN NUMBER,
6768 p_default_value IN NUMBER,
6769 p_estimation_period_start_date IN DATE,
6770 p_estimation_period_end_date IN DATE,
6771 x_estimated_meter_reading OUT NOCOPY NUMBER,
6772 x_estimated_usage_qty OUT NOCOPY NUMBER,
6773 x_estimated_period_start_rdg OUT NOCOPY NUMBER,
6774 X_Return_Status OUT NOCOPY VARCHAR2,
6775 X_Msg_Count OUT NOCOPY NUMBER,
6776 X_Msg_Data OUT NOCOPY VARCHAR2
6777 )
6778 IS
6779 l_api_name CONSTANT VARCHAR2(30) := 'ESTIMATE_FIXED_VALUES';
6780 l_api_version CONSTANT NUMBER := 1.0;
6781 l_msg_data VARCHAR2(2000);
6782 l_msg_index NUMBER;
6783 l_msg_count NUMBER;
6784 --
6785 CURSOR PRIOR_RDG_VALUES(b_counter_id NUMBER, b_rdg_date DATE) IS
6786 select b.net_reading "prev_reading",b.value_timestamp "prev_rdg_date"
6787 from CSI_COUNTER_READINGS b
6788 where b.counter_id = b_counter_id
6789 and b.value_timestamp < b_rdg_date
6790 and nvl(b.disabled_flag,'N') = 'N'
6791 order by b.value_timestamp desc;
6792 --
6793 CURSOR PASSED_DT_RDG_VALUES(b_counter_id NUMBER, b_rdg_date DATE) IS
6794 select b.net_reading "passed_dt_reading", b.value_timestamp "passed_rdg_date"
6795 from CSI_COUNTER_READINGS b
6796 where b.counter_id = b_counter_id
6797 and nvl(b.disabled_flag,'N') = 'N'
6798 and trunc(b.value_timestamp) = trunc(b_rdg_date)
6799 order by b.value_timestamp desc;
6800 --
6801 l_passed_dt_reading NUMBER;
6802 l_passed_rdg_date DATE;
6803 l_adjustment_usage_amount NUMBER;
6804 l_estimated_meter_reading NUMBER;
6805 l_creation_date DATE;
6806 l_period_days NUMBER;
6807 l_default_value NUMBER;
6808 l_captured_date DATE;
6809 l_period_start_date_reading NUMBER;
6810 l_prev_reading NUMBER;
6811 l_prev_value_timestamp DATE;
6812 l_fixed_value NUMBER;
6813 l_period_start_reading NUMBER;
6814 l_estimated_usage NUMBER;
6815 BEGIN
6816 SAVEPOINT ESTIMATE_FIXED_VALUES;
6817 -- Initialize message list if p_init_msg_list is set to TRUE.
6818 IF FND_API.to_Boolean( p_init_msg_list ) THEN
6819 FND_MSG_PUB.initialize;
6820 END IF;
6821 -- Initialize API return status to SUCCESS
6822 x_return_status := FND_API.G_RET_STS_SUCCESS;
6823 --
6824 csi_ctr_gen_utility_pvt.put_line( 'Inside Estimate_Fixed_Values...');
6825 --
6826
6827 -- Read the debug profiles values in to global variable 7197402
6828 CSI_CTR_GEN_UTILITY_PVT.read_debug_profiles;
6829
6830 -- Standard call to check for call compatibility.
6831 IF NOT FND_API.Compatible_API_Call (l_api_version,
6832 p_api_version,
6833 l_api_name ,
6834 G_PKG_NAME ) THEN
6835 RAISE FND_API.G_EXC_UNEXPECTED_ERROR;
6836 END IF;
6837 --
6838 IF p_estimation_period_start_date IS NOT NULL THEN
6839 csi_ctr_gen_utility_pvt.put_line('Calling Est_Period_Start_Readings...');
6840 EST_PERIOD_START_READINGS(
6841 P_api_version => 1.0,
6842 P_Init_Msg_List => P_Init_Msg_List,
6843 P_Commit => P_Commit,
6844 p_validation_level => p_validation_level,
6845 p_counter_id => p_counter_id,
6846 p_default_value => p_default_value,
6847 p_avg_calculation_start_date => null,
6848 p_calculation_start_date => p_estimation_period_start_date,
6849 x_calc_start_reading => l_period_start_reading,
6850 X_Return_Status => X_Return_Status,
6851 X_Msg_Count => X_Msg_Count,
6852 X_Msg_Data => X_Msg_Data
6853 );
6854 IF x_return_status <> FND_API.G_RET_STS_SUCCESS THEN
6855 csi_ctr_gen_utility_pvt.put_line('ERROR FROM Est_Period_Start_Readings API ');
6856 l_msg_index := 1;
6857 l_msg_count := x_msg_count;
6858 WHILE l_msg_count > 0 LOOP
6859 x_msg_data := FND_MSG_PUB.GET
6860 ( l_msg_index,
6861 FND_API.G_FALSE
6862 );
6863 csi_ctr_gen_utility_pvt.put_line('MESSAGE DATA = '||x_msg_data);
6864 l_msg_index := l_msg_index + 1;
6865 l_msg_count := l_msg_count - 1;
6866 END LOOP;
6867 RAISE FND_API.G_EXC_ERROR;
6868 END IF;
6869 END IF;
6870 -- fetch the reading of the passed estimation period end date
6871 OPEN PASSED_DT_RDG_VALUES(p_counter_id, p_estimation_period_end_date);
6872 FETCH PASSED_DT_RDG_VALUES
6873 INTO l_estimated_meter_reading,l_passed_rdg_date;
6874 CLOSE PASSED_DT_RDG_VALUES;
6875 -- if no actual reading on passed estimation period end dt then compute the reading.
6876 IF l_estimated_meter_reading is NULL THEN
6877 open prior_rdg_values(p_counter_id, p_estimation_period_end_date);
6878 fetch prior_rdg_values into l_prev_reading,l_prev_value_timestamp;
6879 close prior_rdg_values;
6880 --
6881 IF l_prev_reading IS NULL THEN
6882 -- raise error message - no readings to calculate
6883 csi_ctr_gen_utility_pvt.ExitWithErrMsg('CSI_API_CTR_NO_RDG_PR_PRD_ENDT');
6884 ELSE -- l_prev_reading IS not null
6885 l_period_days := trunc(p_estimation_period_end_date) - trunc(l_prev_value_timestamp) ;
6886 l_estimated_meter_reading:=(l_prev_reading +(P_fixed_value*l_period_days)) ;
6887 END IF;
6888 END IF;
6889 --
6890 x_estimated_meter_reading := l_estimated_meter_reading;
6891 IF p_estimation_period_start_date IS NOT NULL THEN
6892 l_estimated_usage := l_estimated_meter_reading - l_period_start_reading;
6893 END If;
6894 --
6895 X_estimated_usage_qty := l_estimated_usage;
6896 x_estimated_period_start_rdg := l_period_start_reading;
6897 --
6898 IF FND_API.to_Boolean(nvl(p_commit,FND_API.G_FALSE)) THEN
6899 COMMIT WORK;
6900 END IF;
6901 --
6902 -- Standard call to get message count and IF count is get message info.
6903 FND_MSG_PUB.Count_And_Get
6904 ( p_count => x_msg_count,
6905 p_data => x_msg_data
6906 );
6907
6908 EXCEPTION
6909 WHEN FND_API.G_EXC_ERROR THEN
6910 ROLLBACK TO ESTIMATE_FIXED_VALUES;
6911 x_return_status := FND_API.G_RET_STS_ERROR ;
6912 FND_MSG_PUB.Count_And_Get
6913 (p_count => x_msg_count,
6914 p_data => x_msg_data
6915 );
6916 WHEN FND_API.G_EXC_UNEXPECTED_ERROR THEN
6917 ROLLBACK TO ESTIMATE_FIXED_VALUES;
6918 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6919 FND_MSG_PUB.Count_And_Get
6920 (
6921 p_count => x_msg_count,
6922 p_data => x_msg_data
6923 );
6924 WHEN OTHERS THEN
6925 x_return_status := FND_API.G_RET_STS_UNEXP_ERROR ;
6926 ROLLBACK TO ESTIMATE_FIXED_VALUES;
6927 IF FND_MSG_PUB.Check_Msg_Level (FND_MSG_PUB.G_MSG_LVL_UNEXP_ERROR) THEN
6928 FND_MSG_PUB.Add_Exc_Msg
6929 ( G_PKG_NAME,
6930 l_api_name
6931 );
6932 END IF;
6933 FND_MSG_PUB.Count_And_Get
6934 ( p_count => x_msg_count,
6935 p_data => x_msg_data
6936 );
6937 END ESTIMATE_FIXED_VALUES;
6938 --
6939 END CSI_COUNTER_READINGS_PVT;