/**
*
*/
package com.webaging.utils;

import java.util.Iterator;
import java.util.List;
import java.util.Properties;

import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;

/**
* @author Ashwin
*
*/
public class MailSender {

/**
* @param from
* @param to
* @param subject
* @param message
* @throws Exception
*/
public static void sendMail(String host, String fromAddress,
List toAddresses, String subject, String messageContent,
String[] attachments) throws Exception {
// Create empty properties
try {
Properties props = System.getProperties();
props.put("mail.pop3.host", host);
Session session = Session.getInstance(props, null);

MimeMessage message = new MimeMessage(session);
InternetAddress from = new InternetAddress(fromAddress);
message.setFrom(from);
message.setSubject(subject);

for (Iterator it = toAddresses.iterator(); it.hasNext();) {
message.addRecipient(Message.RecipientType.TO,
new InternetAddress((String) it.next()));
}

Multipart multipart = new MimeMultipart();
MimeBodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setContent(messageContent + "

", "text/html");
multipart.addBodyPart(messageBodyPart);

// add any file attachments to the message
addAtachments(attachments, multipart);

message.setContent(multipart);
// Now Send the message
Transport.send(message);

} catch (Exception e) {
throw e;
}

}

/**
* @param attachments
* @param multipart
* @throws MessagingException
* @throws AddressException
*/
protected static void addAtachments(String[] attachments,
Multipart multipart) throws MessagingException, AddressException {
for (int i = 0; i <= attachments.length - 1; i++) {
String filename = attachments[i];
MimeBodyPart attachmentBodyPart = new MimeBodyPart();

// use a JAF FileDataSource as it does MIME type detection
DataSource source = new FileDataSource(filename);
attachmentBodyPart.setDataHandler(new DataHandler(source));

// assume that the filename you want to send is the same as the
// actual file name - could alter this to remove the file path
attachmentBodyPart.setFileName(filename);

// add the attachment
multipart.addBodyPart(attachmentBodyPart);
}
}

}

package com.ashwin;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import javax.mail.Address;
import javax.mail.Authenticator;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.Part;
import javax.mail.Session;
import javax.mail.Store;
import javax.mail.event.FolderListener;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

public class MailReaderUtility {

public static void main(String[] args) {
Authenticator auth = null;
Folder folder = null;
Store store = null;
String comment = "";
String subject = "";
String from = "";

try {

auth = new SMTPAuthenticator(args[0],args[1]);

// Create empty properties
Properties props = System.getProperties();
props.put("mail.pop3.host", args[2]);
// get session
Session session = Session.getDefaultInstance(props, auth);
// Get the store
store = session.getStore("pop3");
store.connect();
// Get folder
FolderListener arg0;
// store.addFolderListener();

// store.addFolderListener();
folder = store.getFolder("INBOX");
folder.open(Folder.READ_WRITE);
// Get directory\\
Message message[] = folder.getMessages();
for (int i = 0, n = message.length; i < n; i++) {
Map dataStore = new HashMap();
Address[] addresses = message[i].getFrom();
InternetAddress address = (InternetAddress) addresses[0];
from = address.getAddress();
subject = message[i].getSubject();
dataStore.put("from", from);
dataStore.put("subject", subject);

if (((MimeMessage) message[i]).getContent() instanceof String) {
// content is texText
// System.out.println(((MimeMessage)
// message[i]).getContent());
comment = ((MimeMessage) message[i]).getContent()
.toString();
dataStore.put("comment", comment);
} else if (((MimeMessage) message[i]).getContent() instanceof Multipart
|| ((MimeMessage) message[i]).getContent() instanceof Part) {
Multipart multiPartcnt = (Multipart) ((MimeMessage) message[i])
.getContent();

Object content = message[i].getContent();
if (content instanceof Multipart) {
handleMultipart((Multipart) content, dataStore);
} else {
handlePart(message[i], dataStore);
}

comment = multiPartcnt.getBodyPart(0).getContent()
.toString();
// recursively iterate over container's contents to
// retrieve
// attachments
} else if (((MimeMessage) message[i]).getContent() instanceof Message) {
// message content could be a message itself
}

System.out.println("From: "+dataStore.get("from"));
System.out.println("Subject: "+dataStore.get("subject"));
String testComment = (String)dataStore.get("comment");
if(testComment.length() < 15){
System.out.println("Data: "+testComment.substring(0, testComment.length()));
}else{
System.out.println("Data: "+testComment.substring(0, 14));
}
System.out.println("------------------------------------");
}
}catch(Exception e){
e.printStackTrace();
}

}

public static void handleMultipart(Multipart multipart,
Map dataStore) throws MessagingException,
IOException {
for (int i = 0, n = multipart.getCount(); i < n; i++) {
handlePart(multipart.getBodyPart(i), dataStore);
}
}

public static void handlePart(Part part, Map dataStore)
throws MessagingException, IOException {
String disposition = part.getDisposition();
String contentType = part.getContentType();
// System.out.println("In Handle Part : " + contentType);
if (disposition == null) { // When just body
// System.out.println("Null: " + contentType);
// Check if plain
if ((contentType.length() >= 10)
&& (contentType.toLowerCase().substring(0, 10)
.equals("text/plain"))) {
// part.writeTo(System.out);
dataStore.put("comment", part.getContent().toString());
} else { // Don't think this will happen
// System.out.println("Other body: " + contentType);
dataStore.put("comment", part.getContent().toString());
}
} else if (disposition.equalsIgnoreCase(Part.ATTACHMENT)) {
// System.out.println("Attachment: " + part.getFileName() + " : "+
// contentType);
List fileNames = (List) dataStore.get("attachment");
if (fileNames == null) {
fileNames = new ArrayList();
}
fileNames.add(part.getFileName());
dataStore.put("attachment", fileNames);
//saveFile(part.getFileName(), part.getInputStream());
} else if (disposition.equalsIgnoreCase(Part.INLINE)) {
// System.out.println("Inline: " + part.getFileName() + " : " +
// contentType);
//saveFile(part.getFileName(), part.getInputStream());
} else { // Should never happen
// System.out.println("Other: " + disposition);
}
}
}

import javax.mail.Authenticator;
import javax.mail.PasswordAuthentication;

/**
* @author ashwin
*
*/
public class SMTPAuthenticator extends Authenticator
{
String masteruser = null;
String masterpswd = null;

SMTPAuthenticator(String user, String password)
{
masteruser = user;
masterpswd = password;
}
public PasswordAuthentication getPasswordAuthentication()
{

/**
*
*/
package com.pos;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Iterator;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageOutputStream;
import javax.swing.JApplet;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTextArea;

/**
* @author Ashwin
*
*/
public class PaintApplet extends JApplet {

public BufferedImage image = null;
private JPanel canvas = new JPanel();
private JPanel colorPanel = new JPanel();
private Point lastPos = null;
private Button captureButton = new Button("Capture");
private Graphics gc;
Graphics2D imageG = null;

/*
* (non-Javadoc)
*
* @see java.applet.Applet#init()
*/
@Override
public void init() {
// TODO Auto-generated method stub
super.init();

setSize(600, 200);

image = new BufferedImage(getWidth(), getHeight(),
BufferedImage.TYPE_INT_ARGB);

// get the image Graphics object
imageG = image.createGraphics();
colorPanel.setLayout(new GridLayout());
canvas.setSize(getWidth(), getHeight());

captureButton.setSize(100, 50);
getContentPane().add(captureButton);
getContentPane().add(canvas, BorderLayout.CENTER);
setVisible(true);

// get the Graphics Context
gc = canvas.getGraphics();
canvas.setBackground(Color.GRAY);
gc.setColor(Color.GRAY);
gc.fillRect(0, 0, image.getWidth(), image.getHeight());
gc.setColor(Color.BLACK);

imageG.setBackground(Color.GRAY);
imageG.setColor(Color.GRAY);
imageG.fillRect(0, 0, image.getWidth(), image.getHeight());
imageG.setColor(Color.BLACK);

captureButton.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent a) {
try {
Container cp = getContentPane();
final Component comp = cp.add(new JSplitPane(
JSplitPane.HORIZONTAL_SPLIT, new JScrollPane(
new JTextArea()), new JScrollPane(
new JTextArea())));
// cp.add(canvas);

File filetoSave = new File("c:\\temp\\test4.jpeg");

// If the file does not exist or the user gives permission,
// save image to file.

ImageWriter writer = null;
ImageOutputStream ios = null;

try {
// Obtain a writer based on the jpeg format.

Iterator iter;
iter = ImageIO.getImageWritersByFormatName("jpeg");

// Validate existence of writer.

if (!iter.hasNext()) {
return;
}

// Extract writer.

writer = (ImageWriter) iter.next();

// Configure writer output destination.

ios = ImageIO.createImageOutputStream(filetoSave);
writer.setOutput(ios);

// Set JPEG compression quality to 95%.

ImageWriteParam iwp = writer.getDefaultWriteParam();
iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
iwp.setCompressionQuality(0.95f);

// Write the image.

writer.write(null, new IIOImage((BufferedImage) image,
null, null), iwp);
} catch (IOException e2) {
e2.getMessage();
} finally {
try {
// Cleanup.

if (ios != null) {
ios.flush();
ios.close();
}

if (writer != null)
writer.dispose();
} catch (IOException e2) {
}
}

} catch (Exception e) {
System.err.println(e);
}
}
});

canvas.addMouseMotionListener(new MouseMotionListener() {
public void mouseDragged(MouseEvent m) {
// the mouse(pen) was dragged, so the pixels at coords found in
// MouseEvent m must be updated with current color
Point p = m.getPoint();
gc.drawLine(lastPos.x, lastPos.y, p.x, p.y);
imageG.drawLine(lastPos.x, lastPos.y, p.x, p.y);
lastPos = p;
}

public void mouseMoved(MouseEvent m) {
}
});
canvas.addMouseListener(new MouseListener() {
public void mouseClicked(MouseEvent e) {
}

public void mousePressed(MouseEvent e) {
lastPos = e.getPoint();
}

public void mouseReleased(MouseEvent e) {
lastPos = null;
}

public void mouseEntered(MouseEvent e) {
}

public void mouseExited(MouseEvent e) {
}
});
}

/**
*
*/
public PaintApplet() {
}

public static void main(String[] args) {
PaintApplet p = new PaintApplet();
}
}

