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

APPS.HZ_GNR_MAP10000 dependencies on HZ_GNR_UTIL_PKG

Line 23: G_MAP_REC HZ_GNR_UTIL_PKG.MAP_REC_TYPE;

19: --------------------------------------
20:
21: g_debug_count NUMBER := 0;
22: g_country_geo_id NUMBER;
23: G_MAP_REC HZ_GNR_UTIL_PKG.MAP_REC_TYPE;
24: G_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
25: G_USAGE_TBL HZ_GNR_UTIL_PKG.USAGE_TBL_TYPE;
26: G_USAGE_DTLS_TBL HZ_GNR_UTIL_PKG.USAGE_DTLS_TBL_TYPE;
27: G_MDU_TBL10000 HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;

Line 24: G_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;

20:
21: g_debug_count NUMBER := 0;
22: g_country_geo_id NUMBER;
23: G_MAP_REC HZ_GNR_UTIL_PKG.MAP_REC_TYPE;
24: G_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
25: G_USAGE_TBL HZ_GNR_UTIL_PKG.USAGE_TBL_TYPE;
26: G_USAGE_DTLS_TBL HZ_GNR_UTIL_PKG.USAGE_DTLS_TBL_TYPE;
27: G_MDU_TBL10000 HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
28: G_MDU_TBL10006 HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;

Line 25: G_USAGE_TBL HZ_GNR_UTIL_PKG.USAGE_TBL_TYPE;

21: g_debug_count NUMBER := 0;
22: g_country_geo_id NUMBER;
23: G_MAP_REC HZ_GNR_UTIL_PKG.MAP_REC_TYPE;
24: G_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
25: G_USAGE_TBL HZ_GNR_UTIL_PKG.USAGE_TBL_TYPE;
26: G_USAGE_DTLS_TBL HZ_GNR_UTIL_PKG.USAGE_DTLS_TBL_TYPE;
27: G_MDU_TBL10000 HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
28: G_MDU_TBL10006 HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
29:

Line 26: G_USAGE_DTLS_TBL HZ_GNR_UTIL_PKG.USAGE_DTLS_TBL_TYPE;

22: g_country_geo_id NUMBER;
23: G_MAP_REC HZ_GNR_UTIL_PKG.MAP_REC_TYPE;
24: G_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
25: G_USAGE_TBL HZ_GNR_UTIL_PKG.USAGE_TBL_TYPE;
26: G_USAGE_DTLS_TBL HZ_GNR_UTIL_PKG.USAGE_DTLS_TBL_TYPE;
27: G_MDU_TBL10000 HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
28: G_MDU_TBL10006 HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
29:
30: --------------------------------------

Line 27: G_MDU_TBL10000 HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;

23: G_MAP_REC HZ_GNR_UTIL_PKG.MAP_REC_TYPE;
24: G_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
25: G_USAGE_TBL HZ_GNR_UTIL_PKG.USAGE_TBL_TYPE;
26: G_USAGE_DTLS_TBL HZ_GNR_UTIL_PKG.USAGE_DTLS_TBL_TYPE;
27: G_MDU_TBL10000 HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
28: G_MDU_TBL10006 HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
29:
30: --------------------------------------
31: -- declaration of private procedures and functions

Line 28: G_MDU_TBL10006 HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;

24: G_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
25: G_USAGE_TBL HZ_GNR_UTIL_PKG.USAGE_TBL_TYPE;
26: G_USAGE_DTLS_TBL HZ_GNR_UTIL_PKG.USAGE_DTLS_TBL_TYPE;
27: G_MDU_TBL10000 HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
28: G_MDU_TBL10006 HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
29:
30: --------------------------------------
31: -- declaration of private procedures and functions
32: --------------------------------------

Line 68: p_loc_components_rec IN HZ_GNR_UTIL_PKG.LOC_COMPONENTS_REC_TYPE,

64: END get_usage_API;
65:
66:
67: PROCEDURE validateForMap(
68: p_loc_components_rec IN HZ_GNR_UTIL_PKG.LOC_COMPONENTS_REC_TYPE,
69: x_map_dtls_tbl IN OUT NOCOPY HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE,
70: X_CAUSE OUT NOCOPY VARCHAR2,
71: X_STATUS OUT NOCOPY VARCHAR2) IS
72:

Line 69: x_map_dtls_tbl IN OUT NOCOPY HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE,

65:
66:
67: PROCEDURE validateForMap(
68: p_loc_components_rec IN HZ_GNR_UTIL_PKG.LOC_COMPONENTS_REC_TYPE,
69: x_map_dtls_tbl IN OUT NOCOPY HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE,
70: X_CAUSE OUT NOCOPY VARCHAR2,
71: X_STATUS OUT NOCOPY VARCHAR2) IS
72:
73:

Line 83: L_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;

79: l_sql VARCHAR2(9000);
80: l_status VARCHAR2(1);
81: l_geography_type VARCHAR2(30);
82: l_geography_id NUMBER;
83: L_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
84:
85: l_module_prefix CONSTANT VARCHAR2(30) := 'HZ:ARHGNRGB:HZ_GNR_MAP10000';
86: l_module CONSTANT VARCHAR2(30) := 'ADDRESS_VALIDATION';
87: l_debug_prefix VARCHAR2(30);

