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.FND_LDAP_USER dependencies on FND_LDAP_UTIL

Line 68: -- function add_uniquemember(p_ldap_user in fnd_ldap_util.ldap_user_type) return pls_integer is

64:
65: --
66: -------------------------------------------------------------------------------
67: --- REMOVED
68: -- function add_uniquemember(p_ldap_user in fnd_ldap_util.ldap_user_type) return pls_integer is
69: -- translate_ldap_error: Internal
70: -- Will attempt to translate the sqlerrms from an dbms_ldap operation into a FND message
71:
72: -------------------------------------------------------------------------------

Line 129: x_result := fnd_ldap_util.G_SUCCESS;

125: begin
126:
127: -- initializing
128: l_module_source := G_MODULE_SOURCE || 'delete_user: ';
129: x_result := fnd_ldap_util.G_SUCCESS;
130:
131: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
132: then
133: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Begin');

Line 148: x_result := fnd_ldap_util.G_FAILURE;

144: then
145: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source,
146: 'NULL guid in FND_USER');
147: end if;
148: x_result := fnd_ldap_util.G_FAILURE;
149: else
150: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
151: then
152: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source,

Line 156: --ldapSession := fnd_ldap_util.get_oid_session;

152: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source,
153: 'FND_USER GUID::'||l_orclguid);
154: end if;
155: l_filter := 'orclguid='||l_orclguid;
156: --ldapSession := fnd_ldap_util.get_oid_session;
157: --searchNodes := fnd_ldap_util.get_search_nodes;
158: l_base := ''; -- don't need any more for guid search
159: l_attrs(0) := 'orclisenabled';
160: l_attrs(1) := 'creatorsname';

Line 157: --searchNodes := fnd_ldap_util.get_search_nodes;

153: 'FND_USER GUID::'||l_orclguid);
154: end if;
155: l_filter := 'orclguid='||l_orclguid;
156: --ldapSession := fnd_ldap_util.get_oid_session;
157: --searchNodes := fnd_ldap_util.get_search_nodes;
158: l_base := ''; -- don't need any more for guid search
159: l_attrs(0) := 'orclisenabled';
160: l_attrs(1) := 'creatorsname';
161: l_attrs(2) := 'orclguid';

Line 186: if (p_forced OR (upper(l_creatorname) = upper(fnd_ldap_util.get_orclappname)

182: end if;
183: l_attrs_vals := dbms_ldap.get_values(ldapSession, l_entry, 'orclguid');
184: l_guid := l_attrs_vals(0);
185:
186: if (p_forced OR (upper(l_creatorname) = upper(fnd_ldap_util.get_orclappname)
187: and l_isenabled is not NULL
188: and (upper(l_isenabled) = 'INACTIVE' or upper(l_isenabled) = 'DISABLED')
189: ) ) then
190: x_result := delete_user_subscription(ldapSession, l_guid);

Line 203: --x_result := fnd_ldap_util.unbind(ldapSession);

199: --end if;
200: --end if;
201: --end if;
202: --end loop;
203: --x_result := fnd_ldap_util.unbind(ldapSession);
204:
205: ELSE
206:
207: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)

Line 209: if (upper(l_creatorname) = upper(fnd_ldap_util.get_orclappname)) THEN

205: ELSE
206:
207: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
208: then
209: if (upper(l_creatorname) = upper(fnd_ldap_util.get_orclappname)) THEN
210: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source,'NOT DELETED BECAUSE was created by '||l_creatorname);
211: END IF;
212:
213: if NOT (l_isenabled is not NULL and (upper(l_isenabled) = 'INACTIVE' or upper(l_isenabled) = 'DISABLED'))

Line 223: x_result := fnd_ldap_util.G_SUCCESS;

219: end if;
220: end if;
221:
222: if (x_result = dbms_ldap.SUCCESS) then
223: x_result := fnd_ldap_util.G_SUCCESS;
224: end if;
225: end if;-- fnd_user guid null check if block ends here
226:
227: if (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL)

Line 238: x_result := fnd_ldap_util.G_FAILURE;

234: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
235: then
236: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);
237: end if;
238: x_result := fnd_ldap_util.G_FAILURE;
239:
240: end delete_user;
241:
242: procedure delete_user(p_user_guid in fnd_user.user_guid%type ,

Line 249: ldapSession := fnd_ldap_util.c_get_oid_session(dummy);

245:
246: ldapSession dbms_ldap.session;
247: dummy pls_integer;
248: BEGIN
249: ldapSession := fnd_ldap_util.c_get_oid_session(dummy);
250: delete_user(ldapSession,p_user_guid,x_result,p_forced);
251: fnd_ldap_util.c_unbind(ldapSession,dummy);
252: end delete_user;
253: procedure delete_user(p_user_guid in fnd_user.user_guid%type ,

Line 251: fnd_ldap_util.c_unbind(ldapSession,dummy);

247: dummy pls_integer;
248: BEGIN
249: ldapSession := fnd_ldap_util.c_get_oid_session(dummy);
250: delete_user(ldapSession,p_user_guid,x_result,p_forced);
251: fnd_ldap_util.c_unbind(ldapSession,dummy);
252: end delete_user;
253: procedure delete_user(p_user_guid in fnd_user.user_guid%type ,
254: x_result out nocopy pls_integer ) is
255:

Line 309: x_result := fnd_ldap_util.G_FAILURE;

305: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
306: then
307: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);
308: end if;
309: x_result := fnd_ldap_util.G_FAILURE;
310: when others then
311: fnd_message.set_name ('FND', 'FND_SSO_UNEXP_ERROR');
312: if (fnd_log.LEVEL_EXCEPTION>= fnd_log.G_CURRENT_RUNTIME_LEVEL)
313: then

Line 316: --x_result := fnd_ldap_util.G_FAILURE;

312: if (fnd_log.LEVEL_EXCEPTION>= fnd_log.G_CURRENT_RUNTIME_LEVEL)
313: then
314: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);
315: end if;
316: --x_result := fnd_ldap_util.G_FAILURE;
317: -- bug 4573677
318: raise;
319:
320: end change_password;

Line 339: dn := fnd_ldap_util.get_dn_for_guid(guid);

335: result pls_integer;
336:
337: begin
338:
339: dn := fnd_ldap_util.get_dn_for_guid(guid);
340: if (dn is not null) then
341: result := FND_LDAP_UTIL.G_SUCCESS;
342: else
343: result := FND_LDAP_UTIL.G_FAILURE;

Line 341: result := FND_LDAP_UTIL.G_SUCCESS;

337: begin
338:
339: dn := fnd_ldap_util.get_dn_for_guid(guid);
340: if (dn is not null) then
341: result := FND_LDAP_UTIL.G_SUCCESS;
342: else
343: result := FND_LDAP_UTIL.G_FAILURE;
344: end if;
345: return result;

Line 343: result := FND_LDAP_UTIL.G_FAILURE;

339: dn := fnd_ldap_util.get_dn_for_guid(guid);
340: if (dn is not null) then
341: result := FND_LDAP_UTIL.G_SUCCESS;
342: else
343: result := FND_LDAP_UTIL.G_FAILURE;
344: end if;
345: return result;
346:
347: EXCEPTION WHEN OTHERS THEN

Line 395: x_result:=fnd_ldap_util.G_SUCCESS;

391: IF (upper(p_old_user_name) =upper(p_new_user_name))THEN
392: IF (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
393: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'END-> SAME NAMES, no changes!');
394: END IF;
395: x_result:=fnd_ldap_util.G_SUCCESS;
396: RETURN;
397: END IF;
398: -- look for the user_id.
399: -- this procedure asumes that name was already changed on FND_USER (not commit maybe)

Line 411: x_result:=fnd_ldap_util.G_FAILURE;

407: WHEN NO_DATA_FOUND THEN
408: IF (fnd_log.LEVEL_UNEXPECTED >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
409: fnd_log.string(fnd_log.LEVEL_UNEXPECTED , l_module_source, 'Cannot locate user_name[new]='||p_new_user_name||' guid='|| p_user_guid||':'||sqlerrm);
410: END IF;
411: x_result:=fnd_ldap_util.G_FAILURE;
412: RETURN;
413: END;
414: /** to do - what if there are multiple linked users ? **/
415: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)

Line 424: ldap := fnd_ldap_util.c_get_oid_session(flag);

420: IF (l_to_synch) THEN
421: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
422: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'SYNC user '||p_new_user_name);
423: END IF;
424: ldap := fnd_ldap_util.c_get_oid_session(flag);
425: IF FND_LDAP_UTIL.loadLdapRecord( ldap, user_rec.user_data, dn , p_user_guid, fnd_ldap_util.G_GUID_KEY) THEN
426: user_rec.dn :=dn;
427: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
428: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Updating dn:'||dn);

Line 425: IF FND_LDAP_UTIL.loadLdapRecord( ldap, user_rec.user_data, dn , p_user_guid, fnd_ldap_util.G_GUID_KEY) THEN

421: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
422: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'SYNC user '||p_new_user_name);
423: END IF;
424: ldap := fnd_ldap_util.c_get_oid_session(flag);
425: IF FND_LDAP_UTIL.loadLdapRecord( ldap, user_rec.user_data, dn , p_user_guid, fnd_ldap_util.G_GUID_KEY) THEN
426: user_rec.dn :=dn;
427: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
428: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Updating dn:'||dn);
429: END IF;

Line 479: x_result := fnd_ldap_util.G_SUCCESS;

475: mod_type => nna,
476: modval => target);
477: x_result:= dbms_ldap.modify_s(ldap,user_rec.dn, ma);
478: if (x_result = dbms_ldap.SUCCESS) then
479: x_result := fnd_ldap_util.G_SUCCESS;
480: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
481: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Updating succedd ');
482: END IF;
483: end if;

