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 DBMS_LDAP

Line 16: function delete_user_nodes(p_ldap_session in dbms_ldap.session, p_orclguid in fnd_user.user_guid%type) return pls_integer;

12: -- End of Package Globals
13: --
14: -------------------------------------------------------------------------------
15:
16: function delete_user_nodes(p_ldap_session in dbms_ldap.session, p_orclguid in fnd_user.user_guid%type) return pls_integer;
17: function delete_user_subscription(p_ldap_session in dbms_ldap.session, guid raw) return pls_integer;
18: function delete_uniquemember(p_ldap_session in dbms_ldap.session, p_orclguid in fnd_user.user_guid%type) return pls_integer;
19: procedure ProcessLoadedLpadUserRecord (p_ldap_user IN OUT nocopy fnd_ldap_user.ldap_user_type ,realmDN in varchar2 ,dn_z in varchar2 );
20: --function CanSync ( p_user_id in pls_integer, p_user_name in varchar2 ) return boolean;

Line 17: function delete_user_subscription(p_ldap_session in dbms_ldap.session, guid raw) return pls_integer;

13: --
14: -------------------------------------------------------------------------------
15:
16: function delete_user_nodes(p_ldap_session in dbms_ldap.session, p_orclguid in fnd_user.user_guid%type) return pls_integer;
17: function delete_user_subscription(p_ldap_session in dbms_ldap.session, guid raw) return pls_integer;
18: function delete_uniquemember(p_ldap_session in dbms_ldap.session, p_orclguid in fnd_user.user_guid%type) return pls_integer;
19: procedure ProcessLoadedLpadUserRecord (p_ldap_user IN OUT nocopy fnd_ldap_user.ldap_user_type ,realmDN in varchar2 ,dn_z in varchar2 );
20: --function CanSync ( p_user_id in pls_integer, p_user_name in varchar2 ) return boolean;
21: function get_user_guid(p_ldap_session in dbms_ldap.session, p_user_name in varchar2, dn out nocopy varchar2) return raw ;

Line 18: function delete_uniquemember(p_ldap_session in dbms_ldap.session, p_orclguid in fnd_user.user_guid%type) return pls_integer;

14: -------------------------------------------------------------------------------
15:
16: function delete_user_nodes(p_ldap_session in dbms_ldap.session, p_orclguid in fnd_user.user_guid%type) return pls_integer;
17: function delete_user_subscription(p_ldap_session in dbms_ldap.session, guid raw) return pls_integer;
18: function delete_uniquemember(p_ldap_session in dbms_ldap.session, p_orclguid in fnd_user.user_guid%type) return pls_integer;
19: procedure ProcessLoadedLpadUserRecord (p_ldap_user IN OUT nocopy fnd_ldap_user.ldap_user_type ,realmDN in varchar2 ,dn_z in varchar2 );
20: --function CanSync ( p_user_id in pls_integer, p_user_name in varchar2 ) return boolean;
21: function get_user_guid(p_ldap_session in dbms_ldap.session, p_user_name in varchar2, dn out nocopy varchar2) return raw ;
22: function isValueOf( u ldap_user_type, fld in varchar2, val in varchar2 ) return boolean;

Line 21: function get_user_guid(p_ldap_session in dbms_ldap.session, p_user_name in varchar2, dn out nocopy varchar2) return raw ;

17: function delete_user_subscription(p_ldap_session in dbms_ldap.session, guid raw) return pls_integer;
18: function delete_uniquemember(p_ldap_session in dbms_ldap.session, p_orclguid in fnd_user.user_guid%type) return pls_integer;
19: procedure ProcessLoadedLpadUserRecord (p_ldap_user IN OUT nocopy fnd_ldap_user.ldap_user_type ,realmDN in varchar2 ,dn_z in varchar2 );
20: --function CanSync ( p_user_id in pls_integer, p_user_name in varchar2 ) return boolean;
21: function get_user_guid(p_ldap_session in dbms_ldap.session, p_user_name in varchar2, dn out nocopy varchar2) return raw ;
22: function isValueOf( u ldap_user_type, fld in varchar2, val in varchar2 ) return boolean;
23: function get_user_guid( p_user_name in varchar2) return raw ;
24: function CanUpdate( attr in varchar2 , user_name in varchar2 , realm in varchar2,x_user_creation in boolean default FALSE) return boolean;
25: function CanPopulate( attr in varchar2 , user_name in varchar2 , realm in varchar2) return boolean;

Line 50: PROCEDURE ProcessUpdateRec(ldap in dbms_ldap.session, dn in varchar2, upd in update_list);

46: );
47:
48: TYPE update_list IS table OF update_record INDEX BY pls_integer;
49:
50: PROCEDURE ProcessUpdateRec(ldap in dbms_ldap.session, dn in varchar2, upd in update_list);
51:
52: --
53: -- LOCAL EXCEPTIONS
54: CANNOT_CREATE_EXCEPTION EXCEPTION;

Line 70: -- Will attempt to translate the sqlerrms from an dbms_ldap operation into a FND message

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: -------------------------------------------------------------------------------
73: function translate_ldap_error( errm in varchar2) return varchar2
74: is

