Thread: [Cobricks-cvscommit] cobricks2/src/org/cobricks/user UserManagerImpl.java

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/cobricks/cobricks2/src/org/cobricks/user
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv26326/src/org/cobricks/user

Modified Files:
	UserManagerImpl.java 
Log Message:
Methods for buddylist and interests attributes of user


Index: UserManagerImpl.java
===================================================================
RCS file: /cvsroot/cobricks/cobricks2/src/org/cobricks/user/UserManagerImpl.java,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9

--- UserManagerImpl.java	16 Apr 2004 09:25:00 -0000	1.8
+++ UserManagerImpl.java	21 Apr 2004 13:36:33 -0000	1.9
@@ -46,6 +46,9 @@
 import org.cobricks.user.attribute.AttributeDescriptor;
 import org.cobricks.user.attribute.AttributeDescriptorManager;
 import org.cobricks.user.attribute.UserJoin;
+import org.globus.test.otherTypes.OtherType;
+
+import org.omg.PortableInterceptor.USER_EXCEPTION;
 
 /**
  * @author michael.koch
@@ -428,6 +431,17 @@
             new Integer(objectIdToDelete));
 
         dbAccess.sqlDelete(attributeDescriptor.getTableName(), attrs);
+
+        if (attrname.equalsIgnoreCase(User.INTERESTS)) {
+            //for attribute interests.categories: delete entry in the table cat_attrsuser
+            attrs.clear();
+            attrs.put("auserid", new Integer(userid));
+            attrs.put("catid", new Integer(objectIdToDelete));
+            dbAccess.sqlDelete("cat_attrsuser", attrs);
+        }
+
+        removeUserObjectFromCache(userid);
+        getUser(userid);
     }
 
     /**
@@ -457,6 +471,23 @@
         attrs.put(ANAME, attrname);
 
         dbAccess.sqlInsert(attributeDescriptor.getTableName(), attrs);
+
+        if (attrname.equalsIgnoreCase(User.INTERESTS)) {
+            //for attribute interests.categories: insert entry for the table cat_attrsuser
+            attrs.clear();
+            attrs.put("auserid", new Integer(userid));
+            attrs.put("catid", new Integer(objectidToAdd));
+            attrs.put(CONTEXTCLASS, attributeDescriptor.getContextClassName());
+            attrs.put(ANAME, attrname);
+            dbAccess.sqlInsert("cat_attrsuser", attrs);
+        }
+
+        //user must be "updated"
+        removeUserObjectFromCache(userid);
+
+        User currentUser = getUser(userid);
+
+        //currentUser.setAttributeLocally(attrname, )
     }
 
     /**
@@ -690,6 +721,10 @@
             return result;
         }
 
+        if (userid < 1) {
+            return null;
+        }
+
         result = new User(userid);
 
         try {
@@ -740,6 +775,7 @@
                 result.setAttributeLocally(User.USERCLASS, tmps);
             }
 
+            //loop over all tables excepting user_main
             for (int k = 1; k < (userTables.length - 1); k++) {
                 List userAttrs = new ArrayList();
                 userAttrs = dbAccess.sqlQuery("select aname, "
@@ -747,33 +783,52 @@
                         + " where userid = " + Integer.toString(userid));
 
                 String aname = "";
+                String anamePrev = "";
                 Object avalue = null;
+                boolean isSet = false;
 
+                //loop over result for one table
                 for (Iterator i = userAttrs.iterator(); i.hasNext();) {
                     Map elem = (Map)i.next();
+
                     aname = (String)elem.get(ANAME);
 
                     AttributeDescriptor attrDescriptor = getAttributeDescriptorManager(result
                                     .getAttribute(User.USERCLASS))
                                                                      .getAttributeDescriptorFor(aname);
+                    isSet = attrDescriptor.getOntologyDataType().isSet();
 
-                    if ((avalue != null)
-                                && (attrDescriptor.getOntologyDataType()
-                                                          .isSet())) {
-                        ((Set)avalue).add(elem.get(userTablesValues[k - 1]));
-                    } else {
-                        if (attrDescriptor.getOntologyDataType().isSet()) {
+                    if ((!(aname.equalsIgnoreCase(anamePrev))
+                                && (!anamePrev.equalsIgnoreCase("")) && isSet)
+                                || (!i.hasNext()
+                                && (!anamePrev.equalsIgnoreCase("")) && isSet)) {
+                        result.setAttributeLocally(aname, avalue);
+                    }
+
+                    anamePrev = aname;
+
+                    /*if ((avalue != null)
+                       && (attrDescriptor.getOntologyDataType()
+                                                 .isSet()))*/
+                    if (isSet) {
+                        if (avalue != null) {
+                            ((Set)avalue).add(elem.get(
+                                    userTablesValues[k - 1]));
+                        } else {
                             //Set avalueSet = new HashSet();
                             avalue = new HashSet();
                             ((Set)avalue).add(elem.get(
                                     userTablesValues[k - 1]));
-                        } else {
-                            avalue = elem.get(userTablesValues[k - 1]);
+
+                            if (!i.hasNext()) {
+                                result.setAttributeLocally(aname, avalue);
+                            }
                         }
+                    } else {
+                        avalue = elem.get(userTablesValues[k - 1]);
+                        result.setAttributeLocally(aname, avalue);
                     }
                 }