Line 502: fnd_ldap_util.c_unbind(ldap,flag);

498: fnd_log.string(fnd_log.LEVEL_UNEXPECTED , l_module_source, 'Cannot locate user_name[new]='||p_new_user_name||' guid='|| p_user_guid||':'||sqlerrm);
499: END IF;
500: raise no_such_user_exp;
501: END IF;
502: fnd_ldap_util.c_unbind(ldap,flag);
503: ELSE
504: x_result := fnd_ldap_util.G_SUCCESS;
505: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
506: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'User is a local user or Synch profile is disabled.');

Line 504: x_result := fnd_ldap_util.G_SUCCESS;

500: raise no_such_user_exp;
501: END IF;
502: fnd_ldap_util.c_unbind(ldap,flag);
503: ELSE
504: x_result := fnd_ldap_util.G_SUCCESS;
505: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
506: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'User is a local user or Synch profile is disabled.');
507: END IF;
508: END IF;

Line 513: IF (x_result = fnd_ldap_util.G_SUCCESS ) THEN

509:
510:
511:
512: IF (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
513: IF (x_result = fnd_ldap_util.G_SUCCESS ) THEN
514: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End-> fnd_ldap_util.G_SUCCESS ');
515: ELSE
516: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End-> fnd_ldap_util.G_FAIL ');
517: END IF;

Line 514: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End-> fnd_ldap_util.G_SUCCESS ');

510:
511:
512: IF (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
513: IF (x_result = fnd_ldap_util.G_SUCCESS ) THEN
514: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End-> fnd_ldap_util.G_SUCCESS ');
515: ELSE
516: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End-> fnd_ldap_util.G_FAIL ');
517: END IF;
518: END IF;

Line 516: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End-> fnd_ldap_util.G_FAIL ');

512: IF (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
513: IF (x_result = fnd_ldap_util.G_SUCCESS ) THEN
514: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End-> fnd_ldap_util.G_SUCCESS ');
515: ELSE
516: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End-> fnd_ldap_util.G_FAIL ');
517: END IF;
518: END IF;
519:
520:

Line 524: fnd_ldap_util.c_unbind(ldap,flag);

520:
521:
522: exception
523: when invalid_new_user_exp then
524: fnd_ldap_util.c_unbind(ldap,flag);
525: fnd_message.set_name ('FND', 'FND_SSO_INVALID_NEW_USER_NAME');
526: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
527: then
528: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);

Line 530: x_result := fnd_ldap_util.G_FAILURE;

526: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
527: then
528: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);
529: end if;
530: x_result := fnd_ldap_util.G_FAILURE;
531: when no_such_user_exp then
532: fnd_ldap_util.c_unbind(ldap,flag);
533: fnd_message.set_name ('FND', 'FND_SSO_USER_NOT_FOUND');
534: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)

Line 532: fnd_ldap_util.c_unbind(ldap,flag);

528: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);
529: end if;
530: x_result := fnd_ldap_util.G_FAILURE;
531: when no_such_user_exp then
532: fnd_ldap_util.c_unbind(ldap,flag);
533: fnd_message.set_name ('FND', 'FND_SSO_USER_NOT_FOUND');
534: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
535: then
536: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);

Line 538: x_result := fnd_ldap_util.G_FAILURE;

534: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
535: then
536: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);
537: end if;
538: x_result := fnd_ldap_util.G_FAILURE;
539: when others then
540: fnd_message.set_name ('FND', 'FND_SSO_UNEXP_ERROR');
541: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
542: then

Line 545: x_result := fnd_ldap_util.G_FAILURE;

541: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
542: then
543: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);
544: end if;
545: x_result := fnd_ldap_util.G_FAILURE;
546: end change_user_name;
547: --
548: -------------------------------------------------------------------------------
549: --

Line 550: -- 1) Fills an usertype fnd_ldap_util.ldap_user_type and call create_user(fnd_ldap_util.ldap_user_type)

546: end change_user_name;
547: --
548: -------------------------------------------------------------------------------
549: --
550: -- 1) Fills an usertype fnd_ldap_util.ldap_user_type and call create_user(fnd_ldap_util.ldap_user_type)
551: -- if it returns failure put a FND_SSO_USER_EXIST on the errors tack
552: --
553: -- 2) Retreive its guid
554: -- 3) Loook at the APPS_SSO_LOCAL_LOGIN ( user=-1 level, which may or may not be site)

Line 579: retval := fnd_ldap_util.G_FAILURE;

575: i pls_integer;
576: some_data boolean := false;
577: BEGIN
578: l_module_source := G_MODULE_SOURCE || 'create_ldap_user: ';
579: retval := fnd_ldap_util.G_FAILURE;
580:
581: IF (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
582: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'Begin');
583:

Line 666: retval := fnd_ldap_util.G_SUCCESS;

662: END IF;
663: dbms_ldap.free_mod_array(modArray);
664: IF ldap_result = dbms_ldap.SUCCESS THEN
665:
666: retval := fnd_ldap_util.G_SUCCESS;
667: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
668: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'created user:' || p_ldap_user.user_name);
669: END IF;
670:

Line 672: p_ldap_user.user_guid := FND_LDAP_UTIL.get_guid_for_dn(p_ldap_session,p_ldap_user.dn );

668: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'created user:' || p_ldap_user.user_name);
669: END IF;
670:
671: -- get the guid
672: p_ldap_user.user_guid := FND_LDAP_UTIL.get_guid_for_dn(p_ldap_session,p_ldap_user.dn );
673: IF (p_ldap_user.user_guid IS NULL) THEN
674: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
675: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Unoticed falure to create created DN [' || p_ldap_user.dn||']');
676: END IF;

Line 677: retval:= fnd_ldap_util.G_FAILURE;

673: IF (p_ldap_user.user_guid IS NULL) THEN
674: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
675: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Unoticed falure to create created DN [' || p_ldap_user.dn||']');
676: END IF;
677: retval:= fnd_ldap_util.G_FAILURE;
678: ELSE
679: retval := fnd_ldap_util.G_SUCCESS;
680: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
681: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'new user:' || p_ldap_user.user_name || ' dn:' || p_ldap_user.dn );

Line 679: retval := fnd_ldap_util.G_SUCCESS;

675: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Unoticed falure to create created DN [' || p_ldap_user.dn||']');
676: END IF;
677: retval:= fnd_ldap_util.G_FAILURE;
678: ELSE
679: retval := fnd_ldap_util.G_SUCCESS;
680: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
681: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'new user:' || p_ldap_user.user_name || ' dn:' || p_ldap_user.dn );
682: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'new user:' || p_ldap_user.user_name || ' guid:' || p_ldap_user.user_guid );
683: END IF;

Line 686: retval := fnd_ldap_util.G_FAILURE;

682: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'new user:' || p_ldap_user.user_name || ' guid:' || p_ldap_user.user_guid );
683: END IF;
684: END IF;
685: ELSE
686: retval := fnd_ldap_util.G_FAILURE;
687: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
688: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Falied to create ['||p_ldap_user.dn||'] user:'||p_ldap_user.user_name);
689: END IF;
690:

Line 715: return 'cn=ACCOUNTS,cn=subscription_data,cn=subscriptions,' || fnd_ldap_util.get_orclappname;

711: Now is simple, in the future may change for multiples realms.
712: */
713: function get_ACCOUNT_dn(p_guid in raw) return varchar2 is
714: begin
715: return 'cn=ACCOUNTS,cn=subscription_data,cn=subscriptions,' || fnd_ldap_util.get_orclappname;
716: end get_ACCOUNT_dn;
717: --
718: -------------------------------------------------------------------------------
719: function create_user_subscription(ldapSession in dbms_ldap.session, p_user_dn in varchar2 , p_guid in raw)

Line 737: retval := fnd_ldap_util.G_FAILURE;

733: err varchar2(1000); --bug 8618800
734: begin
735: l_module_source := G_MODULE_SOURCE || 'create_user_subscription: ';
736: -- set default value to failure. change to success when user created successfully
737: retval := fnd_ldap_util.G_FAILURE;
738: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
739: then
740: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Begin guid='||p_guid);
741: end if;

Line 743: -- ldapSession := fnd_ldap_util.c_get_oid_session(flag);

739: then
740: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Begin guid='||p_guid);
741: end if;
742:
743: -- ldapSession := fnd_ldap_util.c_get_oid_session(flag);
744:
745: -- userDN := fnd_ldap_util.get_dn_for_guid(p_guid);
746:
747: acctNode := get_ACCOUNT_dn(p_guid);

Line 745: -- userDN := fnd_ldap_util.get_dn_for_guid(p_guid);

741: end if;
742:
743: -- ldapSession := fnd_ldap_util.c_get_oid_session(flag);
744:
745: -- userDN := fnd_ldap_util.get_dn_for_guid(p_guid);
746:
747: acctNode := get_ACCOUNT_dn(p_guid);
748: -- num_attributes := process_attributes(p_ldap_user, x_atts => l_atts,
749: -- x_att_values => l_att_values);

Line 764: fnd_ldap_util.add_attribute_M(ldapSession,acctNode,'uniqueMember',p_user_dn);

760: retval := dbms_ldap.add_s(ld => ldapSession, entrydn => subsNode, modptr => modArray);
761:
762: if (retval = dbms_ldap.SUCCESS) then
763: --retval := add_uniquemember(p_ldap_user);
764: fnd_ldap_util.add_attribute_M(ldapSession,acctNode,'uniqueMember',p_user_dn);
765: retval:= fnd_ldap_util.G_SUCCESS;
766: else
767: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
768: then

Line 765: retval:= fnd_ldap_util.G_SUCCESS;