Line 100: PROCEDURE delete_user(ldapSession in dbms_ldap.session, p_user_guid in fnd_user.user_guid%type ,

96: end translate_ldap_error;
97:
98: --
99: -------------------------------------------------------------------------------
100: PROCEDURE delete_user(ldapSession in dbms_ldap.session, p_user_guid in fnd_user.user_guid%type ,
101: x_result out nocopy pls_integer,
102: p_forced in boolean default false) is
103:
104:

Line 109: --ldapSession dbms_ldap.session;

105: l_module_source varchar2(256) := G_MODULE_SOURCE || 'delete_user: ';
106: l_orclappname varchar2(256);
107: l_user_name varchar2(256);
108: subsNode varchar2(1000);
109: --ldapSession dbms_ldap.session;
110: l_message dbms_ldap.message := null;
111: l_entry dbms_ldap.message := null;
112: l_attrs dbms_ldap.string_collection;
113: l_attrs_vals dbms_ldap.string_collection;

Line 110: l_message dbms_ldap.message := null;

106: l_orclappname varchar2(256);
107: l_user_name varchar2(256);
108: subsNode varchar2(1000);
109: --ldapSession dbms_ldap.session;
110: l_message dbms_ldap.message := null;
111: l_entry dbms_ldap.message := null;
112: l_attrs dbms_ldap.string_collection;
113: l_attrs_vals dbms_ldap.string_collection;
114: l_isenabled varchar2(100);

Line 111: l_entry dbms_ldap.message := null;

107: l_user_name varchar2(256);
108: subsNode varchar2(1000);
109: --ldapSession dbms_ldap.session;
110: l_message dbms_ldap.message := null;
111: l_entry dbms_ldap.message := null;
112: l_attrs dbms_ldap.string_collection;
113: l_attrs_vals dbms_ldap.string_collection;
114: l_isenabled varchar2(100);
115: l_creatorname varchar2(1000);

Line 112: l_attrs dbms_ldap.string_collection;

108: subsNode varchar2(1000);
109: --ldapSession dbms_ldap.session;
110: l_message dbms_ldap.message := null;
111: l_entry dbms_ldap.message := null;
112: l_attrs dbms_ldap.string_collection;
113: l_attrs_vals dbms_ldap.string_collection;
114: l_isenabled varchar2(100);
115: l_creatorname varchar2(1000);
116: searchNodes dbms_ldap.string_collection;

Line 113: l_attrs_vals dbms_ldap.string_collection;

109: --ldapSession dbms_ldap.session;
110: l_message dbms_ldap.message := null;
111: l_entry dbms_ldap.message := null;
112: l_attrs dbms_ldap.string_collection;
113: l_attrs_vals dbms_ldap.string_collection;
114: l_isenabled varchar2(100);
115: l_creatorname varchar2(1000);
116: searchNodes dbms_ldap.string_collection;
117: l_filter varchar2(256);-- := 'cn=' || p_user_name; Commented out by scheruku to use orclguid instead

Line 116: searchNodes dbms_ldap.string_collection;

112: l_attrs dbms_ldap.string_collection;
113: l_attrs_vals dbms_ldap.string_collection;
114: l_isenabled varchar2(100);
115: l_creatorname varchar2(1000);
116: searchNodes dbms_ldap.string_collection;
117: l_filter varchar2(256);-- := 'cn=' || p_user_name; Commented out by scheruku to use orclguid instead
118: l_base varchar2(1000);
119: l_guid raw(256);
120: l_fnd_op pls_integer;

Line 167: x_result := dbms_ldap.search_s(ld => ldapSession, base => l_base,

163: -- search and delete the user only if the creator is the current apps instance and if the user is disabled.
164:
165: --for i in 0..searchNodes.count-1 loop
166: --l_base := searchNodes(i);
167: x_result := dbms_ldap.search_s(ld => ldapSession, base => l_base,
168: scope => dbms_ldap.SCOPE_SUBTREE, filter => l_filter, attrs => l_attrs, attronly => 0, res => l_message);
169: if (x_result is not NULL) then
170:
171: l_entry := dbms_ldap.first_entry(ldapSession, l_message);

Line 168: scope => dbms_ldap.SCOPE_SUBTREE, filter => l_filter, attrs => l_attrs, attronly => 0, res => l_message);

164:
165: --for i in 0..searchNodes.count-1 loop
166: --l_base := searchNodes(i);
167: x_result := dbms_ldap.search_s(ld => ldapSession, base => l_base,
168: scope => dbms_ldap.SCOPE_SUBTREE, filter => l_filter, attrs => l_attrs, attronly => 0, res => l_message);
169: if (x_result is not NULL) then
170:
171: l_entry := dbms_ldap.first_entry(ldapSession, l_message);
172: if l_entry is not null then

Line 171: l_entry := dbms_ldap.first_entry(ldapSession, l_message);

167: x_result := dbms_ldap.search_s(ld => ldapSession, base => l_base,
168: scope => dbms_ldap.SCOPE_SUBTREE, filter => l_filter, attrs => l_attrs, attronly => 0, res => l_message);
169: if (x_result is not NULL) then
170:
171: l_entry := dbms_ldap.first_entry(ldapSession, l_message);
172: if l_entry is not null then
173:
174: -- get the first entry
175: l_entry := dbms_ldap.first_entry(ldapSession, l_message);

Line 175: l_entry := dbms_ldap.first_entry(ldapSession, l_message);

171: l_entry := dbms_ldap.first_entry(ldapSession, l_message);
172: if l_entry is not null then
173:
174: -- get the first entry
175: l_entry := dbms_ldap.first_entry(ldapSession, l_message);
176:
177: l_attrs_vals := dbms_ldap.get_values(ldapSession, l_entry, 'creatorsname');
178: l_creatorname := l_attrs_vals(0);
179: l_attrs_vals := dbms_ldap.get_values(ldapSession, l_entry, 'orclisenabled');

Line 177: l_attrs_vals := dbms_ldap.get_values(ldapSession, l_entry, 'creatorsname');

173:
174: -- get the first entry
175: l_entry := dbms_ldap.first_entry(ldapSession, l_message);
176:
177: l_attrs_vals := dbms_ldap.get_values(ldapSession, l_entry, 'creatorsname');
178: l_creatorname := l_attrs_vals(0);
179: l_attrs_vals := dbms_ldap.get_values(ldapSession, l_entry, 'orclisenabled');
180: if l_attrs_vals is not NULL and l_attrs_vals.count > 0 then
181: l_isenabled := l_attrs_vals(0);

Line 179: l_attrs_vals := dbms_ldap.get_values(ldapSession, l_entry, 'orclisenabled');

175: l_entry := dbms_ldap.first_entry(ldapSession, l_message);
176:
177: l_attrs_vals := dbms_ldap.get_values(ldapSession, l_entry, 'creatorsname');
178: l_creatorname := l_attrs_vals(0);
179: l_attrs_vals := dbms_ldap.get_values(ldapSession, l_entry, 'orclisenabled');
180: if l_attrs_vals is not NULL and l_attrs_vals.count > 0 then
181: l_isenabled := l_attrs_vals(0);
182: end if;
183: l_attrs_vals := dbms_ldap.get_values(ldapSession, l_entry, 'orclguid');

Line 183: l_attrs_vals := dbms_ldap.get_values(ldapSession, l_entry, 'orclguid');

179: l_attrs_vals := dbms_ldap.get_values(ldapSession, l_entry, 'orclisenabled');
180: if l_attrs_vals is not NULL and l_attrs_vals.count > 0 then
181: l_isenabled := l_attrs_vals(0);
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

Line 222: if (x_result = dbms_ldap.SUCCESS) then

218: end if;
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:

Line 246: ldapSession dbms_ldap.session;

242: procedure delete_user(p_user_guid in fnd_user.user_guid%type ,
243: x_result out nocopy pls_integer,
244: p_forced in boolean ) is
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);

Line 256: ldapSession dbms_ldap.session;

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:
256: ldapSession dbms_ldap.session;
257: dummy pls_integer;
258: BEGIN
259:
260: delete_user(p_user_guid,x_result,false);

Line 363: ldap dbms_ldap.session;

359: x_result out nocopy pls_integer) is
360: l_module_source VARCHAR2(256);
361: l_user_id fnd_user.user_id%type;
362: l_to_synch BOOLEAN;
363: ldap dbms_ldap.session;
364: flag pls_integer;
365: user_rec FND_LDAP_USER.ldap_user_type;
366: invalid_new_user_exp EXCEPTION;
367: no_such_user_exp EXCEPTION;

