public int retornaIdResp(String nome, int tipo) throws SQLException {
if (tipo == 0) {
sql = "select idgrupo from grupo where descricao = ?";
if (!FabricaConexoes.verificaConexao()) FabricaConexoes.getConexao();
stm = FabricaConexoes.returnStatement(sql);
stm.setString(1, nome);
rs = FabricaConexoes.returnResult(stm);
rs.next();
return rs.getInt("idgrupo");
} else if (tipo == 1) {
sql = "select idusuario from usuario where nome = ?";
if (!FabricaConexoes.verificaConexao()) FabricaConexoes.getConexao();
stm = FabricaConexoes.returnStatement(sql);
stm.setString(1, nome);
rs = FabricaConexoes.returnResult(stm);
rs.next();
return rs.getInt("idusuario");
} else if (tipo == 2) {
return 0;
} else if (tipo == 3) {
return 3;
} else {
return 0;
}
}
public boolean savePassword(String password) {
if (passwordExist()) {
_log.warning(
"[SecondaryPasswordAuth]" + _activeClient.getAccountName() + " forced savePassword");
_activeClient.closeNow();
return false;
}
if (!validatePassword(password)) {
_activeClient.sendPacket(new Ex2ndPasswordAck(0, Ex2ndPasswordAck.WRONG_PATTERN));
return false;
}
password = cryptPassword(password);
try (Connection con = DatabaseFactory.getInstance().getConnection();
PreparedStatement statement = con.prepareStatement(INSERT_PASSWORD)) {
statement.setString(1, _activeClient.getAccountName());
statement.setString(2, VAR_PWD);
statement.setString(3, password);
statement.execute();
} catch (Exception e) {
_log.log(Level.SEVERE, "Error while writing password.", e);
return false;
}
_password = password;
return true;
}
public boolean guardarUsuario() {
boolean resp = false;
try {
// Realizar consulta INSERT
String sql =
"INSERT INTO usuarios(nombres,apellidos, nacimiento,identificador, tipo, correo, telefono, estado_usuario, nick, contraseña, materia) "
+ "VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?,?,?)";
PreparedStatement cmd = cn.prepareStatement(sql);
// Llenar los parámetros
cmd.setString(1, nombres);
cmd.setString(2, apellidos);
cmd.setString(3, nacimiento);
cmd.setString(4, identificador);
cmd.setString(5, tipo);
cmd.setString(6, correo);
cmd.setString(7, telefono);
cmd.setBoolean(8, estado);
cmd.setString(9, usuario);
cmd.setString(10, contraseña);
cmd.setString(11, materia);
// Si da error devuelve 1, caso contrario 0
// Tomar en cuenta el "!" de negación
if (!cmd.execute()) {
resp = true;
}
// cmd.close();
// cn.close();
} catch (Exception e) {
System.out.println(e.toString());
}
return resp;
}
public static void insertCountry(Connection conn, String name, String abbrev)
throws SQLException {
PreparedStatement stmt = conn.prepareStatement("INSERT INTO countries VALUES (NULL, ?, ?)");
stmt.setString(1, name);
stmt.setString(2, abbrev);
stmt.execute();
}
private void setParam(PreparedStatement pst, Object param, int i) throws SQLException {
if (param instanceof Integer) {
int value = ((Integer) param).intValue();
pst.setInt(i + 1, value);
} else if (param instanceof String) {
String s = (String) param;
pst.setString(i + 1, s);
} else if (param instanceof Double) {
double d = ((Double) param).doubleValue();
pst.setDouble(i + 1, d);
} else if (param instanceof Float) {
float f = ((Float) param).floatValue();
pst.setFloat(i + 1, f);
} else if (param instanceof Long) {
long l = ((Long) param).longValue();
pst.setLong(i + 1, l);
} else if (param instanceof Boolean) {
boolean b = ((Boolean) param).booleanValue();
pst.setBoolean(i + 1, b);
} else if (param instanceof Date) {
Date d = (Date) param;
pst.setDate(i + 1, d);
} else if (param instanceof Timestamp) {
Timestamp d = (Timestamp) param;
pst.setTimestamp(i + 1, d);
} else if (param instanceof Object) {
pst.setString(i + 1, param.toString());
}
}
private void writeToDatabase(Date time, Value<?> value) {
try {
Parameter<?> parameter = value.getParameter();
if (!parameter.isNumeric()) {
throw new IllegalArgumentException("The value '" + value.toString() + "' is not numeric!");
}
BigDecimal decimalValue = null;
BigInteger integerValue = null;
if (Long.class.isAssignableFrom(parameter.getType())) {
integerValue = BigInteger.valueOf((Long) value.getValue());
} else {
decimalValue = BigDecimal.valueOf((Double) value.getValue());
}
preparedStatement.setTime(1, new Time(time.getTime()));
preparedStatement.setString(2, server);
preparedStatement.setString(3, parameter.getName());
preparedStatement.setString(4, parameter.getUnit());
preparedStatement.setString(5, parameter.getType().getName());
preparedStatement.setString(6, parameter.getDescription());
preparedStatement.setBigDecimal(7, decimalValue);
preparedStatement.setLong(8, integerValue.longValue());
preparedStatement.setString(9, parameter.getLevelOfMeasurement().name());
preparedStatement.execute();
} catch (SQLException e) {
throw new RuntimeException("Could not insert event into event log.", e);
}
}
public boolean eDitAlk(AnliKu ht) {
String sql =
"UPDATE alk SET casetitle=?,casecontent=?,keyword=?,taxtype=?,"
+ "area=?,note=? WHERE id=?";
try {
////////////////////////////////
conn = (Connection) DruidConn.getConnection();
DruidConn.startTransaction();
ps = conn.prepareStatement(sql);
ps.setString(1, ht.getCasetitle());
ps.setString(2, ht.getCasecontent());
ps.setString(3, ht.getKeyword());
ps.setString(4, ht.getTaxtype());
ps.setString(5, ht.getArea());
ps.setString(6, ht.getNote());
ps.setInt(7, ht.getId());
if (ps.executeUpdate() == 1) {
return true;
}
///////////////////////////////////
} catch (Exception e) {
e.printStackTrace();
} finally {
DruidConn.commit();
close();
}
return false;
}
public void addContent(DeweyID deweyID, StringBuilder contentBuilder, int parentCID)
throws IOException, Exception {
String content = new String(contentBuilder);
try {
if (con != null) {
String sqlQuery =
"INSERT INTO \"OrderedByCID\" (\"CID\", \"DeweyID\" , \"Value\") VALUES (?, ? ,?);";
PreparedStatement pst = con.prepareStatement(sqlQuery);
pst.setInt(1, deweyID.getCID());
pst.setString(2, deweyID.toString());
pst.setString(3, content);
pst.executeUpdate();
pst.close();
}
} catch (SQLException e) {
System.out.println("JDBC Driver is not Configured Correctly !");
e.printStackTrace();
return;
}
// text contents are not added to element index,thier CID shouldn be Zero
// elemIndex.insert(0,deweyID);
// bTreeIndex.insert(deweyID,-2,content);
// System.out.println("CID: -2");
// structSumIndex.add(-2,content,parentCID);THIS IS NOT NEEDED
// checkBufPool();
}
@Override
public void put(Emp object) {
Emp emp = object;
String sql;
if (emp.getId() == null) {
emp.setId(DBSrv.getInstance().getNextId());
sql = "INSERT INTO DDT_EMP(lname,fname,mname,d_hire,d_fire,id) " + "VALUES(?,?,?,?,?,?)";
} else {
sql =
"UPDATE DDT_EMP SET "
+ " lname = ?, "
+ " fname = ?, "
+ " mname = ?, "
+ " d_hire = ?, "
+ " d_fire = ? "
+ " WHERE id = ?";
}
try {
PreparedStatement st = conn.prepareStatement(sql);
st.setString(1, emp.getLastName());
st.setString(2, emp.getFirstName());
st.setString(3, emp.getMiddleName());
st.setDate(4, DBSrv.UtilToSQL(emp.getHireDate()));
st.setDate(5, DBSrv.UtilToSQL(emp.getFireDate()));
st.setInt(6, emp.getId());
st.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}
}
public CFSecurityTSecGroupBuff lockBuff(
CFSecurityAuthorization Authorization, CFSecurityTSecGroupPKey PKey) {
final String S_ProcName = "lockBuff";
if (!schema.isTransactionOpen()) {
throw CFLib.getDefaultExceptionFactory()
.newUsageException(getClass(), S_ProcName, "Transaction not open");
}
ResultSet resultSet = null;
try {
Connection cnx = schema.getCnx();
long TenantId = PKey.getRequiredTenantId();
int TSecGroupId = PKey.getRequiredTSecGroupId();
String sql =
"SELECT * FROM "
+ schema.getLowerDbSchemaName()
+ ".sp_lock_tsecgrp( ?, ?, ?, ?, ?"
+ ", "
+ "?"
+ ", "
+ "?"
+ " )";
if (stmtLockBuffByPKey == null) {
stmtLockBuffByPKey = cnx.prepareStatement(sql);
}
int argIdx = 1;
stmtLockBuffByPKey.setLong(
argIdx++, (Authorization == null) ? 0 : Authorization.getSecClusterId());
stmtLockBuffByPKey.setString(
argIdx++, (Authorization == null) ? "" : Authorization.getSecUserId().toString());
stmtLockBuffByPKey.setString(
argIdx++, (Authorization == null) ? "" : Authorization.getSecSessionId().toString());
stmtLockBuffByPKey.setLong(
argIdx++, (Authorization == null) ? 0 : Authorization.getSecClusterId());
stmtLockBuffByPKey.setLong(
argIdx++, (Authorization == null) ? 0 : Authorization.getSecTenantId());
stmtLockBuffByPKey.setLong(argIdx++, TenantId);
stmtLockBuffByPKey.setInt(argIdx++, TSecGroupId);
resultSet = stmtLockBuffByPKey.executeQuery();
if (resultSet.next()) {
CFSecurityTSecGroupBuff buff = unpackTSecGroupResultSetToBuff(resultSet);
if (resultSet.next()) {
throw CFLib.getDefaultExceptionFactory()
.newRuntimeException(getClass(), S_ProcName, "Did not expect multi-record response");
}
return (buff);
} else {
return (null);
}
} catch (SQLException e) {
throw CFLib.getDefaultExceptionFactory().newDbException(getClass(), S_ProcName, e);
} finally {
if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException e) {
}
resultSet = null;
}
}
}
/**
* Adds a LOINCCode to an office visit.
*
* @param LOINCCode A string of the code being added.
* @param visitID The ID of the office visit the code is being added to.
* @param pid The patient's MID associated with this transaction.
* @return The unique ID of the code that was added.
* @throws DBException
*/
public long addLabProcedureToOfficeVisit(String LOINCCode, long visitID, long pid)
throws DBException {
Connection conn = null;
PreparedStatement ps = null;
try {
conn = factory.getConnection();
ps =
conn.prepareStatement(
"INSERT INTO LabProcedure (LaboratoryProcedureCode,OfficeVisitID,"
+ "Commentary, Results, PatientMID, Status, Rights) VALUES (?,?,?,?,?,?,?)");
ps.setString(1, LOINCCode);
ps.setLong(2, visitID);
ps.setString(3, "");
ps.setString(4, "");
ps.setLong(5, pid);
ps.setString(6, LabProcedureBean.Not_Received);
ps.setString(7, "ALLOWED");
ps.executeUpdate();
return DBUtil.getLastInsert(conn);
} catch (SQLException e) {
e.printStackTrace();
throw new DBException(e);
} finally {
DBUtil.closeConnection(conn, ps);
}
}
public void setValues(PreparedStatement ps) throws SQLException {
ps.setString(1, job.getJobStatus().name());
ps.setString(2, job.getErrorMessage());
ps.setTimestamp(3, new Timestamp(job.getModifiedAt().getTime()));
ps.setInt(4, job.getReturnCode());
ps.setString(5, job.getJobId());
}
protected void saveAccount(String name, double money) {
if (accountExists(name)) {
String sql = "UPDATE " + accounts + " SET " + pbalance + "=? WHERE " + pname + "=?";
try {
PreparedStatement prest = database.prepare(sql);
prest.setDouble(1, money);
prest.setString(2, name);
prest.executeUpdate();
prest.close();
} catch (SQLException e) {
}
} else {
String sql = "INSERT INTO " + accounts + " (" + pname + ", " + pbalance + ") VALUES (?, ?)";
try {
PreparedStatement prest = database.prepare(sql);
prest.setString(1, name);
prest.setDouble(2, money);
prest.executeUpdate();
prest.close();
} catch (SQLException e) {
}
}
}
@Override
protected Profile createConcrete() throws SQLException {
PreparedStatement insert =
conn.prepareStatement(
"INSERT INTO profile (id, surname,givenName, user, organization) VALUES (?,?,?,?,?)");
insert.setInt(1, input.getId());
insert.setString(2, input.getSurname());
insert.setString(3, input.getGivenName());
if (input.getUserId() == null) {
insert.setNull(4, Types.INTEGER);
} else {
insert.setInt(4, input.getUserId());
}
insert.setInt(5, input.getOrganizationId());
int insertCount = insert.executeUpdate();
if (insertCount != 1) {
throw new GeneralException("Unexpected insert count: " + insertCount);
}
if (input.getUserId() != null) {
authorizationPersistenceHelper.grantToCollectionsInOrganization(
conn, ROLE_ADMIN, input.getOrganizationId(), input.getId());
}
return input;
}
/**
* 更新任务
*
* @param task
* @throws SQLException
*/
public long update(Task task) throws SQLException {
// ID,NAME,STATUS,CTIME,FTIME,MESSAGE
String upSql =
"update " + TABLE_NAME + " set NAME=?,STATUS=?,CTIME=?,FTIME=?,MESSAGE=? where ID=?";
Connection conn = null;
PreparedStatement upStmt = null;
try {
conn = DBUtil.getConnection();
conn.setAutoCommit(false);
upStmt = conn.prepareStatement(upSql);
upStmt.setString(1, task.getName());
upStmt.setInt(2, task.getStatus());
upStmt.setLong(3, task.getcTime());
upStmt.setLong(4, task.getfTime());
upStmt.setString(5, task.getMessage());
upStmt.setLong(6, task.getId());
upStmt.execute();
this.orderDAO.update(conn, task.getOrders());
conn.commit();
return task.getId();
} catch (Exception e) {
LOG.error("Will rollback");
conn.rollback();
LOG.error(e.getMessage(), e);
throw new RuntimeException(e);
} finally {
if (upStmt != null) {
upStmt.close();
}
if (conn != null) {
conn.close();
}
}
}
/**
* Method called by the Form panel to delete existing data.
*
* @param persistentObject value object to delete
* @return an ErrorResponse value object in case of errors, VOResponse if the operation is
* successfully completed
*/
public Response deleteRecord(ValueObject persistentObject) throws Exception {
PreparedStatement stmt = null;
try {
EmpVO vo = (EmpVO) persistentObject;
// delete from WORKING_DAYS...
stmt = conn.prepareStatement("delete from WORKING_DAYS where EMP_CODE=?");
stmt.setString(1, vo.getEmpCode());
stmt.execute();
stmt.close();
// delete from EMP...
stmt = conn.prepareStatement("delete from EMP where EMP_CODE=?");
stmt.setString(1, vo.getEmpCode());
stmt.execute();
gridFrame.reloadData();
frame.getGrid().clearData();
return new VOResponse(vo);
} catch (SQLException ex) {
ex.printStackTrace();
return new ErrorResponse(ex.getMessage());
} finally {
try {
stmt.close();
conn.commit();
} catch (SQLException ex1) {
}
}
}
public boolean ModificarUsuario() {
boolean resp = false;
try {
// Realizar consulta INSERT
String sql =
"UPDATE usuarios SET nombres=?,apellidos=?,nacimiento=?, identificador=?, tipo=?, correo=?, telefono=?, estado_usuario=?, nick=?, contraseña=?, materia=? WHERE id_usuario=?";
PreparedStatement cmd = cn.prepareStatement(sql);
// Llenar los parámetros
cmd.setString(1, nombres);
cmd.setString(2, apellidos);
cmd.setString(3, nacimiento);
cmd.setString(4, identificador);
cmd.setString(5, tipo);
cmd.setString(6, correo);
cmd.setString(7, telefono);
cmd.setBoolean(8, estado);
cmd.setString(9, usuario);
cmd.setString(10, contraseña);
cmd.setString(11, materia);
cmd.setInt(12, id);
// Si da error devuelve 1, caso contrario 0
// Tomar en cuenta el "!" de negación
if (!cmd.execute()) {
resp = true;
}
// cmd.close();
// cn.close();
} catch (Exception e) {
System.out.println(e.toString());
}
return resp;
}
/**
* Returns a list of information related to prescription reports given all of the office visits
* and the patient ID. The patient ID is necessary in case the office visit IDs are for different
* patients (the disambiguation is for security reasons).
*
* @param ovIDs A java.util.List of Longs for the office visits.
* @param patientID A long representing the MID of the patient in question.
* @return A java.util.List of prescription reports.
* @throws DBException
*/
public List<PrescriptionReportBean> getPrescriptionReportsByDate(
long patientID, String startDate, String endDate) throws DBException {
Connection conn = null;
PreparedStatement ps = null;
try {
conn = factory.getConnection();
ps =
conn.prepareStatement(
"SELECT * FROM NDCodes, OVMedication, OfficeVisits "
+ "WHERE NDCodes.Code=OVMedication.NDCode AND OVMedication.VisitID=OfficeVisits.ID "
+ "AND PatientID=? AND ((DATE(?) < OVMedication.EndDate AND DATE(?) > OVMedication.StartDate)"
+ "OR (DATE(?) > OVMedication.StartDate AND DATE(?) < OVMedication.EndDate ) OR "
+ "(DATE(?) <= OVMedication.StartDate AND DATE(?) >= OVMedication.StartDate)) "
+ "ORDER BY VisitDate DESC");
ps.setLong(1, patientID);
ps.setString(2, startDate);
ps.setString(3, startDate);
ps.setString(4, endDate);
ps.setString(5, endDate);
ps.setString(6, startDate);
ps.setString(7, endDate);
ResultSet rs = ps.executeQuery();
return prescriptionReportBeanLoader.loadList(rs);
} catch (SQLException e) {
e.printStackTrace();
throw new DBException(e);
} finally {
DBUtil.closeConnection(conn, ps);
}
}
public void addValue(DeweyID deweyID, String value, int parentCID) throws IOException, Exception {
// we may have problem here
// maybe we should update previously inserted attributes instead of insert new one
// FOR ATTrib Values (Actually they are behaved the same as text contents)
// text contents are not added to element index,thier CID shouldn be Zero
// elemIndex.insert(0,deweyID);
// bTreeIndex.insert(deweyID,-1,value);
logManager.LogManager.log(6, value);
logManager.LogManager.log(6, "Value: " + deweyID.toString());
try {
if (con != null) {
String sqlQuery =
"INSERT INTO \"OrderedByCID\" (\"CID\", \"DeweyID\" , \"Value\") VALUES (?, ? ,?);";
PreparedStatement pst = con.prepareStatement(sqlQuery);
pst.setInt(1, deweyID.getCID());
pst.setString(2, deweyID.toString());
pst.setString(3, value);
pst.executeUpdate();
pst.close();
}
} catch (SQLException e) {
System.out.println("JDBC Driver is not Configured Correctly !");
e.printStackTrace();
return;
}
// structSumIndex.add(-1,value,parentCID);THIS IS NOT NEEDED!
// checkBufPool();
}
private void setValues(PreparedStatement ps, OfficeVisitBean ov) throws SQLException {
ps.setDate(1, new java.sql.Date(ov.getVisitDate().getTime()));
ps.setString(2, ov.getNotes());
ps.setLong(3, ov.getHcpID());
ps.setLong(4, ov.getPatientID());
ps.setString(5, ov.getHospitalID());
}
public void setString(PreparedStatement ps, int param, String value) {
try {
if (getDatastoreAdapter().supportsOption(DatastoreAdapter.BLOB_SET_USING_SETSTRING)) {
if (value == null) {
if (column.isDefaultable() && column.getDefaultValue() != null) {
ps.setString(param, column.getDefaultValue().toString().trim());
} else {
ps.setNull(param, getJDBCType());
}
} else {
ps.setString(param, value);
}
} else {
if (value == null) {
if (column != null && column.isDefaultable() && column.getDefaultValue() != null) {
ps.setBlob(param, new BlobImpl(column.getDefaultValue().toString().trim()));
} else {
ps.setNull(param, getJDBCType());
}
} else {
ps.setBlob(param, new BlobImpl(value));
}
}
} catch (SQLException e) {
throw new NucleusDataStoreException(
Localiser.msg("055001", "String", "" + value, column, e.getMessage()), e);
} catch (IOException e) {
throw new NucleusDataStoreException(
Localiser.msg("055001", "String", "" + value, column, e.getMessage()), e);
}
}
public static void Update(Unlocked p) throws ResponseException {
PreparedStatement statement = null;
String query =
"Update unlocked SET fk_profile_id=?,bonus_info=?,content_info=? where fk_profile_id=?;";
Connection connect = null;
IConnection c = MiscUtil.getIConnection();
try {
connect = c.init();
statement = connect.prepareStatement(query);
statement.setLong(1, p.getProfileId());
statement.setString(2, p.getBonusInfo());
statement.setString(3, p.getContentInfo());
statement.setLong(4, p.getProfileId());
statement.executeUpdate();
} catch (SQLException e) {
logger.error("SQL Error", e);
throw new ResponseException("SQL Error", HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
} catch (ResponseException e) {
throw e;
} finally {
try {
if (statement != null) statement.close();
if (connect != null) connect.close();
} catch (SQLException e) {
logger.error("SQL Error", e);
}
}
}
protected void updateURLTitle(long groupId, String articleId, String urlTitle) throws Exception {
String normalizedURLTitle = FriendlyURLNormalizerUtil.normalize(urlTitle, _friendlyURLPattern);
if (urlTitle.equals(normalizedURLTitle)) {
return;
}
normalizedURLTitle =
JournalArticleLocalServiceUtil.getUniqueUrlTitle(groupId, articleId, normalizedURLTitle);
Connection con = null;
PreparedStatement ps = null;
try {
con = DataAccess.getUpgradeOptimizedConnection();
ps = con.prepareStatement("update JournalArticle set urlTitle = ? where urlTitle = ?");
ps.setString(1, normalizedURLTitle);
ps.setString(2, urlTitle);
ps.executeUpdate();
} finally {
DataAccess.cleanUp(con, ps);
}
}
public boolean changePassword(String oldPassword, String newPassword) {
if (!passwordExist()) {
_log.warning(
"[SecondaryPasswordAuth]" + _activeClient.getAccountName() + " forced changePassword");
_activeClient.closeNow();
return false;
}
if (!checkPassword(oldPassword, true)) {
return false;
}
if (!validatePassword(newPassword)) {
_activeClient.sendPacket(new Ex2ndPasswordAck(2, Ex2ndPasswordAck.WRONG_PATTERN));
return false;
}
newPassword = cryptPassword(newPassword);
try (Connection con = DatabaseFactory.getInstance().getConnection();
PreparedStatement statement = con.prepareStatement(UPDATE_PASSWORD)) {
statement.setString(1, newPassword);
statement.setString(2, _activeClient.getAccountName());
statement.setString(3, VAR_PWD);
statement.execute();
} catch (Exception e) {
_log.log(Level.SEVERE, "Error while reading password.", e);
return false;
}
_password = newPassword;
_authed = false;
return true;
}
public static final void reportPost(Report report) {
Connection connection = null;
PreparedStatement stmt = null;
String sql =
"INSERT INTO luser_reports_post (post_id,whistleblower_id,wrongdoing_id,category,reason) VALUES (?,?,?,?,?)";
try {
connection = DBConnection.getConnection();
stmt = connection.prepareStatement(sql);
stmt.setInt(1, report.getPostId());
stmt.setString(2, report.getWhistleblowerId());
stmt.setString(3, report.getWrongdoingId());
stmt.setString(4, report.getCategory());
stmt.setString(5, report.getReason());
stmt.executeUpdate();
} catch (SQLException ex) {
Logger.getLogger(PostMapper.class.getName()).log(Level.SEVERE, null, ex);
} finally {
if (stmt != null)
try {
stmt.close();
} catch (SQLException e1) {
e1.printStackTrace();
}
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
public void addToDataBase(String userName, String email) {
Connection koneksi = null;
PreparedStatement pstmt = null;
String str = "";
try {
Class.forName("com.mysql.jdbc.Driver").newInstance();
koneksi =
DriverManager.getConnection("jdbc:mysql://localhost/shopkartdb", "shopkart", "welcome");
System.out.println("I am Here " + koneksi);
String sql = "INSERT INTO loginInfo(" + "userName," + "emailID) " + "VALUES(?,?)";
pstmt = koneksi.prepareStatement(sql);
pstmt.setString(1, userName);
pstmt.setString(2, email);
pstmt.executeUpdate();
System.out.println("Hello");
koneksi.close();
} catch (SQLException sqle) {
str = "SQLException error";
} catch (ClassNotFoundException cnfe) {
str = "ClassNotFoundException error";
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
private int insertPageContent(
String text, int resultPageNumber, String searchEngineName, int crawlRecordId) {
try {
PreparedStatement pstmt =
con.prepareStatement(
"INSERT INTO pagecontent (htmlcontent, resultPageNumber, searchEngineName, crawlRecordId,queryText) VALUES (?,?,?,?,?);",
Statement.RETURN_GENERATED_KEYS);
pstmt.setString(1, text);
pstmt.setInt(2, resultPageNumber);
pstmt.setString(3, searchEngineName);
pstmt.setInt(4, crawlRecordId);
pstmt.setString(5, query);
pstmt.executeUpdate();
java.sql.ResultSet generatedKeys = pstmt.getGeneratedKeys();
if (generatedKeys.next()) {
return generatedKeys.getInt(1);
}
pstmt.close();
} catch (Exception ex) {
String a = "";
String b = "";
}
return 0;
}
public User gerUserByLogin(String email, String password) {
Connection connection = null;
PreparedStatement statement = null;
ResultSet resultSet = null;
User user = new User();
String selectQuery = "SELECT * FROM users WHERE user_email = ? AND user_password = ?";
try {
connection = datasource.getConnection();
statement = connection.prepareStatement(selectQuery);
statement.setString(1, email);
statement.setString(2, password);
resultSet = statement.executeQuery();
while (resultSet.next()) {
int userId = resultSet.getInt("user_id");
String userName = resultSet.getString("user_name");
String userPassword = resultSet.getString("user_password");
String userEmail = resultSet.getString("user_email");
String userStatus = resultSet.getString("user_status");
user.setUserId(userId);
user.setUserName(userName);
user.setUserPassword(userPassword);
user.setUserEmail(userEmail);
user.setUserStatus(userStatus);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
datasource.closePreparedStatement(statement);
datasource.closeConnection(connection);
datasource.closeResultSet(resultSet);
}
return user;
}
public int addDevice(Object o) {
int rowsAdded = 0;
try {
Connection connect = conn.use();
Device dev = (Device) o;
String SQL =
"INSERT INTO device(Brand, Model, Serial_Number, Computer_Name, Location, Asset_Tag, Cost, Start_Date, End_Date, Term) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
PreparedStatement ps = connect.prepareStatement(SQL);
ps.setString(1, dev.getBrand());
ps.setString(2, dev.getModel());
ps.setString(3, dev.getSerialNumber());
ps.setString(4, dev.getComputerName());
ps.setString(5, dev.getLocation());
ps.setString(6, dev.getAssetTag());
ps.setInt(7, dev.getCost());
ps.setDate(8, dev.getStartDate());
ps.setDate(9, dev.getEndDate());
ps.setInt(10, dev.getTerm());
rowsAdded = ps.executeUpdate();
ps.close();
conn.release(connect);
} catch (SQLException ex) {
System.out.println("Error in add device: ");
Logger.getLogger(DeviceBroker.class.getName()).log(Level.SEVERE, null, ex);
}
return rowsAdded;
}
/*
* (non-Javadoc)
*
* @see
* sg.edu.nus.iss.phoenix.authenticate.dao.impl.UserDao#save(java.sql.Connection
* , sg.edu.nus.iss.phoenix.authenticate.entity.User)
*/
@Override
public void save(User valueObject) throws NotFoundException, SQLException {
String sql = "UPDATE user SET password = ?, name = ?, role = ? WHERE (id = ? ) ";
PreparedStatement stmt = null;
try {
stmt = this.connection.prepareStatement(sql);
stmt.setString(1, valueObject.getPassword());
stmt.setString(2, valueObject.getName());
stmt.setString(3, valueObject.getRoles().get(0).getRole());
stmt.setString(4, valueObject.getId());
int rowcount = databaseUpdate(stmt);
if (rowcount == 0) {
// System.out.println("Object could not be saved! (PrimaryKey not found)");
throw new NotFoundException("Object could not be saved! (PrimaryKey not found)");
}
if (rowcount > 1) {
// System.out.println("PrimaryKey Error when updating DB! (Many objects were affected!)");
throw new SQLException("PrimaryKey Error when updating DB! (Many objects were affected!)");
}
} finally {
if (stmt != null) stmt.close();
}
}