761:
762: if (retval = dbms_ldap.SUCCESS) then
763: --retval := add_uniquemember(p_ldap_user);
764: fnd_ldap_util.add_attribute_M(ldapSession,acctNode,'uniqueMember',p_user_dn);
765: retval:= fnd_ldap_util.G_SUCCESS;
766: else
767: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
768: then
769: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Failed! retval='||retval||' subsNode:'||subsNode);

Line 774: --fnd_ldap_util.c_unbind(ldapSession,flag);

770: end if;
771: end if;
772:
773: dbms_ldap.free_mod_array(modptr => modArray);
774: --fnd_ldap_util.c_unbind(ldapSession,flag);
775:
776: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
777: then
778: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'End');

Line 796: retval := fnd_ldap_util.G_SUCCESS;

792: if (instr(err,'Already exists. Object already exists') > 0) then
793: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
794: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'User already subscribed');
795: end if;
796: retval := fnd_ldap_util.G_SUCCESS;
797: return retval;
798: else
799: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
800: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Failed! retval='||retval||' subsNode:'||subsNode);

Line 902: usersNode := fnd_ldap_util.get_dn_for_guid(p_orclguid => p_orclguid);

898: end if;
899:
900:
901:
902: usersNode := fnd_ldap_util.get_dn_for_guid(p_orclguid => p_orclguid);
903:
904: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
905: then
906: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'DN for user with GUID::'

Line 946: subsNode := 'cn=ACCOUNTS,cn=subscription_data,cn=subscriptions,' || fnd_ldap_util.get_orclappname;

942: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Begin');
943: end if;
944:
945: -- delete subcriptions with orclOwnerGUID
946: subsNode := 'cn=ACCOUNTS,cn=subscription_data,cn=subscriptions,' || fnd_ldap_util.get_orclappname;
947: l_result := dbms_ldap.search_s(ld => p_ldap_session, base => subsNode,
948: scope => dbms_ldap.SCOPE_SUBTREE, filter => 'orclOwnerGUID=' || l_user_guid, attrs => l_attrs, attronly => 0, res => l_message);
949: if (l_result is not NULL) then
950: l_entry := dbms_ldap.first_entry(p_ldap_session, l_message);

Line 987: retval := fnd_ldap_util.G_FAILURE;

983:
984: begin
985: l_module_source := G_MODULE_SOURCE || 'delete_uniquemember: ';
986: -- set default value to failure. change to success when added successfully
987: retval := fnd_ldap_util.G_FAILURE;
988: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
989: then
990: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Begin');
991: end if;

Line 993: subsNode := 'cn=ACCOUNTS,cn=subscription_data,cn=subscriptions,' || fnd_ldap_util.get_orclappname;

989: then
990: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Begin');
991: end if;
992:
993: subsNode := 'cn=ACCOUNTS,cn=subscription_data,cn=subscriptions,' || fnd_ldap_util.get_orclappname;
994:
995: modArray := dbms_ldap.create_mod_array(num => 1);
996:
997: modmultivalues(0) := fnd_ldap_util.get_dn_for_guid(p_orclguid);

Line 997: modmultivalues(0) := fnd_ldap_util.get_dn_for_guid(p_orclguid);

993: subsNode := 'cn=ACCOUNTS,cn=subscription_data,cn=subscriptions,' || fnd_ldap_util.get_orclappname;
994:
995: modArray := dbms_ldap.create_mod_array(num => 1);
996:
997: modmultivalues(0) := fnd_ldap_util.get_dn_for_guid(p_orclguid);
998:
999: dbms_ldap.populate_mod_array(modptr => modArray, mod_op => dbms_ldap.mod_delete, mod_type => 'uniquemember', modval => modmultivalues);
1000:
1001: retval := dbms_ldap.modify_s(ld => p_ldap_Session, entrydn => subsNode, modptr => modArray);

Line 1005: retval := fnd_ldap_util.G_SUCCESS;

1001: retval := dbms_ldap.modify_s(ld => p_ldap_Session, entrydn => subsNode, modptr => modArray);
1002:
1003:
1004: if (retval = dbms_ldap.SUCCESS) then
1005: retval := fnd_ldap_util.G_SUCCESS;
1006: end if;
1007:
1008: dbms_ldap.free_mod_array(modptr => modArray);
1009:

Line 1032: usertype fnd_ldap_util.ldap_user_type;

1028: procedure disable_user(p_user_guid in raw,
1029: p_user_name in varchar2,
1030: x_result out nocopy pls_integer) is
1031:
1032: usertype fnd_ldap_util.ldap_user_type;
1033: l_module_source varchar2(256);
1034: no_such_user_exp exception;
1035: l_user_id fnd_user.user_id%type;
1036: l_local_login varchar2(30);

Line 1057: if x_result <> fnd_ldap_util.G_SUCCESS then

1053: update_user(p_user_guid =>p_user_guid,p_user_name =>p_user_name,
1054: p_end_date =>sysdate-100,
1055: p_expire_password => 0,x_password => x_password,x_result => x_result , x_user_creation=>FALSE);
1056:
1057: if x_result <> fnd_ldap_util.G_SUCCESS then
1058: raise no_such_user_exp;
1059: end if;
1060: exception
1061: when no_such_user_exp then

Line 1067: x_result := fnd_ldap_util.G_FAILURE;

1063: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1064: then
1065: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);
1066: end if;
1067: x_result := fnd_ldap_util.G_FAILURE;
1068: when others then
1069: fnd_message.set_name ('FND', 'FND_SSO_UNEXP_ERROR');
1070: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1071: then

Line 1074: x_result := fnd_ldap_util.G_FAILURE;

1070: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1071: then
1072: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);
1073: end if;
1074: x_result := fnd_ldap_util.G_FAILURE;
1075:
1076: end disable_user;
1077: --
1078: --

Line 1138: -- retval := fnd_ldap_util.G_FAILURE;

1134: ridx pls_integer;
1135: sbase dbms_ldap.string_collection;
1136: begin
1137: l_module_source := G_MODULE_SOURCE || 'get_user_guid: ';
1138: -- retval := fnd_ldap_util.G_FAILURE;
1139: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1140: then
1141: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Begin');
1142: end if;

Line 1192: --result := fnd_ldap_util.unbind(ldapSession);

1188: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'User '||p_user_name||' not found');
1189: END IF;
1190: end if;
1191:
1192: --result := fnd_ldap_util.unbind(ldapSession);
1193:
1194: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1195: then
1196: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'End');

Line 1207: --dummy := fnd_ldap_util.c_get_oid_session(result);

1203: then
1204: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);
1205: -- print stack just for 7306960
1206: --result:= -99;
1207: --dummy := fnd_ldap_util.c_get_oid_session(result);
1208: end if;
1209: raise;
1210:
1211: end get_user_guid;

Line 1226: l_ldap := fnd_ldap_util.c_get_oid_session(dummy);

1222: l_ldap dbms_ldap.session;
1223: ret fnd_user.user_guid%type;
1224: dummy pls_integer;
1225: BEGIN
1226: l_ldap := fnd_ldap_util.c_get_oid_session(dummy);
1227: ret := get_user_guid(l_ldap,p_user_name);
1228: fnd_ldap_util.C_unbind(l_ldap,dummy);
1229: return ret;
1230: EXCEPTION

Line 1228: fnd_ldap_util.C_unbind(l_ldap,dummy);

1224: dummy pls_integer;
1225: BEGIN
1226: l_ldap := fnd_ldap_util.c_get_oid_session(dummy);
1227: ret := get_user_guid(l_ldap,p_user_name);
1228: fnd_ldap_util.C_unbind(l_ldap,dummy);
1229: return ret;
1230: EXCEPTION
1231: WHEN OTHERS THEN
1232: fnd_ldap_util.c_unbind(l_ldap,dummy);

Line 1232: fnd_ldap_util.c_unbind(l_ldap,dummy);