/**
*
*/
package com.pos;

import java.awt.Dimension;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.io.File;

import javax.imageio.ImageIO;

/**
* @author Ashwin
*
*/
public class Screenshot {
public static void main(String[] args) throws Exception {
// make sure we have exactly two arguments,
// a waiting period and a file name
if (args.length != 2) {
System.err.println("Usage: java Screenshot "
+ "WAITSECONDS OUTFILE.png");
System.exit(1);
}
// check if file name is valid
String outFileName = args[1];
if (!outFileName.toLowerCase().endsWith(".png")) {
System.err.println("Error: output file name must "
+ "end with \".png\".");
System.exit(1);
}
// wait for a user-specified time
try {
long time = Long.parseLong(args[0]) * 1000L;
System.out.println("Waiting " + (time / 1000L) + " second(s)...");
Thread.sleep(time);
} catch (NumberFormatException nfe) {
System.err.println(args[0] + " does not seem to be a "
+ "valid number of seconds.");
System.exit(1);
}
// determine current screen size
Toolkit toolkit = Toolkit.getDefaultToolkit();
Dimension screenSize = toolkit.getScreenSize();
Rectangle screenRect = new Rectangle(screenSize);
// create screen shot
Robot robot = new Robot();
BufferedImage image = robot.createScreenCapture(screenRect);
// save captured image to PNG file
ImageIO.write(image, "png", new File(outFileName));
// give feedback
System.out.println("Saved screen shot (" + image.getWidth() + " x "
+ image.getHeight() + " pixels) to file\"" + outFileName
+ "\".");
// use System.exit if the program hangs after writing the file;
// that's an old bug which got fixed only recently
// System.exit(0);
}
}