Line 127: IF HZ_GNR_UTIL_PKG.getLocCompCount(L_MAP_DTLS_TBL) = 0 THEN

123: x_status := FND_API.g_ret_sts_success;
124: RETURN;
125: END IF;
126:
127: IF HZ_GNR_UTIL_PKG.getLocCompCount(L_MAP_DTLS_TBL) = 0 THEN
128: --hk_debugl('HZ_GNR_UTIL_PKG.getLocCompCount = 0');
129:
130: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN
131: hz_utility_v2pub.debug

Line 128: --hk_debugl('HZ_GNR_UTIL_PKG.getLocCompCount = 0');

124: RETURN;
125: END IF;
126:
127: IF HZ_GNR_UTIL_PKG.getLocCompCount(L_MAP_DTLS_TBL) = 0 THEN
128: --hk_debugl('HZ_GNR_UTIL_PKG.getLocCompCount = 0');
129:
130: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN
131: hz_utility_v2pub.debug
132: (p_message => ' HZ_GNR_UTIL_PKG.getLocCompCount = 0 ',

Line 132: (p_message => ' HZ_GNR_UTIL_PKG.getLocCompCount = 0 ',

128: --hk_debugl('HZ_GNR_UTIL_PKG.getLocCompCount = 0');
129:
130: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN
131: hz_utility_v2pub.debug
132: (p_message => ' HZ_GNR_UTIL_PKG.getLocCompCount = 0 ',
133: p_prefix => l_debug_prefix,
134: p_msg_level => fnd_log.level_statement,
135: p_module_prefix => l_module_prefix,
136: p_module => l_module

Line 142: IF HZ_GNR_UTIL_PKG.fix_child(L_MAP_DTLS_TBL) = FALSE THEN

138: END IF;
139:
140: --No other location component value other than country is passed.
141: --Following call will try to derive missing lower level compoents
142: IF HZ_GNR_UTIL_PKG.fix_child(L_MAP_DTLS_TBL) = FALSE THEN
143: x_cause := 'MISSING_CHILD';
144:
145: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN
146: hz_utility_v2pub.debug

Line 213: l_sql := HZ_GNR_UTIL_PKG.getQuery(L_MAP_DTLS_TBL,L_MAP_DTLS_TBL,x_status);

209: l_geography_type := l_type5;
210: END IF;
211:
212:
213: l_sql := HZ_GNR_UTIL_PKG.getQuery(L_MAP_DTLS_TBL,L_MAP_DTLS_TBL,x_status);
214: --hk_debugl('The SQL query');
215: --hk_debugl(l_sql);
216:
217: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 259: HZ_GNR_UTIL_PKG.fix_no_match(L_MAP_DTLS_TBL,x_status);

255:
256: --hk_debugl('NOT FOUND of the first fetch');
257: --hk_debugt(L_MAP_DTLS_TBL);
258: x_cause := 'NO_MATCH';
259: HZ_GNR_UTIL_PKG.fix_no_match(L_MAP_DTLS_TBL,x_status);
260: --hk_debugl('Map_loc table after Fix');
261: --hk_debugt(L_MAP_DTLS_TBL);
262: x_status := FND_API.G_RET_STS_ERROR;
263: ELSE

Line 282: l_sql := HZ_GNR_UTIL_PKG.getQueryforMultiMatch(L_MAP_DTLS_TBL,L_MAP_DTLS_TBL,x_status);

278: IF c_getGeo%FOUND THEN -- not able to identify a unique record
279:
280: -- Get the query again with identifier type as NAME if multiple match found
281: -- If it returns a record, we are able to derive a unique record for identifier type as NAME
282: l_sql := HZ_GNR_UTIL_PKG.getQueryforMultiMatch(L_MAP_DTLS_TBL,L_MAP_DTLS_TBL,x_status);
283: OPEN c_getGeo1 FOR l_sql USING G_MAP_REC.COUNTRY_CODE,g_country_geo_id
284: ,l_type2,l_value2,l_type3,l_value3,l_type4,l_value4,l_type5,l_value5,l_geography_type;
285:
286: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 366: IF HZ_GNR_UTIL_PKG.fix_multiparent(l_geography_id,L_MAP_DTLS_TBL) = TRUE THEN

362:
363: END IF;
364:
365: IF l_multiple_parent_flag = 'Y' THEN
366: IF HZ_GNR_UTIL_PKG.fix_multiparent(l_geography_id,L_MAP_DTLS_TBL) = TRUE THEN
367: NULL; -- a unique record is found
368: ELSE -- Multiple parent case not able to find a unique record
369:
370: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 427: IF HZ_GNR_UTIL_PKG.fix_child(L_MAP_DTLS_TBL) = FALSE THEN

423: );
424: END IF;
425:
426: --Following call will try to derive missing lower level compoents
427: IF HZ_GNR_UTIL_PKG.fix_child(L_MAP_DTLS_TBL) = FALSE THEN
428: x_cause := 'MISSING_CHILD';
429:
430: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN
431: hz_utility_v2pub.debug

Line 487: l_loc_components_rec HZ_GNR_UTIL_PKG.LOC_COMPONENTS_REC_TYPE;

483: X_ADDR_WARN_MSG OUT NOCOPY VARCHAR2,
484: X_ADDR_VAL_STATUS OUT NOCOPY VARCHAR2,
485: X_STATUS OUT NOCOPY VARCHAR2) IS
486:
487: l_loc_components_rec HZ_GNR_UTIL_PKG.LOC_COMPONENTS_REC_TYPE;
488:
489: TYPE getGeo IS REF CURSOR;
490: c_getGeo getGeo;
491: c_getGeo1 getGeo;

Line 502: L_MDU_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;

498: l_status VARCHAR2(1);
499: l_get_addr_val VARCHAR2(1);
500: l_geography_type VARCHAR2(30);
501: l_geography_id NUMBER;
502: L_MDU_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
503: LL_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
504: L_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
505:
506: l_module_prefix CONSTANT VARCHAR2(30) := 'HZ:ARHGNRGB:HZ_GNR_MAP10000';

Line 503: LL_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;

499: l_get_addr_val VARCHAR2(1);
500: l_geography_type VARCHAR2(30);
501: l_geography_id NUMBER;
502: L_MDU_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
503: LL_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
504: L_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
505:
506: l_module_prefix CONSTANT VARCHAR2(30) := 'HZ:ARHGNRGB:HZ_GNR_MAP10000';
507: l_module CONSTANT VARCHAR2(30) := 'ADDRESS_VALIDATION';

Line 504: L_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;

500: l_geography_type VARCHAR2(30);
501: l_geography_id NUMBER;
502: L_MDU_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
503: LL_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
504: L_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
505:
506: l_module_prefix CONSTANT VARCHAR2(30) := 'HZ:ARHGNRGB:HZ_GNR_MAP10000';
507: l_module CONSTANT VARCHAR2(30) := 'ADDRESS_VALIDATION';
508: l_debug_prefix VARCHAR2(30) := p_location_id;

Line 560: IF HZ_GNR_UTIL_PKG.check_GNR_For_Usage(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

556: END IF;
557:
558: IF P_LOCATION_ID IS NOT NULL AND P_CALLED_FROM <> 'GNR' THEN
559: --hk_debugl('Before check_GNR_For_Usage');
560: IF HZ_GNR_UTIL_PKG.check_GNR_For_Usage(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
561: L_USAGE_CODE,L_MDU_TBL,x_status) = TRUE THEN
562: --hk_debugl('After check_GNR_For_Usage with status :- '||x_status);
563:
564: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 591: HZ_GNR_UTIL_PKG.getLocCompValues(G_MAP_REC.LOC_TBL_NAME,L_LOC_COMPONENTS_REC,L_MAP_DTLS_TBL,x_status);

587: );
588: END IF;
589:
590: -- After the following call L_MAP_DTLS_TBL will have the components value populated.
591: HZ_GNR_UTIL_PKG.getLocCompValues(G_MAP_REC.LOC_TBL_NAME,L_LOC_COMPONENTS_REC,L_MAP_DTLS_TBL,x_status);
592:
593: -- Below code will overwrite the LOC_COMPVAL for COUNTRY to COUNTRY_CODE
594: -- This change is to update COUNTRY column in locations table with COUNTRY_CODE
595: -- even if the table has Country name in this column and the validation is success

Line 599: HZ_GNR_UTIL_PKG.getLocCompValues(G_MAP_REC.LOC_TBL_NAME,L_LOC_COMPONENTS_REC,L_MDU_TBL,x_status);

595: -- even if the table has Country name in this column and the validation is success
596: L_MAP_DTLS_TBL(1).LOC_COMPVAL := G_MAP_REC.COUNTRY_CODE;
597:
598: -- After the following call L_MDU_TBL will have the components value populated.
599: HZ_GNR_UTIL_PKG.getLocCompValues(G_MAP_REC.LOC_TBL_NAME,L_LOC_COMPONENTS_REC,L_MDU_TBL,x_status);
600:
601: --hk_debugl(' value of X_CALL_MAP : '||X_CALL_MAP);
602: IF X_CALL_MAP = 'Y' THEN
603: LL_MAP_DTLS_TBL := L_MAP_DTLS_TBL;

Line 638: IF HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL) = FND_API.G_RET_STS_SUCCESS THEN