Line 373: target dbms_ldap.string_collection;

369: val varchar2(4000);
370: nna varchar2(200);
371: handle pls_integer;
372: upd update_list;
373: target dbms_ldap.string_collection;
374: fld VARCHAR2(200);
375: i pls_integer;
376: ma dbms_ldap.mod_array;
377: found boolean;

Line 376: ma dbms_ldap.mod_array;

372: upd update_list;
373: target dbms_ldap.string_collection;
374: fld VARCHAR2(200);
375: i pls_integer;
376: ma dbms_ldap.mod_array;
377: found boolean;
378: PRAGMA EXCEPTION_INIT (no_such_user_exp, -20001);
379: x_fnd pls_integer;
380: x_oid pls_integer;

Line 472: ma := dbms_ldap.create_mod_array(num=> 1);

468: IF found THEN
469: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
470: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Updating LDAP ');
471: END IF;
472: ma := dbms_ldap.create_mod_array(num=> 1);
473: dbms_ldap.populate_mod_array(modptr => ma,
474: mod_op => DBMS_LDAP.MOD_REPLACE,
475: mod_type => nna,
476: modval => target);

Line 473: dbms_ldap.populate_mod_array(modptr => ma,

469: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
470: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Updating LDAP ');
471: END IF;
472: ma := dbms_ldap.create_mod_array(num=> 1);
473: dbms_ldap.populate_mod_array(modptr => ma,
474: mod_op => DBMS_LDAP.MOD_REPLACE,
475: mod_type => nna,
476: modval => target);
477: x_result:= dbms_ldap.modify_s(ldap,user_rec.dn, ma);

Line 474: mod_op => DBMS_LDAP.MOD_REPLACE,

470: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Updating LDAP ');
471: END IF;
472: ma := dbms_ldap.create_mod_array(num=> 1);
473: dbms_ldap.populate_mod_array(modptr => ma,
474: mod_op => DBMS_LDAP.MOD_REPLACE,
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

Line 477: x_result:= dbms_ldap.modify_s(ldap,user_rec.dn, ma);

473: dbms_ldap.populate_mod_array(modptr => ma,
474: mod_op => DBMS_LDAP.MOD_REPLACE,
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 ');

Line 478: if (x_result = dbms_ldap.SUCCESS) then

474: mod_op => DBMS_LDAP.MOD_REPLACE,
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;

Line 484: dbms_ldap.free_mod_array(modptr => ma);

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;
484: dbms_ldap.free_mod_array(modptr => ma);
485: ELSE
486: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
487: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Cannot update nickname attribute');
488: END IF;

Line 560: p_ldap_session IN dbms_ldap.session,

556: -- Any EXCEPTION will be logged and passed up
557:
558:
559: FUNCTION create_ldap_user (
560: p_ldap_session IN dbms_ldap.session,
561: p_ldap_user IN OUT nocopy ldap_user_type)
562: RETURN pls_integer
563: IS
564: l_module_source VARCHAR2(256);

Line 567: modArray dbms_ldap.mod_array;

563: IS
564: l_module_source VARCHAR2(256);
565: retval pls_integer;
566: ldap_result pls_integer;
567: modArray dbms_ldap.mod_array;
568: atName VARCHAR2(4000);
569: atVal VARCHAR2(4000);
570: handler pls_integer;
571: myid INTEGER;

Line 573: list1 dbms_ldap.string_collection;

569: atVal VARCHAR2(4000);
570: handler pls_integer;
571: myid INTEGER;
572: l_dn VARCHAR2(4000);
573: list1 dbms_ldap.string_collection;
574: n pls_integer;
575: i pls_integer;
576: some_data boolean := false;
577: BEGIN

Line 616: modArray := dbms_ldap.create_mod_array(num=> p_ldap_user.user_data.count);

612:
613:
614: FND_OID_PLUG.fixupLDAPUser(p_ldap_user,FND_OID_PLUG.G_CREATE_USER);
615:
616: modArray := dbms_ldap.create_mod_array(num=> p_ldap_user.user_data.count);
617: atName := p_ldap_user.user_data.first ;
618:
619: WHILE atName IS NOT NULL
620: LOOP

Line 646: dbms_ldap.populate_mod_array(modptr => modArray, mod_op => DBMS_LDAP.MOD_ADD, mod_type => atName, modval => list1);

642: n := n+1;
643: i := p_ldap_user.user_data(atName).next(i);
644: EXIT WHEN i IS NULL;
645: END LOOP;
646: dbms_ldap.populate_mod_array(modptr => modArray, mod_op => DBMS_LDAP.MOD_ADD, mod_type => atName, modval => list1);
647: some_data := true;
648: ELSE
649: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
650: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Populate modarray : count='|| p_ldap_user.user_data.count);

Line 657: ldap_result := dbms_ldap.add_s(ld => p_ldap_session, entrydn => p_ldap_user.dn , modptr =>modArray);

653: atName := p_ldap_user.user_data.next(atName);
654: END LOOP;
655:
656: if (some_data) THEN
657: ldap_result := dbms_ldap.add_s(ld => p_ldap_session, entrydn => p_ldap_user.dn , modptr =>modArray);
658: ELSE
659: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
660: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'add_s no data to load');
661: END IF;

Line 663: dbms_ldap.free_mod_array(modArray);

659: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
660: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'add_s no data to load');
661: END IF;
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

Line 664: IF ldap_result = dbms_ldap.SUCCESS THEN

660: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'add_s no data to load');
661: END IF;
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);

Line 719: function create_user_subscription(ldapSession in dbms_ldap.session, p_user_dn in varchar2 , p_guid in raw)

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)
720: return pls_integer is
721:
722: l_module_source varchar2(256);
723: subsNode varchar2(4000);

Line 728: --ldapSession dbms_ldap.session;

724: acctNode varchar2(4000);
725: --userDN varchar2(4000):= p_user_dn;
726: result pls_integer;
727: retval pls_integer;
728: --ldapSession dbms_ldap.session;
729: modArray dbms_ldap.mod_array;
730: modmultivalues dbms_ldap.string_collection;
731: i number;
732: flag pls_integer;

Line 729: modArray dbms_ldap.mod_array;

725: --userDN varchar2(4000):= p_user_dn;
726: result pls_integer;
727: retval pls_integer;
728: --ldapSession dbms_ldap.session;
729: modArray dbms_ldap.mod_array;
730: modmultivalues dbms_ldap.string_collection;
731: i number;
732: flag pls_integer;
733: err varchar2(1000); --bug 8618800

Line 730: modmultivalues dbms_ldap.string_collection;

726: result pls_integer;
727: retval pls_integer;
728: --ldapSession dbms_ldap.session;
729: modArray dbms_ldap.mod_array;
730: modmultivalues dbms_ldap.string_collection;
731: i number;
732: flag pls_integer;
733: err varchar2(1000); --bug 8618800
734: begin