1228: fnd_ldap_util.C_unbind(l_ldap,dummy);
1229: return ret;
1230: EXCEPTION
1231: WHEN OTHERS THEN
1232: fnd_ldap_util.c_unbind(l_ldap,dummy);
1233: IF (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
1234: fnd_log.string(fnd_log.LEVEL_EXCEPTION, G_MODULE_SOURCE || 'get_user_guid: ', sqlerrm);
1235: END IF;
1236: raise;

Line 1279: if (l_result = fnd_ldap_util.G_SUCCESS) then

1275: fnd_oid_util.add_user_to_OID_sub_list(p_orclguid => l_orclguid, x_result => l_result);
1276:
1277: x_result := l_result;
1278:
1279: if (l_result = fnd_ldap_util.G_SUCCESS) then
1280: x_user_guid := l_orclguid;
1281:
1282: fnd_profile.get_specific(
1283: name_z => 'APPS_SSO_LOCAL_LOGIN',

Line 1297: x_result := fnd_ldap_util.G_FAILURE;

1293:
1294: -- user does not exist in OID
1295: else
1296: fnd_message.set_name('FND', 'FND_SSO_USER_NOT_FOUND');
1297: x_result := fnd_ldap_util.G_FAILURE;
1298: end if;
1299:
1300: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1301: then

Line 1316: function process_attributes(p_ldap_user in fnd_ldap_util.ldap_user_type,

1312:
1313: end link_user;
1314: --
1315: -------------------------------------------------------------------------------
1316: function process_attributes(p_ldap_user in fnd_ldap_util.ldap_user_type,
1317: p_operation_type in pls_integer default G_CREATE,
1318: x_atts out nocopy dbms_ldap.string_collection,
1319: x_att_values out nocopy dbms_ldap.string_collection)
1320: return number is

Line 1495: if (l_user_exists = fnd_ldap_util.G_SUCCESS) then

1491: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'No other FND users linked to this OID User');
1492: end if;
1493: l_user_exists := user_exists_by_guid( p_user_guid);
1494:
1495: if (l_user_exists = fnd_ldap_util.G_SUCCESS) then
1496:
1497: l_ldap_session := fnd_ldap_util.c_get_oid_session(dummy);
1498:
1499: x_result := delete_user_subscription(l_ldap_session, p_user_guid);

Line 1497: l_ldap_session := fnd_ldap_util.c_get_oid_session(dummy);

1493: l_user_exists := user_exists_by_guid( p_user_guid);
1494:
1495: if (l_user_exists = fnd_ldap_util.G_SUCCESS) then
1496:
1497: l_ldap_session := fnd_ldap_util.c_get_oid_session(dummy);
1498:
1499: x_result := delete_user_subscription(l_ldap_session, p_user_guid);
1500: x_result := delete_uniquemember(l_ldap_session, p_user_guid);
1501:

Line 1505: x_result := fnd_ldap_util.G_FAILURE;

1501:
1502: -- user does not exist in OID
1503: else
1504: fnd_message.set_name('FND', 'FND_SSO_USER_NOT_FOUND');
1505: x_result := fnd_ldap_util.G_FAILURE;
1506: end if;
1507:
1508: -- other users linked
1509: else

Line 1516: x_result := fnd_ldap_util.G_FAILURE;

1512: then
1513: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Other FND users linked to this OID User');
1514: end if;
1515:
1516: x_result := fnd_ldap_util.G_FAILURE;
1517: fnd_message.set_name ('FND', 'FND_SSO_USER_MULT_LINKED');
1518:
1519: end if;
1520: if ( l_ldap_session is not null) then

Line 1521: fnd_ldap_util.c_unbind(l_ldap_session,dummy);

1517: fnd_message.set_name ('FND', 'FND_SSO_USER_MULT_LINKED');
1518:
1519: end if;
1520: if ( l_ldap_session is not null) then
1521: fnd_ldap_util.c_unbind(l_ldap_session,dummy);
1522: end if ;
1523: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1524: then
1525: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'End');

Line 1530: fnd_ldap_util.c_unbind(l_ldap_session,dummy);

1526: end if;
1527:
1528: exception
1529: when others then
1530: fnd_ldap_util.c_unbind(l_ldap_session,dummy);
1531: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1532: then
1533: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);
1534: end if;

Line 1560: -- usertype fnd_ldap_util.ldap_user_type;

1556: x_user_creation in boolean default FALSE ) is
1557:
1558:
1559: l_orclisEnabled varchar2(256);
1560: -- usertype fnd_ldap_util.ldap_user_type;
1561: ldap_user fnd_ldap_user.ldap_user_type;
1562: l_module_source varchar2(256);
1563: no_such_user_exp exception;
1564: l_nickname varchar2(256);

Line 1638: if (p_expire_password is not null and p_expire_password <> fnd_ldap_util.G_TRUE) THEN

1634: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
1635: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source,'Password is not null');
1636: end if;
1637:
1638: if (p_expire_password is not null and p_expire_password <> fnd_ldap_util.G_TRUE) THEN
1639:
1640: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
1641: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source,'So far password will not be expired - proxy as user');
1642: end if;

Line 1674: fnd_ldap_util.proxy_as_user(p_orclguid => p_user_guid,x_ldap_session => ldap);

1670: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1671: then
1672: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Getting a proxied connection to avoid password forced change: NEW LDAP connection required');
1673: end if;
1674: fnd_ldap_util.proxy_as_user(p_orclguid => p_user_guid,x_ldap_session => ldap);
1675: else
1676: ldap := FND_LDAP_UTIL.c_get_oid_session(flag);
1677: l_use_proxy :=1;
1678: end if;

Line 1676: ldap := FND_LDAP_UTIL.c_get_oid_session(flag);

1672: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Getting a proxied connection to avoid password forced change: NEW LDAP connection required');
1673: end if;
1674: fnd_ldap_util.proxy_as_user(p_orclguid => p_user_guid,x_ldap_session => ldap);
1675: else
1676: ldap := FND_LDAP_UTIL.c_get_oid_session(flag);
1677: l_use_proxy :=1;
1678: end if;
1679:
1680: l_guid := p_user_guid;

Line 1681: IF FND_LDAP_UTIL.loadLdapRecord( ldap , ldap_user.user_data,dn,l_guid,FND_LDAP_UTIL.G_GUID_KEY)

1677: l_use_proxy :=1;
1678: end if;
1679:
1680: l_guid := p_user_guid;
1681: IF FND_LDAP_UTIL.loadLdapRecord( ldap , ldap_user.user_data,dn,l_guid,FND_LDAP_UTIL.G_GUID_KEY)
1682: THEN
1683: ldap_user.dn :=dn;
1684: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
1685: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Updating dn:'||dn);

Line 1747: x_result := fnd_ldap_util.G_SUCCESS;

1743: END IF;
1744: if (upd.count>0) THEN
1745: ProcessUpdateRec(ldap,ldap_user.dn,upd);
1746: END IF;
1747: x_result := fnd_ldap_util.G_SUCCESS;
1748: /*
1749: CANNOT CHANGE USERNAME
1750: Unless the old is known, and that is not possible because already was changed on FND_USER...
1751: IF (x_result=FND_LDAP_UTIl.G_SUCCESS AND p_user_name is not null and isValueOf(ldap_user,ldap_user.nickname_att_name, p_user_name) ) THEN

Line 1751: IF (x_result=FND_LDAP_UTIl.G_SUCCESS AND p_user_name is not null and isValueOf(ldap_user,ldap_user.nickname_att_name, p_user_name) ) THEN

1747: x_result := fnd_ldap_util.G_SUCCESS;
1748: /*
1749: CANNOT CHANGE USERNAME
1750: Unless the old is known, and that is not possible because already was changed on FND_USER...
1751: IF (x_result=FND_LDAP_UTIl.G_SUCCESS AND p_user_name is not null and isValueOf(ldap_user,ldap_user.nickname_att_name, p_user_name) ) THEN
1752: change_user_name(p_user_guid,ldap_user.user_name,p_user_name,x_name_change);
1753: x_result :=x_name_change;
1754: END IF;
1755: */

Line 1764: ldap_result := fnd_ldap_util.unbind(ldap);

1760: end if;
1761: raise no_such_user_exp;
1762: END IF;
1763: if ( l_use_proxy=2 ) then
1764: ldap_result := fnd_ldap_util.unbind(ldap);
1765: elsif l_use_proxy=1 then
1766: FND_LDAP_UTIL.c_unbind(ldap,flag);
1767: end if;
1768: l_use_proxy:=0;

Line 1766: FND_LDAP_UTIL.c_unbind(ldap,flag);

1762: END IF;
1763: if ( l_use_proxy=2 ) then
1764: ldap_result := fnd_ldap_util.unbind(ldap);
1765: elsif l_use_proxy=1 then
1766: FND_LDAP_UTIL.c_unbind(ldap,flag);
1767: end if;
1768: l_use_proxy:=0;
1769:
1770: -- ldap:=null;

Line 1773: x_result := fnd_ldap_util.G_SUCCESS;

1769:
1770: -- ldap:=null;
1771:
1772: else
1773: x_result := fnd_ldap_util.G_SUCCESS;
1774: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1775: then
1776: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source,
1777: 'User is a local user or synch is disabled for this user.');

Line 1783: if ( x_result = fnd_ldap_util.G_SUCCESS) THEN

1779: end if;
1780:
1781: if (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1782: then
1783: if ( x_result = fnd_ldap_util.G_SUCCESS) THEN
1784: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End->SUCCESS');
1785: ELSE
1786: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End->FAIL');
1787: END IF;

Line 1790: if x_result <> fnd_ldap_util.G_SUCCESS then

1786: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End->FAIL');
1787: END IF;
1788: end if;
1789:
1790: if x_result <> fnd_ldap_util.G_SUCCESS then
1791: raise no_such_user_exp;
1792: else
1793: fnd_profile.get_specific(
1794: name_z => 'APPS_SSO_LOCAL_LOGIN',

Line 1807: ldap_result := fnd_ldap_util.unbind(ldap);

1803:
1804: exception
1805: when no_such_user_exp then
1806: if ( l_use_proxy=2 ) then
1807: ldap_result := fnd_ldap_util.unbind(ldap);
1808: elsif l_use_proxy=1 then
1809: FND_LDAP_UTIL.c_unbind(ldap,flag);
1810: end if;
1811: l_use_proxy:=0;

Line 1809: FND_LDAP_UTIL.c_unbind(ldap,flag);

1805: when no_such_user_exp then
1806: if ( l_use_proxy=2 ) then
1807: ldap_result := fnd_ldap_util.unbind(ldap);
1808: elsif l_use_proxy=1 then
1809: FND_LDAP_UTIL.c_unbind(ldap,flag);
1810: end if;
1811: l_use_proxy:=0;
1812: fnd_message.set_name ('FND', 'FND_SSO_USER_NOT_FOUND');
1813: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)

Line 1817: x_result := fnd_ldap_util.G_FAILURE;

1813: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1814: then
1815: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);
1816: end if;
1817: x_result := fnd_ldap_util.G_FAILURE;
1818: when others then
1819: if ( l_use_proxy=2 ) then
1820: ldap_result := fnd_ldap_util.unbind(ldap);
1821: elsif l_use_proxy=1 then

Line 1820: ldap_result := fnd_ldap_util.unbind(ldap);

1816: end if;
1817: x_result := fnd_ldap_util.G_FAILURE;
1818: when others then
1819: if ( l_use_proxy=2 ) then
1820: ldap_result := fnd_ldap_util.unbind(ldap);
1821: elsif l_use_proxy=1 then
1822: FND_LDAP_UTIL.c_unbind(ldap,flag);
1823: end if;
1824: l_use_proxy:=0;

