Files
qqq/qqq-middleware-slack/src/main/java/com/kingsrook/qqq/slack/QSlackImplementation.java
Darin Kelkhoff e078015732 CE-881 - Refactoring exports & reports
- add some fields together into ReportDestination class
- pass more data into export streamers (views) and add preRun method
- Add queryHint POTENTIALLY_LARGE_NUMBER_OF_RESULTS
- add pivot views
- optionally take in full ReportMetaData object instead of a name (e.g., for a user-defined/saved report)
2024-03-27 20:11:38 -05:00

773 lines
30 KiB
Java

/*
* QQQ - Low-code Application Framework for Engineers.
* Copyright (C) 2021-2022. Kingsrook, LLC
* 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
* contact@kingsrook.com
* https://github.com/Kingsrook/
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.kingsrook.qqq.slack;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import com.kingsrook.qqq.backend.core.actions.dashboard.RenderWidgetAction;
import com.kingsrook.qqq.backend.core.actions.metadata.MetaDataAction;
import com.kingsrook.qqq.backend.core.actions.reporting.ExportAction;
import com.kingsrook.qqq.backend.core.actions.tables.GetAction;
import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
import com.kingsrook.qqq.backend.core.actions.values.QValueFormatter;
import com.kingsrook.qqq.backend.core.adapters.QInstanceAdapter;
import com.kingsrook.qqq.backend.core.exceptions.QAuthenticationException;
import com.kingsrook.qqq.backend.core.exceptions.QException;
import com.kingsrook.qqq.backend.core.exceptions.QInstanceValidationException;
import com.kingsrook.qqq.backend.core.exceptions.QModuleDispatchException;
import com.kingsrook.qqq.backend.core.instances.QInstanceValidator;
import com.kingsrook.qqq.backend.core.instances.QMetaDataVariableInterpreter;
import com.kingsrook.qqq.backend.core.logging.QLogger;
import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
import com.kingsrook.qqq.backend.core.model.actions.metadata.MetaDataInput;
import com.kingsrook.qqq.backend.core.model.actions.metadata.MetaDataOutput;
import com.kingsrook.qqq.backend.core.model.actions.reporting.ExportInput;
import com.kingsrook.qqq.backend.core.model.actions.reporting.ExportOutput;
import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportDestination;
import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportFormat;
import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
import com.kingsrook.qqq.backend.core.model.actions.widgets.RenderWidgetInput;
import com.kingsrook.qqq.backend.core.model.actions.widgets.RenderWidgetOutput;
import com.kingsrook.qqq.backend.core.model.dashboard.widgets.ChartData;
import com.kingsrook.qqq.backend.core.model.dashboard.widgets.LineChartData;
import com.kingsrook.qqq.backend.core.model.dashboard.widgets.StatisticsData;
import com.kingsrook.qqq.backend.core.model.data.QRecord;
import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
import com.kingsrook.qqq.backend.core.model.metadata.dashboard.QWidgetMetaDataInterface;
import com.kingsrook.qqq.backend.core.model.metadata.fields.DisplayFormat;
import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
import com.kingsrook.qqq.backend.core.utils.StringUtils;
import com.kingsrook.qqq.backend.javalin.QJavalinImplementation;
import com.slack.api.Slack;
import com.slack.api.methods.SlackApiException;
import com.slack.api.methods.request.files.FilesUploadRequest;
import io.javalin.apibuilder.EndpointGroup;
import io.javalin.http.ContentType;
import io.javalin.http.Context;
import org.apache.commons.io.FileUtils;
import org.apache.http.NameValuePair;
import org.apache.http.client.utils.URLEncodedUtils;
import org.json.JSONArray;
import org.json.JSONObject;
import static io.javalin.apibuilder.ApiBuilder.path;
import static io.javalin.apibuilder.ApiBuilder.post;
/*******************************************************************************
** QQQ Slack implementation. Given a QInstance, defines all routes needed
** to respond to Slack http requests and give appropriate responses
**
*******************************************************************************/
public class QSlackImplementation
{
private static final QLogger LOG = QLogger.getLogger(QSlackImplementation.class);
static QInstance qInstance;
/*******************************************************************************
**
*******************************************************************************/
public QSlackImplementation(QInstance qInstance) throws QInstanceValidationException
{
QSlackImplementation.qInstance = qInstance;
new QInstanceValidator().validate(qInstance);
}
/*******************************************************************************
**
*******************************************************************************/
public QSlackImplementation(String qInstanceFilePath) throws IOException
{
LOG.info("Loading qInstance from file (assuming json): " + qInstanceFilePath);
String qInstanceJson = FileUtils.readFileToString(new File(qInstanceFilePath));
QSlackImplementation.qInstance = new QInstanceAdapter().jsonToQInstanceIncludingBackends(qInstanceJson);
}
/*******************************************************************************
**
*******************************************************************************/
public EndpointGroup getRoutes()
{
return (() ->
{
path("/slack", () ->
{
post("/", QSlackImplementation::slack);
});
});
}
/*******************************************************************************
** handle slack command posts
*******************************************************************************/
private static void slack(Context context)
{
try
{
///////////////////////////////////////////
// get the input data from slack request //
///////////////////////////////////////////
String result = context.body();
List<NameValuePair> params = URLEncodedUtils.parse(new URI("?" + result), StandardCharsets.UTF_8);
String command = null;
String text = null;
for(NameValuePair nameValuePair : params)
{
if(nameValuePair.getName().equalsIgnoreCase("command"))
{
command = nameValuePair.getValue();
}
else if(nameValuePair.getName().equalsIgnoreCase("text"))
{
text = nameValuePair.getValue();
}
}
if(command == null)
{
buildSlackMessage(context, "Error", "No command was entered");
}
else if(text == null || !StringUtils.hasContent(text))
{
buildSlackMetaData(context);
}
else
{
String[] parts = text.trim().split("\\W");
if(text.trim().startsWith("table"))
{
String tableName = null;
String action = null;
if(parts.length < 2)
{
buildSlackMessage(context, "Error", "A valid table name must be provided");
return;
}
if(!qInstance.getTables().containsKey(parts[1]))
{
buildSlackMessage(context, "Error", "Table [" + parts[1] + "] could not be found");
return;
}
tableName = parts[1];
if(parts.length < 3 || (!parts[2].equalsIgnoreCase("query") && !parts[2].equalsIgnoreCase("get") && !parts[2].equalsIgnoreCase("export")))
{
buildSlackMessage(context, "Error", "A valid table action must be provided: export, get, or query");
return;
}
action = parts[2];
if(action.equals("query"))
{
buildQueryResultMessage(context, tableName);
return;
}
else if(action.equals("export"))
{
if(parts.length < 4)
{
buildSlackMessage(context, "Error", "A format must be provided for the export action: csv, json, xlsx");
return;
}
////////////////////////////
// make sure valid format //
////////////////////////////
ReportFormat format = ReportFormat.fromString(parts[3]);
if(format == null)
{
buildSlackMessage(context, "Error", "A format must be one of the following: csv, json, xlsx");
return;
}
buildExportMessage(context, tableName, format.name());
return;
}
else if(action.equals("get"))
{
if(parts.length < 4)
{
buildSlackMessage(context, "Error", "A primary key must be provided for the get action");
return;
}
buildGetResultMessage(context, tableName, parts[3]);
return;
}
buildSlackMessage(context, "Success", "Load table data");
}
if(text.trim().startsWith("widget"))
{
String widgetName = null;
if(parts.length < 2)
{
buildSlackMessage(context, "Error", "A valid widget name name must be provided");
return;
}
widgetName = parts[1];
buildWidgetMessage(context, widgetName);
}
else
{
buildSlackMessage(context, "Error", "Invalid command was entered");
}
}
}
catch(Exception e)
{
handleException(context, e);
}
}
/*******************************************************************************
** build up slack message
*******************************************************************************/
private static void buildSlackMessage(Context context, String title, String message)
{
context.contentType(ContentType.JSON);
JSONObject response = new JSONObject();
JSONArray blocksArray = new JSONArray();
blocksArray.put(createSlackBlock(title, message));
response.put("response_type", "in_channel");
response.put("blocks", blocksArray);
context.result(response.toString());
}
/*******************************************************************************
** handle slack command posts
*******************************************************************************/
private static void buildSlackMetaData(Context context) throws QException
{
MetaDataInput metaDataInput = new MetaDataInput();
setupSession(context, metaDataInput);
MetaDataAction metaDataAction = new MetaDataAction();
MetaDataOutput metaDataOutput = metaDataAction.execute(metaDataInput);
context.contentType(ContentType.JSON);
JSONObject response = new JSONObject();
JSONArray blocksArray = new JSONArray();
response.put("response_type", "in_channel");
response.put("blocks", blocksArray);
////////////
// tables //
////////////
StringBuilder tables = new StringBuilder("\n*Tables*\n");
List<String> tableNameList = metaDataOutput.getTables().keySet().stream().sorted().toList();
for(int i = 0; i < tableNameList.size(); i++)
{
tables.append(metaDataOutput.getTables().get(tableNameList.get(i)).getLabel()).append(" [").append(tableNameList.get(i)).append("]\n");
if(i == 4 && tableNameList.size() > 5)
{
tables.append("... and ").append(tableNameList.size() - 5).append(" more\n");
break;
}
}
blocksArray.put(createSlackBlock("Tables", tables.toString()));
///////////////
// processes //
///////////////
StringBuilder processes = new StringBuilder();
List<String> processNameList = metaDataOutput.getProcesses().keySet().stream().sorted().toList();
for(int i = 0; i < processNameList.size(); i++)
{
processes.append(metaDataOutput.getProcesses().get(processNameList.get(i)).getLabel()).append(" [").append(processNameList.get(i)).append("]\n");
if(i == 9 && processNameList.size() > 10)
{
processes.append("... and ").append(processNameList.size() - 10).append(" more\n");
break;
}
}
blocksArray.put(createSlackBlock("Processes", processes.toString()));
/////////////
// reports //
/////////////
StringBuilder reports = new StringBuilder();
List<String> reportNameList = metaDataOutput.getReports().keySet().stream().sorted().toList();
for(int i = 0; i < reportNameList.size(); i++)
{
reports.append(metaDataOutput.getReports().get(reportNameList.get(i)).getLabel()).append(" [").append(reportNameList.get(i)).append("]\n");
if(i == 9 && reportNameList.size() > 10)
{
reports.append("... and ").append(reportNameList.size() - 10).append(" more\n");
break;
}
}
blocksArray.put(createSlackBlock("Reports", reports.toString()));
/////////////
// widgets //
/////////////
StringBuilder widgets = new StringBuilder();
List<String> widgetNameList = metaDataOutput.getWidgets().keySet().stream().sorted().toList();
for(int i = 0; i < widgetNameList.size(); i++)
{
//////////////////////////////
// only allow certain types //
//////////////////////////////
String widgetName = widgetNameList.get(i);
String widgetType = qInstance.getWidget(widgetName).getType();
if(!widgetType.contains("tatistics") && !widgetType.equals("table") && !widgetType.contains("ineChart"))
{
continue;
}
if(widgetName.contains("YTDSpend") || widgetName.contains("ShipmentsByWarehouse") || widgetName.contains("Overrides") || widgetName.contains("TNT") || widgetName.contains("ParcelInvoice") || widgetName.contains("BillingWork") || widgetName.contains("AssociatedParcel") || widgetName.contains("FreightStudy"))
{
continue;
}
widgets.append(metaDataOutput.getWidgets().get(widgetName).getLabel()).append(" [").append(widgetName).append("]\n");
}
blocksArray.put(createSlackBlock("Widgets", widgets.toString()));
context.result(response.toString());
}
/*******************************************************************************
** handle slack command posts
*******************************************************************************/
private static void buildQueryResultMessage(Context context, String tableName) throws QException
{
try
{
QueryInput queryInput = new QueryInput();
queryInput.setFilter(new QQueryFilter().withLimit(10));
queryInput.setTableName(tableName);
setupSession(context, queryInput);
QueryOutput output = new QueryAction().execute(queryInput);
StringBuilder results = new StringBuilder();
if(CollectionUtils.nullSafeHasContents(output.getRecords()))
{
for(QRecord qRecord : output.getRecords())
{
results.append(qRecord.toString()).append("\n");
}
}
else
{
results.append("No results were found");
}
JSONObject response = new JSONObject();
JSONArray blocksArray = new JSONArray();
blocksArray.put(createSlackBlock("Query on table [" + tableName + "] results", results.toString()));
response.put("response_type", "in_channel");
response.put("blocks", blocksArray);
context.result(response.toString());
}
catch(Exception e)
{
buildSlackMessage(context, "Error", e.getMessage());
}
}
/*******************************************************************************
*
*******************************************************************************/
private static void buildExportMessage(Context context, String tableName, String format) throws QException
{
try(ByteArrayOutputStream baos = new ByteArrayOutputStream())
{
ExportInput exportInput = new ExportInput();
exportInput.setLimit(1000);
exportInput.setTableName(tableName);
exportInput.setReportDestination(new ReportDestination()
.withReportFormat(ReportFormat.valueOf(format))
.withReportOutputStream(baos));
setupSession(context, exportInput);
ExportOutput output = new ExportAction().execute(exportInput);
JSONObject response = new JSONObject();
JSONArray blocksArray = new JSONArray();
blocksArray.put(createSlackBlock("Export of table [" + tableName + "] has been generated", ""));
response.put("response_type", "in_channel");
response.put("blocks", blocksArray);
context.result(response.toString());
//////////////////////////////////////////////////////////////
// you can get this instance via ctx.client() in a Bolt app //
//////////////////////////////////////////////////////////////
var client = Slack.getInstance().methods();
client.filesUpload(FilesUploadRequest.builder()
.token("xoxb-1413823704023-4637156460004-e6Vwq23PjTDw5D7OzOp2fIWi")
.channels(List.of("C04JNM6BTMY"))
.filetype(format)
.filename("test." + format)
.fileData(baos.toByteArray())
.build()
);
}
catch(Exception e)
{
buildSlackMessage(context, "Error", e.getMessage());
}
}
/*******************************************************************************
*
*******************************************************************************/
private static void buildGetResultMessage(Context context, String tableName, Serializable id) throws QException
{
try
{
QTableMetaData tableMetaData = qInstance.getTable(tableName);
GetInput getInput = new GetInput();
getInput.setPrimaryKey(id);
getInput.setTableName(tableName);
setupSession(context, getInput);
GetOutput output = new GetAction().execute(getInput);
StringBuilder results = new StringBuilder();
if(output.getRecord() != null)
{
List<String> fieldNameList = tableMetaData.getFields().keySet().stream().sorted().toList();
for(String fieldName : fieldNameList)
{
QFieldMetaData fieldMetaData = tableMetaData.getField(fieldName);
results.append(fieldMetaData.getLabel()).append(": ").append(output.getRecord().getValue(fieldName)).append("\n");
}
}
else
{
results.append("Record was not found");
}
JSONObject response = new JSONObject();
JSONArray blocksArray = new JSONArray();
blocksArray.put(createSlackBlock("Get [" + id + "] on table [" + tableName + "] results", results.toString()));
response.put("response_type", "in_channel");
response.put("blocks", blocksArray);
context.result(response.toString());
}
catch(Exception e)
{
buildSlackMessage(context, "Error", e.getMessage());
}
}
/*******************************************************************************
*
*******************************************************************************/
private static void buildWidgetMessage(Context context, String widgetName) throws QException
{
try
{
JSONObject response = new JSONObject();
JSONArray blocksArray = new JSONArray();
QWidgetMetaDataInterface widgetMetaData = qInstance.getWidget(widgetName);
RenderWidgetInput input = new RenderWidgetInput()
.withWidgetMetaData(widgetMetaData);
setupSession(context, input);
RenderWidgetOutput output = new RenderWidgetAction().execute(input);
blocksArray.put(createSlackBlock(null, convertWidgetDataToSlackMessage(widgetMetaData, output)));
response.put("response_type", "in_channel");
response.put("blocks", blocksArray);
context.result(response.toString());
}
catch(Exception e)
{
buildSlackMessage(context, "Error", e.getMessage());
}
}
/*******************************************************************************
*
*******************************************************************************/
public static String convertWidgetDataToSlackMessage(QWidgetMetaDataInterface widgetMetaData, RenderWidgetOutput widgetOutput) throws QException
{
StringBuilder results = new StringBuilder("\n");
if(widgetOutput.getWidgetData() instanceof StatisticsData data)
{
results.append("\n*").append(widgetMetaData.getLabel()).append("*: ").append(QValueFormatter.formatValue(DisplayFormat.COMMAS, data.getCount()));
}
else if(widgetOutput.getWidgetData() instanceof LineChartData data)
{
LineChartData.Data lineChartData = data.getChartData();
if(lineChartData != null && CollectionUtils.nullSafeHasContents(lineChartData.getLabels()))
{
for(int i = 0; i < lineChartData.getLabels().size(); i++)
{
results.append("*").append(lineChartData.getLabels().get(i)).append("*: ");
for(LineChartData.Data.Dataset dataset : lineChartData.getDatasets())
{
List<String> dataSetDataStrings = new ArrayList<>();
for(Number dataValue : dataset.getData())
{
dataSetDataStrings.add(QValueFormatter.formatValue(DisplayFormat.COMMAS, dataValue));
}
results.append(dataset.getLabel()).append(" [").append(StringUtils.join(",", dataSetDataStrings)).append("] ");
}
results.append("\n");
}
}
else
{
results.append("No data was found");
}
}
else if(widgetOutput.getWidgetData() instanceof ChartData data)
{
ChartData.Data chartData = data.getChartData();
if(chartData != null && CollectionUtils.nullSafeHasContents(chartData.getLabels()))
{
for(int i = 0; i < chartData.getLabels().size(); i++)
{
results.append("*").append(chartData.getLabels().get(i)).append("*: ");
for(ChartData.Data.Dataset dataset : chartData.getDatasets())
{
results.append(QValueFormatter.formatValue(DisplayFormat.COMMAS, dataset.getData().get(i)));
}
results.append("\n");
}
}
else
{
results.append("No data was found");
}
}
/*
else
{
results.append("\n*").append(widgetMetaData.getLabel()).append("*: ").append(widgetOutput.getWidgetData());
}
*/
else
{
results.append("Unsupported widget type");
}
return (results.toString());
}
/*******************************************************************************
** creates a slack block jsonString
*******************************************************************************/
private static JSONObject createSlackBlock(String title, String body)
{
JSONObject text = new JSONObject();
JSONObject block = new JSONObject();
block.put("type", "section");
block.put("text", text);
text.put("type", "mrkdwn");
StringBuilder output = new StringBuilder();
if(title != null)
{
output.append("\n*").append(title).append("*\n");
}
output.append(body);
text.put("text", output.toString());
return (block);
}
/*******************************************************************************
** send a message to Slack
**
*******************************************************************************/
public static void postMessage(String text)
{
//////////////////////////////////////////////////////////////
// you can get this instance via ctx.client() in a Bolt app //
//////////////////////////////////////////////////////////////
var client = Slack.getInstance().methods();
String slackToken = new QMetaDataVariableInterpreter().interpret("${env.SLACK_TOKEN}");
String slackChannel = new QMetaDataVariableInterpreter().interpret("${env.SLACK_CHANNEL_ID}");
try
{
///////////////////////////////////////////////////////////////////
// Call the chat.postMessage method using the built-in WebClient //
///////////////////////////////////////////////////////////////////
var result = client.chatPostMessage(r -> r
.token(slackToken)
.channel(slackChannel)
.mrkdwn(true)
.text(text)
);
//////////////////////////////////////////////////////////////////////////
// Print result, which includes information about the message (like TS) //
//////////////////////////////////////////////////////////////////////////
LOG.info("Slack post result {}", result);
}
catch(IOException | SlackApiException e)
{
LOG.error("error: {}", e.getMessage(), e);
}
}
/*******************************************************************************
**
*******************************************************************************/
public static void setupSession(Context context, AbstractActionInput input) throws QModuleDispatchException, QAuthenticationException
{
QJavalinImplementation.setupSession(context, input);
/*
QAuthenticationModuleDispatcher qAuthenticationModuleDispatcher = new QAuthenticationModuleDispatcher();
QAuthenticationModuleInterface authenticationModule = qAuthenticationModuleDispatcher.getQModule(input.getAuthenticationMetaData());
boolean needToSetSessionIdCookie = false;
try
{
Map<String, String> authenticationContext = new HashMap<>();
String sessionIdCookieValue = context.cookie(SESSION_ID_COOKIE_NAME);
String authorizationHeaderValue = context.header("Authorization");
if(StringUtils.hasContent(sessionIdCookieValue))
{
////////////////////////////////////////
// first, look for a sessionId cookie //
////////////////////////////////////////
authenticationContext.put(SESSION_ID_COOKIE_NAME, sessionIdCookieValue);
needToSetSessionIdCookie = true;
}
else if(authorizationHeaderValue != null)
{
/////////////////////////////////////////////////////////////////////////////////////////////////
// second, look for the authorization header: //
// either with a "Basic " prefix (for a username:password pair) //
// or with a "Bearer " prefix (for a token that can be handled the same as a sessionId cookie) //
/////////////////////////////////////////////////////////////////////////////////////////////////
String basicPrefix = "Basic ";
String bearerPrefix = "Bearer ";
if(authorizationHeaderValue.startsWith(basicPrefix))
{
authorizationHeaderValue = authorizationHeaderValue.replaceFirst(basicPrefix, "");
authenticationContext.put(BASIC_AUTH_NAME, authorizationHeaderValue);
needToSetSessionIdCookie = true;
}
else if(authorizationHeaderValue.startsWith(bearerPrefix))
{
authorizationHeaderValue = authorizationHeaderValue.replaceFirst(bearerPrefix, "");
authenticationContext.put(SESSION_ID_COOKIE_NAME, authorizationHeaderValue);
}
else
{
LOG.debug("Authorization header value did not have Basic or Bearer prefix. [" + authorizationHeaderValue + "]");
}
}
else
{
LOG.debug("Neither [" + SESSION_ID_COOKIE_NAME + "] cookie nor [Authorization] header was present in request.");
}
QSession session = authenticationModule.createSession(qInstance, authenticationContext);
/////////////////////////////////////////////////////////////////////////////////
// if we got a session id cookie in, then send it back with updated cookie age //
/////////////////////////////////////////////////////////////////////////////////
if(needToSetSessionIdCookie)
{
context.cookie(SESSION_ID_COOKIE_NAME, session.getIdReference(), SESSION_COOKIE_AGE);
}
setUserTimezoneOffsetMinutesHeaderInSession(context, session);
}
catch(QAuthenticationException qae)
{
////////////////////////////////////////////////////////////////////////////////
// if exception caught, clear out the cookie so the frontend will reauthorize //
////////////////////////////////////////////////////////////////////////////////
if(needToSetSessionIdCookie)
{
context.removeCookie(SESSION_ID_COOKIE_NAME);
}
throw (qae);
}
*/
}
/*******************************************************************************
**
*******************************************************************************/
public static void handleException(Context context, Exception e)
{
buildSlackMessage(context, "Error", e.getMessage());
}
}