DHTML Web Tab Control

<!--

// Tab Name | URL | * (Default Selected Tab)
var tabs = new Array
(
"MSDN|http://msdn.microsoft.com",
"CNN|http://www.cnn.com",
"NASA|http://www.nasa.gov",
"Google|http://www.google.com|*",
"Forbes|http://www.forbes.com"
);

// Align Tab: LEFT, CENTER, RIGHT
var tabAlign = "RIGHT";

/*********************************************/

function tabOnClick(ID)
{
var oElement = null;

for (var i = 0; i < tabs.length; i++)
{
oElement = document.getElementById(i);
oElement.className = "tabOff";
}

oElement = document.getElementById(ID);
oElement.className = "tabOn";

var tab = tabs[ID].split("|");
divTabFrame.innerHTML = "";

document.body.focus();
}

function tabLoad()
{
var HTML = "";

HTML += "

";
for (var i = 0; i < tabs.length; i++)
{
var tab = tabs[i].split("|");
HTML += " ";
}

divTabButtons.innerHTML = HTML;

for (var i = 0; i

Rico.loadModule('LiveGridAjax','LiveGridMenu','greenHdg.css');
Rico.loadModule('LiveGridMenu');

Rico.onLoad( function() {
var buffer = new Rico.Buffer.AjaxXML('test.xml');
var opts = {
useUnformattedColWidth: false,
defaultWidth : 90,
visibleRows : 'data',
frozenColumns: 1,
canPrint: false,
highltOnMouseOver: true,
rowHighlightColor: '#c4c4c5',
specFilterSort: {type:'raw', canSort:true, canFilter:true, quotes:"'"},
specFilter: {type:'raw', canSort:false, canFilter:true, quotes:"'"},
specSort: {type:'raw', canSort:true, canFilter:false, quotes:"'"},
columnSpecs : ['specSort','specFilterSort','specSort','specSort','specFilterSort']
};
var grid = new Rico.LiveGrid('data_grid', buffer, opts);
grid.menu=new Rico.GridMenu();

});

import javax.servlet.ServletContext;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
* @author Ashwin Gets System variables that were loaded at server startup from
* the server.properties file
*/
public class PropertyLoader {
private static final Log log = LogFactory.getLog(PropertyLoader.class);
private static boolean initializedFromFile = false;

/**
* Get the Property From Server.properties. This is used when we want to
* read property from file each and every time
*
* @param key
* @return
*/
public static String getProperty(String key) {
Properties props = new Properties();
InputStream stream = PropertyLoader.class
.getResourceAsStream("/server.properties");
try {
props.load(stream);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return props.getProperty(key);
}

/**
* This is used when we just want to load all properties loaded and are sure
* that those dont change while server is running thereby reducing load of
* reading from file
*
* Get the value of the key passed.
*
* @param key
* the token
* @return the value if there is one, otherwise null
*/
public static final String getSystemString(String key) {
String value = null;
try {
value = System.getProperty(key);

} catch (NullPointerException e) {
// ignore just return null;
}
return value;
}

/**
* Gets the boolean value if the string equalsIgnoreCase true, otherwise
* false.
*
* @param key
* the token
* @return true if the value is ignorecase true all other values including
* null return false.
*/
public static final boolean getBoolean(String key) {
String token = getSystemString(key);
if (token == null) {
return false;
}
if (token.equalsIgnoreCase("true")) {
return true;
}
return false;
}

public static final void loadSystemProperties() throws IOException {
loadSystemProperties("/server.properties");
}

/**
* Give the classpath qualified name of the filename to load, e.g.
*
*

	 *  /config.properties
	 * 

*
* @param file
* the classpath qualified filename of the file to load
*/
public static final void loadSystemProperties(String file)
throws IOException {
Properties props = new Properties();
InputStream stream = PropertyLoader.class.getResourceAsStream(file);
props.load(stream);

Iterator iterator = props.keySet().iterator();
while (iterator.hasNext()) {
String key = (String) iterator.next();
String value = props.getProperty(key);
System.getProperties().setProperty(key, value);
}
initializedFromFile = true;
}

/**
* Sets the property and returns the previous value
*
* @param key
* @param value
*/
public static final String setSystemProperty(String key, String value) {
if (!initializedFromFile) {
log
.warn("Attempting to set System Property "
+ key
+ " to "
+ value
+ " but the file System Properties have not yet been read.");
}
return System.setProperty(key, value);
}

/**
* Replaces all config parameters in the string with the actual values.
* Parameters are in the form ${PARAM_NAME}. If a parameter tag is
* encountered, and the corresponding value cannot be retrieved, an
* exception will be generated.
*/
public static void resolveParameterTags(StringBuffer sb) {
int basePos = 0;
String rstr = sb.toString();
final String tagStartToken = "${";
final String tagEndToken = "}";
int pos = rstr.indexOf(tagStartToken);

while (pos >= 0) {
int endPos = rstr.indexOf(tagEndToken, pos);

if (endPos < 0) {
String msg = "Parameter tag not closed: " + rstr;
throw new IllegalArgumentException(msg);
}

String pName = rstr.substring(pos + tagStartToken.length(), endPos);
String parameterValue = getSystemString(pName);

if (parameterValue == null || "".equals(parameterValue)) {
String msg = "Missing configuration parameter " + pName
+ " for tag " + rstr;
throw new IllegalArgumentException(msg);
}

// replace the parameter
sb.replace(basePos + pos, basePos + endPos + tagEndToken.length(),
parameterValue);

// point base position to the rest of the string
basePos = basePos + pos + parameterValue.length();
rstr = sb.substring(basePos);
pos = rstr.indexOf(tagStartToken);
}
}

public static long getLong(String key, long i) {
String token = getSystemString(key);
if (token == null) {
return i;
}
return Long.parseLong(token);
}

public static int getInt(String key, int i) {
String token = getSystemString(key);
if (token == null) {
return i;
}
return Integer.parseInt(token);
}

public static void loadSystemProperties(ServletContext servletContext,
String file) throws IOException {
// TODO Auto-generated method stub
Properties props = new Properties();
InputStream stream = servletContext.getResourceAsStream(file);
props.load(stream);

Iterator iterator = props.keySet().iterator();
while (iterator.hasNext()) {
String key = (String) iterator.next();
String value = props.getProperty(key);
System.getProperties().setProperty(key, value);
}
initializedFromFile = true;

}
}

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
* @author Ashwin
*
*/
public class ObjectGrapher {

/**
* @param args
*/
public static void main(String[] args) {
try {
Connection con = DBUtils.getConnection();
DatabaseMetaData metaData = con.getMetaData();
ResultSet rs = metaData.getTables(null, null, "%", null);
List tableNamesList = new ArrayList();
Map tableMap = new HashMap();

while (rs.next()) {
String tableName = rs.getString(3);
tableNamesList.add(tableName);
}
if (rs != null) {
rs.close();
}

// Iterate Throught the List
for (int i = 0; i < tableNamesList.size(); i++) {

for (int j = 0; j < tableNamesList.size(); j++) {

// If both are same tablename we dnt need to find any
// relation
if (i == j) {
continue;
}

String primaryTable = (String) tableNamesList.get(i);
String foreignTable = (String) tableNamesList.get(j);

rs = metaData.getCrossReference(null, null, primaryTable,
null, null, foreignTable);

while (rs.next()) {
DBTable primaryDBTable = null;
DBTable foreignDBTable = null;

String primaryTableName = rs.getString("PKTABLE_NAME");
String foreignTableName = rs.getString("FKTABLE_NAME");

if (tableMap.get(primaryTableName) != null) {
primaryDBTable = (DBTable) tableMap
.get(primaryTableName);
} else {
primaryDBTable = new DBTable();
primaryDBTable.setTableName(primaryTableName);
}

if (tableMap.get(foreignTableName) != null) {
foreignDBTable = (DBTable) tableMap
.get(foreignTableName);
} else {
foreignDBTable = new DBTable();
foreignDBTable.setTableName(foreignTableName);
}

foreignDBTable.addRelations(primaryDBTable);

tableMap.put(foreignTableName, foreignDBTable);
tableMap.put(primaryTableName, primaryDBTable);

System.out.println("Primary Key Table Name :"
+ rs.getString("PKTABLE_NAME")
+ " Primary Key Column :"
+ rs.getString("PKCOLUMN_NAME"));
System.out.println("Foreign Key Table Name :"
+ rs.getString("FKTABLE_NAME")
+ " Foreign Key Column :"
+ rs.getString("FKCOLUMN_NAME"));
System.out
.println("--------------------------------------------------------------------");
}

if (rs != null) {
rs.close();
}
}
}

} catch (Exception e) {
e.printStackTrace();
}
}

SystemDAO.getBucketTypes(callbackProxy);
}