634: -- hk_debugt(LL_MAP_DTLS_TBL);
635: -- hk_debugl('Usage Map Table With loc comp values');
636: -- hk_debugt(L_MDU_TBL);
637:
638: IF HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL) = FND_API.G_RET_STS_SUCCESS THEN
639: -- hk_debugl('COMPLETE mapping is error but is sufficient for passed usage. So setting X_STATUS to success');
640: x_status := FND_API.g_ret_sts_success;
641:
642: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 672: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);

668: p_module => l_module
669: );
670: END IF;
671:
672: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
673: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
674: L_USAGE_CODE,'S',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
675: END IF;
676:

Line 673: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

669: );
670: END IF;
671:
672: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
673: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
674: L_USAGE_CODE,'S',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
675: END IF;
676:
677: X_CALL_MAP := 'N';

Line 687: IF HZ_GNR_UTIL_PKG.do_usage_val(l_cause,L_MAP_DTLS_TBL,L_MDU_TBL,LL_MAP_DTLS_TBL,l_status) = FALSE THEN

683: --hk_debugl('Table that is returned by Validate For Map');
684: --hk_debugt(LL_MAP_DTLS_TBL);
685: --hk_debugl('Usage Map Table With loc comp values');
686: --hk_debugt(L_MDU_TBL);
687: IF HZ_GNR_UTIL_PKG.do_usage_val(l_cause,L_MAP_DTLS_TBL,L_MDU_TBL,LL_MAP_DTLS_TBL,l_status) = FALSE THEN
688:
689: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN
690: hz_utility_v2pub.debug
691: (p_message => ' No usage level validation is required. Call create_gnr with the map status',

Line 700: IF HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL) = FND_API.G_RET_STS_ERROR THEN

