private void startTag(String aPrefix, String aName, XmlPullParser aParser) throws Exception {
if ("entry".equals(aName)) {
tweets.addTweet(currentTweet = new Tweet());
} else if ("published".equals(aName)) {
aParser.next();
currentTweet.setPublished(dateFormat.parse(aParser.getText()));
} else if (("title".equals(aName)) && (currentTweet != null)) {
aParser.next();
currentTweet.setTitle(aParser.getText());
} else if ("content".equals(aName)) {
Content _c = new Content();
_c.setType(aParser.getAttributeValue(null, "type"));
aParser.next();
_c.setValue(aParser.getText());
currentTweet.setContent(_c);
} else if ("lang".equals(aName)) {
aParser.next();
currentTweet.setLanguage(aParser.getText());
} else if ("author".equals(aName)) {
currentTweet.setAuthor(currentAuthor = new Author());
} else if ("name".equals(aName)) {
aParser.next();
currentAuthor.setName(aParser.getText());
} else if ("uri".equals(aName)) {
aParser.next();
currentAuthor.setUri(aParser.getText());
}
}
/**
* Parses a string as a date
*
* @param str The string containing the date
* @return The date value parsed from the string
* @throws IOException If there's an error parsing the date
*/
public Object parseDate(String str, DateFormat dateFormat) throws IOException {
// If there isn't any, don't parse
if (str == null) return null;
try {
return dateFormat.parse(str);
} catch (ParseException exc) {
throw new IOException("Error parsing date " + str);
}
}
// 将从SQL数据库中选择出来的日期性字段格式化为本地日期描述
public String FormatDate(String DateStr) {
if (DateStr.equals(null) || DateStr.equals("")) {
return " - - ";
} else {
try {
DateFormat df = DateFormat.getDateInstance();
Date d = df.parse(DateStr);
df = DateFormat.getDateInstance(DateFormat.FULL);
return df.format(d);
} catch (ParseException e) {
System.err.println("bean_ElearnTools.FormatDate error: " + e.getMessage());
return DateStr;
}
}
}
// =====================================================
// setEXIFpictureMetadaten()
//
// Aus dem Image-Original werden die EXIF-Daten f�r die
// PM_PictureMetadatenX geholt und eingetragen
// =====================================================
public static void setEXIFpictureMetadaten(PM_Picture picture) {
PM_PictureImageMetadaten imageMetadaten = picture.getImageMetadaten();
// ----------------------------------------------------
// FujiFilm Makernote: SequenceNummer --> virtPicture
// ----------------------------------------------------
// -------------------------------------------------------
// Date
// ------------------------------------------------------
String tagDatum = "Date/Time Original";
String description = "";
if (imageMetadaten.hasTag(tagDatum)) {
description = imageMetadaten.getDescription(tagDatum);
}
// ----------------------------------------------------
// Datum nicht vorhanden oder ung�ltig
// ----------------------------------------------------
Date myDate = null;
if (description.length() == 0 || description.equals("0000:00:00 00:00:00")) {
// System.out.println("...... Datum = " + description + " kann nicht konvertiert
// werden");
File f = picture.getFileOriginal();
Date date = new Date(f.lastModified());
picture.meta.setDateImport(date);
picture.meta.setDateCurrent(new Date(date.getTime()));
return;
}
// ----------------------------------------------------
// g�ltiges Datum gefunden
// ----------------------------------------------------
DateFormat df = new SimpleDateFormat("yyyy:MM:dd HH:mm:ss");
try {
myDate = df.parse(description);
} catch (ParseException e) {
// System.out.println("ParseException fuer Datum = " + description);
myDate = new Date(System.currentTimeMillis()); // default
}
picture.meta.setDateImport(myDate);
picture.meta.setDateCurrent(new Date(myDate.getTime()));
}
/**
* Tries very, very hard to parse the a date. We assume that the text is neither empty nor <code>
* null</code>.
*/
private Date parseDate(String text) {
DateFormat formats[] =
new DateFormat[] {
DateFormat.getDateInstance(DateFormat.SHORT),
DateFormat.getDateInstance(DateFormat.MEDIUM),
DateFormat.getDateInstance(DateFormat.LONG),
DateFormat.getDateInstance(DateFormat.FULL),
};
for (int i = 0; i < formats.length; i++) {
DateFormat df = formats[i];
try {
Date date = df.parse(text);
return date;
} catch (ParseException ex) {
continue;
}
}
error("Could not parse date: " + text);
return null;
}
public static void main(String[] args) {
if (args.length != 2) {
System.out.println(
"Usage: java Purger <folder> <date>\n"
+ " - folder: is the path to account.txt and athena.txt files.\n"
+ " - date: accounts created before this date will be purged (dd/mm/yy or yyyy-mm-dd).");
return;
}
int accounts = 0;
int characters = 0;
int deletedCharacters = 0;
Vector activeAccounts = new Vector();
File folder = new File(args[0]);
// Do some sanity checking
if (!folder.exists()) {
System.out.println("Folder does not exist!");
return;
}
if (!folder.isDirectory()) {
System.out.println("Folder is not a folder!");
return;
}
File oldAccount = new File(folder, "account.txt");
File oldAthena = new File(folder, "athena.txt");
File newAccount = new File(folder, "account.txt.new");
File newAthena = new File(folder, "athena.txt.new");
DateFormat dateFormat;
Date purgeDate = null;
for (String format : new String[] {"dd/MM/yy", "yyyy-MM-dd"}) {
dateFormat = new SimpleDateFormat(format);
try {
purgeDate = dateFormat.parse(args[1]);
break;
} catch (ParseException e) {
}
}
if (purgeDate == null) {
System.out.println("ERROR: Date format not recognized.");
return;
}
String line;
// Remove accounts
try {
FileInputStream fin = new FileInputStream(oldAccount);
BufferedReader input = new BufferedReader(new InputStreamReader(fin));
FileOutputStream fout = new FileOutputStream(newAccount);
PrintStream output = new PrintStream(fout);
while ((line = input.readLine()) != null) {
boolean copy = false;
String[] fields = line.split("\t");
// Check if we're reading a comment or the last line
if (line.substring(0, 2).equals("//") || fields[1].charAt(0) == '%') {
copy = true;
} else {
// Server accounts should not be purged
if (!fields[4].equals("S")) {
accounts++;
dateFormat = new SimpleDateFormat("yyyy-MM-dd");
try {
Date date = dateFormat.parse(fields[3]);
if (date.after(purgeDate)) {
activeAccounts.add(fields[0]);
copy = true;
}
} catch (ParseException e) {
System.out.println(
"ERROR: Wrong date format in account.txt. (" + accounts + ": " + line + ")");
// return;
} catch (Exception e) {
e.printStackTrace();
return;
}
} else {
copy = true;
}
}
if (copy) {
try {
output.println(line);
} catch (Exception e) {
System.err.println("ERROR: Unable to write file.");
}
}
}
input.close();
output.close();
} catch (FileNotFoundException e) {
System.out.println("ERROR: file " + oldAccount.getAbsolutePath() + " not found.");
return;
} catch (Exception e) {
System.out.println("ERROR: unable to process account.txt");
e.printStackTrace();
return;
}
System.out.println(
"Removed " + (accounts - activeAccounts.size()) + "/" + accounts + " accounts.");
// Remove characters
try {
FileInputStream fin = new FileInputStream(oldAthena);
BufferedReader input = new BufferedReader(new InputStreamReader(fin));
FileOutputStream fout = new FileOutputStream(newAthena);
PrintStream output = new PrintStream(fout);
while ((line = input.readLine()) != null) {
boolean copy = false;
String[] fields = line.split("\t");
// Check if we're reading a comment or the last line
if (line.substring(0, 2).equals("//") || fields[1].charAt(0) == '%') {
copy = true;
} else {
characters++;
String id = fields[1].substring(0, fields[1].indexOf(','));
if (activeAccounts.contains(id)) {
copy = true;
} else {
deletedCharacters++;
}
}
if (copy) {
output.println(line);
}
}
input.close();
output.close();
} catch (FileNotFoundException e) {
System.out.println("ERROR: file " + oldAthena.getAbsolutePath() + " not found.");
return;
} catch (Exception e) {
System.out.println("ERROR: unable to process athena.txt");
e.printStackTrace();
return;
}
System.out.println("Removed " + deletedCharacters + "/" + characters + " characters.");
}
/**
* Displays a given Meeting page for a HTTP Get, or creates a new Meeting for a HTTP Post
*
* <p>- Requires a cookie for the session user - Requires a meetingId request parameter for a GET
* - Requires description, createdByUserId, datepicker, meetingTime, groupId request parameters
* for a POST
*
* @param req The HTTP Request
* @param res The HTTP Response
*/
public void meetingAction(HttpServletRequest req, HttpServletResponse res) {
// Ensure there is a cookie for the session user
if (AccountController.redirectIfNoCookie(req, res)) return;
Map<String, Object> viewData = new HashMap<String, Object>();
viewData.put("title", "Meeting");
// Initialise Manager connections
MeetingManager meetingMan = new MeetingManager();
GroupManager groupMan = new GroupManager();
if (req.getMethod() == HttpMethod.Get) {
// Get request parameter
int meetingId = Integer.parseInt(req.getParameter("meetingId"));
Meeting meeting = meetingMan.get(meetingId);
if (meeting != null) {
List<User> meetingUsers = groupMan.getGroupUsers(meeting.getGroupId());
viewData.put("meetingUsers", meetingUsers);
viewData.put("meeting", meeting);
view(req, res, "/views/group/Meeting.jsp", viewData);
} else {
httpNotFound(req, res);
}
} else if (req.getMethod() == HttpMethod.Post) {
// Get details from request
String description = req.getParameter("description");
int createdByUserId = Integer.parseInt(req.getParameter("createdByUserId"));
Date dateCreated = new Date();
String meetingDate = req.getParameter("datepicker");
String meetingTime = req.getParameter("meetingTime");
// Parse meeting date time details
DateFormat format = new SimpleDateFormat("MM/dd/yyyy HH:mm");
Date dateDue = new Date();
try {
dateDue = format.parse(meetingDate + " " + meetingTime);
} catch (ParseException e) {
// Unable to parse date. This shouldn't happen since we are
// performing javascript validation.
}
int groupId = Integer.parseInt(req.getParameter("groupId"));
// Create a Meeting
Meeting meeting = new Meeting();
meeting.setDescription(description);
meeting.setCreatedByUserId(createdByUserId);
meeting.setDateCreated(dateCreated);
meeting.setDateDue(dateDue);
meeting.setGroupId(groupId);
meetingMan.createMeeting(meeting);
int meetingId = meetingMan.getIdFor(meeting);
meeting.setId(meetingId);
UserManager userMan = new UserManager();
User createdByUser = userMan.get(createdByUserId);
// Create a notification for all users in group
NotificationManager notificationMan = new NotificationManager();
List<User> users = groupMan.getGroupUsers(groupId);
for (User u : users) {
Notification notification =
new Notification(
u.getId(),
u,
groupId,
null,
"Meeting " + description + " was created by " + createdByUser.getFullName(),
"/group/meeting?meetingId=" + meetingId);
notificationMan.createNotification(notification);
}
// Update the User Session to show new meeting
HttpSession session = req.getSession();
Session userSession = (Session) session.getAttribute("userSession");
User admin = userSession.getUser();
admin.getMeetings().add(meeting);
// Show meeting page
viewData.put("meetingUsers", users);
viewData.put("meeting", meeting);
view(req, res, "/views/group/Meeting.jsp", viewData);
}
}