Ignore:
Timestamp:
10/05/11 00:39:28 (13 years ago)
Author:
sherbold
Message:
  • extended de.ugoe.cs.eventbench.web.WeblogParser? with functionality to determine frequent users
  • adapted command loadSessionsFromClickstream allow optional determination of frequent users
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/web/WeblogParser.java

    r225 r232  
    1010import java.util.Collection; 
    1111import java.util.HashMap; 
     12import java.util.HashSet; 
    1213import java.util.LinkedList; 
    1314import java.util.List; 
    1415import java.util.Map; 
     16import java.util.Set; 
    1517 
    1618import de.ugoe.cs.eventbench.web.data.WebEvent; 
     
    6971        /** 
    7072         * <p> 
     73         * List that stores the users (identified through their cookie id) to each 
     74         * sequence. 
     75         * </p> 
     76         */ 
     77        private List<String> users; 
     78 
     79        /** 
     80         * <p> 
     81         * List that stores the frequent users (identified through their cookie id) 
     82         * to each sequence. 
     83         * </p> 
     84         */ 
     85        private List<String> frequentUsers; 
     86 
     87        /** 
     88         * <p> 
     89         * Sequences for all frequent users. 
     90         * </p> 
     91         */ 
     92        private List<Collection<List<WebEvent>>> sequencesFrequentUsers; 
     93 
     94        /** 
     95         * <p> 
     96         * Threshold that defines how many sessions of a user are require to deem 
     97         * the user frequent. Note, that only sessions whose lengths is in range if 
     98         * {@link #minLength} and {@link #maxLength} are counted. 
     99         * </p> 
     100         */ 
     101        private int frequentUsersThreshold = -1; 
     102 
     103        /** 
     104         * <p> 
    71105         * Name and path of the robot filter. 
    72106         * </p> 
     
    164198        public void setUrl(String url) { 
    165199                this.url = url; 
     200        } 
     201 
     202        /** 
     203         * <p> 
     204         * Sets the threshold for frequent users. 
     205         * </p> 
     206         *  
     207         * @param threshold 
     208         *            threshold value; if the value is &lt;1, the sessions of the 
     209         *            frequent users will not be determined 
     210         */ 
     211        public void setFrequentUserThreshold(int threshold) { 
     212                this.frequentUsersThreshold = threshold; 
     213        } 
     214 
     215        /** 
     216         * <p> 
     217         * Returns the IDs of all frequent users. 
     218         * </p> 
     219         *  
     220         * @return IDs of the frequent users 
     221         */ 
     222        public List<String> getFrequentUsers() { 
     223                return frequentUsers; 
     224        } 
     225 
     226        /** 
     227         * <p> 
     228         * Returns the sequences of all frequent users. 
     229         * </p> 
     230         * </p> 
     231         *  
     232         * @return list of the sequences of all frequent users 
     233         */ 
     234        public List<Collection<List<WebEvent>>> getFrequentUserSequences() { 
     235                return sequencesFrequentUsers; 
    166236        } 
    167237 
     
    192262 
    193263                sequences = new ArrayList<List<WebEvent>>(); 
     264                users = new ArrayList<String>(); 
    194265 
    195266                int lineCounter = 0; 
     
    216287                        if (values.length == 6) { // post vars found 
    217288                                for (String postVar : values[5].trim().split(" ")) { 
    218                                         postedVars.add(postVar); 
     289                                        // TODO manual filtering of bad variables, should be 
     290                                        // automated 
     291                                        if (!postVar.contains("and")) { 
     292                                                postedVars.add(postVar); 
     293                                        } 
    219294                                } 
    220295                        } 
     
    236311                                                cookieSessionMap.put(cookie, sessionIds); 
    237312                                                sequences.add(new LinkedList<WebEvent>()); 
     313                                                users.add(cookie); 
    238314                                        } 
    239315                                        Integer lastSessionIndex = sessionIds 
     
    251327                                                newSession.add(event); 
    252328                                                sequences.add(newSession); 
     329                                                users.add(cookie); 
    253330                                        } else { 
    254331                                                lastSession.add(event); 
     
    260337                        } 
    261338                } 
     339                Console.traceln("" + sequences.size() + " user sequences found"); 
    262340                pruneSequences(); 
    263         } 
    264  
    265         /** 
    266          * <p> 
    267          * Prunes sequences shorter than {@link #minLength}. 
     341                Console.traceln("" + sequences.size() 
     342                                + " remaining after pruning of sequences shorter than " 
     343                                + minLength); 
     344                Set<String> uniqueUsers = new HashSet<String>(users); 
     345                Console.traceln("" + uniqueUsers.size() + " unique users"); 
     346                if (frequentUsersThreshold > 0) { 
     347                        generateFrequentUserSequences(uniqueUsers); 
     348                } 
     349        } 
     350 
     351        /** 
     352         * <p> 
     353         * Generates the frequent user sequences, according to the threshold 
     354         * {@link #frequentUsersThreshold}. 
     355         * </p> 
     356         *  
     357         * @param uniqueUsers 
     358         *            set with all user IDs 
     359         */ 
     360        private void generateFrequentUserSequences(Set<String> uniqueUsers) { 
     361                frequentUsers = new ArrayList<String>(); 
     362                sequencesFrequentUsers = new ArrayList<Collection<List<WebEvent>>>(); 
     363                for (String user : uniqueUsers) { 
     364                        List<String> tmp = new ArrayList<String>(); 
     365                        tmp.add(user); 
     366                        List<String> usersCopy = new LinkedList<String>(users); 
     367                        usersCopy.retainAll(tmp); 
     368                        int size = usersCopy.size(); 
     369                        if (size >= frequentUsersThreshold) { 
     370                                frequentUsers.add(user); 
     371                                Collection<List<WebEvent>> sequencesUser = new ArrayList<List<WebEvent>>(); 
     372                                for (int i = 0; i < sequences.size(); i++) { 
     373                                        if (users.get(i).equals(user)) { 
     374                                                sequencesUser.add(sequences.get(i)); 
     375                                        } 
     376                                } 
     377                                sequencesFrequentUsers.add(sequencesUser); 
     378 
     379                        } 
     380                } 
     381                Console.traceln("" + frequentUsers.size() + " users with more than " 
     382                                + frequentUsersThreshold + " sequences"); 
     383        } 
     384 
     385        /** 
     386         * <p> 
     387         * Prunes sequences shorter than {@link #minLength} and longer than 
     388         * {@link #maxLength}. 
    268389         * </p> 
    269390         */ 
    270391        private void pruneSequences() { 
    271                 Console.traceln("" + sequences.size() + " user sequences found"); 
    272                 // prune sequences shorter than min-length and longer than maxLength 
    273392                int i = 0; 
    274393                while (i < sequences.size()) { 
     
    276395                                        || sequences.get(i).size() > maxLength) { 
    277396                                sequences.remove(i); 
     397                                users.remove(i); 
    278398                        } else { 
    279399                                i++; 
    280400                        } 
    281401                } 
    282                 Console.traceln("" + sequences.size() 
    283                                 + " remaining after pruning of sequences shorter than " 
    284                                 + minLength); 
     402 
    285403        } 
    286404 
     
    338456                        for (String paramPair : paramPairs) { 
    339457                                String[] paramSplit = paramPair.split("="); 
    340                                 getVars.add(paramSplit[0]); 
     458                                // TODO manual filtering of bad variables, should be automated 
     459                                if (!paramSplit[0].contains("and")) { 
     460                                        getVars.add(paramSplit[0]); 
     461                                } 
    341462                        } 
    342463                } 
Note: See TracChangeset for help on using the changeset viewer.