Line 751: modArray := dbms_ldap.create_mod_array(num => 2);

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);
750:
751: modArray := dbms_ldap.create_mod_array(num => 2);
752:
753: modmultivalues(0) := 'orclServiceSubscriptionDetail';
754: dbms_ldap.populate_mod_array(modptr => modArray, mod_op => dbms_ldap.mod_add, mod_type => 'objectclass', modval => modmultivalues);
755:

Line 754: dbms_ldap.populate_mod_array(modptr => modArray, mod_op => dbms_ldap.mod_add, mod_type => 'objectclass', modval => modmultivalues);

750:
751: modArray := dbms_ldap.create_mod_array(num => 2);
752:
753: modmultivalues(0) := 'orclServiceSubscriptionDetail';
754: dbms_ldap.populate_mod_array(modptr => modArray, mod_op => dbms_ldap.mod_add, mod_type => 'objectclass', modval => modmultivalues);
755:
756: modmultivalues(0) := p_user_dn;
757: dbms_ldap.populate_mod_array(modptr => modArray, mod_op => dbms_ldap.mod_add, mod_type => 'seeAlso', modval => modmultivalues);
758:

Line 757: dbms_ldap.populate_mod_array(modptr => modArray, mod_op => dbms_ldap.mod_add, mod_type => 'seeAlso', modval => modmultivalues);

753: modmultivalues(0) := 'orclServiceSubscriptionDetail';
754: dbms_ldap.populate_mod_array(modptr => modArray, mod_op => dbms_ldap.mod_add, mod_type => 'objectclass', modval => modmultivalues);
755:
756: modmultivalues(0) := p_user_dn;
757: dbms_ldap.populate_mod_array(modptr => modArray, mod_op => dbms_ldap.mod_add, mod_type => 'seeAlso', modval => modmultivalues);
758:
759: subsNode := 'orclOwnerGUID=' || p_guid|| ',' || acctNode;
760: retval := dbms_ldap.add_s(ld => ldapSession, entrydn => subsNode, modptr => modArray);
761:

Line 760: retval := dbms_ldap.add_s(ld => ldapSession, entrydn => subsNode, modptr => modArray);

756: modmultivalues(0) := p_user_dn;
757: dbms_ldap.populate_mod_array(modptr => modArray, mod_op => dbms_ldap.mod_add, mod_type => 'seeAlso', modval => modmultivalues);
758:
759: subsNode := 'orclOwnerGUID=' || p_guid|| ',' || acctNode;
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);

Line 762: if (retval = dbms_ldap.SUCCESS) then

758:
759: subsNode := 'orclOwnerGUID=' || p_guid|| ',' || acctNode;
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

Line 773: dbms_ldap.free_mod_array(modptr => modArray);

769: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Failed! retval='||retval||' subsNode:'||subsNode);
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

Line 885: function delete_user_nodes(p_ldap_session in dbms_ldap.session,

881: -------------------------------------------------------------------------------
882: --
883: --Added by scheruku for Nickname changes
884: -------------------------------------------------------------------------------
885: function delete_user_nodes(p_ldap_session in dbms_ldap.session,
886: p_orclguid in fnd_user.user_guid%type) return pls_integer is
887:
888: l_module_source varchar2(256);
889: usersNode varchar2(1000);

Line 890: usersNodes dbms_ldap.string_collection;

886: p_orclguid in fnd_user.user_guid%type) return pls_integer is
887:
888: l_module_source varchar2(256);
889: usersNode varchar2(1000);
890: usersNodes dbms_ldap.string_collection;
891: l_result pls_integer;
892:
893: begin
894: l_module_source := G_MODULE_SOURCE || 'delete_user_nodes: ';

Line 910: l_result := dbms_ldap.delete_s(ld => p_ldap_session, entrydn => usersNode);

906: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'DN for user with GUID::'
907: ||p_orclguid||' DN::'||usersNode);
908: end if;
909:
910: l_result := dbms_ldap.delete_s(ld => p_ldap_session, entrydn => usersNode);
911:
912: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
913: then
914: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'End');

Line 927: function delete_user_subscription(p_ldap_session in dbms_ldap.session, guid in raw)

923:
924: end delete_user_nodes;
925: --
926: ------------------------------------------------------------------------------
927: function delete_user_subscription(p_ldap_session in dbms_ldap.session, guid in raw)
928: return pls_integer is
929:
930: l_module_source varchar2(256);
931: subsNode varchar2(1000);

Line 933: l_attrs dbms_ldap.string_collection;

929:
930: l_module_source varchar2(256);
931: subsNode varchar2(1000);
932: l_user_guid raw(256) := guid;
933: l_attrs dbms_ldap.string_collection;
934: l_message dbms_ldap.message := null;
935: l_result pls_integer;
936: l_entry dbms_ldap.message := null;
937:

Line 934: l_message dbms_ldap.message := null;

930: l_module_source varchar2(256);
931: subsNode varchar2(1000);
932: l_user_guid raw(256) := guid;
933: l_attrs dbms_ldap.string_collection;
934: l_message dbms_ldap.message := null;
935: l_result pls_integer;
936: l_entry dbms_ldap.message := null;
937:
938: begin

Line 936: l_entry dbms_ldap.message := null;

932: l_user_guid raw(256) := guid;
933: l_attrs dbms_ldap.string_collection;
934: l_message dbms_ldap.message := null;
935: l_result pls_integer;
936: l_entry dbms_ldap.message := null;
937:
938: begin
939: l_module_source := G_MODULE_SOURCE || 'delete_user_subscription ';
940: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)

Line 947: l_result := dbms_ldap.search_s(ld => p_ldap_session, base => subsNode,

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);
951: if l_entry is not null then

Line 948: scope => dbms_ldap.SCOPE_SUBTREE, filter => 'orclOwnerGUID=' || l_user_guid, attrs => l_attrs, attronly => 0, res => l_message);

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);
951: if l_entry is not null then
952: l_result := dbms_ldap.delete_s(ld => p_ldap_session, entrydn => 'orclOwnerGUID=' || l_user_guid||','||subsNode);

Line 950: l_entry := dbms_ldap.first_entry(p_ldap_session, l_message);

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);
951: if l_entry is not null then
952: l_result := dbms_ldap.delete_s(ld => p_ldap_session, entrydn => 'orclOwnerGUID=' || l_user_guid||','||subsNode);
953: end if;
954: end if;

Line 952: l_result := dbms_ldap.delete_s(ld => p_ldap_session, entrydn => 'orclOwnerGUID=' || l_user_guid||','||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);
951: if l_entry is not null then
952: l_result := dbms_ldap.delete_s(ld => p_ldap_session, entrydn => 'orclOwnerGUID=' || l_user_guid||','||subsNode);
953: end if;
954: end if;
955:
956: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)