696: );
697: END IF;
698:
699: -- This means no usage level validation is required
700: IF HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL) = FND_API.G_RET_STS_ERROR THEN
701:
702: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
703: -- This below call is to derive the address validation status and set the message
704: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'E',x_status);

Line 702: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);

698:
699: -- This means no usage level validation is required
700: IF HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL) = FND_API.G_RET_STS_ERROR THEN
701:
702: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
703: -- This below call is to derive the address validation status and set the message
704: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'E',x_status);
705: --hk_debugl('Calling create_gnr With Map_status "E"');
706:

Line 704: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'E',x_status);

700: IF HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL) = FND_API.G_RET_STS_ERROR THEN
701:
702: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
703: -- This below call is to derive the address validation status and set the message
704: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'E',x_status);
705: --hk_debugl('Calling create_gnr With Map_status "E"');
706:
707: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN
708: hz_utility_v2pub.debug

Line 717: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

713: p_module => l_module
714: );
715: END IF;
716:
717: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
718: L_USAGE_CODE,'E',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
719: --hk_debugl('Status after create_gnr : '||l_status);
720: ELSE
721:

Line 722: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);

718: L_USAGE_CODE,'E',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
719: --hk_debugl('Status after create_gnr : '||l_status);
720: ELSE
721:
722: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
723: -- This below call is to derive the address validation status and set the message
724: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'S',x_status);
725: --hk_debugl('Calling create_gnr With Map_status "S"');
726:

Line 724: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'S',x_status);

720: ELSE
721:
722: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
723: -- This below call is to derive the address validation status and set the message
724: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'S',x_status);
725: --hk_debugl('Calling create_gnr With Map_status "S"');
726:
727: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN
728: hz_utility_v2pub.debug

Line 737: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

733: p_module => l_module
734: );
735: END IF;
736:
737: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
738: L_USAGE_CODE,'S',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
739: --hk_debugl('Status after create_gnr : '||l_status);
740: x_status := FND_API.g_ret_sts_success;
741: END IF;

Line 774: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(L_MDU_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'S',x_status);

770: -- and country is already populated in the L_MDU_TBL in the initialization section of this package.
771: --hk_debugt(L_MDU_TBL); ----- Code to display the output.
772: --hk_debugl('Calling create_gnr With Map_status "S"');
773: -- This below call is to derive the address validation status and set the message
774: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(L_MDU_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'S',x_status);
775:
776: IF P_LOCATION_ID IS NOT NULL THEN
777: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
778: L_USAGE_CODE,'S',L_LOC_COMPONENTS_REC,p_lock_flag,L_MDU_TBL,l_status);

Line 777: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

773: -- This below call is to derive the address validation status and set the message
774: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(L_MDU_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'S',x_status);
775:
776: IF P_LOCATION_ID IS NOT NULL THEN
777: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
778: L_USAGE_CODE,'S',L_LOC_COMPONENTS_REC,p_lock_flag,L_MDU_TBL,l_status);
779: END IF;
780:
781: x_status := FND_API.g_ret_sts_success;

Line 815: l_sql := HZ_GNR_UTIL_PKG.getQuery(L_MAP_DTLS_TBL,L_MDU_TBL,x_status);

811: END IF;
812:
813:
814: LL_MAP_DTLS_TBL := L_MAP_DTLS_TBL;
815: l_sql := HZ_GNR_UTIL_PKG.getQuery(L_MAP_DTLS_TBL,L_MDU_TBL,x_status);
816: --hk_debugl('The SQL query');
817: --hk_debugl(l_sql);
818:
819: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 846: HZ_GNR_UTIL_PKG.fix_no_match(LL_MAP_DTLS_TBL,x_status);

842: p_module => l_module
843: );
844: END IF;
845:
846: HZ_GNR_UTIL_PKG.fix_no_match(LL_MAP_DTLS_TBL,x_status);
847: x_status := FND_API.G_RET_STS_ERROR;
848: ELSE
849: --Fetching once more to see where there are multiple records
850:

Line 867: l_sql := HZ_GNR_UTIL_PKG.getQueryforMultiMatch(L_MAP_DTLS_TBL,L_MDU_TBL,x_status);

