Please take time to read the code disclaimer.

<--Go back to Kent's Projects

<--Go back to project post

package metadatagenerator;

import broadscope.StaticClass;
import java.io.*;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.*;

/**
 *
 * @author Kent
 */
public class Conference {

  private ConferenceMDGenerator owner;
  private String name = "";
  private String landingPage = "";
  private String conferenceString = "";
  private Language englishLanguage = null;
  private LinkedList sessionsList = new LinkedList();
  private boolean selected = false;
  private boolean ignore = false;
  private Map conferenceUrlMap = new TreeMap();
  //
  //Strings
  private String newSessionString = "";
  private String sessionNameString = "";
  private String sessionNameString2 = "\\r\\s*";
  //Patterns
  private Pattern newSessionPattern = Pattern.compile(newSessionString, Pattern.DOTALL);
  private Pattern sessionNamePattern = Pattern.compile(sessionNameString, Pattern.DOTALL);
  private Pattern sessionNamePattern2 = Pattern.compile(sessionNameString2, Pattern.DOTALL);
  //

  /**
   * This is the constructor
   * @param owner the ConferenceMDGenerator which got this conference
   */
  public Conference(ConferenceMDGenerator owner) {
    this.owner = owner;
  }

  /**
   * This method will read the information we need from the web
   */
  public void conferenceReader() {
    try {
      String languagesStartString = "";
      Pattern languagesStartPattern = Pattern.compile(languagesStartString, Pattern.DOTALL);
      BufferedReader reader = StaticClass.getBufferedReader(landingPage);
      String line = "";
      StringBuilder totalStringBuilder = new StringBuilder();
      boolean readNextLine = true;
      //Scanner
      line = reader.readLine();
      while (line != null) {
        if (!readNextLine) {
          readNextLine = true;
        }
        totalStringBuilder.append(line).append(StaticClass.newline);
        if (newSessionPattern.matcher(line).find()) {
          line = readAllSessions(reader, line);
          readNextLine = false;
        } else if (languagesStartPattern.matcher(line).find()) {
          readAllLanguages(reader, line);
        }
        if (readNextLine) {
          line = reader.readLine();
        }
      }
      conferenceString = totalStringBuilder.toString();
    } catch (IOException ex) {
      Logger.getLogger(Conference.class.getName()).log(Level.SEVERE, null, ex);
    }
  }

  //
  /**
   * This method will loop through sessions
   * @param reader
   * @param line
   * @return line - changed
   * @throws IOException  
   */
  public String readAllSessions(BufferedReader reader, String line) throws IOException {
    String endSessionsString = "";
    String sessionTalksString = "(.*?)"; //1: URL, 2: Title
    String sessionTalksString2 = "(.*?)"; //1: Speaker
    Pattern endSessionsPattern = Pattern.compile(endSessionsString, Pattern.DOTALL);
    Pattern sessionTalksPattern = Pattern.compile(sessionTalksString, Pattern.DOTALL);
    Pattern sessionTalksPattern2 = Pattern.compile(sessionTalksString2, Pattern.DOTALL);
    StringBuilder sessionStringBuilder = new StringBuilder();
    sessionStringBuilder.append(line);
    boolean endSessionsScan = false;
    boolean scanNewSession = false;
    while (!endSessionsScan) {
      while ((line = reader.readLine()) != null && !endSessionsScan && !scanNewSession) {
        if (sessionNamePattern.matcher(line).find() || sessionNamePattern2.matcher(line).find() || sessionTalksPattern.matcher(line).find() || sessionTalksPattern2.matcher(line).find()) {
          sessionStringBuilder.append(line);
        } else if (newSessionPattern.matcher(line).find()) {
          scanNewSession = true;
        }
        if (endSessionsPattern.matcher(line).find()) {
          endSessionsScan = true;
        }
      }
      regexSession(sessionStringBuilder.toString());
      sessionStringBuilder = new StringBuilder();
      scanNewSession = false;
    }
    return line;
  }

  /**
   * This method will regex the session string to create a new session type or add it to a current session type
   * @param sessionString 
   */
  public void regexSession(String sessionString) {
    SessionType newSessionType = null;
    Matcher sessionNameMatcher = sessionNamePattern.matcher(sessionString);
    Matcher sessionNameMatcher2 = sessionNamePattern2.matcher(sessionString);
    Matcher nameMatcher = null;
    if (sessionNameMatcher.find()) {
      nameMatcher = sessionNameMatcher;
    } else if (sessionNameMatcher2.find()) {
      nameMatcher = sessionNameMatcher2;
    }
    boolean found = false;
    String sessionName = nameMatcher.group(1);
    sessionName = sessionName.replaceAll("[S-s]ession", "").trim();
    for (SessionType sessionType : owner.getAllSessionTypesList()) {
      if (sessionType.getName().equals(sessionName)) {
        newSessionType = sessionType;
        found = true;
        break;
      }
    }
    if (!found) {
      newSessionType = new SessionType();
      newSessionType.setName(sessionName);
      owner.getAllSessionTypesList().add(newSessionType);
    }
    Session newSession = new Session(this, newSessionType);
    newSession.setSessionString(sessionString);
    newSession.regExTalks();
    sessionsList.add(newSession);
    newSessionType.getSessionList().add(newSession);
  }
  //