Line 971: function delete_uniquemember(p_ldap_session in dbms_ldap.session,

967:
968: end delete_user_subscription;
969: --
970: -------------------------------------------------------------------------------
971: function delete_uniquemember(p_ldap_session in dbms_ldap.session,
972: p_orclguid in fnd_user.user_guid%type) return pls_integer is
973:
974: l_module_source varchar2(256);
975: subsNode varchar2(1000);

Line 977: usersNodes dbms_ldap.string_collection;

973:
974: l_module_source varchar2(256);
975: subsNode varchar2(1000);
976: usersNode varchar2(1000);
977: usersNodes dbms_ldap.string_collection;
978: result pls_integer;
979: retval pls_integer;
980: modArray dbms_ldap.mod_array;
981: modmultivalues dbms_ldap.string_collection;

Line 980: modArray dbms_ldap.mod_array;

976: usersNode varchar2(1000);
977: usersNodes dbms_ldap.string_collection;
978: result pls_integer;
979: retval pls_integer;
980: modArray dbms_ldap.mod_array;
981: modmultivalues dbms_ldap.string_collection;
982: i number;
983:
984: begin

Line 981: modmultivalues dbms_ldap.string_collection;

977: usersNodes dbms_ldap.string_collection;
978: result pls_integer;
979: retval pls_integer;
980: modArray dbms_ldap.mod_array;
981: modmultivalues dbms_ldap.string_collection;
982: i number;
983:
984: begin
985: l_module_source := G_MODULE_SOURCE || 'delete_uniquemember: ';

Line 995: modArray := dbms_ldap.create_mod_array(num => 1);

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);
998:
999: dbms_ldap.populate_mod_array(modptr => modArray, mod_op => dbms_ldap.mod_delete, mod_type => 'uniquemember', modval => modmultivalues);

Line 999: dbms_ldap.populate_mod_array(modptr => modArray, mod_op => dbms_ldap.mod_delete, mod_type => 'uniquemember', modval => modmultivalues);

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);
1002:
1003:

Line 1001: retval := dbms_ldap.modify_s(ld => p_ldap_Session, entrydn => subsNode, modptr => modArray);

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);
1002:
1003:
1004: if (retval = dbms_ldap.SUCCESS) then
1005: retval := fnd_ldap_util.G_SUCCESS;

Line 1004: if (retval = dbms_ldap.SUCCESS) then

1000:
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);

Line 1008: dbms_ldap.free_mod_array(modptr => modArray);

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:
1010: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1011: then
1012: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'End');

Line 1118: function get_user_guid(p_ldap_session in dbms_ldap.session, p_user_name in varchar2, dn out nocopy varchar2)

1114:
1115: -----------------------------------------
1116: --
1117: -------------------------------------------------------------------------------
1118: function get_user_guid(p_ldap_session in dbms_ldap.session, p_user_name in varchar2, dn out nocopy varchar2)
1119: return raw is
1120:
1121: l_module_source varchar2(256);
1122: result pls_integer;

Line 1124: l_message dbms_ldap.message := null;

1120:
1121: l_module_source varchar2(256);
1122: result pls_integer;
1123: l_user_guid raw(256);
1124: l_message dbms_ldap.message := null;
1125: l_entry dbms_ldap.message := null;
1126: l_attrs dbms_ldap.string_collection;
1127: searchBase varchar2(1000);
1128: searchFilter varchar2(1000);

Line 1125: l_entry dbms_ldap.message := null;

1121: l_module_source varchar2(256);
1122: result pls_integer;
1123: l_user_guid raw(256);
1124: l_message dbms_ldap.message := null;
1125: l_entry dbms_ldap.message := null;
1126: l_attrs dbms_ldap.string_collection;
1127: searchBase varchar2(1000);
1128: searchFilter varchar2(1000);
1129: orclguid varchar2(1000);

Line 1126: l_attrs dbms_ldap.string_collection;

1122: result pls_integer;
1123: l_user_guid raw(256);
1124: l_message dbms_ldap.message := null;
1125: l_entry dbms_ldap.message := null;
1126: l_attrs dbms_ldap.string_collection;
1127: searchBase varchar2(1000);
1128: searchFilter varchar2(1000);
1129: orclguid varchar2(1000);
1130: ldapSession dbms_ldap.session;

Line 1130: ldapSession dbms_ldap.session;

1126: l_attrs dbms_ldap.string_collection;
1127: searchBase varchar2(1000);
1128: searchFilter varchar2(1000);
1129: orclguid varchar2(1000);
1130: ldapSession dbms_ldap.session;
1131: dummy dbms_ldap.session;
1132:
1133: realmList dbms_ldap.string_collection;
1134: ridx pls_integer;

Line 1131: dummy dbms_ldap.session;

1127: searchBase varchar2(1000);
1128: searchFilter varchar2(1000);
1129: orclguid varchar2(1000);
1130: ldapSession dbms_ldap.session;
1131: dummy dbms_ldap.session;
1132:
1133: realmList dbms_ldap.string_collection;
1134: ridx pls_integer;
1135: sbase dbms_ldap.string_collection;

Line 1133: realmList dbms_ldap.string_collection;

1129: orclguid varchar2(1000);
1130: ldapSession dbms_ldap.session;
1131: dummy dbms_ldap.session;
1132:
1133: realmList dbms_ldap.string_collection;
1134: ridx pls_integer;
1135: sbase dbms_ldap.string_collection;
1136: begin
1137: l_module_source := G_MODULE_SOURCE || 'get_user_guid: ';

Line 1135: sbase dbms_ldap.string_collection;

1131: dummy dbms_ldap.session;
1132:
1133: realmList dbms_ldap.string_collection;
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)

Line 1159: result := dbms_ldap.search_s(ld => ldapSession,

1155: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1156: then
1157: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'realm:'||r||' base:'||sbase(s)||' filter:'||searchFilter);
1158: end if;
1159: result := dbms_ldap.search_s(ld => ldapSession,
1160: base => sbase(s),
1161: scope => dbms_ldap.SCOPE_SUBTREE,
1162: filter => searchFilter,
1163: attrs => l_attrs, attronly => 0,

Line 1161: scope => dbms_ldap.SCOPE_SUBTREE,

1157: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'realm:'||r||' base:'||sbase(s)||' filter:'||searchFilter);
1158: end if;
1159: result := dbms_ldap.search_s(ld => ldapSession,
1160: base => sbase(s),
1161: scope => dbms_ldap.SCOPE_SUBTREE,
1162: filter => searchFilter,
1163: attrs => l_attrs, attronly => 0,
1164: res => l_message);
1165: l_entry := dbms_ldap.first_entry(ldapSession, l_message);

Line 1165: l_entry := dbms_ldap.first_entry(ldapSession, l_message);