Line 1822: FND_LDAP_UTIL.c_unbind(ldap,flag);

1818: when others then
1819: if ( l_use_proxy=2 ) then
1820: ldap_result := fnd_ldap_util.unbind(ldap);
1821: elsif l_use_proxy=1 then
1822: FND_LDAP_UTIL.c_unbind(ldap,flag);
1823: end if;
1824: l_use_proxy:=0;
1825:
1826: fnd_message.set_name ('FND', 'FND_SSO_UNEXP_ERROR');

Line 1831: -- x_result := fnd_ldap_util.G_FAILURE;

1827: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1828: then
1829: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);
1830: end if;
1831: -- x_result := fnd_ldap_util.G_FAILURE;
1832: raise;
1833:
1834: end update_user;
1835:

Line 1857: o in out nocopy fnd_ldap_util.ldap_user_type )

1853: END update_user;
1854: --
1855: -------------------------------------------------------------------------------
1856: PROCEDURE ConverToNew(n in out nocopy fnd_ldap_user.ldap_user_type,
1857: o in out nocopy fnd_ldap_util.ldap_user_type )
1858: IS
1859: BEGIN
1860:
1861: o.object_name := n.user_name;

Line 1905: retval := fnd_ldap_util.G_FAILURE;

1901:
1902: begin
1903: l_module_source := G_MODULE_SOURCE || 'update_user_nodes: ';
1904: -- set default value to failure. change to success when user created successfully
1905: retval := fnd_ldap_util.G_FAILURE;
1906: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1907: then
1908: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Begin');
1909: end if;

Line 1911: usersNode := fnd_ldap_util.get_dn_for_guid(p_orclguid, p_ldap_session);

1907: then
1908: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Begin');
1909: end if;
1910:
1911: usersNode := fnd_ldap_util.get_dn_for_guid(p_orclguid, p_ldap_session);
1912: -- dbms_ldap.use_exception := true;
1913:
1914: retval := dbms_ldap.modify_s(ld => p_ldap_session, entrydn => usersNode, modptr => p_mod_array);
1915:

Line 1917: retval := fnd_ldap_util.G_SUCCESS;

1913:
1914: retval := dbms_ldap.modify_s(ld => p_ldap_session, entrydn => usersNode, modptr => p_mod_array);
1915:
1916: if (retval = dbms_ldap.SUCCESS) then
1917: retval := fnd_ldap_util.G_SUCCESS;
1918: end if;
1919:
1920: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1921: then

Line 1941: return fnd_ldap_util.G_FAILURE;

1937: fnd_message.set_token('SQLMSG',sqlerrm);
1938: elsif (l_message='FND_SSO_UNEXP_ERROR') then
1939: fnd_message.set_token('SQLMSG',sqlerrm);
1940: end if;
1941: return fnd_ldap_util.G_FAILURE;
1942: when others then
1943: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1944: then
1945: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, sqlerrm);

Line 1958: ldap := fnd_ldap_util.c_get_oid_session(flag);

1954: ret pls_integer;
1955: ret2 pls_integer;
1956: flag pls_integer;
1957: begin
1958: ldap := fnd_ldap_util.c_get_oid_session(flag);
1959: ret := user_exists(ldap,p_user_name);
1960: fnd_ldap_util.c_unbind(ldap,flag);
1961: return ret;
1962: EXCEPTION

Line 1960: fnd_ldap_util.c_unbind(ldap,flag);

1956: flag pls_integer;
1957: begin
1958: ldap := fnd_ldap_util.c_get_oid_session(flag);
1959: ret := user_exists(ldap,p_user_name);
1960: fnd_ldap_util.c_unbind(ldap,flag);
1961: return ret;
1962: EXCEPTION
1963: WHEN OTHERS THEN
1964: fnd_ldap_util.c_unbind(ldap,flag);

Line 1964: fnd_ldap_util.c_unbind(ldap,flag);

1960: fnd_ldap_util.c_unbind(ldap,flag);
1961: return ret;
1962: EXCEPTION
1963: WHEN OTHERS THEN
1964: fnd_ldap_util.c_unbind(ldap,flag);
1965: IF (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
1966: fnd_log.string(fnd_log.LEVEL_EXCEPTION, G_MODULE_SOURCE || 'user_exists: ', sqlerrm);
1967: END IF;
1968: raise;

Line 1985: retval := fnd_ldap_util.G_FAILURE;

1981: guid raw(16);
1982:
1983: begin
1984: l_module_source := G_MODULE_SOURCE || 'user_exists: ';
1985: retval := fnd_ldap_util.G_FAILURE;
1986: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1987: then
1988: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Begin');
1989: end if;

Line 1993: retval := fnd_ldap_util.G_SUCCESS;

1989: end if;
1990:
1991: guid := get_user_guid(p_user_name);
1992: if (guid is not null ) then
1993: retval := fnd_ldap_util.G_SUCCESS;
1994: else
1995: retval :=fnd_ldap_util.G_FAILURE;
1996: end if;
1997:

Line 1995: retval :=fnd_ldap_util.G_FAILURE;

1991: guid := get_user_guid(p_user_name);
1992: if (guid is not null ) then
1993: retval := fnd_ldap_util.G_SUCCESS;
1994: else
1995: retval :=fnd_ldap_util.G_FAILURE;
1996: end if;
1997:
1998:
1999: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)

Line 2111: return fnd_ldap_util.G_FAILURE;

2107: if (fnd_log.LEVEL_UNEXPECTED >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2108: then
2109: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source, 'END: refusing to validate empty username and/or password');
2110: end if;
2111: return fnd_ldap_util.G_FAILURE;
2112: end if;
2113:
2114: -- Find the DN of the linked guid
2115: begin

Line 2123: return fnd_ldap_util.G_FAILURE;

2119: then
2120: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source, 'END: Null guid in FND_USER for: '||p_user_name);
2121: end if;
2122: fnd_message.set_name('FND','FND_SSO_NOT_LINKED');
2123: return fnd_ldap_util.G_FAILURE;
2124: end if;
2125: exception when no_data_found then
2126: if (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2127: then

Line 2131: return fnd_ldap_util.G_FAILURE;

2127: then
2128: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'END: user not found');
2129: end if;
2130: fnd_message.set_name('FND','FND_SSO_LOGIN_FAILED'); -- do no disclusre the real causeL
2131: return fnd_ldap_util.G_FAILURE;
2132: when others then
2133: if (fnd_log.LEVEL_UNEXPECTED >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2134: then
2135: fnd_log.string(fnd_log.LEVEL_UNEXPECTED ,l_module_source, 'END with exception: '||sqlcode||'-'||sqlerrm);

Line 2138: return fnd_ldap_util.G_FAILURE;

2134: then
2135: fnd_log.string(fnd_log.LEVEL_UNEXPECTED ,l_module_source, 'END with exception: '||sqlcode||'-'||sqlerrm);
2136: end if;
2137: fnd_message.set_name('FND','FND-9914'); -- unexpected error
2138: return fnd_ldap_util.G_FAILURE;
2139: end;
2140:
2141: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2142: then

Line 2149: user_dn := fnd_Ldap_util.get_dn_for_guid(l_user_guid); -- may raise no data found for invalid guids

2145:
2146:
2147: -- Obtain the user DN using the GUID
2148: begin
2149: user_dn := fnd_Ldap_util.get_dn_for_guid(l_user_guid); -- may raise no data found for invalid guids
2150: exception when no_data_found then
2151: if (fnd_log.LEVEL_UNEXPECTED >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2152: then
2153: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source, 'Guid['||l_user_guid||'] for '||p_user_name||' is not a valid guid');

Line 2156: return fnd_ldap_util.G_FAILURE;

2152: then
2153: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source, 'Guid['||l_user_guid||'] for '||p_user_name||' is not a valid guid');
2154: end if;
2155: fnd_message.set_name('FND','FND_SSO_USER_NOT_FOUND'); -- Carefull, this is INVALID GUID message, wrong acronym though
2156: return fnd_ldap_util.G_FAILURE;
2157: end;
2158:
2159: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2160: then

Line 2166: l_host := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_HOST);

2162: end if;
2163:
2164:
2165:
2166: l_host := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_HOST);
2167: l_port := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_PORT);
2168:
2169: if (l_host is null or l_port is null) then
2170: if (fnd_log.LEVEL_UNEXPECTED >= fnd_log.G_CURRENT_RUNTIME_LEVEL)

Line 2167: l_port := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_PORT);

2163:
2164:
2165:
2166: l_host := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_HOST);
2167: l_port := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_PORT);
2168:
2169: if (l_host is null or l_port is null) then
2170: if (fnd_log.LEVEL_UNEXPECTED >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2171: then

Line 2176: return fnd_ldap_util.G_FAILURE;

2172: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source, 'Invalid OiD Setup: host:'||l_host||' port:'||l_port);
2173: end if;
2174:
2175: fnd_message.set_name('FND','FND-9903'); -- OID setup is incomplete
2176: return fnd_ldap_util.G_FAILURE;
2177: end if;
2178:
2179: l_ldap_auth := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_DBLDAPAUTHLEVEL);
2180:

Line 2179: l_ldap_auth := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_DBLDAPAUTHLEVEL);

2175: fnd_message.set_name('FND','FND-9903'); -- OID setup is incomplete
2176: return fnd_ldap_util.G_FAILURE;
2177: end if;
2178:
2179: l_ldap_auth := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_DBLDAPAUTHLEVEL);
2180:
2181: if (l_ldap_auth>0) then
2182: l_db_wlt_url := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_DBWALLETDIR);
2183: l_db_wlt_pwd := fnd_preference.eget(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_DBWALLETPASS, FND_LDAP_UTIL.G_LDAP_PWD);

