public void save() {
boolean isNoticed = false;
if (!notice.isVisible()) {
isNoticed = true;
notice.setVisible(true);
notice.setText("Saving...");
}
if (getOptions() != null) {
DB database = null;
try {
database = factory.open(this.leveldbStore.getSelectedFile(), getOptions());
DBIterator iterator = database.iterator();
HashSet<byte[]> keys = new HashSet<>();
for (iterator.seekToFirst(); iterator.hasNext(); iterator.next()) {
keys.add(iterator.peekNext().getKey());
}
iterator.close();
for (byte[] key : keys) {
database.delete(key);
}
for (int i = 0; i < dataList.getModel().getSize(); ++i) {
DBItem item = dataList.getModel().getElementAt(i);
database.put(item.key, item.value);
}
} catch (Exception e) {
JOptionPane.showMessageDialog(pane, "Unable to open database:\n" + e);
e.printStackTrace();
} finally {
if (database != null) {
try {
database.close();
} catch (IOException e) {
JOptionPane.showMessageDialog(pane, "Unable to close database:\n" + e);
e.printStackTrace();
}
}
saveButton.setEnabled(false);
}
}
if (isNoticed) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
notice.setVisible(false);
notice.setText("");
}
}
/**
* ************************************************************************ Start Workflow.
*
* @param AD_Workflow_ID workflow
* @return true if started
*/
private boolean startWorkflow(int AD_Workflow_ID) {
log.fine(AD_Workflow_ID + " - " + m_pi);
boolean started = false;
if (DB.isRemoteProcess()) {
log.info("trying to running on the server");
Server server = CConnection.get().getServer();
try {
if (server != null) { // See ServerBean
log.info("running on the server");
m_pi = server.workflow(m_wscctx, m_pi, AD_Workflow_ID);
log.finest("server => " + m_pi);
started = true;
}
} catch (Exception ex) {
log.log(Level.SEVERE, "AppsServer error", ex);
started = false;
}
}
// Run locally
if (!started && !m_IsServerProcess) {
log.info("running locally");
MWorkflow wf = MWorkflow.get(m_wscctx, AD_Workflow_ID);
MWFProcess wfProcess = null;
if (m_pi.isBatch()) wfProcess = wf.start(m_pi); // may return null
else wfProcess = wf.startWait(m_pi); // may return null
started = wfProcess != null;
}
return started;
} // startWorkflow
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String deleteProductValue = "false";
try {
// Get the form data
int productID = Integer.parseInt(request.getParameter("productID"));
PrintWriter out = response.getWriter();
DB db = mongo.getDB("FashionFactoryProd");
DBCollection myProducts = db.getCollection("productInfo");
DBCollection myTrending = db.getCollection("myTrending");
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("productID", productID);
DBCursor cursor = myProducts.find(searchQuery);
if (cursor.count() == 0) {
deleteProductValue = "false";
request.setAttribute("deleteProductValue", deleteProductValue);
RequestDispatcher rd = request.getRequestDispatcher("deleteProduct.jsp");
rd.forward(request, response);
} else {
int product = 0;
while (cursor.hasNext()) {
BasicDBObject obj = (BasicDBObject) cursor.next();
product = obj.getInt("productID");
if (product == productID) {
myProducts.remove(obj);
myTrending.remove(searchQuery);
deleteProductValue = "true";
request.setAttribute("deleteProductValue", deleteProductValue);
RequestDispatcher rd = request.getRequestDispatcher("deleteProduct.jsp");
rd.forward(request, response);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public void delete(byte[] key) {
if (getOptions() != null) {
DB database = null;
try {
database = factory.open(this.leveldbStore.getSelectedFile(), getOptions());
database.delete(key);
} catch (Exception e) {
JOptionPane.showMessageDialog(pane, "Unable to open database:\n" + e);
e.printStackTrace();
} finally {
if (database != null) {
try {
database.close();
} catch (IOException e) {
JOptionPane.showMessageDialog(pane, "Unable to close database:\n" + e);
e.printStackTrace();
}
}
}
}
}
/**
* Load Regions (cached)
*
* @param ctx context
*/
private static void loadAllRegions(Ctx ctx) {
String sql = "SELECT * FROM C_Region WHERE IsActive='Y'";
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt = DB.prepareStatement(sql, (Trx) null);
rs = pstmt.executeQuery();
while (rs.next()) {
MRegion r = new MRegion(ctx, rs, null);
s_regions.put(String.valueOf(r.getC_Region_ID()), r);
if (r.isDefault()) s_default = r;
}
} catch (SQLException e) {
s_log.log(Level.SEVERE, sql, e);
} finally {
DB.closeResultSet(rs);
DB.closeStatement(pstmt);
}
s_log.fine(s_regions.size() + " - default=" + s_default);
} // loadAllRegions
/**
* ************************************************************************ Start Java Process
* Class. instanciate the class implementing the interface ProcessCall. The class can be a
* Server/Client class (when in Package org compiere.process or org.compiere.model) or a client
* only class (e.g. in org.compiere.report)
*
* @return true if success
*/
private boolean startProcess() {
log.fine(m_pi.toString());
boolean started = false;
if (DB.isRemoteProcess()) {
Server server = CConnection.get().getServer();
try {
if (server != null) { // See ServerBean
m_pi = server.process(m_wscctx, m_pi);
log.finest("server => " + m_pi);
started = true;
}
} catch (UndeclaredThrowableException ex) {
Throwable cause = ex.getCause();
if (cause != null) {
if (cause instanceof InvalidClassException)
log.log(
Level.SEVERE, "Version Server <> Client: " + cause.toString() + " - " + m_pi, ex);
else
log.log(Level.SEVERE, "AppsServer error(1b): " + cause.toString() + " - " + m_pi, ex);
} else log.log(Level.SEVERE, " AppsServer error(1) - " + m_pi, ex);
started = false;
} catch (Exception ex) {
Throwable cause = ex.getCause();
if (cause == null) cause = ex;
log.log(Level.SEVERE, "AppsServer error - " + m_pi, cause);
started = false;
}
}
// Run locally
if (!started && !m_IsServerProcess) {
ProcessCall myObject = null;
try {
Class myClass = Class.forName(m_pi.getClassName());
myObject = (ProcessCall) myClass.newInstance();
if (myObject == null) m_pi.setSummary("No Instance for " + m_pi.getClassName(), true);
else myObject.startProcess(m_wscctx, m_pi, m_trx);
if (m_trx != null) {
m_trx.commit();
m_trx.close();
}
} catch (Exception e) {
if (m_trx != null) {
m_trx.rollback();
m_trx.close();
}
m_pi.setSummary("Error starting Class " + m_pi.getClassName(), true);
log.log(Level.SEVERE, m_pi.getClassName(), e);
}
}
return !m_pi.isError();
} // startProcess
void checkAuth(DB db) {
if (db._username == null) return;
if (_authed.containsKey(db)) return;
if (_inauth) return;
_inauth = true;
try {
if (db.reauth()) {
_authed.put(db, true);
return;
}
} finally {
_inauth = false;
}
throw new MongoInternalException("can't reauth!");
}
/**
* ************************************************************************ Start Database Process
*
* @param ProcedureName PL/SQL procedure name
* @return true if success
*/
private boolean startDBProcess(String ProcedureName) {
// execute on this thread/connection
log.fine(ProcedureName + "(" + m_pi.getAD_PInstance_ID() + ")");
String sql = "{call " + ProcedureName + "(?)}";
try {
CallableStatement cstmt = DB.prepareCall(sql, ResultSet.CONCUR_UPDATABLE, null); // ro??
cstmt.setInt(1, m_pi.getAD_PInstance_ID());
cstmt.executeUpdate();
cstmt.close();
} catch (Exception e) {
log.log(Level.SEVERE, sql, e);
m_pi.setSummary(Msg.getMsg(m_wscctx, "ProcessRunError") + " " + e.getLocalizedMessage());
m_pi.setError(true);
return false;
}
// log.fine(Log.l4_Data, "ProcessCtl.startProcess - done");
return true;
} // startDBProcess
public void openDatabase(File select) {
if (getOptions() != null) {
DB database = null;
try {
database = factory.open(select, getOptions());
DBIterator iterator = database.iterator();
ArrayList<DBItem> data = new ArrayList<>();
String reg = findField.getText().trim();
for (iterator.seekToFirst(); iterator.hasNext(); iterator.next()) {
if (reg.isEmpty()
|| new BigInteger(iterator.peekNext().getKey()).toString(16).contains(reg)
|| LevelDBViewer.toHexString(iterator.peekNext().getKey()).contains(reg)
|| new BigInteger(iterator.peekNext().getValue()).toString(16).contains(reg)
|| LevelDBViewer.toHexString(iterator.peekNext().getValue()).contains(reg)
|| new String(iterator.peekNext().getKey()).contains(reg)
|| new String(iterator.peekNext().getValue()).contains(reg)) {
data.add(new DBItem(iterator.peekNext().getKey(), iterator.peekNext().getValue()));
}
}
iterator.close();
dialog.getRootPane().setDefaultButton(putButton);
dataList.getSelectionModel().clearSelection();
dataList.setListData(data.toArray(new DBItem[data.size()]));
putButton.setEnabled(true);
key.setEnabled(true);
value.setEnabled(true);
findField.setEnabled(true);
deleteButton.setEnabled(true);
putType.setEnabled(true);
signedBox.setEnabled(true);
// saveButton.setEnabled(true);
hexValue.setText("");
stringValue.setText("");
hexKey.setText("");
stringKey.setText("");
lengthLabel.setText("");
keyLength.setText("");
valueLength.setText("");
} catch (Exception e) {
JOptionPane.showMessageDialog(pane, "Unable to open database:\n" + e);
e.printStackTrace();
} finally {
if (database != null) {
try {
database.close();
} catch (IOException e) {
JOptionPane.showMessageDialog(pane, "Unable to close database:\n" + e);
e.printStackTrace();
}
}
}
}
}
public static void main(String[] args) {
try {
meet myobj = new meet();
// load jsiconfig.txt
ArrayList<String> myconfiglist = new ArrayList<String>();
myconfiglist = myobj.loadArray("jsiconfig.txt");
// The text uri
// "mongodb://*****:*****@ds023288.mongolab.com:23288/sample";
String textUri = myconfiglist.get(0);
// Create MongoClientURI object from which you get MongoClient obj
MongoClientURI uri = new MongoClientURI(textUri);
// Connect to that uri
MongoClient m = new MongoClient(uri);
// get the database named sample
String DBname = myconfiglist.get(1);
DB d = m.getDB(DBname);
// get the collection mycollection in sample
String collectionName = myconfiglist.get(2);
DBCollection collection = d.getCollection(collectionName);
// System.out.println("Config: "+textUri+":"+DBname+":"+collectionName);
// twitter4j
// Twitter twitter = new TwitterFactory().getInstance();
Twitter twitter = new TwitterFactory().getSingleton();
User user = twitter.verifyCredentials();
// Twitter collection of latest tweets into the home account - defaulted to latest 20 tweets//
//////////////////////////////////////////////////////////////
ArrayList<String> mylatesttweetslist = new ArrayList<String>();
// get list of tweets from a user or the next tweet listed
try {
long actid = 0;
// twitter.createFriendship(actid);
// The factory instance is re-useable and thread safe.
// Twitter twitter = TwitterFactory.getSingleton();
List<Status> statuses = twitter.getHomeTimeline();
System.out.println("Showing home timeline.");
for (Status status : statuses) {
// System.out.println(status.getUser().getName() + ":" +status.getText());
// Addes timeline to an array
String mytweets = status.getUser().getName() + ":" + status.getText();
mylatesttweetslist.add(mytweets);
}
;
} catch (TwitterException te) {
te.printStackTrace();
System.out.println("Failed to get timeline: " + te.getMessage());
System.exit(-1);
}
// MongoDB Insert Below //
//////////////////////////
// System Date
Date sd = new Date();
String sysdate = sd.toString();
// Toggle the below to display and insert the transactions as required
boolean showtrans = true;
boolean inserttrans = true;
// checkArray - loads args to a text string to allow the contains function
String checkString = "";
for (int ck = 0; ck < args.length; ck++) {
checkString = checkString + args[ck];
}
;
// display transactions flag on runnning jsimongo eg: java jsimongo -d will NOT display
// transactions
// insert transactions flag on runnning jsimongo eg: java jsimongo -i will NOT insert
// transactions
if (args.length > 0) {
if (checkString.contains("-d")) showtrans = false;
if (checkString.contains("-i")) inserttrans = false;
}
;
int x = 0;
for (String atweet : mylatesttweetslist) {
x++;
// Display tweets to console
if (showtrans == true) {
System.out.println("tweet : " + atweet);
System.out.println("Created_DateTime : " + sysdate); // was sysdate
}
;
// Insert JSON into MongoDB
if (inserttrans == true) {
BasicDBObject b = new BasicDBObject();
System.out.println("tweet : " + atweet);
System.out.println("Created_DateTime : " + sysdate); // was sysdate
// Insert the JSON object into the chosen collection
collection.insert(b);
}
;
Thread.sleep(1);
}
;
System.out.println("End, the number of tweets inserted at this time was: " + x);
} catch (Exception e) {
e.printStackTrace();
}
}
public void run() {
try {
_db.init();
} catch (DBException e) {
e.printStackTrace();
e.printStackTrace(System.out);
return;
}
try {
_workloadstate = _workload.initThread(_props, _threadid, _threadcount);
} catch (WorkloadException e) {
e.printStackTrace();
e.printStackTrace(System.out);
return;
}
// spread the thread operations out so they don't all hit the DB at the same time
try {
// GH issue 4 - throws exception if _target>1 because random.nextInt argument must be >0
// and the sleep() doesn't make sense for granularities < 1 ms anyway
if ((_target > 0) && (_target <= 1.0)) {
sleep(Utils.random().nextInt((int) (1.0 / _target)));
}
} catch (InterruptedException e) {
// do nothing.
}
try {
if (_dotransactions) {
long st = System.currentTimeMillis();
while (((_opcount == 0) || (_opsdone < _opcount)) && !_workload.isStopRequested()) {
if (!_workload.doTransaction(_db, _workloadstate)) {
break;
}
_opsdone++;
// throttle the operations
if (_target > 0) {
// this is more accurate than other throttling approaches we have tried,
// like sleeping for (1/target throughput)-operation latency,
// because it smooths timing inaccuracies (from sleep() taking an int,
// current time in millis) over many operations
while (System.currentTimeMillis() - st < ((double) _opsdone) / _target) {
try {
sleep(1);
} catch (InterruptedException e) {
// do nothing.
}
}
}
}
} else {
long st = System.currentTimeMillis();
while (((_opcount == 0) || (_opsdone < _opcount)) && !_workload.isStopRequested()) {
if (!_workload.doInsert(_db, _workloadstate)) {
break;
}
_opsdone++;
// throttle the operations
if (_target > 0) {
// this is more accurate than other throttling approaches we have tried,
// like sleeping for (1/target throughput)-operation latency,
// because it smooths timing inaccuracies (from sleep() taking an int,
// current time in millis) over many operations
while (System.currentTimeMillis() - st < ((double) _opsdone) / _target) {
try {
sleep(1);
} catch (InterruptedException e) {
// do nothing.
}
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
e.printStackTrace(System.out);
System.exit(0);
}
try {
_db.cleanup();
} catch (DBException e) {
e.printStackTrace();
e.printStackTrace(System.out);
return;
}
}
/**
* Execute Process Instance and Lock UI. Calls lockUI and unlockUI if parent is a ASyncProcess
*
* <pre>
* - Get Process Information
* - Call Class
* - Submit SQL Procedure
* - Run SQL Procedure
* </pre>
*/
public void run() {
log.fine("AD_PInstance_ID=" + m_pi.getAD_PInstance_ID() + ", Record_ID=" + m_pi.getRecord_ID());
// Lock
// lock();
// try {System.out.println(">> sleeping ..");sleep(20000);System.out.println(".. sleeping <<");}
// catch (Exception e) {}
// Get Process Information: Name, Procedure Name, ClassName, IsReport, IsDirectPrint
String ProcedureName = "";
int AD_ReportView_ID = 0;
int AD_Workflow_ID = 0;
boolean IsReport = false;
boolean IsDirectPrint = false;
//
String sql =
"SELECT p.Name, p.ProcedureName,p.ClassName, p.AD_Process_ID," // 1..4
+ " p.isReport,p.IsDirectPrint,p.AD_ReportView_ID,p.AD_Workflow_ID," // 5..8
+ " CASE WHEN COALESCE(p.Statistic_Count,0)=0 THEN 0 ELSE p.Statistic_Seconds/p.Statistic_Count END CASE,"
+ " p.IsServerProcess "
+ "FROM AD_Process p"
+ " INNER JOIN AD_PInstance i ON (p.AD_Process_ID=i.AD_Process_ID) "
+ "WHERE p.IsActive='Y'"
+ " AND i.AD_PInstance_ID=?";
if (!Env.isBaseLanguage(m_wscctx, "AD_Process"))
sql =
"SELECT t.Name, p.ProcedureName,p.ClassName, p.AD_Process_ID," // 1..4
+ " p.isReport, p.IsDirectPrint,p.AD_ReportView_ID,p.AD_Workflow_ID," // 5..8
+ " CASE WHEN COALESCE(p.Statistic_Count,0)=0 THEN 0 ELSE p.Statistic_Seconds/p.Statistic_Count END CASE,"
+ " p.IsServerProcess "
+ "FROM AD_Process p"
+ " INNER JOIN AD_PInstance i ON (p.AD_Process_ID=i.AD_Process_ID) "
+ " INNER JOIN AD_Process_Trl t ON (p.AD_Process_ID=t.AD_Process_ID"
+ " AND t.AD_Language='"
+ Env.getAD_Language(m_wscctx)
+ "') "
+ "WHERE p.IsActive='Y'"
+ " AND i.AD_PInstance_ID=?";
//
try {
PreparedStatement pstmt =
DB.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, null);
pstmt.setInt(1, m_pi.getAD_PInstance_ID());
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
m_pi.setTitle(rs.getString(1));
if (m_waiting != null) m_waiting.setTitle(m_pi.getTitle());
ProcedureName = rs.getString(2);
m_pi.setClassName(rs.getString(3));
m_pi.setAD_Process_ID(rs.getInt(4));
// Report
if ("Y".equals(rs.getString(5))) {
IsReport = true;
if ("Y".equals(rs.getString(6)) && !Ini.isPropertyBool(Ini.P_PRINTPREVIEW))
IsDirectPrint = true;
}
AD_ReportView_ID = rs.getInt(7);
AD_Workflow_ID = rs.getInt(8);
//
int estimate = rs.getInt(9);
if (estimate != 0) {
m_pi.setEstSeconds(estimate + 1); // admin overhead
if (m_waiting != null) m_waiting.setTimerEstimate(m_pi.getEstSeconds());
}
m_IsServerProcess = "Y".equals(rs.getString(10));
} else log.log(Level.SEVERE, "No AD_PInstance_ID=" + m_pi.getAD_PInstance_ID());
rs.close();
pstmt.close();
} catch (SQLException e) {
m_pi.setSummary(
Msg.getMsg(m_wscctx, "ProcessNoProcedure") + " " + e.getLocalizedMessage(), true);
// unlock();
log.log(Level.SEVERE, "run", e);
return;
}
// No PL/SQL Procedure
if (ProcedureName == null) ProcedureName = "";
/** ******************************************************************** Workflow */
if (AD_Workflow_ID > 0) {
startWorkflow(AD_Workflow_ID);
// unlock();
return;
}
/** ******************************************************************** Start Optional Class */
if (m_pi.getClassName() != null) {
// Run Class
if (!startProcess()) {
// unlock();
return;
}
// No Optional SQL procedure ... done
if (!IsReport && ProcedureName.length() == 0) {
// unlock ();
return;
}
// No Optional Report ... done
if (IsReport && AD_ReportView_ID == 0) {
// unlock ();
return;
}
}
// If not a report, we need a prodedure name
if (!IsReport && ProcedureName.length() == 0) {
m_pi.setSummary(Msg.getMsg(m_wscctx, "ProcessNoProcedure"), true);
// unlock();
return;
}
/** ******************************************************************** Report submission */
if (IsReport) {
// Optional Pre-Report Process
if (ProcedureName.length() > 0) {
if (!startDBProcess(ProcedureName)) {
// unlock();
return;
}
} // Pre-Report
// Start Report -----------------------------------------------
boolean ok = ReportCtl.start(m_pi, IsDirectPrint);
m_pi.setSummary("Report", !ok);
// unlock ();
}
/** ******************************************************************** Process submission */
else {
if (!startDBProcess(ProcedureName)) {
// unlock();
return;
}
// Success - getResult
ProcessInfoUtil.setSummaryFromDB(m_pi);
// unlock();
} // *** Process submission ***
// log.fine(Log.l3_Util, "ProcessCtl.run - done");
} // run
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
MongoClient mc = new MongoClient("localhost");
DB db = mc.getDB("mydb");
DBCollection dbc = db.getCollection("books");
/*BasicDBObject book=
new BasicDBObject();
book.put("name", "자바의 정석");
book.put("pages", 600);
dbc.insert(book);
book=
new BasicDBObject();
book.put("name", "스프링4");
book.put("pages", 250);
dbc.insert(book);
book=
new BasicDBObject();
book.put("name", "JQuery");
book.put("pages", 150);
dbc.insert(book);
book=
new BasicDBObject();
book.put("name", "오라클 프로그램");
book.put("pages", 800);
dbc.insert(book);
book=
new BasicDBObject();
book.put("name", "AngularJS");
book.put("pages", 130);
dbc.insert(book);
book=
new BasicDBObject();
book.put("name", "MongoDB");
book.put("pages", 650);
dbc.insert(book);
book=
new BasicDBObject();
book.put("name", "Hadoop");
book.put("pages", 300);
dbc.insert(book);
book=
new BasicDBObject();
book.put("name", "HIVE");
book.put("pages", 350);
dbc.insert(book);
book=
new BasicDBObject();
book.put("name", "PIG");
book.put("pages", 650);
dbc.insert(book);
book=
new BasicDBObject();
book.put("name", "HTML5");
book.put("pages", 360);
dbc.insert(book);*/
String map =
"function(){"
+ "var category;"
+ "if(this.pages>=300){"
+ "category='Big Books';"
+ "}else{"
+ "category='Small Books';}"
+ "emit(category,{name:this.name});}";
String reduce =
"function(key,values){"
+ "var sum=0;"
+ "values.forEach(function(doc){"
+ "sum+=1;"
+ "});"
+ "return {books:sum};}";
MapReduceCommand cmd =
new MapReduceCommand(dbc, map, reduce, null, MapReduceCommand.OutputType.INLINE, null);
MapReduceOutput out = dbc.mapReduce(cmd);
for (DBObject o : out.results()) {
System.out.println(o.toString());
}
} catch (Exception ex) {
System.out.println(ex.getMessage());
}
}