1161: scope => dbms_ldap.SCOPE_SUBTREE,
1162: filter => searchFilter,
1163: attrs => l_attrs, attronly => 0,
1164: res => l_message);
1165: l_entry := dbms_ldap.first_entry(ldapSession, l_message);
1166: if (l_entry is not null) then
1167: l_attrs := dbms_ldap.get_values(ldapSession, l_entry, 'orclguid');
1168: dn := dbms_ldap.get_dn(ldapSession,l_entry);
1169: orclguid := l_attrs(0);

Line 1167: l_attrs := dbms_ldap.get_values(ldapSession, l_entry, 'orclguid');

1163: attrs => l_attrs, attronly => 0,
1164: res => l_message);
1165: l_entry := dbms_ldap.first_entry(ldapSession, l_message);
1166: if (l_entry is not null) then
1167: l_attrs := dbms_ldap.get_values(ldapSession, l_entry, 'orclguid');
1168: dn := dbms_ldap.get_dn(ldapSession,l_entry);
1169: orclguid := l_attrs(0);
1170: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1171: then

Line 1168: dn := dbms_ldap.get_dn(ldapSession,l_entry);

1164: res => l_message);
1165: l_entry := dbms_ldap.first_entry(ldapSession, l_message);
1166: if (l_entry is not null) then
1167: l_attrs := dbms_ldap.get_values(ldapSession, l_entry, 'orclguid');
1168: dn := dbms_ldap.get_dn(ldapSession,l_entry);
1169: orclguid := l_attrs(0);
1170: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1171: then
1172: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'FOUND under base='||sbase(s)||

Line 1213: function get_user_guid(p_ldap_session in dbms_ldap.session, p_user_name in varchar2)

1209: raise;
1210:
1211: end get_user_guid;
1212:
1213: function get_user_guid(p_ldap_session in dbms_ldap.session, p_user_name in varchar2)
1214: return raw is
1215: dn varchar2(4000);
1216: begin
1217: return get_user_guid(p_ldap_session,p_user_name,dn);

Line 1222: l_ldap dbms_ldap.session;

1218: end;
1219:
1220: function get_user_guid( p_user_name in varchar2)
1221: return raw is
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);

Line 1318: x_atts out nocopy dbms_ldap.string_collection,

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
1321:
1322: l_module_source varchar2(256);

Line 1319: x_att_values out nocopy dbms_ldap.string_collection)

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
1321:
1322: l_module_source varchar2(256);
1323: num_attributes number;

Line 1468: l_ldap_session dbms_ldap.session :=null;

1464: l_found boolean;
1465: l_module_source varchar2(256);
1466: l_local_login varchar2(100);
1467: l_profile_defined boolean;
1468: l_ldap_session dbms_ldap.session :=null;
1469: l_user_exists pls_integer;
1470: dn varchar2(2000);
1471: dummy pls_integer;
1472:

Line 1573: ldap dbms_ldap.session;

1569: l_profile_defined boolean;
1570: l_to_synch boolean;
1571:
1572: l_guid FND_USER.user_guid%type:= p_user_guid;
1573: ldap dbms_ldap.session;
1574: flag pls_integer;
1575: dn varchar2(4000);
1576: realm varchar2(4000);
1577: upd update_list;

Line 1708: upd(i).op := DBMS_LDAP.MOD_REPLACE;

1704: ) THEN
1705: i:= upd.count;
1706: upd(i).att := 'userpassword';
1707: upd(i).val := p_password;
1708: upd(i).op := DBMS_LDAP.MOD_REPLACE;
1709: END IF;
1710: IF (p_description is not null and NOT isValueOf(ldap_user,'description',p_description)
1711: and canUpdate('description',ldap_user.user_name, ldap_user.realmDN,x_user_creation) ) THEN
1712: i:= upd.count;

Line 1715: upd(i).op := DBMS_LDAP.MOD_REPLACE;

1711: and canUpdate('description',ldap_user.user_name, ldap_user.realmDN,x_user_creation) ) THEN
1712: i:= upd.count;
1713: upd(i).att := 'description';
1714: upd(i).val := p_description;
1715: upd(i).op := DBMS_LDAP.MOD_REPLACE;
1716: END IF;
1717:
1718: IF (p_email_address is not null and NOT isValueOf(ldap_user,'mail',p_email_address)
1719: and canUpdate('mail',ldap_user.user_name, ldap_user.realmDN,x_user_creation) ) THEN

Line 1723: upd(i).op := DBMS_LDAP.MOD_REPLACE;

1719: and canUpdate('mail',ldap_user.user_name, ldap_user.realmDN,x_user_creation) ) THEN
1720: i:= upd.count;
1721: upd(i).att := 'mail';
1722: upd(i).val := p_email_address;
1723: upd(i).op := DBMS_LDAP.MOD_REPLACE;
1724: END IF;
1725: IF (p_fax is not null and NOT isValueOf(ldap_user,'facsimileTelephoneNumber',p_fax)
1726: and canUpdate('facsimileTelephoneNumber',ldap_user.user_name, ldap_user.realmDN,x_user_creation)
1727: ) THEN

Line 1731: upd(i).op := DBMS_LDAP.MOD_REPLACE;

1727: ) THEN
1728: i:= upd.count;
1729: upd(i).att := 'facsimileTelephoneNumber';
1730: upd(i).val := p_fax;
1731: upd(i).op := DBMS_LDAP.MOD_REPLACE;
1732: END IF;
1733: decode_dates(p_user_name, p_start_date, p_end_date,
1734: x_orclisEnabled => l_orclisEnabled,
1735: x_user_id => l_user_id);

Line 1742: upd(i).op := DBMS_LDAP.MOD_REPLACE;

1738: and l_orclIsEnabled = fnd_oid_util.G_ENABLED) THEN
1739: i:= upd.count;
1740: upd(i).att := 'orclIsEnabled';
1741: upd(i).val := l_orclIsEnabled;
1742: upd(i).op := DBMS_LDAP.MOD_REPLACE;
1743: END IF;
1744: if (upd.count>0) THEN
1745: ProcessUpdateRec(ldap,ldap_user.dn,upd);
1746: END IF;

Line 1894: function update_user_nodes(p_ldap_session in dbms_ldap.session, p_mod_array in dbms_ldap.mod_array, p_orclguid in raw)

1890:
1891: END ConverToNew;
1892:
1893: -------------------------------------------------------------------------------
1894: function update_user_nodes(p_ldap_session in dbms_ldap.session, p_mod_array in dbms_ldap.mod_array, p_orclguid in raw)
1895: return pls_integer is
1896:
1897: l_module_source varchar2(256);
1898: usersNode varchar2(1000);

Line 1912: -- dbms_ldap.use_exception := true;

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:
1916: if (retval = dbms_ldap.SUCCESS) then