Line 2182: l_db_wlt_url := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_DBWALLETDIR);

2178:
2179: l_ldap_auth := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_DBLDAPAUTHLEVEL);
2180:
2181: if (l_ldap_auth>0) then
2182: l_db_wlt_url := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_DBWALLETDIR);
2183: l_db_wlt_pwd := fnd_preference.eget(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_DBWALLETPASS, FND_LDAP_UTIL.G_LDAP_PWD);
2184: if (l_db_wlt_url is null or l_db_wlt_pwd is null) then
2185: if (fnd_log.LEVEL_UNEXPECTED >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2186: then

Line 2183: l_db_wlt_pwd := fnd_preference.eget(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_DBWALLETPASS, FND_LDAP_UTIL.G_LDAP_PWD);

2179: l_ldap_auth := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_DBLDAPAUTHLEVEL);
2180:
2181: if (l_ldap_auth>0) then
2182: l_db_wlt_url := fnd_preference.get(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_DBWALLETDIR);
2183: l_db_wlt_pwd := fnd_preference.eget(FND_LDAP_UTIL.G_INTERNAL, FND_LDAP_UTIL.G_LDAP_SYNCH, FND_LDAP_UTIL.G_DBWALLETPASS, FND_LDAP_UTIL.G_LDAP_PWD);
2184: if (l_db_wlt_url is null or l_db_wlt_pwd is null) then
2185: if (fnd_log.LEVEL_UNEXPECTED >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2186: then
2187: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source, 'Invalid Wallet Setup: authLEvel:'

Line 2192: return fnd_ldap_util.G_FAILURE;

2188: ||l_ldap_auth||' url:'||l_db_wlt_url||' pwd:'||l_db_wlt_url);
2189: end if;
2190:
2191: fnd_message.set_name('FND','FND-9903'); -- OID setup is incomplete
2192: return fnd_ldap_util.G_FAILURE;
2193: end if;
2194: else
2195: if (fnd_log.LEVEL_STATEMENT>= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2196: then

Line 2212: return fnd_ldap_util.G_FAILURE;

2208: then
2209: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source, 'Cannot contact OID (init failed) at '||l_host||':'||l_port||':'||sqlcode||'-'||sqlerrm);
2210: end if;
2211: fnd_message.set_name('FND','FND_SSO_SYSTEM_NOT_AVAIL');
2212: return fnd_ldap_util.G_FAILURE;
2213: when others then
2214: raise;
2215: end;
2216:

Line 2228: return fnd_ldap_util.G_FAILURE;

2224: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source,' Cannot establish SSL channel to OiD: '||sqlcode||'-'||sqlerrm);
2225: end if;
2226:
2227: fnd_message.set_name('FND','FND_SSO_INV_AUTH_MODE'); -- Invalid SSL authcode... it is enouggh description
2228: return fnd_ldap_util.G_FAILURE;
2229: end;
2230:
2231: if (fnd_log.LEVEL_STATEMENT>= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2232: then

Line 2302: return fnd_ldap_util.G_FAILURE;

2298: if (fnd_log.LEVEL_PROCEDURE>= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2299: then
2300: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'END: bind error: '||l_message);
2301: end if;
2302: return fnd_ldap_util.G_FAILURE;
2303: when others then
2304: if (fnd_log.LEVEL_UNEXPECTED>= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2305: then
2306: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source, 'END: unexpected'||l_message);

Line 2308: return fnd_ldap_util.G_FAILURE;

2304: if (fnd_log.LEVEL_UNEXPECTED>= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2305: then
2306: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source, 'END: unexpected'||l_message);
2307: end if;
2308: return fnd_ldap_util.G_FAILURE;
2309: end;
2310:
2311:
2312: l_retval:= dbms_ldap.unbind_s(ldapSession);

Line 2317: return fnd_ldap_util.G_SUCCESS;

2313: if (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2314: then
2315: fnd_log.string(fnd_log.LEVEL_PROCEDURE , l_module_source, 'END: Valid Username/password');
2316: end if;
2317: return fnd_ldap_util.G_SUCCESS;
2318:
2319: exception when others then
2320: if (fnd_log.LEVEL_UNEXPECTED>= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2321: then

Line 2325: return fnd_ldap_util.G_FAILURE;

2321: then
2322: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source, 'END: unexpected '||sqlcode||' - '||sqlerrm);
2323: end if;
2324: fnd_message.set_name('FND','FND-9914'); -- unexpected error
2325: return fnd_ldap_util.G_FAILURE;
2326: end validate_login;
2327:
2328:
2329: function get_user_name_from_data( dn in varchar2, data in FND_LDAP_UTIL.ldap_record_values )

Line 2329: function get_user_name_from_data( dn in varchar2, data in FND_LDAP_UTIL.ldap_record_values )

2325: return fnd_ldap_util.G_FAILURE;
2326: end validate_login;
2327:
2328:
2329: function get_user_name_from_data( dn in varchar2, data in FND_LDAP_UTIL.ldap_record_values )
2330: return varchar2 is
2331: l_realm_idx pls_integer;
2332: nna varchar2(2000);
2333: ret varchar2(4000);

Line 2353: l_user_data FND_LDAP_UTIL.ldap_record_type;

2349: ldapSession dbms_ldap.session;
2350: flag pls_integer;
2351: ret varchar2(4000);
2352: l_dn varchar2(4000);
2353: l_user_data FND_LDAP_UTIL.ldap_record_type;
2354: l_realm_idx pls_integer;
2355: nna varchar2(2000);
2356:
2357: BEGIN

Line 2358: ldapSession := fnd_ldap_util.c_get_oid_session(flag);

2354: l_realm_idx pls_integer;
2355: nna varchar2(2000);
2356:
2357: BEGIN
2358: ldapSession := fnd_ldap_util.c_get_oid_session(flag);
2359:
2360: l_dn := FND_LDAP_UTIL.get_dn_for_guid(p_guid);
2361: l_realm_idx := FND_SSO_REGISTRATION.getUserRealmIndex(l_dn);
2362: ret:= null;

Line 2360: l_dn := FND_LDAP_UTIL.get_dn_for_guid(p_guid);

2356:
2357: BEGIN
2358: ldapSession := fnd_ldap_util.c_get_oid_session(flag);
2359:
2360: l_dn := FND_LDAP_UTIL.get_dn_for_guid(p_guid);
2361: l_realm_idx := FND_SSO_REGISTRATION.getUserRealmIndex(l_dn);
2362: ret:= null;
2363: if (l_realm_idx >=0 ) THEN
2364: nna:=fnd_sso_registration.get_realm_attribute(l_realm_idx, 'orclcommonnicknameattribute');

Line 2365: if ( FND_LDAP_UTIL.LoadLdapRecord(ldapsession, l_user_data ,p_guid,FND_LDAP_UTIL.G_GUID_KEY)) THEN

2361: l_realm_idx := FND_SSO_REGISTRATION.getUserRealmIndex(l_dn);
2362: ret:= null;
2363: if (l_realm_idx >=0 ) THEN
2364: nna:=fnd_sso_registration.get_realm_attribute(l_realm_idx, 'orclcommonnicknameattribute');
2365: if ( FND_LDAP_UTIL.LoadLdapRecord(ldapsession, l_user_data ,p_guid,FND_LDAP_UTIL.G_GUID_KEY)) THEN
2366: if (l_user_data.data.exists(nna)) THEN
2367: ret := l_user_data.data(nna)(0);
2368: end if;
2369: end if;

Line 2372: fnd_ldap_util.c_unbind(ldapSession,flag);

2368: end if;
2369: end if;
2370: END IF;
2371:
2372: fnd_ldap_util.c_unbind(ldapSession,flag);
2373: return ret;
2374:
2375: EXCEPTION WHEN OTHERS THEN
2376: fnd_ldap_util.c_unbind(ldapSession,flag);

Line 2376: fnd_ldap_util.c_unbind(ldapSession,flag);

2372: fnd_ldap_util.c_unbind(ldapSession,flag);
2373: return ret;
2374:
2375: EXCEPTION WHEN OTHERS THEN
2376: fnd_ldap_util.c_unbind(ldapSession,flag);
2377: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2378: then
2379: fnd_log.string(fnd_log.LEVEL_EXCEPTION, G_MODULE_SOURCE||'.get_username_from_guid: ', sqlerrm);
2380: end if;

Line 2442: IF FND_LDAP_UTIL.loadldaprecord(ldap,p_ldap_user.user_data,p_ldap_user.dn,dn_z,FND_LDAP_UTIL.G_DN_KEY) THEN

2438: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2439: then
2440: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, ' Realm->:'||realmDN);
2441: end if;
2442: IF FND_LDAP_UTIL.loadldaprecord(ldap,p_ldap_user.user_data,p_ldap_user.dn,dn_z,FND_LDAP_UTIL.G_DN_KEY) THEN
2443: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2444: then
2445: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, ' Complete the record ' );
2446: end if;

Line 2475: IF FND_LDAP_UTIL.loadldaprecord(ldap,p_ldap_user.user_data,p_ldap_user.dn,dn,FND_LDAP_UTIL.G_DN_KEY) THEN

2471: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2472: then
2473: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, ' Found guid:'||guid);
2474: end if;
2475: IF FND_LDAP_UTIL.loadldaprecord(ldap,p_ldap_user.user_data,p_ldap_user.dn,dn,FND_LDAP_UTIL.G_DN_KEY) THEN
2476: ProcessLoadedLpadUserRecord(p_ldap_user,realmDN,dn);
2477: if (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2478: then
2479: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, ' END-> FOUND');

Line 2532: ldapSession := fnd_ldap_util.c_get_oid_session(flag);