-
-                result.setAttributeLocally(aname, avalue);
             }
 
             setUserObjectInCache(result);
@@ -853,7 +908,33 @@
     }
 
     /**
-     * returns true if user with this userlogin exists param userlogin
+     * Method for checking if the user with
+     *
+     * @param userLogin and
+     * @param email exist, for "forgot password" function of the plattform
+     *
+     * @return user, if it exist, o/w null
+     **/
+    public User checkUser(String userLogin, String email) {
+        int userid = getUserIdForUserLogin(userLogin);
+
+        if (userid > 0) {
+            User user = getUser(userid);
+
+            if (user.getAttribute(User.EMAIL).equalsIgnoreCase(email)) {
+                return user;
+            }
+
+            return null;
+        }
+
+        return null;
+    }
+
+    /**
+     * @param userlogin
+     *
+     * @return true if user with this userlogin exists
      **/
     public boolean checkUser(String userlogin)
         throws Exception {
@@ -976,6 +1057,7 @@
 
                 // adding of created user to the UserCache
                 setUserObjectInCache(newUser);
+                logger.debug("rasmer User cache" + userObjects.size());
 
                 return newUser;
             }
@@ -990,7 +1072,7 @@
     public Object generateCredential() {
         Random randomGenerator = new Random();
 
-        //The length of password is between 6 and 8 symbols
+        //The length of password must be between 6 and 8 symbols
         int lengthOfPassword = randomGenerator.nextInt(3) + 6;
         int tmp;
         StringBuffer sb = new StringBuffer("");
@@ -1173,13 +1255,71 @@
     }
 
     /**
+     * This method update
      *
+     * @param user with all it's attributes an delete attributes that are not
+     *        longer defined
      **/
     public void updateUser(User user) {
+        Map attrsNew = new HashMap();
+        Map attrsOld = new HashMap();
+        Map toDelete = new HashMap();
+        attrsNew = user.getAttributes();
+        AttributeDescriptor attributeDescriptor = null;
+
+        int userid = user.getId();
+        String userclass = user.getAttribute(User.USERCLASS);
+
+        removeUserObjectFromCache(userid);
+
+        User userOld = getUser(userid);
+        attrsOld = userOld.getAttributes();
+
+        //the user was not changed
+        if (attrsOld.equals(attrsNew)) {
+            return;
+        } else {
+            for (Iterator i = attrsOld.entrySet().iterator(); i.hasNext();) {
+                Map.Entry attribute = (Map.Entry)i.next();
+                String aname = (String)attribute.getKey();
+
+                if (!attrsNew.containsKey(aname)) {
+                    toDelete.put(aname, attribute.getValue());
+                }
+            }
+
+            try {
+                updateUser(userid, attrsNew);
+            } catch (CobricksException cE) {
+                logger.error("ERROR in updateUser(user) ", cE);
+            }
+            Map userMainAttrsToDelete = new HashMap();
+            Map otherTableAttrsToDelete = new HashMap();
+            for (Iterator i = toDelete.entrySet().iterator(); i.hasNext();) {
+                Map.Entry attrToDelete = (Map.Entry) i.next();
+                String aname = (String)attrToDelete.getKey();
+                try{
+                attributeDescriptor = getAttributeDescriptorManager(userclass).getAttributeDescriptorFor(aname);
+                }catch (Exception e){}
+                if (attributeDescriptor.getTableName().equalsIgnoreCase(TABLE_USER_MAIN)){
+                    userMainAttrsToDelete.put(aname, attrToDelete.getValue());
+                }
+                else{
+                    otherTableAttrsToDelete.clear();
+                    otherTableAttrsToDelete.put(User.USERID, new Integer(userid));
+                    otherTableAttrsToDelete.put(attributeDescriptor.getConditionFieldName(), aname);
+                    dbAccess.sqlDelete(attributeDescriptor.getTableName(), otherTableAttrsToDelete);
+                }
+                
+            }
+        }
     }
 
     /**
+     * This method update user with
      *
+     * @param userid , just change the attributes in
+     * @param attrs
      **/
     public void updateUser(int userid, Map attrs)
         throws CobricksException {
@@ -1187,24 +1327,13 @@
         String where;
         AttributeDescriptor attrDesc = null;
         Map attrsToUpdate = new HashMap();
+        StringBuffer where_ = new StringBuffer();
 
-        /*
-           List attrnames_main = new ArrayList();
-           List attrnames_attr = new ArrayList();
-           List attrnames_attrcategory = new ArrayList();
-           List attrnames_attritem = new ArrayList();
-           List attrnames_attruser = new ArrayList();
-                   List attrnames_attrdate = new ArrayList();
-           Map attrs_main = new HashMap();
-           Map attrs_attr = new HashMap();
-           Map attrs_attrcategory = new HashMap();
-           Map attrs_attritem = new HashMap();
-           Map attrs_attruser = new HashMap();
-           Map attrs_attrdate = new HashMap();
-         */
         for (Iterator i = attrs.entrySet().iterator(); i.hasNext();) {
             Map.Entry mEntry = (Map.Entry)i.next();
             String aname = (String)(mEntry.getKey());
+            String attrColumnName;
+
             Map attrsForTable = new HashMap();
             Map uClass = new HashMap();
             uClass = dbAccess.sqlQuerySingleRow(
@@ -1214,40 +1343,98 @@
                         User.USERCLASS)).getAttributeDescriptorFor(aname);
 
             tableName = attrDesc.getTableName();
+            attrColumnName = attrDesc.getValueFieldName();
 
             if (logger.isDebugEnabled()) {
                 logger.debug(
                     "table in UserManagerImpl in updateUser for attr "
-                    + aname + " is " + tableName);
+                    + aname + " (" + attrColumnName + ") " + " is "
+                    + tableName);
             }
 