863: IF c_getGeo%FOUND THEN -- not able to identify a unique record
864:
865: -- Get the query again with identifier type as NAME if multiple match found
866: -- If it returns a record, we are able to derive a unique record for identifier type as NAME
867: l_sql := HZ_GNR_UTIL_PKG.getQueryforMultiMatch(L_MAP_DTLS_TBL,L_MDU_TBL,x_status);
868: OPEN c_getGeo1 FOR l_sql USING G_MAP_REC.COUNTRY_CODE,g_country_geo_id
869: ,l_type2,l_value2,l_type3,l_value3,l_type4,l_value4,l_geography_type;
870:
871: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 914: HZ_GNR_UTIL_PKG.fix_no_match(LL_MAP_DTLS_TBL,x_status);

910: );
911: END IF;
912:
913: LL_MAP_DTLS_TBL := L_MAP_DTLS_TBL;
914: HZ_GNR_UTIL_PKG.fix_no_match(LL_MAP_DTLS_TBL,x_status);
915: x_status := FND_API.G_RET_STS_ERROR;
916: END IF;
917:
918: ELSE -- Not able to found a unique record with identifier type as NAME

Line 950: IF HZ_GNR_UTIL_PKG.fix_multiparent(l_geography_id,LL_MAP_DTLS_TBL) = TRUE THEN

946:
947: END IF;
948:
949: IF l_multiple_parent_flag = 'Y' AND x_status <> FND_API.G_RET_STS_ERROR THEN
950: IF HZ_GNR_UTIL_PKG.fix_multiparent(l_geography_id,LL_MAP_DTLS_TBL) = TRUE THEN
951: NULL;
952: ELSE -- Multiple parent case not able to find a unique record
953:
954: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 1006: IF HZ_GNR_UTIL_PKG.fix_child(LL_MAP_DTLS_TBL) = FALSE THEN

1002: p_module => l_module
1003: );
1004: END IF;
1005:
1006: IF HZ_GNR_UTIL_PKG.fix_child(LL_MAP_DTLS_TBL) = FALSE THEN
1007: x_status := HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL);
1008: END IF;
1009:
1010: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 1007: x_status := HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL);

1003: );
1004: END IF;
1005:
1006: IF HZ_GNR_UTIL_PKG.fix_child(LL_MAP_DTLS_TBL) = FALSE THEN
1007: x_status := HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL);
1008: END IF;
1009:
1010: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN
1011: hz_utility_v2pub.debug

Line 1022: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);

1018: END IF;
1019:
1020: --hk_debugl('LL_MAP_DTLS_TBL before fill_values');
1021: --hk_debugt(LL_MAP_DTLS_TBL);
1022: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
1023: --hk_debugl('LL_MAP_DTLS_TBL after fill_values');
1024: --hk_debugt(LL_MAP_DTLS_TBL);
1025:
1026: IF x_status = FND_API.g_ret_sts_success THEN

Line 1031: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,x_status,x_status);

1027: -- We need to call the getAddrValStatus only once. All other cases we are looking into x_call_map
1028: -- In some case the below code will execute with the x_call_map as N
1029: IF l_get_addr_val = 'Y' THEN
1030: -- This below call is to derive the address validation status and set the message
1031: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,x_status,x_status);
1032: END IF;
1033:
1034: IF P_LOCATION_ID IS NOT NULL THEN
1035:

Line 1046: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

1042: p_module => l_module
1043: );
1044: END IF;
1045:
1046: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
1047: L_USAGE_CODE,'S',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
1048: --hk_debugl('Prceossed GNR With Status : S and returned with Status : '||l_status);
1049: END IF;
1050: ELSE

Line 1055: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,x_status,x_status);

1051: -- We need to call the getAddrValStatus only once. All other cases we are looking into x_call_map
1052: -- In some case the below code will execute with the x_call_map as N
1053: IF l_get_addr_val = 'Y' THEN
1054: -- This below call is to derive the address validation status and set the message
1055: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,x_status,x_status);
1056: END IF;
1057:
1058: IF P_LOCATION_ID IS NOT NULL THEN
1059:

Line 1070: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

1066: p_module => l_module
1067: );
1068: END IF;
1069:
1070: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
1071: L_USAGE_CODE,'E',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
1072: --hk_debugl('Prceossed GNR With Status : E and returned with Status : '||l_status);
1073: END IF;
1074: END IF;

Line 1117: l_loc_components_rec HZ_GNR_UTIL_PKG.LOC_COMPONENTS_REC_TYPE;

1113: X_ADDR_WARN_MSG OUT NOCOPY VARCHAR2,
1114: X_ADDR_VAL_STATUS OUT NOCOPY VARCHAR2,
1115: X_STATUS OUT NOCOPY VARCHAR2) IS
1116:
1117: l_loc_components_rec HZ_GNR_UTIL_PKG.LOC_COMPONENTS_REC_TYPE;
1118:
1119: TYPE getGeo IS REF CURSOR;
1120: c_getGeo getGeo;
1121: c_getGeo1 getGeo;

Line 1132: L_MDU_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;