  //
  /**
   * This method will read all the languages
   * @param reader
   * @param line
   * @throws IOException  
   */
  public void readAllLanguages(BufferedReader reader, String line) throws IOException {
    StringBuilder languagesStringBuilder = new StringBuilder();
    String languagesEndString = "";
    Pattern languagesEndPattern = Pattern.compile(languagesEndString, Pattern.DOTALL);
    do {
      languagesStringBuilder.append(line);
      if (languagesEndPattern.matcher(line).find()) {
        break;
      } else {
        line = reader.readLine();
      }
    } while (!languagesEndPattern.matcher(line).find());
    regexLangauges(languagesStringBuilder.toString());
  }

  /**
   * This method will regex the languages string to get all the languages in which the conference is available
   * @param languagesString to be regexed
   */
  public void regexLangauges(String languagesString) {
    String languageString = "(.*?)"; //group1: conferenceURL, group2: abb, group3: englishName, group4: name;
    Pattern languagePattern = Pattern.compile(languageString, Pattern.DOTALL);
    Matcher languageMatcher = languagePattern.matcher(languagesString);
    while (languageMatcher.find()) {
      boolean found = false;
      LanguageType languageType = null;
      for (LanguageType conferenceLanguageType : owner.getAllLanguageTypesList()) {
        if (conferenceLanguageType.getEnglishName().equals(languageMatcher.group(3))) {
          languageType = conferenceLanguageType;
          found = true;
          break;
        }
      }
      if (!found) {
        languageType = new LanguageType();
        languageType.setAbb(languageMatcher.group(2));
        languageType.setEnglishName(languageMatcher.group(3));
        languageType.setName(languageMatcher.group(4));
        languageType.resetMormonSite();
        owner.getAllLanguageTypesList().add(languageType);
      }
      conferenceUrlMap.put(languageType.getEnglishName(), languageMatcher.group(1).replace("&", "&"));
    }
  }

  //
  //
  /**
   * @return the landingPage
   */
  public String getLandingPage() {
    return landingPage;
  }

  /**
   * @param landingPage the landingPage to set
   */
  public void setLandingPage(String landingPage) {
    this.landingPage = landingPage;
  }

  /**
   * @return the sessionsList
   */
  public LinkedList getSessionsList() {
    return sessionsList;
  }

  /**
   * @param sessionsList the sessionsList to set
   */
  public void setSessionsList(LinkedList sessionsList) {
    this.sessionsList = sessionsList;
  }

  /**
   * @return the name
   */
  public String getName() {
    return name;
  }

  /**
   * @param name the name to set
   */
  public void setName(String name) {
    this.name = name;
  }

  /**
   * @return the conferenceString
   */
  public String getConferenceString() {
    return conferenceString;
  }

  /**
   * @param conferenceString the conferenceString to set
   */
  public void setConferenceString(String conferenceString) {
    this.conferenceString = conferenceString;
  }

  /**
   * @return the selected
   */
  public boolean isSelected() {
    return selected;
  }

  /**
   * @param selected the selected to set
   */
  public void setSelected(boolean selected) {
    this.selected = selected;
  }

  /**
   * @return the owner
   */
  public ConferenceMDGenerator getOwner() {
    return owner;
  }

  /**
   * @param owner the owner to set
   */
  public void setOwner(ConferenceMDGenerator owner) {
    this.owner = owner;
  }

  /**
   * @return the ignore
   */
  public boolean isIgnore() {
    return ignore;
  }

  /**
   * @param ignore the ignore to set
   */
  public void setIgnore(boolean ignore) {
    this.ignore = ignore;
  }

  /**
   * @return the englishLanguage
   */
  public Language getEnglishLanguage() {
    return englishLanguage;
  }

  /**
   * @param englishLanguage the englishLanguage to set
   */
  public void setEnglishLanguage(Language englishLanguage) {
    this.englishLanguage = englishLanguage;
  }

  /**
   * @return the conferenceUrlMap
   */
  public Map getConferenceUrlMap() {
    return conferenceUrlMap;
  }

  /**
   * @param conferenceUrlMap the conferenceUrlMap to set
   */
  public void setConferenceUrlMap(Map conferenceUrlMap) {
    this.conferenceUrlMap = conferenceUrlMap;
  }
  //

  @Override
  public String toString() {
    return name;
  }
}
    
(.*?)
(.*?)