Line 1914: retval := dbms_ldap.modify_s(ld => p_ldap_session, entrydn => usersNode, modptr => p_mod_array);

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:
1916: if (retval = dbms_ldap.SUCCESS) then
1917: retval := fnd_ldap_util.G_SUCCESS;
1918: end if;

Line 1916: if (retval = dbms_ldap.SUCCESS) then

1912: -- dbms_ldap.use_exception := true;
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)

Line 1928: when dbms_ldap.general_error then

1924: return retval;
1925:
1926: exception
1927: -- bug 4573677
1928: when dbms_ldap.general_error then
1929: l_message := translate_ldap_error(sqlerrm);
1930: if (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
1931: then
1932: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source, 'error '||l_message||':'||sqlerrm);

Line 1953: ldap dbms_ldap.session;

1949: end update_user_nodes;
1950:
1951: function user_exists(p_user_name in varchar2)
1952: return pls_integer is
1953: ldap dbms_ldap.session;
1954: ret pls_integer;
1955: ret2 pls_integer;
1956: flag pls_integer;
1957: begin

Line 1972: function user_exists(ldap in dbms_ldap.session,p_user_name in varchar2)

1968: raise;
1969: end user_exists;
1970: --
1971: -------------------------------------------------------------------------------
1972: function user_exists(ldap in dbms_ldap.session,p_user_name in varchar2)
1973: return pls_integer is
1974:
1975: l_module_source varchar2(256);
1976: --result pls_integer;

Line 2038: function comparePassword(ldapSession in dbms_ldap.session, user_dn in varchar2 , p_password in varchar2) return boolean is

2034: * user_dn: user DN
2035: * p_password: password
2036: **/
2037:
2038: function comparePassword(ldapSession in dbms_ldap.session, user_dn in varchar2 , p_password in varchar2) return boolean is
2039: l_result pls_integer;
2040: result boolean;
2041: l_module_source varchar2(256);
2042: begin

Line 2048: l_result := dbms_ldap.compare_s(ld => ldapSession, dn => user_dn, attr => 'userpassword', value => p_password);

2044: if (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2045: then
2046: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'BEGIN DN:'||user_dn);
2047: end if;
2048: l_result := dbms_ldap.compare_s(ld => ldapSession, dn => user_dn, attr => 'userpassword', value => p_password);
2049: result := l_result= dbms_ldap.COMPARE_TRUE;
2050: if (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2051: then
2052: if (result) then

Line 2049: result := l_result= dbms_ldap.COMPARE_TRUE;

2045: then
2046: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'BEGIN DN:'||user_dn);
2047: end if;
2048: l_result := dbms_ldap.compare_s(ld => ldapSession, dn => user_dn, attr => 'userpassword', value => p_password);
2049: result := l_result= dbms_ldap.COMPARE_TRUE;
2050: if (fnd_log.LEVEL_PROCEDURE >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2051: then
2052: if (result) then
2053: fnd_log.string(fnd_log.LEVEL_PROCEDURE, l_module_source, 'END: Yes');

Line 2083: ldapSession dbms_ldap.session;

2079: l_user_guid raw(256);
2080: l_user_name fnd_user.user_name%type;
2081: l_enabled boolean;
2082: l_ldap_attr_list ldap_attr_list;
2083: ldapSession dbms_ldap.session;
2084: l_retval pls_integer;
2085: user_dn varchar2(4000);
2086: l_ldap_auth varchar2(256);
2087: l_db_wlt_url varchar2(256);

Line 2201: dbms_ldap.use_exception := TRUE;

2197: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'WARNING: NON-SSL connection to OiD, check that the Net is secure');
2198: end if;
2199: end if;
2200:
2201: dbms_ldap.use_exception := TRUE;
2202:
2203: begin
2204: begin
2205: ldapSession := DBMS_LDAP.init(l_host, l_port);

Line 2205: ldapSession := DBMS_LDAP.init(l_host, l_port);

2201: dbms_ldap.use_exception := TRUE;
2202:
2203: begin
2204: begin
2205: ldapSession := DBMS_LDAP.init(l_host, l_port);
2206: exception when dbms_ldap.init_failed then
2207: if (fnd_log.LEVEL_UNEXPECTED>= fnd_log.G_CURRENT_RUNTIME_LEVEL)
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);

Line 2206: exception when dbms_ldap.init_failed then

2202:
2203: begin
2204: begin
2205: ldapSession := DBMS_LDAP.init(l_host, l_port);
2206: exception when dbms_ldap.init_failed then
2207: if (fnd_log.LEVEL_UNEXPECTED>= fnd_log.G_CURRENT_RUNTIME_LEVEL)
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;

Line 2220: l_retval := dbms_ldap.open_ssl(ldapSession, 'file:'||l_db_wlt_url, l_db_wlt_pwd, l_ldap_auth);

2216:
2217: if (l_ldap_auth>0) then
2218:
2219: begin
2220: l_retval := dbms_ldap.open_ssl(ldapSession, 'file:'||l_db_wlt_url, l_db_wlt_pwd, l_ldap_auth);
2221: exception when others then
2222: if (fnd_log.LEVEL_UNEXPECTED>= fnd_log.G_CURRENT_RUNTIME_LEVEL)
2223: then
2224: fnd_log.string(fnd_log.LEVEL_UNEXPECTED, l_module_source,' Cannot establish SSL channel to OiD: '||sqlcode||'-'||sqlerrm);

Line 2238: l_retval := dbms_ldap.simple_bind_s(ldapSession, user_dn , p_password);

2234: end if;
2235: end if;
2236:
2237:
2238: l_retval := dbms_ldap.simple_bind_s(ldapSession, user_dn , p_password);
2239:
2240: -- we do analyze in extense the possible DBMS_LDAP exceptions to return accurate messages
2241:
2242:

Line 2240: -- we do analyze in extense the possible DBMS_LDAP exceptions to return accurate messages

2236:
2237:
2238: l_retval := dbms_ldap.simple_bind_s(ldapSession, user_dn , p_password);
2239:
2240: -- we do analyze in extense the possible DBMS_LDAP exceptions to return accurate messages
2241:
2242:
2243: exception
2244: when dbms_ldap.general_error then

Line 2244: when dbms_ldap.general_error then

2240: -- we do analyze in extense the possible DBMS_LDAP exceptions to return accurate messages
2241:
2242:
2243: exception
2244: when dbms_ldap.general_error then
2245: -- here comes the explanation
2246: l_message := sqlerrm;
2247: -- first we check if the password is real,
2248:

Line 2312: l_retval:= dbms_ldap.unbind_s(ldapSession);

2308: return fnd_ldap_util.G_FAILURE;
2309: end;
2310:
2311:
2312: l_retval:= dbms_ldap.unbind_s(ldapSession);
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;

Line 2349: ldapSession dbms_ldap.session;