1128: l_status VARCHAR2(1);
1129: l_get_addr_val VARCHAR2(1);
1130: l_geography_type VARCHAR2(30);
1131: l_geography_id NUMBER;
1132: L_MDU_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
1133: LL_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
1134: L_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
1135:
1136: l_module_prefix CONSTANT VARCHAR2(30) := 'HZ:ARHGNRGB:HZ_GNR_MAP10000';

Line 1133: LL_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;

1129: l_get_addr_val VARCHAR2(1);
1130: l_geography_type VARCHAR2(30);
1131: l_geography_id NUMBER;
1132: L_MDU_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
1133: LL_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
1134: L_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
1135:
1136: l_module_prefix CONSTANT VARCHAR2(30) := 'HZ:ARHGNRGB:HZ_GNR_MAP10000';
1137: l_module CONSTANT VARCHAR2(30) := 'ADDRESS_VALIDATION';

Line 1134: L_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;

1130: l_geography_type VARCHAR2(30);
1131: l_geography_id NUMBER;
1132: L_MDU_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
1133: LL_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
1134: L_MAP_DTLS_TBL HZ_GNR_UTIL_PKG.MAPLOC_REC_TBL_TYPE;
1135:
1136: l_module_prefix CONSTANT VARCHAR2(30) := 'HZ:ARHGNRGB:HZ_GNR_MAP10000';
1137: l_module CONSTANT VARCHAR2(30) := 'ADDRESS_VALIDATION';
1138: l_debug_prefix VARCHAR2(30) := p_location_id;

Line 1190: IF HZ_GNR_UTIL_PKG.check_GNR_For_Usage(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

1186: END IF;
1187:
1188: IF P_LOCATION_ID IS NOT NULL AND P_CALLED_FROM <> 'GNR' THEN
1189: --hk_debugl('Before check_GNR_For_Usage');
1190: IF HZ_GNR_UTIL_PKG.check_GNR_For_Usage(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
1191: L_USAGE_CODE,L_MDU_TBL,x_status) = TRUE THEN
1192: --hk_debugl('After check_GNR_For_Usage with status :- '||x_status);
1193:
1194: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 1221: HZ_GNR_UTIL_PKG.getLocCompValues(G_MAP_REC.LOC_TBL_NAME,L_LOC_COMPONENTS_REC,L_MAP_DTLS_TBL,x_status);

1217: );
1218: END IF;
1219:
1220: -- After the following call L_MAP_DTLS_TBL will have the components value populated.
1221: HZ_GNR_UTIL_PKG.getLocCompValues(G_MAP_REC.LOC_TBL_NAME,L_LOC_COMPONENTS_REC,L_MAP_DTLS_TBL,x_status);
1222:
1223: -- Below code will overwrite the LOC_COMPVAL for COUNTRY to COUNTRY_CODE
1224: -- This change is to update COUNTRY column in locations table with COUNTRY_CODE
1225: -- even if the table has Country name in this column and the validation is success

Line 1229: HZ_GNR_UTIL_PKG.getLocCompValues(G_MAP_REC.LOC_TBL_NAME,L_LOC_COMPONENTS_REC,L_MDU_TBL,x_status);

1225: -- even if the table has Country name in this column and the validation is success
1226: L_MAP_DTLS_TBL(1).LOC_COMPVAL := G_MAP_REC.COUNTRY_CODE;
1227:
1228: -- After the following call L_MDU_TBL will have the components value populated.
1229: HZ_GNR_UTIL_PKG.getLocCompValues(G_MAP_REC.LOC_TBL_NAME,L_LOC_COMPONENTS_REC,L_MDU_TBL,x_status);
1230:
1231: --hk_debugl(' value of X_CALL_MAP : '||X_CALL_MAP);
1232: IF X_CALL_MAP = 'Y' THEN
1233: LL_MAP_DTLS_TBL := L_MAP_DTLS_TBL;

Line 1268: IF HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL) = FND_API.G_RET_STS_SUCCESS THEN

1264: -- hk_debugt(LL_MAP_DTLS_TBL);
1265: -- hk_debugl('Usage Map Table With loc comp values');
1266: -- hk_debugt(L_MDU_TBL);
1267:
1268: IF HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL) = FND_API.G_RET_STS_SUCCESS THEN
1269: -- hk_debugl('COMPLETE mapping is error but is sufficient for passed usage. So setting X_STATUS to success');
1270: x_status := FND_API.g_ret_sts_success;
1271:
1272: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 1302: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);

1298: p_module => l_module
1299: );
1300: END IF;
1301:
1302: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
1303: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
1304: L_USAGE_CODE,'S',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
1305: END IF;
1306:

Line 1303: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

1299: );
1300: END IF;
1301:
1302: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
1303: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
1304: L_USAGE_CODE,'S',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
1305: END IF;
1306:
1307: X_CALL_MAP := 'N';

Line 1317: IF HZ_GNR_UTIL_PKG.do_usage_val(l_cause,L_MAP_DTLS_TBL,L_MDU_TBL,LL_MAP_DTLS_TBL,l_status) = FALSE THEN