2528: ldapSession dbms_ldap.session;
2529: flag pls_integer;
2530: l_module varchar2(200) := G_MODULE_SOURCE||'.SearchUser[public]';
2531: BEGIN
2532: ldapSession := fnd_ldap_util.c_get_oid_session(flag);
2533: ret:= false;
2534: ret := SearchUser(ldapSession, p_ldap_user , username_z);
2535:
2536: fnd_ldap_util.c_unbind(ldapSession,flag);

Line 2536: fnd_ldap_util.c_unbind(ldapSession,flag);

2532: ldapSession := fnd_ldap_util.c_get_oid_session(flag);
2533: ret:= false;
2534: ret := SearchUser(ldapSession, p_ldap_user , username_z);
2535:
2536: fnd_ldap_util.c_unbind(ldapSession,flag);
2537: return ret;
2538:
2539: EXCEPTION WHEN OTHERS THEN
2540: fnd_ldap_util.c_unbind(ldapSession,flag);

Line 2540: fnd_ldap_util.c_unbind(ldapSession,flag);

2536: fnd_ldap_util.c_unbind(ldapSession,flag);
2537: return ret;
2538:
2539: EXCEPTION WHEN OTHERS THEN
2540: fnd_ldap_util.c_unbind(ldapSession,flag);
2541: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2542: then
2543: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module, sqlerrm);
2544: end if;

Line 2634: retval := fnd_ldap_util.G_FAILURE;

2630: l_session_flag boolean := false;
2631: BEGIN
2632: l_module_source := G_MODULE_SOURCE || 'pvt_create_user: ';
2633: -- set default value to failure. change to success when user created successfully
2634: retval := fnd_ldap_util.G_FAILURE;
2635: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2636: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Begin');
2637: END IF;
2638: ldapSession := fnd_ldap_util.c_get_oid_session(flag);

Line 2638: ldapSession := fnd_ldap_util.c_get_oid_session(flag);

2634: retval := fnd_ldap_util.G_FAILURE;
2635: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2636: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Begin');
2637: END IF;
2638: ldapSession := fnd_ldap_util.c_get_oid_session(flag);
2639:
2640: l_session_flag := true; /* fix for bug 8271359 */
2641:
2642: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then

Line 2717: IF (retval <> fnd_ldap_util.G_SUCCESS) THEN

2713: end if;
2714:
2715: retval := create_user_subscription(ldapSession, p_ldap_user.dn , p_ldap_user.user_guid);
2716:
2717: IF (retval <> fnd_ldap_util.G_SUCCESS) THEN
2718: if (fnd_log.LEVEL_UNEXPECTED >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2719: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source,
2720: 'Failed to create subscription for create_user("'||p_ldap_user.user_name
2721: ||'"), user existed and (APPS_SSO_LINK_SAME_NAMES=Enabled)');

Line 2735: fnd_ldap_util.c_unbind(ldapSession,flag);

2731: if (l_session_flag = true) then
2732: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2733: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'LDAP SESSION closing ' );
2734: end if;
2735: fnd_ldap_util.c_unbind(ldapSession,flag);
2736: l_session_flag := false;
2737: end if;
2738: -- Bug 8618800 - User already exists and Link Same Names is enabled - simply link the users
2739: -- return retval;

Line 2796: fnd_ldap_util.c_unbind(ldapSession,flag);

2792: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2793: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'LDAP SESSION closing ' );
2794: end if;
2795: l_session_flag := false;
2796: fnd_ldap_util.c_unbind(ldapSession,flag);
2797: end if;
2798: RETURN fnd_ldap_util.G_FAILURE;
2799: END IF;
2800:

Line 2798: RETURN fnd_ldap_util.G_FAILURE;

2794: end if;
2795: l_session_flag := false;
2796: fnd_ldap_util.c_unbind(ldapSession,flag);
2797: end if;
2798: RETURN fnd_ldap_util.G_FAILURE;
2799: END IF;
2800:
2801: setAttribute(p_ldap_user,'objectClass','top',true);
2802: setAttribute(p_ldap_user,'objectClass','inetorgperson',false);

Line 2807: IF (retval <> fnd_ldap_util.G_SUCCESS) THEN

2803: setAttribute(p_ldap_user,'objectClass','orcluserv2',false);
2804:
2805: retval := create_ldap_user(ldapSession, p_ldap_user);
2806:
2807: IF (retval <> fnd_ldap_util.G_SUCCESS) THEN
2808: if (fnd_log.LEVEL_UNEXPECTED >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2809: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source, 'User creation failed');
2810: end if;
2811: ELSE

Line 2816: IF (retval <> fnd_ldap_util.G_SUCCESS) THEN

