@Override
public Set<UserRole> getUserRoles(String sessID, String user)
throws RemoteException, SessionExpiredException, SQLException, SecurityException {
String thisUser = SessionManager.getInstance().getUserForSession(sessID);
String thisDatabase = SessionManager.getInstance().getDatabaseForSession(sessID);
// check that this user ibelongs to this database
if (!isUserOfThisDatabase(sessID)) {
LOG.error(
"User "
+ thisUser
+ " is not a member of the database "
+ thisDatabase
+ ", and can't query roles for user "
+ user);
throw new SecurityException(
"Can't get roles for user "
+ user
+ " on this database. User making request is not a user of this database.");
}
// Check that this user is either requesting his own roles, OR is an administrator.
if (user.equals(thisUser) || isAdmin(sessID)) {
// ok to proceed
return getRolesForUser(sessID, user);
} else {
String err =
"User "
+ user
+ " does not have administrative permission to request roles available for user "
+ user;
LOG.error(err);
throw new SecurityException(err);
}
}
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.sendcode_screen);
setTitle(LOG_TAG);
serverProvider = new ServerProvider(this);
SessionManager.init(this);
SessionManager.readSession();
BookManager.BuildBook(getResources().openRawResource(R.raw.json));
if (SessionManager.getS().isAuthKeyOk()) {
Log.i(LOG_TAG, "auth_key loaded from preferences.");
} else {
Log.i(LOG_TAG, "Generating new Auth key...");
new AuthKeyGenerator().execute();
}
sendCodeButton = (Button) findViewById(R.id.button222);
sendCodeButton.setOnClickListener(sendCodeButtonClickListener);
tel1Text = (EditText) findViewById(R.id.tel1);
tel2Text = (EditText) findViewById(R.id.tel2);
control = IMControl.getInstance();
control.setServer(serverProvider.getServerInfo());
connectAction();
}
public void testNewSessionFailBefore() throws Exception {
KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
kbuilder.add(ResourceFactory.newClassPathResource("sampleFailBefore.bpmn"), ResourceType.BPMN2);
KnowledgeBase kbase = kbuilder.newKnowledgeBase();
SessionManagerFactory factory = new NewSessionSessionManagerFactory(kbase);
SessionManager sessionManager = factory.getSessionManager();
try {
ProcessInstance processInstance =
sessionManager.getKnowledgeSession().startProcess("com.sample.bpmn.hello", null);
fail("Started process instance " + processInstance.getId());
} catch (RuntimeException e) {
// do nothing
}
// TODO: whenever transaction fails, do we need to dispose? can we?
// sessionManager.dispose();
List<Status> statusses = new ArrayList<Status>();
statusses.add(Status.Reserved);
sessionManager = factory.getSessionManager();
List<TaskSummary> tasks =
sessionManager.getTaskService().getTasksAssignedAsPotentialOwner("mary", "en-UK");
assertEquals(0, tasks.size());
sessionManager.dispose();
factory.dispose();
}
public void logOut() {
session.logOut();
Log.i("Manager Login status after logout::", Boolean.toString(session.isLoggedIn()));
Intent intent = new Intent(getApplicationContext(), LoginPage.class);
startActivity(intent);
}
@Route(method = HttpRequest.Method.POST, urlPattern = "/register")
public HttpResponse register(
HttpRequest request,
@Param("name") String name,
@Param("surname") String surname,
@Param("email") String email,
@Param("password") String password) {
User user = new User(DB.getInstance().getNewId(), name, surname, email, password);
DB.getInstance().addUser(user);
HttpResponse response = new HttpResponse("Successfully created an user", 200);
Cookie c = new Cookie("auth", request);
response.addCookie(c);
String sessionId = SessionManager.getSessionIdForRequest(request);
SessionManager.getInstance().addSession(sessionId, new Integer(user.id));
try {
String body = TemplateProcessor.process("profile.html", user.getJsonData().build());
response.setBody(body);
} catch (IOException e) {
response.setStatusCode(500);
}
return response;
}
public void performCRUDTest(String objectTypeName) throws Exception {
try {
s_log.info("CRUDTest on " + objectTypeName);
DataObject object = SessionManager.getSession().create(objectTypeName);
reportPropertyTypes(object);
initializeObject(object, null);
OID id = object.getOID();
s_log.info("Initialized object with id: " + id);
object.save();
object = SessionManager.getSession().retrieve(id);
Assert.assertNotNull(
object, "Object of type: " + objectTypeName + "and id: " + id + " was not found!");
checkDefaultValues(object);
checkUpdates(object, null);
deleteObject(id);
} catch (Exception e) {
s_log.info("END CRUDTest on " + objectTypeName + " With error!");
s_log.info(e.getMessage());
s_log.info("");
s_log.info("");
throw e;
}
s_log.info("END CRUDTest on " + objectTypeName);
s_log.info("");
s_log.info("");
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_user_activities);
findID();
SessionManager sessionManager = new SessionManager(this);
HashMap<String, String> emailid = sessionManager.getUserDetails();
aciviityuserId = emailid.get(SessionManager.KEY_EMAIL);
activitysearch_url =
"http://rsmile.quaeretech.com/RealtorSmile.svc/GetContactRecords/" + aciviityuserId;
new ActitivityAsyncTask().execute(activitysearch_url);
if (isNotAdded) {
checkBox_header1.setOnClickListener(
new View.OnClickListener() {
@Override
public void onClick(View v) {
for (int i = 0; i < activitycustomSearchlist.size(); i++) {
mChecked.put(i, checkBox_header1.isChecked());
}
activityadapter.notifyDataSetChanged();
}
});
isNotAdded = false;
}
}
public void testNewSessionDispose() throws Exception {
KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
kbuilder.add(ResourceFactory.newClassPathResource("sample.bpmn"), ResourceType.BPMN2);
KnowledgeBase kbase = kbuilder.newKnowledgeBase();
SessionManagerFactory factory = new NewSessionSessionManagerFactory(kbase);
final SessionManager sessionManager = factory.getSessionManager();
UserTransaction ut = (UserTransaction) new InitialContext().lookup("java:comp/UserTransaction");
ut.begin();
sessionManager.getKnowledgeSession().startProcess("com.sample.bpmn.hello", null);
TransactionManagerServices.getTransactionManager()
.getTransaction()
.registerSynchronization(
new Synchronization() {
public void beforeCompletion() {}
public void afterCompletion(int status) {
try {
sessionManager.dispose();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
ut.commit();
factory.dispose();
}
public void run() {
Log.d(logTag, "Receiver started");
receiverThread = Thread.currentThread();
while (true) {
try {
if (connection != null) {
Log.d(logTag, "Waiting for message from PCF...");
final Message result = connection.receive().await();
if (result != null) {
Log.d(logTag, "Received message from PCF: " + new String(result.getPayload()));
SessionManager.handlePatientResults(new String(result.getPayload()));
}
}
} catch (Exception e) {
if (die.get()) {
// user initiated disconnect
die.set(false);
} else {
// unexpected failure
SessionManager.connectionFailure(host);
}
break;
}
}
try {
connection.disconnect().await();
Log.d(logTag, "Receiver stopped");
} catch (Exception e) {
Log.e(logTag, e.getMessage());
}
}
public PageIterable<DaoUserContent> getHistory() {
final Query query = SessionManager.getNamedQuery("team.getHistory");
final Query size = SessionManager.getNamedQuery("team.getHistory.size");
final QueryCollection<DaoUserContent> q = new QueryCollection<DaoUserContent>(query, size);
q.setEntity("team", this);
return q;
}
@Before
public void setUp() {
SessionManager s = new SessionManager();
User user = new User("Hue", "1234", "admin");
String token = s.authenticate("Hue", "1234");
session = new Session(user, token);
expiredSession = new Session(user, token, -1);
}
@Test
public void session() throws Exception {
Client c = new Client();
Server<Object> s = new Server<Object>(TEST_AUTHENTICATOR, TEST_MANAGER);
assertEquals(TEST_AUTHENTICATOR, s.getAuthenticator());
try {
c.assertValidSession();
fail();
} catch (I18NException ex) {
assertEquals(Messages.NOT_LOGGED_IN, ex.getI18NBoundMessage());
}
c.login(TEST_USER, TEST_PASSWORD);
SessionId id = c.getSessionId();
assertNotNull(id);
assertEquals(id, c.getContext().getSessionId());
assertEquals(TEST_USER, TEST_MANAGER.get(id).getUser());
try {
c.login(TEST_USER, TEST_PASSWORD);
fail();
} catch (I18NException ex) {
assertEquals(Messages.ALREADY_LOGGED_IN, ex.getI18NBoundMessage());
}
assertEquals(id, c.getSessionId());
assertEquals(TEST_USER, TEST_MANAGER.get(id).getUser());
c.logout();
assertNull(c.getSessionId());
assertNull(c.getContext().getSessionId());
assertNull(TEST_MANAGER.get(id));
try {
c.login(TEST_USER_D, TEST_PASSWORD);
fail();
} catch (RemoteException ex) {
assertEquals(Messages.BAD_CREDENTIALS, ((I18NException) ex.getCause()).getI18NBoundMessage());
}
assertNull(c.getSessionId());
c.logout();
s.stop();
try {
c.login(TEST_USER, TEST_PASSWORD);
fail();
} catch (WebServiceException ex) {
// Desired.
}
}
public static DaoVersionedString createAndPersist(final String content, final DaoMember author) {
final Session session = SessionManager.getSessionFactory().getCurrentSession();
final DaoVersionedString bug = new DaoVersionedString(content, author);
try {
session.save(bug);
} catch (final HibernateException e) {
session.getTransaction().rollback();
SessionManager.getSessionFactory().getCurrentSession().beginTransaction();
throw e;
}
return bug;
}
private void logoutUser() {
session.setLogin(false);
session.setEmail(null);
session.setPublics(null);
session.setUsername(null);
session.setId(null);
// Launching the login activity
Intent intent = new Intent(Register.this, Accueil.class);
startActivity(intent);
finish();
}
private void testStartProcess(SessionManagerFactory factory) throws Exception {
SessionManager sessionManager = factory.getSessionManager();
long taskId;
synchronized (
(SingleSessionCommandService)
((CommandBasedStatefulKnowledgeSession) sessionManager.getKnowledgeSession())
.getCommandService()) {
UserTransaction ut =
(UserTransaction) new InitialContext().lookup("java:comp/UserTransaction");
ut.begin();
System.out.println(
"Starting process on ksession " + sessionManager.getKnowledgeSession().getId());
ProcessInstance processInstance =
sessionManager.getKnowledgeSession().startProcess("com.sample.bpmn.hello", null);
System.out.println(
"Started process instance "
+ processInstance.getId()
+ " on ksession "
+ sessionManager.getKnowledgeSession().getId());
long workItemId =
((HumanTaskNodeInstance)
((WorkflowProcessInstance) processInstance).getNodeInstances().iterator().next())
.getWorkItemId();
taskId = sessionManager.getTaskService().getTaskByWorkItemId(workItemId).getId();
System.out.println("Created task " + taskId);
ut.commit();
}
sessionManager.getTaskService().claim(taskId, "mary");
sessionManager.dispose();
}
public void testSingletonSessionMemory() throws Exception {
for (int i = 0; i < 1000; i++) {
KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
kbuilder.add(ResourceFactory.newClassPathResource("sample.bpmn"), ResourceType.BPMN2);
KnowledgeBase kbase = kbuilder.newKnowledgeBase();
SessionManagerFactory factory = new SingletonSessionManagerFactory(kbase);
SessionManager sessionManager = factory.getSessionManager();
sessionManager.dispose();
factory.dispose();
System.gc();
Thread.sleep(100);
System.gc();
System.out.println(Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory());
}
}
/** @return all the member in this team. (Use a HQL query). */
public PageIterable<DaoMember> getMembers() {
final Session session = SessionManager.getSessionFactory().getCurrentSession();
final Query filter =
session.createFilter(getTeamMembership(), "select this.member order by login");
final Query count = session.createFilter(getTeamMembership(), "select count(*)");
return new QueryCollection<DaoMember>(filter, count);
}
@Override
public Set<UserRole> getAllRoles(String sessID)
throws RemoteException, SQLException, SecurityException, SessionExpiredException {
String thisDatabase = SessionManager.getInstance().getDatabaseForSession(sessID);
TableSchema roleTable = MedSavantDatabase.UserRoleTableSchema;
SelectQuery sq = new SelectQuery();
sq.addFromTable(roleTable.getTable());
sq.addColumns(
roleTable.getDBColumn(MedSavantDatabase.UserRoleTableSchema.COLUMNNAME_OF_ID),
roleTable.getDBColumn(MedSavantDatabase.UserRoleTableSchema.COLUMNNAME_OF_ROLENAME),
roleTable.getDBColumn(
MedSavantDatabase.UserRoleTableSchema.COLUMNNAME_OF_ROLE_DESCRIPTION));
sq.setIsDistinct(true);
ResultSet rs = null;
try {
rs = ConnectionController.executeQuery(sessID, sq.toString());
Set<UserRole> roleSet = new TreeSet<UserRole>();
while (rs.next()) {
int roleId = rs.getInt(1);
String roleName = rs.getString(2);
String roleDescription = rs.getString(3);
roleSet.add(new UserRole(roleId, roleName, roleDescription, thisDatabase));
}
return roleSet;
} finally {
if (rs != null) {
rs.close();
}
}
}
public synchronized void invalidate() {
checkValidSession();
sessionManager.inValidateSession(id);
isValid = false;
values.clear();
}
public static ArrayList<byte[]> createReqSmsMessage(Contact contact)
throws FailedToSendSessionRequestException {
final int MAX_REQUEST_LENGTH = 256;
final int REQUEST_SMS_LENGTH = 128;
try {
byte[] request = SessionManager.generateSessionRequest(contact);
if (request.length != MAX_REQUEST_LENGTH)
throw new FailedToSendSessionRequestException("Request length is not standard");
byte[] firstMessage = Arrays.copyOfRange(request, 0, REQUEST_SMS_LENGTH);
byte[] secondMessage = Arrays.copyOfRange(request, REQUEST_SMS_LENGTH, request.length);
byte[] firstType = new byte[1];
firstType[0] = (byte) SmsMessage.Type.RequestFirstSMS.ordinal();
byte[] secondType = new byte[1];
secondType[0] = (byte) SmsMessage.Type.RequestSecondSMS.ordinal();
ArrayList<byte[]> partialRequests = new ArrayList<byte[]>(2);
partialRequests.add(Arrays.concatenate(firstType, firstMessage));
partialRequests.add(Arrays.concatenate(secondType, secondMessage));
return partialRequests;
} catch (FailedToGenerateSessionRequestException e) {
throw new FailedToSendSessionRequestException("Failed to send the session request sms");
}
}
@Override
public UserRole getRoleByName(String sessID, String roleName)
throws RemoteException, SessionExpiredException, SQLException {
String thisDatabase = SessionManager.getInstance().getDatabaseForSession(sessID);
TableSchema roleTable = MedSavantDatabase.UserRoleTableSchema;
SelectQuery sq = new SelectQuery();
sq.addFromTable(roleTable.getTable());
sq.addAllColumns();
sq.addCondition(
BinaryCondition.equalTo(
roleTable.getDBColumn(MedSavantDatabase.UserRoleTableSchema.COLUMNNAME_OF_ROLENAME),
roleName));
ResultSet rs = null;
try {
rs = ConnectionController.executeQuery(sessID, sq.toString());
if (rs.next()) {
int roleId = rs.getInt(1);
String name = rs.getString(2);
String roleDescription = rs.getString(3);
return new UserRole(roleId, name, roleDescription, thisDatabase);
}
return null;
} finally {
if (rs != null) {
rs.close();
}
}
}
@Override
public void run() {
try {
while (true) {
// Get next message from client.
Object msg = _in.readObject();
// If this client hasn't joined the game yet, only accept
// join requests.
if (_viewListener == null) {
if (msg instanceof RequestJoin) {
SessionManager.joinGame(ViewProxy.this, ((RequestJoin) msg).getGameId());
}
// Skip other message checks.
continue;
}
// Listen for only AbaloneMessage's
if (!(msg instanceof AbaloneMessage)) continue;
if (msg instanceof RequestMove) {
_viewListener.requestMove((RequestMove) msg);
} else if (msg instanceof RequestLeave) {
_viewListener.leaveGame();
}
}
} catch (IOException e) {
} catch (ClassNotFoundException e) {
} finally {
if (_viewListener != null) _viewListener.leaveGame();
}
}
@Override
public UserLevel getSessionUsersLevel(String sessID)
throws SQLException, RemoteException, SessionExpiredException {
// username for this session
String name = SessionManager.getInstance().getUserForSession(sessID);
return getUserLevel(sessID, name);
}
/**
* Opens this database. The database should be opened after construction. or reopened by the
* close(int closemode) method during a "shutdown compact". Closes the log if there is an error.
*/
void reopen() {
boolean isNew = false;
setState(DATABASE_OPENING);
try {
nameManager = new HsqlNameManager(this);
granteeManager = new GranteeManager(this);
userManager = new UserManager(this);
schemaManager = new SchemaManager(this);
persistentStoreCollection = new PersistentStoreCollectionDatabase(this);
isReferentialIntegrity = true;
sessionManager = new SessionManager(this);
collation = collation.newDatabaseInstance();
dbInfo = DatabaseInformation.newDatabaseInformation(this);
txManager = new TransactionManager2PL(this);
lobManager.createSchema();
sessionManager.getSysLobSession().setSchema(SqlInvariants.LOBS_SCHEMA);
schemaManager.setSchemaChangeTimestamp();
schemaManager.createSystemTables();
// completed metadata
logger.open();
isNew = logger.isNewDatabase;
if (isNew) {
String username = urlProperties.getProperty("user", "SA");
String password = urlProperties.getProperty("password", "");
userManager.createFirstUser(username, password);
schemaManager.createPublicSchema();
logger.checkpoint(false);
}
lobManager.open();
dbInfo.setWithContent(true);
checkpointRunner = new CheckpointRunner();
timeoutRunner = new TimeoutRunner();
} catch (Throwable e) {
logger.close(Database.CLOSEMODE_IMMEDIATELY);
logger.releaseLock();
setState(DATABASE_SHUTDOWN);
clearStructures();
DatabaseManager.removeDatabase(this);
if (!(e instanceof HsqlException)) {
e = Error.error(ErrorCode.GENERAL_ERROR, e);
}
logger.logSevereEvent("could not reopen database", e);
throw (HsqlException) e;
}
setState(DATABASE_ONLINE);
}
public static boolean isSessionAvailable(HttpServletRequest request) {
if ("true".equals((String) request.getSession().getAttribute("login"))) return true;
Cookie[] cookies = request.getCookies();
if (null == cookies) {
return false;
}
for (Cookie cookie : cookies) {
if ("JSESSIONID".equals(cookie.getName())) {
String sessionId = cookie.getValue();
HttpSession oldSession = SessionManager.find(sessionId);
HttpSession newSession = request.getSession();
boolean previousLogin = false;
if (null != oldSession && null != oldSession.getAttribute("profile")) {
newSession.setAttribute("profile", oldSession.getAttribute("profile"));
}
if (null != oldSession && null != oldSession.getAttribute("login")) {
newSession.setAttribute("login", oldSession.getAttribute("login"));
previousLogin = true;
}
if (previousLogin) {
return true;
}
break;
}
}
return false;
}
/**
* Closes this Database using the specified mode.
*
* <p>
*
* <ol>
* <LI>closemode -1 performs SHUTDOWN IMMEDIATELY, equivalent to a poweroff or crash.
* <LI>closemode 0 performs a normal SHUTDOWN that checkpoints the database normally.
* <LI>closemode 1 performs a shutdown compact that scripts out the contents of any CACHED
* tables to the log then deletes the existing *.data file that contains the data for all
* CACHED table before the normal checkpoint process which in turn creates a new, compact
* *.data file.
* </ol>
*/
public void close(int closemode) {
HsqlException he = null;
setState(DATABASE_CLOSING);
sessionManager.closeAllSessions();
sessionManager.clearAll();
if (filesReadOnly) {
closemode = CLOSEMODE_IMMEDIATELY;
}
/**
* @todo fredt - impact of possible error conditions in closing the log should be investigated
* for the CLOSEMODE_COMPACT mode
*/
logger.closePersistence(closemode);
lobManager.close();
try {
if (closemode == CLOSEMODE_COMPACT) {
clearStructures();
reopen();
setState(DATABASE_CLOSING);
logger.closePersistence(CLOSEMODE_NORMAL);
}
} catch (Throwable t) {
if (t instanceof HsqlException) {
he = (HsqlException) t;
} else {
he = Error.error(ErrorCode.GENERAL_ERROR, t.toString());
}
}
logger.releaseLock();
setState(DATABASE_SHUTDOWN);
clearStructures();
// fredt - this could change to avoid removing a db from the
// DatabaseManager repository if there are pending getDatabase()
// calls
DatabaseManager.removeDatabase(this);
if (he != null) {
throw he;
}
}
/**
* Opens this database. The database should be opened after construction. or reopened by the
* close(int closemode) method during a "shutdown compact". Closes the log if there is an error.
*/
void reopen() throws HsqlException {
boolean isNew;
setState(DATABASE_OPENING);
try {
databaseProperties = new HsqlDatabaseProperties(this);
isNew = !DatabaseURL.isFileBasedDatabaseType(sType) || !databaseProperties.checkFileExists();
if (isNew && urlProperties.isPropertyTrue("ifexists")) {
throw Trace.error(Trace.DATABASE_NOT_EXISTS, sName);
}
databaseProperties.load();
databaseProperties.setURLProperties(urlProperties);
compiledStatementManager.reset();
nameManager = new HsqlNameManager();
granteeManager = new GranteeManager(this);
userManager = new UserManager(this);
hAlias = Library.getAliasMap();
schemaManager = new SchemaManager(this);
bReferentialIntegrity = true;
sessionManager = new SessionManager(this);
txManager = new TransactionManager(this);
collation = new Collation();
dbInfo = DatabaseInformation.newDatabaseInformation(this);
databaseProperties.setDatabaseVariables();
if (DatabaseURL.isFileBasedDatabaseType(sType)) {
logger.openLog(this);
}
if (isNew) {
sessionManager
.getSysSession()
.sqlExecuteDirectNoPreChecks("CREATE USER SA PASSWORD \"\" ADMIN");
logger.synchLogForce();
}
dbInfo.setWithContent(true);
} catch (Throwable e) {
logger.closeLog(Database.CLOSEMODE_IMMEDIATELY);
logger.releaseLock();
setState(DATABASE_SHUTDOWN);
clearStructures();
DatabaseManager.removeDatabase(this);
if (!(e instanceof HsqlException)) {
e = Trace.error(Trace.GENERAL_ERROR, e.toString());
}
throw (HsqlException) e;
}
setState(DATABASE_ONLINE);
}
@Test
public void test_serialize_and_restore_wrongkey() throws Exception {
ClientCredential credential =
new ClientCredential("ClientCredential#clientId", "ClientCredential#clientSecret");
ClientCredential wrongCredential =
new ClientCredential("ClientCredential#clientId", "ClientCredential#clientSecret#wrong");
GoogleTokenResponse tokenResponse = new GoogleTokenResponse();
tokenResponse.setAccessToken("accessToken");
tokenResponse.setRefreshToken("refreshToken");
tokenResponse.setExpiresInSeconds(3600L);
String session = SessionManager.serialize(tokenResponse, credential);
GoogleTokenResponse decoded = SessionManager.restore(session, wrongCredential);
assertThat(decoded, is(nullValue()));
}
private void showAuthToken() {
if (sessionManager.isLoggedIn()) {
// mToken.setText(sessionManager.getCurrentToken());
} else {
// mToken.setText(getString(R.string.no_auth_token));
}
}
@Override
public ResponseMessage execute() {
SessionManager sm = sessionManager;
Session session = sm.getSession(sessionHandler);
if (session == null) {
return ResponseMessage.ErrorMessage("Bad session handler.");
}
Signer signer = session.getSigner();
try {
signer.init(this.mechanism, this.privateKeyHandler);
return ResponseMessage.OKMessage();
} catch (Exception e) {
return ResponseMessage.ErrorMessage(e.getLocalizedMessage());
}
}