1313: --hk_debugl('Table that is returned by Validate For Map');
1314: --hk_debugt(LL_MAP_DTLS_TBL);
1315: --hk_debugl('Usage Map Table With loc comp values');
1316: --hk_debugt(L_MDU_TBL);
1317: IF HZ_GNR_UTIL_PKG.do_usage_val(l_cause,L_MAP_DTLS_TBL,L_MDU_TBL,LL_MAP_DTLS_TBL,l_status) = FALSE THEN
1318:
1319: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN
1320: hz_utility_v2pub.debug
1321: (p_message => ' No usage level validation is required. Call create_gnr with the map status',

Line 1330: IF HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL) = FND_API.G_RET_STS_ERROR THEN

1326: );
1327: END IF;
1328:
1329: -- This means no usage level validation is required
1330: IF HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL) = FND_API.G_RET_STS_ERROR THEN
1331:
1332: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
1333: -- This below call is to derive the address validation status and set the message
1334: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'E',x_status);

Line 1332: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);

1328:
1329: -- This means no usage level validation is required
1330: IF HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL) = FND_API.G_RET_STS_ERROR THEN
1331:
1332: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
1333: -- This below call is to derive the address validation status and set the message
1334: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'E',x_status);
1335: --hk_debugl('Calling create_gnr With Map_status "E"');
1336:

Line 1334: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'E',x_status);

1330: IF HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL) = FND_API.G_RET_STS_ERROR THEN
1331:
1332: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
1333: -- This below call is to derive the address validation status and set the message
1334: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'E',x_status);
1335: --hk_debugl('Calling create_gnr With Map_status "E"');
1336:
1337: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN
1338: hz_utility_v2pub.debug

Line 1347: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

1343: p_module => l_module
1344: );
1345: END IF;
1346:
1347: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
1348: L_USAGE_CODE,'E',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
1349: --hk_debugl('Status after create_gnr : '||l_status);
1350: ELSE
1351:

Line 1352: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);

1348: L_USAGE_CODE,'E',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
1349: --hk_debugl('Status after create_gnr : '||l_status);
1350: ELSE
1351:
1352: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
1353: -- This below call is to derive the address validation status and set the message
1354: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'S',x_status);
1355: --hk_debugl('Calling create_gnr With Map_status "S"');
1356:

Line 1354: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'S',x_status);

1350: ELSE
1351:
1352: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
1353: -- This below call is to derive the address validation status and set the message
1354: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'S',x_status);
1355: --hk_debugl('Calling create_gnr With Map_status "S"');
1356:
1357: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN
1358: hz_utility_v2pub.debug

Line 1367: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

1363: p_module => l_module
1364: );
1365: END IF;
1366:
1367: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
1368: L_USAGE_CODE,'S',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
1369: --hk_debugl('Status after create_gnr : '||l_status);
1370: x_status := FND_API.g_ret_sts_success;
1371: END IF;

Line 1404: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(L_MDU_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'S',x_status);

1400: -- and country is already populated in the L_MDU_TBL in the initialization section of this package.
1401: --hk_debugt(L_MDU_TBL); ----- Code to display the output.
1402: --hk_debugl('Calling create_gnr With Map_status "S"');
1403: -- This below call is to derive the address validation status and set the message
1404: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(L_MDU_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'S',x_status);
1405:
1406: IF P_LOCATION_ID IS NOT NULL THEN
1407: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
1408: L_USAGE_CODE,'S',L_LOC_COMPONENTS_REC,p_lock_flag,L_MDU_TBL,l_status);

Line 1407: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

1403: -- This below call is to derive the address validation status and set the message
1404: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(L_MDU_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,'S',x_status);
1405:
1406: IF P_LOCATION_ID IS NOT NULL THEN
1407: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
1408: L_USAGE_CODE,'S',L_LOC_COMPONENTS_REC,p_lock_flag,L_MDU_TBL,l_status);
1409: END IF;
1410:
1411: x_status := FND_API.g_ret_sts_success;

Line 1445: l_sql := HZ_GNR_UTIL_PKG.getQuery(L_MAP_DTLS_TBL,L_MDU_TBL,x_status);

1441: END IF;
1442:
1443:
1444: LL_MAP_DTLS_TBL := L_MAP_DTLS_TBL;
1445: l_sql := HZ_GNR_UTIL_PKG.getQuery(L_MAP_DTLS_TBL,L_MDU_TBL,x_status);
1446: --hk_debugl('The SQL query');
1447: --hk_debugl(l_sql);
1448:
1449: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 1476: HZ_GNR_UTIL_PKG.fix_no_match(LL_MAP_DTLS_TBL,x_status);

1472: p_module => l_module
1473: );
1474: END IF;
1475:
1476: HZ_GNR_UTIL_PKG.fix_no_match(LL_MAP_DTLS_TBL,x_status);
1477: x_status := FND_API.G_RET_STS_ERROR;
1478: ELSE
1479: --Fetching once more to see where there are multiple records
1480:

Line 1497: l_sql := HZ_GNR_UTIL_PKG.getQueryforMultiMatch(L_MAP_DTLS_TBL,L_MDU_TBL,x_status);