2812: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2813: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'LDAP user created, now creating susbscriptions');
2814: END IF;
2815: retval := create_user_subscription(ldapSession, p_ldap_user.dn, p_ldap_user.user_guid);
2816: IF (retval <> fnd_ldap_util.G_SUCCESS) THEN
2817: IF (fnd_log.LEVEL_UNEXPECTED>= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2818: fnd_log.string(fnd_log.LEVEL_UNEXPECTED ,l_module_source, 'Subscription creation failed for a new user, removing user');
2819: END IF;
2820: delete_user(ldapSession, p_ldap_user.user_guid,result);

Line 2821: IF (result <>fnd_ldap_util.G_SUCCESS) THEN

2817: IF (fnd_log.LEVEL_UNEXPECTED>= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2818: fnd_log.string(fnd_log.LEVEL_UNEXPECTED ,l_module_source, 'Subscription creation failed for a new user, removing user');
2819: END IF;
2820: delete_user(ldapSession, p_ldap_user.user_guid,result);
2821: IF (result <>fnd_ldap_util.G_SUCCESS) THEN
2822: if (fnd_log.LEVEL_UNEXPECTED >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2823: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source, ' unable to remove user ');
2824: end if;
2825: END IF;

Line 2831: fnd_ldap_util.c_unbind(ldapSession,flag);

2827: ELSIF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2828: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Subscription creation succeeded');
2829: END IF;
2830:
2831: fnd_ldap_util.c_unbind(ldapSession,flag);
2832: l_session_flag := false;
2833:
2834: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2835: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'l_session_flag : = false ' );

Line 2840: IF (retval = fnd_ldap_util.G_SUCCESS) THEN

2836: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'LDAP SESSION CLOSED NORMALLY : ' );
2837: end if;
2838:
2839: IF (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2840: IF (retval = fnd_ldap_util.G_SUCCESS) THEN
2841: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End ->fnd_ldap_util.G_SUCCESS');
2842: ELSE
2843: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End ->fnd_ldap_util.G_FAILURE');
2844: END IF ;

Line 2841: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End ->fnd_ldap_util.G_SUCCESS');

2837: end if;
2838:
2839: IF (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2840: IF (retval = fnd_ldap_util.G_SUCCESS) THEN
2841: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End ->fnd_ldap_util.G_SUCCESS');
2842: ELSE
2843: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End ->fnd_ldap_util.G_FAILURE');
2844: END IF ;
2845: END IF;

Line 2843: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End ->fnd_ldap_util.G_FAILURE');

2839: IF (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2840: IF (retval = fnd_ldap_util.G_SUCCESS) THEN
2841: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End ->fnd_ldap_util.G_SUCCESS');
2842: ELSE
2843: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'End ->fnd_ldap_util.G_FAILURE');
2844: END IF ;
2845: END IF;
2846: END IF;
2847: RETURN retval;

Line 2855: fnd_ldap_util.c_unbind(ldapSession,flag);

2851: if l_session_flag = true then
2852: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2853: fnd_log.string(fnd_log.LEVEL_ERROR, l_module_source, 'LDAP SESSION closing in CANNOT CREATE EXCEPTION BLOCK - START ' );
2854: end if;
2855: fnd_ldap_util.c_unbind(ldapSession,flag);
2856:
2857: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2858: fnd_log.string(fnd_log.LEVEL_ERROR, l_module_source, 'LDAP SESSION closed in CANNOT CREATE EXCEPTION BLOCK - END ');
2859: end if;

Line 2866: RETURN fnd_ldap_util.G_FAILURE;

2862: IF (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2863: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, 'Error creating ldap user "' ||p_ldap_user.user_name||'" ' ||' Incorrect configuration' );
2864: END IF;
2865: fnd_message.set_name ('FND', 'FND-9903');
2866: RETURN fnd_ldap_util.G_FAILURE;
2867:
2868: WHEN duplicate_dn_EXCEPTION THEN
2869: if l_session_flag = true then
2870: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then

Line 2873: fnd_ldap_util.c_unbind(ldapSession,flag);

2869: if l_session_flag = true then
2870: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2871: fnd_log.string(fnd_log.LEVEL_ERROR, l_module_source, 'LDAP SESSION closing in Duplicate DN EXCEPTION BLOCK - START ' );
2872: end if;
2873: fnd_ldap_util.c_unbind(ldapSession,flag);
2874:
2875: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2876: fnd_log.string(fnd_log.LEVEL_ERROR, l_module_source, 'LDAP SESSION closed in Duplicate DN EXCEPTION BLOCK - END ');
2877: end if;

Line 2884: RETURN fnd_ldap_util.G_FAILURE;

2880: IF (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2881: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, 'Error creating ldap user "' ||p_ldap_user.user_name||'" ' ||' DN already exists [DN:'||p_ldap_user.dn ||']' );
2882: END IF;
2883: fnd_message.set_name ('FND', 'FND_SSO_USER_EXISTS');
2884: RETURN fnd_ldap_util.G_FAILURE;
2885: WHEN duplicate_username_EXCEPTION THEN
2886: if l_session_flag = true then
2887: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2888: fnd_log.string(fnd_log.LEVEL_ERROR, l_module_source, 'LDAP SESSION closing in Duplicate Username EXCEPTION BLOCK - START ' );

Line 2890: fnd_ldap_util.c_unbind(ldapSession,flag);

2886: if l_session_flag = true then
2887: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2888: fnd_log.string(fnd_log.LEVEL_ERROR, l_module_source, 'LDAP SESSION closing in Duplicate Username EXCEPTION BLOCK - START ' );
2889: end if;
2890: fnd_ldap_util.c_unbind(ldapSession,flag);
2891:
2892: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2893: fnd_log.string(fnd_log.LEVEL_ERROR, l_module_source, 'LDAP SESSION closed in Duplicate username EXCEPTION BLOCK - END ');
2894: end if;

Line 2901: RETURN fnd_ldap_util.G_FAILURE;

2897: IF (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2898: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, 'Error creating ldap user "' ||p_ldap_user.user_name||'" ' ||' username already exists [guid:'||p_ldap_user.user_guid||']' );
2899: END IF;
2900: fnd_message.set_name ('FND', 'FND_SSO_USER_EXISTS');
2901: RETURN fnd_ldap_util.G_FAILURE;
2902: WHEN link_create_failed_EXCEPTION THEN
2903: if l_session_flag = true then
2904: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2905: fnd_log.string(fnd_log.LEVEL_ERROR, l_module_source, 'LDAP SESSION closing in Link create failed EXCEPTION BLOCK - START ' );

Line 2907: fnd_ldap_util.c_unbind(ldapSession,flag);

2903: if l_session_flag = true then
2904: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2905: fnd_log.string(fnd_log.LEVEL_ERROR, l_module_source, 'LDAP SESSION closing in Link create failed EXCEPTION BLOCK - START ' );
2906: end if;
2907: fnd_ldap_util.c_unbind(ldapSession,flag);
2908:
2909: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2910: fnd_log.string(fnd_log.LEVEL_ERROR, l_module_source, 'LDAP SESSION closed in Link create failed EXCEPTION BLOCK - END ');
2911: end if;

Line 2918: RETURN fnd_ldap_util.G_FAILURE;

2914: IF (fnd_log.LEVEL_EXCEPTION>= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
2915: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, 'Error creating sunscriptions for "'||p_ldap_user.user_name||'" guid:'||p_ldap_user.user_guid );
2916: END IF;
2917: fnd_message.set_name('FND','FND_SSO_LINK_USER_FAILED');
2918: RETURN fnd_ldap_util.G_FAILURE;
2919: WHEN OTHERS THEN
2920: if l_session_flag = true then
2921: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2922: fnd_log.string(fnd_log.LEVEL_ERROR, l_module_source, 'LDAP SESSION closing in WHEN OTHERS EXCEPTION BLOCK - START ' );

Line 2924: fnd_ldap_util.c_unbind(ldapSession,flag);

2920: if l_session_flag = true then
2921: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2922: fnd_log.string(fnd_log.LEVEL_ERROR, l_module_source, 'LDAP SESSION closing in WHEN OTHERS EXCEPTION BLOCK - START ' );
2923: end if;
2924: fnd_ldap_util.c_unbind(ldapSession,flag);
2925:
2926: if (fnd_log.LEVEL_ERROR >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
2927: fnd_log.string(fnd_log.LEVEL_ERROR, l_module_source, 'LDAP SESSION closed in WHEN OTHERS EXCEPTION BLOCK - END ');
2928: end if;

Line 2995: IF (p_expire_password = fnd_ldap_util.G_TRUE) THEN

2991: END IF;
2992:
2993: /* Bug 9271995: Always create the user with the password
2994: By default it will remain expired
2995: IF (p_expire_password = fnd_ldap_util.G_TRUE) THEN
2996: l_password := p_password;
2997: ELSE
2998: l_password := NULL;
2999: END IF;

Line 3007: IF ( (p_expire_password = fnd_ldap_util.G_FALSE) AND (l_disabled_usr) ) THEN

3003: the flag to disabled after the password has been updated by proxying as that user. This is because
3004: we cannot proxy as a disabled user. */
3005: -- Bug 9398572.
3006: -- IF ( (l_password IS NULL) AND l_disabled_usr ) THEN
3007: IF ( (p_expire_password = fnd_ldap_util.G_FALSE) AND (l_disabled_usr) ) THEN
3008: l_enabled := fnd_oid_util.G_DISABLED;
3009: --usertype.orclisEnabled := fnd_oid_util.G_ENABLED;
3010: setAttribute(l_usr,'orclisEnabled',fnd_oid_util.G_ENABLED,true);
3011: END IF;

Line 3014: --l_nickname := fnd_ldap_util.get_orclcommonnicknameattr(user_name);

3010: setAttribute(l_usr,'orclisEnabled',fnd_oid_util.G_ENABLED,true);
3011: END IF;
3012: -- first create user. If self service, then pass in a null password
3013: user_name := p_user_name;
3014: --l_nickname := fnd_ldap_util.get_orclcommonnicknameattr(user_name);
3015: l_nickname := FND_SSO_REGISTRATION.get_realm_attribute(p_realm,'orclCommonNickNameAttribute');
3016: -- usertype.uid := p_user_name;
3017: -- usertype.sn := p_user_name;
3018: -- usertype.cn := p_user_name;

Line 3041: IF (upper(l_nickname) = fnd_ldap_util.G_MAIL) THEN

3037: -- IF (l_password IS NOT NULL) then
3038: -- setAttribute(l_usr,'userPassword',l_password,true);
3039: -- END IF;
3040:
3041: IF (upper(l_nickname) = fnd_ldap_util.G_MAIL) THEN
3042: --usertype.mail := p_user_name;
3043: setAttribute(l_usr,'mail',p_user_name,true);
3044: ELSE
3045: --usertype.mail := p_email_address;

Line 3048: IF (upper(l_nickname) = fnd_ldap_util.G_FACSIMILETELEPHONENUMBER) THEN

3044: ELSE
3045: --usertype.mail := p_email_address;
3046: setAttribute(l_usr,'mail',p_email_address,true);
3047: END IF;
3048: IF (upper(l_nickname) = fnd_ldap_util.G_FACSIMILETELEPHONENUMBER) THEN
3049: --usertype.facsimileTelephoneNumber := p_user_name;
3050: setAttribute(l_usr,'facsimileTelephoneNumber',p_user_name,true);
3051: ELSE
3052: --usertype.facsimileTelephoneNumber := p_fax;

Line 3068: x_result := fnd_ldap_util.G_SUCCESS;

3064: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) then
3065: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'OID user already exists...set flag and status. Password related task should be bypassed');
3066: end if;
3067: l_oid_user_exists := 'Y';
3068: x_result := fnd_ldap_util.G_SUCCESS;
3069: end if;
3070:
3071:
3072: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN

Line 3073: if (x_result = fnd_ldap_util.G_SUCCESS) then

3069: end if;
3070:
3071:
3072: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
3073: if (x_result = fnd_ldap_util.G_SUCCESS) then
3074: fnd_log.string(fnd_log.LEVEL_STATEMENT,l_module_source,'Successfully created LDAP user');
3075: else
3076: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source,'Failed to create LDAP user');
3077: end if;

Line 3081: IF (p_expire_password = fnd_ldap_util.G_TRUE) THEN

3077: end if;
3078: END IF;
3079:
3080: -- NOTE: This code seems to be a NOOP and may be removed
3081: IF (p_expire_password = fnd_ldap_util.G_TRUE) THEN
3082: l_password := p_password;
3083: ELSE
3084: l_password := NULL;
3085: END IF;

Line 3088: IF (x_result = fnd_ldap_util.G_SUCCESS) THEN

3084: l_password := NULL;
3085: END IF;
3086:
3087: -- Bug 13692093: Added check for LINK_EXISTING which is a successful linking of a new FND and existing LDAP user
3088: IF (x_result = fnd_ldap_util.G_SUCCESS) THEN
3089: -- x_user_guid := get_user_guid(p_user_name);
3090: x_user_guid := l_usr.user_guid;
3091: fnd_profile.get_specific( name_z => 'APPS_SSO_LOCAL_LOGIN', user_id_z => -1, val_z => l_local_login, defined_z => l_profile_defined);
3092: IF (l_local_login = 'SSO') THEN

Line 3096: IF ( (x_result = fnd_ldap_util.G_SUCCESS and l_oid_user_exists = 'N') )THEN

3092: IF (l_local_login = 'SSO') THEN
3093: x_password := fnd_web_sec.EXTERNAL_PWD;
3094: END IF;
3095: -- if p_expire_password = false then update the user password (and password only)
3096: IF ( (x_result = fnd_ldap_util.G_SUCCESS and l_oid_user_exists = 'N') )THEN
3097: begin
3098: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
3099: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source,'User has been created - now set password');
3100: END IF;

Line 3118: IF ( (l_cp_result = fnd_ldap_util.G_FAILURE ) OR (l_du_result = fnd_ldap_util.G_FAILURE) ) THEN

3114: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source,'Setting user to disabled.');
3115: end if;
3116: disable_user(x_user_guid, p_user_name, l_du_result);
3117: END IF;
3118: IF ( (l_cp_result = fnd_ldap_util.G_FAILURE ) OR (l_du_result = fnd_ldap_util.G_FAILURE) ) THEN
3119: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
3120: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source,'Error occurred - delete user');
3121: end if;
3122:

Line 3125: x_result := fnd_ldap_util.G_SUCCESS;

3121: end if;
3122:
3123: delete_user(x_user_guid, x_result);
3124: ELSE
3125: x_result := fnd_ldap_util.G_SUCCESS;
3126: END IF;
3127: END IF;
3128: ELSE
3129: fnd_message.set_name ('FND', 'FND_SSO_USER_EXISTS');