source: main/trunk/greenstone3/src/java/org/greenstone/gsdl3/util/UserTermInfo.java@ 35287

/*
 *    UserTermInfo.java
 *    Copyright (C) 2008 New Zealand Digital Library, http://www.nzdl.org
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

package org.greenstone.gsdl3.util;

import java.util.Set;
import java.util.TreeSet;

public class UserTermInfo
{
    private String username;
    private String password;
    private String origGroups;
        private String expandedGroups = null;
    private String accountstatus;
    private String comment;
    private String email;

    public UserTermInfo(String username, String password, String groups,
            String accountStatus, String comment, String email) {
    this.username = username;
    this.password = password;
    this.origGroups = groups;
    //this.expandedGroups = UserTermInfo.expandGroups(this.origGroups); // Will do lazy evaluation
    this.accountstatus = accountStatus;
    this.comment = comment;
    this.email = email;
    }
    
    public String toString()
    {
        String result = "";
        result += "<username = " + username + ">";
        result += "<password = " + password + ">";
        result += "<groups = " + origGroups + ">";
        result += "<enable = " + accountstatus + ">";
        result += "<comment = " + comment + ">";
        // no line for email?
        return result;
    }


    public String getUsername() {
    return username;
    }

    public String getPassword() {
    return password;
    }

    public String getOrigGroups() {
    return origGroups;
    }    
    
    public String getExpandedGroups() {
    //return expandedGroups;
    //return UserTermInfo.expandGroups(this.origGroups); // not storing, evaluating on demand
    
    // lazy evaluation: getExpandedGroups() doesn't get called on every enquiry about
    // a UserTermInfo struct. It only gets called on authenticated-ping system-action
    // (including via ServletRealmCheck being run from run from commandline or gliserver.pl)
    // So for a whole list of users and the UserTermInfo struct of each,
    // don't pre-calculate and store the expanded groups.
    // Is it meaningful to store this at all Ever or better to always evaluate on demand?
    if(expandedGroups == null) {
        expandedGroups = UserTermInfo.expandGroups(this.origGroups);
    }
    return expandedGroups;
    }

    public String getAccountStatus() {
    return accountstatus;
    }

    public String getComment() {
    return comment;
    }

    public String getEmail() {
    return email;
    }

    public void setEmail(String email) {
    this.email = email;
    }

    /** We might have groups of the form katoa.maori.(placename.)iwi-name.hapu-name.personal-name
     * ("katoa" means all, we could also use "mema" meaning member for this initial position).
     * We want to expand such a group into the multiple groups it encompasses:
     *   katoa, katoa.maori, katoa.maori.place, katoa.maori.place.iwi,
     *   katoa.maori.place.iwi.hapu, katoa.maori.place.iwi.hapu.person
     * This method looks through all the groups and if any contains a period,
     * it will expand such into all their explicit subgroups.
     * @param groups: String listing command-separated groups, any of which may
     * need expanding out.
     * @return a comma-separated String listing all the original groups plus any expanded groups
     * in natural order (so alphabetised).
     *
     * Tested at https://www.jdoodle.com/online-java-compiler/, where main contains:
     *    String groups = "all-collections-editor, katoa.maori.place.iwi.hapu.person, admin";
     *
     *    System.out.println(expandGroups(groups));
     * Produces:
     *    all-collections-editor,katoa,katoa.maori,katoa.maori.place,katoa.maori.place.iwi,katoa.maori.place.iwi.hapu,katoa.maori.place.iwi.hapu.person,admin
     *
     * Also tested with the expandable string at start and at end of list of groups input string.
     *
     * This expansion method doesn't preserve overall ordering,
     * e.g. if groups = "all-collections-editor, katoa.maori.place.iwi.hapu.person, admin"
     * result is:
     *    admin,all-collections-editor,katoa,katoa.maori,katoa.maori.place,katoa.maori.place.iwi,katoa.maori.place.iwi.hapu,katoa.maori.place.iwi.hapu.person
     * Where admin is now at start and all-colls-editor now comes after it.
     * However, this method will ensure the requirement of no duplicates,
     * e.g. only one katoa, one katoa.maori etc.
     * to minimising checking if a user has necessary group membership,
     *   e.g. String groups = "all-collections-editor, admin, org.waikato.cs.dl.anu , org.waikato.cs.dl.pinky";
     * Produces the result:
     *    admin,all-collections-editor,org,org.waikato,org.waikato.cs,org.waikato.cs.dl,org.waikato.cs.dl.anu,org.waikato.cs.dl.pinky
     */
    public static String expandGroups(String groups) {
    if(groups.indexOf('.') == -1) {
        return groups;
    }
    else {
        Set<String> allGroups = new TreeSet<String>();
        String[] indivGroups = groups.split("\\s*,\\s*"); // simultaneously get rid of whitespace surrounding commas
        for(String s : indivGroups) {
        int indexOfPeriod = s.indexOf('.');

        if(indexOfPeriod != -1) {
            do {            
            String expandedGroup = s.substring(0, indexOfPeriod);
            allGroups.add(expandedGroup);
            indexOfPeriod += 1;         
            indexOfPeriod = s.indexOf('.', indexOfPeriod);
            } while(indexOfPeriod != -1);           
        }

        // Whether this particular group contained a period or not,
        // remember to add this group string in in its entirety too
        allGroups.add(s);
        }
    

        StringBuilder expandedGroupList = new StringBuilder();//"<groups = \"");
        for(String s : allGroups) {
        expandedGroupList.append(s);
        expandedGroupList.append(',');
        }
        expandedGroupList.deleteCharAt(expandedGroupList.length()-1); // remove extraneous comma
        
        //expandedGroupList.append("\">");
        
        return expandedGroupList.toString();
    }
    }


     /*
    public static String expandGroups(String groups) {
    if(groups.indexOf('.') == -1) {
        return groups;
    }
    else {
        // Build up the string again
        StringBuilder expandedGroupList = new StringBuilder();      

        String[] indivGroups = groups.split("\\s*,\\s*"); // simultaneously get rid of any whitespace surrounding commas
        for(String s : indivGroups) {
        int indexOfPeriod = s.indexOf('.');

        if(indexOfPeriod != -1) {
            do {
            String expandedGroup = s.substring(0, indexOfPeriod);
            expandedGroupList.append(expandedGroup);
            expandedGroupList.append(',');
            indexOfPeriod += 1;         
            indexOfPeriod = s.indexOf('.', indexOfPeriod);
            } while(indexOfPeriod != -1);
        }

        // Whether this particular group s contained a period or not,
        // remember to add this group string, s, back in in its entirety too        
        expandedGroupList.append(s);
        expandedGroupList.append(',');
        }
        expandedGroupList.deleteCharAt(expandedGroupList.length()-1); // remove extraneous comma        
        return expandedGroupList.toString();
    }
    }
    */
    
}