1493: IF c_getGeo%FOUND THEN -- not able to identify a unique record
1494:
1495: -- Get the query again with identifier type as NAME if multiple match found
1496: -- If it returns a record, we are able to derive a unique record for identifier type as NAME
1497: l_sql := HZ_GNR_UTIL_PKG.getQueryforMultiMatch(L_MAP_DTLS_TBL,L_MDU_TBL,x_status);
1498: OPEN c_getGeo1 FOR l_sql USING G_MAP_REC.COUNTRY_CODE,g_country_geo_id
1499: ,l_type2,l_value2,l_type3,l_value3,l_type4,l_value4,l_geography_type;
1500:
1501: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 1544: HZ_GNR_UTIL_PKG.fix_no_match(LL_MAP_DTLS_TBL,x_status);

1540: );
1541: END IF;
1542:
1543: LL_MAP_DTLS_TBL := L_MAP_DTLS_TBL;
1544: HZ_GNR_UTIL_PKG.fix_no_match(LL_MAP_DTLS_TBL,x_status);
1545: x_status := FND_API.G_RET_STS_ERROR;
1546: END IF;
1547:
1548: ELSE -- Not able to found a unique record with identifier type as NAME

Line 1580: IF HZ_GNR_UTIL_PKG.fix_multiparent(l_geography_id,LL_MAP_DTLS_TBL) = TRUE THEN

1576:
1577: END IF;
1578:
1579: IF l_multiple_parent_flag = 'Y' AND x_status <> FND_API.G_RET_STS_ERROR THEN
1580: IF HZ_GNR_UTIL_PKG.fix_multiparent(l_geography_id,LL_MAP_DTLS_TBL) = TRUE THEN
1581: NULL;
1582: ELSE -- Multiple parent case not able to find a unique record
1583:
1584: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 1636: IF HZ_GNR_UTIL_PKG.fix_child(LL_MAP_DTLS_TBL) = FALSE THEN

1632: p_module => l_module
1633: );
1634: END IF;
1635:
1636: IF HZ_GNR_UTIL_PKG.fix_child(LL_MAP_DTLS_TBL) = FALSE THEN
1637: x_status := HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL);
1638: END IF;
1639:
1640: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN

Line 1637: x_status := HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL);

1633: );
1634: END IF;
1635:
1636: IF HZ_GNR_UTIL_PKG.fix_child(LL_MAP_DTLS_TBL) = FALSE THEN
1637: x_status := HZ_GNR_UTIL_PKG.get_usage_val_status(LL_MAP_DTLS_TBL,L_MDU_TBL);
1638: END IF;
1639:
1640: IF (fnd_log.level_statement >= fnd_log.g_current_runtime_level) THEN
1641: hz_utility_v2pub.debug

Line 1652: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);

1648: END IF;
1649:
1650: --hk_debugl('LL_MAP_DTLS_TBL before fill_values');
1651: --hk_debugt(LL_MAP_DTLS_TBL);
1652: HZ_GNR_UTIL_PKG.fill_values(LL_MAP_DTLS_TBL);
1653: --hk_debugl('LL_MAP_DTLS_TBL after fill_values');
1654: --hk_debugt(LL_MAP_DTLS_TBL);
1655:
1656: IF x_status = FND_API.g_ret_sts_success THEN

Line 1661: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,x_status,x_status);

1657: -- We need to call the getAddrValStatus only once. All other cases we are looking into x_call_map
1658: -- In some case the below code will execute with the x_call_map as N
1659: IF l_get_addr_val = 'Y' THEN
1660: -- This below call is to derive the address validation status and set the message
1661: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,x_status,x_status);
1662: END IF;
1663:
1664: IF P_LOCATION_ID IS NOT NULL THEN
1665:

Line 1676: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

1672: p_module => l_module
1673: );
1674: END IF;
1675:
1676: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
1677: L_USAGE_CODE,'S',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
1678: --hk_debugl('Prceossed GNR With Status : S and returned with Status : '||l_status);
1679: END IF;
1680: ELSE

Line 1685: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,x_status,x_status);

1681: -- We need to call the getAddrValStatus only once. All other cases we are looking into x_call_map
1682: -- In some case the below code will execute with the x_call_map as N
1683: IF l_get_addr_val = 'Y' THEN
1684: -- This below call is to derive the address validation status and set the message
1685: X_ADDR_VAL_STATUS := HZ_GNR_UTIL_PKG.getAddrValStatus(LL_MAP_DTLS_TBL,L_MDU_TBL,P_CALLED_FROM,P_ADDR_VAL_LEVEL,x_addr_warn_msg,x_status,x_status);
1686: END IF;
1687:
1688: IF P_LOCATION_ID IS NOT NULL THEN
1689:

Line 1700: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,

1696: p_module => l_module
1697: );
1698: END IF;
1699:
1700: HZ_GNR_UTIL_PKG.create_gnr(P_LOCATION_ID,G_MAP_REC.LOC_TBL_NAME,
1701: L_USAGE_CODE,'E',L_LOC_COMPONENTS_REC,p_lock_flag,LL_MAP_DTLS_TBL,l_status);
1702: --hk_debugl('Prceossed GNR With Status : E and returned with Status : '||l_status);
1703: END IF;
1704: END IF;