2345:
2346: function get_username_from_guid(p_guid in fnd_user.user_guid%type)
2347: return varchar2
2348: is
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;

Line 2391: FUNCTION SearchUser (ldap in out nocopy dbms_ldap.session ,

2387: -- Fills the record with relevant information
2388: ---
2389: --- FUTURE: it is possible to cache , seems that the user is looked up several times in some flows.
2390:
2391: FUNCTION SearchUser (ldap in out nocopy dbms_ldap.session ,
2392: p_ldap_user IN OUT nocopy fnd_ldap_user.ldap_user_type ,
2393: username_z in varchar2 default null,
2394: dn_z in varchar2 default null) return boolean
2395: IS

Line 2528: ldapSession dbms_ldap.session;

2524: FUNCTION SearchUser ( username_z in varchar2,
2525: p_ldap_user IN OUT nocopy fnd_ldap_user.ldap_user_type) return boolean
2526: IS
2527: ret boolean;
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);

Line 2612: ldapSession dbms_ldap.session;

2608: IS
2609: l_module_source VARCHAR2(256);
2610: retval pls_integer;
2611: result pls_integer;
2612: ldapSession dbms_ldap.session;
2613: flag pls_integer;
2614: l_userDN VARCHAR2(4000);
2615: l_user_guid VARCHAR2(4000);
2616: l_oid_username VARCHAR2(4000);

Line 3239: FUNCTION locateIdx ( col in out nocopy DBMS_LDAP.STRING_COLLECTION , val in varchar ) return pls_integer

3235:
3236: */
3237:
3238:
3239: FUNCTION locateIdx ( col in out nocopy DBMS_LDAP.STRING_COLLECTION , val in varchar ) return pls_integer
3240: is
3241: i pls_integer;
3242: BEGIN
3243: if (col is null or val is null ) then

Line 3262: lista DBMS_LDAP.STRING_COLLECTION ;

3258: attVal in varchar2,
3259: replaceIt in boolean default false )
3260: IS
3261: old_idx pls_integer;
3262: lista DBMS_LDAP.STRING_COLLECTION ;
3263: l_name varchar2(4000) := lower(attName);
3264: BEGIN
3265: if (replaceIt) then
3266: usr.user_data.delete(l_name);

Line 3495: PROCEDURE ProcessUpdateRec(ldap in dbms_ldap.session, dn in varchar2, upd in update_list)

3491:
3492: END CanSync;
3493:
3494: -------------------------------------------------------------------------------
3495: PROCEDURE ProcessUpdateRec(ldap in dbms_ldap.session, dn in varchar2, upd in update_list)
3496: IS
3497: i pls_integer;
3498: ma dbms_ldap.mod_array := null;
3499: l dbms_ldap.string_collection;

Line 3498: ma dbms_ldap.mod_array := null;

3494: -------------------------------------------------------------------------------
3495: PROCEDURE ProcessUpdateRec(ldap in dbms_ldap.session, dn in varchar2, upd in update_list)
3496: IS
3497: i pls_integer;
3498: ma dbms_ldap.mod_array := null;
3499: l dbms_ldap.string_collection;
3500: m varchar2(100);
3501: l_module_source varchar2(400);
3502: BEGIN

Line 3499: l dbms_ldap.string_collection;

3495: PROCEDURE ProcessUpdateRec(ldap in dbms_ldap.session, dn in varchar2, upd in update_list)
3496: IS
3497: i pls_integer;
3498: ma dbms_ldap.mod_array := null;
3499: l dbms_ldap.string_collection;
3500: m varchar2(100);
3501: l_module_source varchar2(400);
3502: BEGIN
3503: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)

Line 3509: ma := dbms_ldap.create_mod_array(num=> upd.count);

3505: l_module_source := G_MODULE_SOURCE || 'ProcessUpdateRec: ';
3506: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'Begin');
3507: end if;
3508:
3509: ma := dbms_ldap.create_mod_array(num=> upd.count);
3510: i:= upd.first;
3511: while i is not null LOOP
3512: l.delete;
3513: l(0) := upd(i).val;

Line 3516: dbms_ldap.populate_mod_array(modptr => ma,

3512: l.delete;
3513: l(0) := upd(i).val;
3514:
3515:
3516: dbms_ldap.populate_mod_array(modptr => ma,
3517: mod_op =>upd(i).op,
3518: mod_type => upd(i).att,
3519: modval => l);
3520: i:=upd.next(i);

Line 3522: i := dbms_ldap.modify_s(ldap,dn,ma);

3518: mod_type => upd(i).att,
3519: modval => l);
3520: i:=upd.next(i);
3521: END LOOP;
3522: i := dbms_ldap.modify_s(ldap,dn,ma);
3523:
3524: if (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL)
3525: then
3526: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module_source, 'END');

Line 3532: dbms_ldap.free_Mod_array(ma);

3528:
3529:
3530: EXCEPTION WHEN OTHERS THEN
3531: if (ma is not null) then
3532: dbms_ldap.free_Mod_array(ma);
3533: END IF;
3534: IF (fnd_log.LEVEL_EXCEPTION >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
3535: fnd_log.string(fnd_log.LEVEL_EXCEPTION, l_module_source , sqlerrm);
3536: END IF;

Line 3544: l dbms_ldap.string_collection;

3540: FUNCTION isValueOf( u ldap_user_type, fld in varchar2, val in varchar2 ) return boolean
3541: IS
3542: i pls_integer;
3543: n varchar2(200) := lower(fld);
3544: l dbms_ldap.string_collection;
3545: BEGIN
3546: if val is null THEN
3547: return false;
3548: END IF;

Line 3567: exp1 dbms_ldap.string_collection;

3563: realmDN in varchar2 ,
3564: dn_z in varchar2 )
3565: IS
3566: realm pls_integer;
3567: exp1 dbms_ldap.string_collection;
3568: i pls_integer;
3569: l_module varchar2(4000):= G_MODULE_SOURCE || 'ProcessLoadedLpadUserRecord: ';
3570: shortest varchar2(4000);
3571: l_v varchar2(4000);

Line 3614: exp1 := dbms_ldap.explode_dn(lower(dn_z),0);

3610: IF (fnd_log.LEVEL_STATEMENT >= fnd_log.G_CURRENT_RUNTIME_LEVEL) THEN
3611: fnd_log.string(fnd_log.LEVEL_STATEMENT, l_module, 'realmDN(resolving):'|| p_ldap_user.realmDN );
3612: END IF;
3613:
3614: exp1 := dbms_ldap.explode_dn(lower(dn_z),0);
3615: i := instr(exp1(0),'=');
3616: p_ldap_user.RDN_ATT_NAME:= substr(exp1(0),0,i-1) ;
3617: p_ldap_user.RDN_VALUE := substr(exp1(0),i+1) ;
3618: p_ldap_user.parent_DN := '';