-            if (attrsToUpdate.containsKey(tableName)) {
-                ((Map)attrsToUpdate.get(tableName)).put(mEntry.getKey(),
-                    mEntry.getValue());
+            if (where_.length() > 0) {
+                where_.delete(0, where_.length());
+            }
+
+            if (!tableName.equalsIgnoreCase(TABLE_USER_MAIN)) {
+                Map entryToUpdate = new HashMap();
+                Object value = mEntry.getValue();
+                entryToUpdate.put(attrColumnName, value);
+
+                if (tableName.equalsIgnoreCase(TABLE_USER_ATTR)) {
+                    String avaluepref = (String)value;
+
+                    if (avaluepref.length() > 100) {
+                        entryToUpdate.put(AVALUEPREFIX,
+                            avaluepref.substring(0, 99));
+                    } else {
+                        entryToUpdate.put(AVALUEPREFIX, avaluepref);
+                    }
+                }
+
+                where_.append(" aname = '");
+                where_.append((String)mEntry.getKey());
+                where_.append("' and ");
+                where_.append("userid = ");
+                where_.append(userid);
+                where = where_.toString();
+                dbAccess.sqlUpdate(tableName, entryToUpdate, where);
             } else {
-                attrsForTable.put(mEntry.getKey(), mEntry.getValue());
-                attrsToUpdate.put(tableName, attrsForTable);
+                if (attrsToUpdate.containsKey(tableName)) {
+                    ((Map)attrsToUpdate.get(tableName)).put(attrColumnName,
+                        mEntry.getValue());
+                } else {
+                    attrsForTable.put(attrColumnName, mEntry.getValue());
+                    attrsToUpdate.put(tableName, attrsForTable);
+                }
             }
         }
 
-        StringBuffer where_ = new StringBuffer("where userid = ");
+        /*
+           for (Iterator i = attrsToUpdate.entrySet().iterator(); i.hasNext();) {
+                Map.Entry tablesAttrs = (Map.Entry) i.next();
+                tableName = (String) tablesAttrs.getKey();
+                            Map tableMap = (Map) tablesAttrs.getValue();
+                            StringBuffer where_ = new StringBuffer("");
+                if(!tableName.equalsIgnoreCase(TABLE_USER_MAIN)){
+                    for (Iterator j = tableMap.entrySethasNext(); j.hasNext()){
+                       Map.Entry tableEntry = (Map.Entry) j.next();
+                                           String anameForUpdate =
+                       Map entryForUpdate = (Map)tableEntry;
+                   }
+                    where_.append(" and aname = " + aname );
+                }
+                where_.append(userid);
+           }
+        
+           StringBuffer where_ = new StringBuffer("");
+           if(!tableName.equalsIgnoreCase(TABLE_USER_MAIN)){
+               where_.append(" and aname = " + aname );
+           }
+           where_.append(userid);
+         */
+        where_ = where_.delete(0, where_.length());
+        where_.append(" userid = ");
         where_.append(userid);
         where = where_.toString();
 
         for (Iterator i = attrsToUpdate.entrySet().iterator(); i.hasNext();) {
-            Map attrsToTable = (Map)i.next();
+            Map.Entry entry = (Map.Entry)i.next();
 
-            for (Iterator j = attrsToTable.entrySet().iterator();
-                        j.hasNext();) {
-                Map.Entry entry = (Map.Entry)j.next();
-                String table = (String)entry.getKey();
-                dbAccess.sqlUpdate(table, (Map)entry.getValue(), where);
+            // for (Iterator j = attrsToTable.entrySet().iterator();
+            //             j.hasNext();) {
+            //     Map.Entry entry = (Map.Entry)j.next();
+            String table = (String)entry.getKey();
+            dbAccess.sqlUpdate(table, (Map)entry.getValue(), where);
 
-                if (logger.isDebugEnabled()) {
-                    logger.debug("update table " + table);
-                }
+            //userObjects.r
+            if (logger.isDebugEnabled()) {
+                logger.debug("update table " + table);
             }
         }
+
+        removeUserObjectFromCache(userid);
+        getUser(userid);
     }
 
     /**





Thread: [Cobricks-cvscommit] cobricks2/src/org/cobricks/user UserManagerImpl.java

cobricks-cvscommit