0001: package com.calipso.reportgenerator.common;
0002:
0003: import com.calipso.reportgenerator.common.ReportGeneratorConfiguration;
0004: import com.calipso.reportgenerator.common.RemoteReportManager;
0005: import com.calipso.reportgenerator.enterprise.common.ReportManagerSFHome;
0006: import com.calipso.reportgenerator.enterprise.common.ReportManagerSF;
0007: import com.calipso.reportgenerator.reportdefinitions.ReportView;
0008: import com.calipso.reportgenerator.reportdefinitions.ReportDefinition;
0009: import com.calipso.reportgenerator.reportdefinitions.ReportSourceDefinition;
0010: import com.calipso.reportgenerator.reportcalculator.Matrix;
0011: import javax.naming.Context;
0012: import javax.naming.InitialContext;
0013: import java.rmi.RemoteException;
0014: import java.util.*;
0015: import java.text.MessageFormat;
0016: import java.io.Serializable;
0017:
0018: /**
0019: * Se crea solo cuando el EJB es de tipo Stateful.
0020: * Representa la capa entre el cliente y la aplicación,
0021: * y presenta los métodos que el cliente podra invocar correspondientes al ReportManager
0022: * agregándole el throws InfoException por el contexto en el que se ejecuta.
0023: * @see com.calipso.reportgenerator.reportmanager.ReportManager
0024: *
0025: */
0026:
0027: public class RemoteReportManagerStateFul extends RemoteReportManager
0028: implements Serializable {
0029: private ReportManagerSF reportManagerRemote;
0030: private String clientIp;
0031:
0032: /**
0033: * Inicializa el RemoteReportManager con la configuración correspondiente
0034: * @param reportGeneratorConfiguration
0035: */
0036: public RemoteReportManagerStateFul(
0037: ReportGeneratorConfiguration reportGeneratorConfiguration,
0038: String distributedHost) {
0039: super (reportGeneratorConfiguration, distributedHost);
0040: }
0041:
0042: /**
0043: * Obtiene un ReportManagerSF creándolo si es necesario.
0044: * @return el ReportManagerRemote correspondiente a la instancia de RemoteReportManagerStateFul
0045: */
0046: public ReportManagerSF getReportManagerRemote()
0047: throws InfoException {
0048: if (reportManagerRemote == null) {
0049: reportManagerRemote = newReportManagerRemote();
0050: }
0051: return reportManagerRemote;
0052: }
0053:
0054: /**
0055: * Crea un nuevo ReportManagerRemote, dicha instancia
0056: * servira para invocar los metodos heredados
0057: * @return el ReportManagerSF correspondiente de la instancia RemoteReportManagerStateful
0058: * @throws com.calipso.reportgenerator.common.InfoException
0059: */
0060: private ReportManagerSF newReportManagerRemote()
0061: throws InfoException {
0062: Hashtable env = getEnviroment();
0063: try {
0064: Context ctx = new InitialContext(env);
0065: Object obj = ctx.lookup(getReportGeneratorConfiguration()
0066: .getReportManagerEJB_SFName());
0067: ReportManagerSFHome home = (ReportManagerSFHome) javax.rmi.PortableRemoteObject
0068: .narrow(obj, ReportManagerSFHome.class);
0069: ReportManagerSF reportManager = home
0070: .create(getReportGeneratorConfiguration());
0071: return reportManager;
0072: } catch (Exception e) {
0073: throw new InfoException(LanguageTraslator.traslate("78"), e);
0074: }
0075: }
0076:
0077: public int PrepareReport(String reportDefId) throws InfoException {
0078: try {
0079: return getReportManagerRemote().PrepareReport(reportDefId);
0080: } catch (RemoteException e) {
0081: throw new InfoException(
0082: MessageFormat
0083: .format(
0084: (LanguageTraslator.traslate("87")),
0085: new Object[] { "RemoteReportManagerStateful-PrepareReport(String reportDefId)" }),
0086: e);
0087: }
0088: }
0089:
0090: public int PrepareReport(String reportDefId, Map paramValues)
0091: throws InfoException {
0092: try {
0093: return getReportManagerRemote().PrepareReport(reportDefId,
0094: paramValues);
0095: } catch (RemoteException e) {
0096: throw new InfoException(
0097: MessageFormat
0098: .format(
0099: (LanguageTraslator.traslate("87")),
0100: new Object[] { "RemoteReportManagerStateful-PrepareReport(String reportDefId, Map paramValues)" }),
0101: e);
0102: }
0103: }
0104:
0105: public void ReleaseReport(int handle) throws InfoException {
0106: try {
0107: getReportManagerRemote().ReleaseReport(handle);
0108: } catch (RemoteException e) {
0109: throw new InfoException(
0110: MessageFormat
0111: .format(
0112: (LanguageTraslator.traslate("87")),
0113: new Object[] { "RemoteReportManagerStateful-ReleaseReport(int handle)" }),
0114: e);
0115: }
0116: }
0117:
0118: public void prepareReportSource(String reportSourceDefinitionId)
0119: throws InfoException {
0120: try {
0121: getReportManagerRemote().prepareReportSource(
0122: reportSourceDefinitionId);
0123: } catch (RemoteException e) {
0124: throw new InfoException(
0125: MessageFormat
0126: .format(
0127: (LanguageTraslator.traslate("87")),
0128: new Object[] { "RemoteReportManagerStateful-prepareReportSource(String reportSourceDefinitionId)" }),
0129: e);
0130: }
0131: }
0132:
0133: public Map getReportDefinitions() throws InfoException {
0134: try {
0135: return getReportManagerRemote().getReportDefinitions();
0136: } catch (RemoteException e) {
0137: throw new InfoException(
0138: MessageFormat
0139: .format(
0140: (LanguageTraslator.traslate("87")),
0141: new Object[] { "RemoteReportManagerStateful-getReportDefinitions()" }),
0142: e);
0143: }
0144: }
0145:
0146: public Map getReportSourceDefinitions() throws InfoException {
0147: try {
0148: return getReportManagerRemote()
0149: .getReportSourceDefinitions();
0150: } catch (RemoteException e) {
0151: throw new InfoException(
0152: MessageFormat
0153: .format(
0154: (LanguageTraslator.traslate("87")),
0155: new Object[] { "RemoteReportManagerStateful-getReportSourceDefinitions()" }),
0156: e);
0157: }
0158: }
0159:
0160: public Map getReportsForEntity(String entityID)
0161: throws InfoException {
0162: try {
0163: return getReportManagerRemote().getReportsForEntity(
0164: entityID);
0165: } catch (RemoteException e) {
0166: throw new InfoException(
0167: MessageFormat
0168: .format(
0169: (LanguageTraslator.traslate("87")),
0170: new Object[] { "RemoteReportManagerStateful-getReportsForEntity(String entityID)" }),
0171: e);
0172: }
0173: }
0174:
0175: public void ExecuteAction(int handle, String actionName,
0176: Object params) throws InfoException {
0177: try {
0178: getReportManagerRemote().ExecuteAction(handle, actionName,
0179: params);
0180: } catch (RemoteException e) {
0181: throw new InfoException(
0182: MessageFormat
0183: .format(
0184: (LanguageTraslator.traslate("87")),
0185: new Object[] { "RemoteReportManagerStateful-ExecuteAction(int handle, String actionName, Object params)" }),
0186: e);
0187: }
0188: }
0189:
0190: public void saveReportDefinition(ReportDefinition reportDefinition)
0191: throws InfoException {
0192: try {
0193: getReportManagerRemote().saveReportDefinition(
0194: reportDefinition);
0195: } catch (RemoteException e) {
0196: throw new InfoException(
0197: MessageFormat
0198: .format(
0199: (LanguageTraslator.traslate("87")),
0200: new Object[] { "RemoteReportManagerStateful-saveReportDefinition(ReportDefinition reportDefinition)" }),
0201: e);
0202: }
0203: }
0204:
0205: public void saveReportSourceDefinition(
0206: ReportSourceDefinition reportSourceDefinition)
0207: throws InfoException {
0208: try {
0209: getReportManagerRemote().saveReportSourceDefinition(
0210: reportSourceDefinition);
0211: } catch (RemoteException e) {
0212: throw new InfoException(
0213: MessageFormat
0214: .format(
0215: (LanguageTraslator.traslate("87")),
0216: new Object[] { "RemoteReportManagerStateful-saveReportSourceDefinition(ReportSourceDefinition reportSourceDefinition)" }),
0217: e);
0218: }
0219: }
0220:
0221: public void invalidateReportSource(String reportSourceDefinitionId)
0222: throws InfoException {
0223: try {
0224: getReportManagerRemote().invalidateReportSource(
0225: reportSourceDefinitionId);
0226: } catch (RemoteException e) {
0227: throw new InfoException(
0228: MessageFormat
0229: .format(
0230: (LanguageTraslator.traslate("87")),
0231: new Object[] { "RemoteReportManagerStateful-invalidateReportSource(String reportSourceDefinitionId)" }),
0232: e);
0233: }
0234: }
0235:
0236: public ReportQuery getReportQuery(int handle) throws InfoException {
0237: try {
0238: return getReportManagerRemote().getReportQuery(handle);
0239: } catch (RemoteException e) {
0240: throw new InfoException(
0241: MessageFormat
0242: .format(
0243: (LanguageTraslator.traslate("87")),
0244: new Object[] { "RemoteReportManagerStateful-getReportQuery(int handle)" }),
0245: e);
0246: }
0247: }
0248:
0249: public ReportQuery getDefaultReportQuery(int handle)
0250: throws InfoException {
0251: try {
0252: return getReportManagerRemote().getDefaultReportQuery(
0253: handle);
0254: } catch (RemoteException e) {
0255: throw new InfoException(
0256: MessageFormat
0257: .format(
0258: (LanguageTraslator.traslate("87")),
0259: new Object[] { "RemoteReportManagerStateful-getDefaultReportQuery(int handle)" }),
0260: e);
0261: }
0262: }
0263:
0264: public ReportQuery getReportQuery(String reportDefinitionId)
0265: throws InfoException {
0266: try {
0267: return getReportManagerRemote().getReportQuery(
0268: reportDefinitionId);
0269: } catch (RemoteException e) {
0270: throw new InfoException(
0271: MessageFormat
0272: .format(
0273: (LanguageTraslator.traslate("87")),
0274: new Object[] { "RemoteReportManagerStateful-getReportQuery(String reportDefinitionId)" }),
0275: e);
0276: }
0277: }
0278:
0279: public ReportQuery getDefaultReportQuery(String reportDefinitionId)
0280: throws InfoException {
0281: try {
0282: return getReportManagerRemote().getDefaultReportQuery(
0283: reportDefinitionId);
0284: } catch (RemoteException e) {
0285: throw new InfoException(
0286: MessageFormat
0287: .format(
0288: (LanguageTraslator.traslate("87")),
0289: new Object[] { "RemoteReportManagerStateful-getDefaultReportQuery(String reportDefinitionId)" }),
0290: e);
0291: }
0292: }
0293:
0294: public ReportResult ExecReportQuery(int handle, Map paramValues)
0295: throws InfoException {
0296: try {
0297: return getReportManagerRemote().ExecReportQuery(handle,
0298: paramValues);
0299: } catch (RemoteException e) {
0300: throw new InfoException(
0301: MessageFormat
0302: .format(
0303: (LanguageTraslator.traslate("87")),
0304: new Object[] { "RemoteReportManagerStateful-ExecReportQuery(int handle, Map paramValues)" }),
0305: e);
0306: }
0307: }
0308:
0309: public ReportResult ExecReportQuery(int handle, ReportQuery query)
0310: throws InfoException {
0311: try {
0312: return getReportManagerRemote().ExecReportQuery(handle,
0313: query);
0314: } catch (RemoteException e) {
0315: throw new InfoException(
0316: MessageFormat
0317: .format(
0318: (LanguageTraslator.traslate("87")),
0319: new Object[] { "RemoteReportManagerStateful-ExecReportQuery(int handle, ReportQuery query)" }),
0320: e);
0321: }
0322: }
0323:
0324: public ReportResult ExecReportQuery(String reportDefinitionID,
0325: Map paramValues) throws InfoException {
0326: try {
0327: return getReportManagerRemote().ExecReportQuery(
0328: reportDefinitionID, paramValues);
0329: } catch (RemoteException e) {
0330: throw new InfoException(
0331: MessageFormat
0332: .format(
0333: (LanguageTraslator.traslate("87")),
0334: new Object[] { "RemoteReportManagerStateful-ExecReportQuery(String reportDefinitionID, Map paramValues)" }),
0335: e);
0336: }
0337: }
0338:
0339: public ReportResult ExecReportQuery(String reportDefId,
0340: ReportQuery query) throws InfoException {
0341: try {
0342: return getReportManagerRemote().ExecReportQuery(
0343: reportDefId, query);
0344: } catch (RemoteException e) {
0345: throw new InfoException(
0346: MessageFormat
0347: .format(
0348: (LanguageTraslator.traslate("87")),
0349: new Object[] { "RemoteReportManagerStateful-ExecReportQuery(String reportDefId, ReportQuery query)" }),
0350: e);
0351: }
0352: }
0353:
0354: public ReportQuery getDefaultReportQuery(int handle, String userID)
0355: throws InfoException {
0356: try {
0357: return getReportManagerRemote().getDefaultReportQuery(
0358: handle, userID);
0359: } catch (RemoteException e) {
0360: throw new InfoException(
0361: MessageFormat
0362: .format(
0363: (LanguageTraslator.traslate("87")),
0364: new Object[] { "RemoteReportManagerStateful-getDefaultReportQuery(int handle,String userID)" }),
0365: e);
0366: }
0367: };
0368:
0369: public Map getReportViews(String reportDefinitionID, String userID)
0370: throws InfoException {
0371: try {
0372: return getReportManagerRemote().getReportViews(
0373: reportDefinitionID, userID);
0374: } catch (RemoteException e) {
0375: throw new InfoException(
0376: MessageFormat
0377: .format(
0378: (LanguageTraslator.traslate("87")),
0379: new Object[] { "RemoteReportManagerStateful-getReportViews(String reportDefinitionID, String userID)" }),
0380: e);
0381: }
0382: };
0383:
0384: public Map getReportViews(String reportDefinitionID)
0385: throws InfoException {
0386: try {
0387: return getReportManagerRemote().getReportViews(
0388: reportDefinitionID);
0389: } catch (RemoteException e) {
0390: throw new InfoException(
0391: MessageFormat
0392: .format(
0393: (LanguageTraslator.traslate("87")),
0394: new Object[] { "RemoteReportManagerStateful-getReportViews(String reportDefinitionID)" }),
0395: e);
0396: }
0397: };
0398:
0399: public ReportResult ExecReportQuery(int handle, String reportViewId)
0400: throws InfoException {
0401: try {
0402: return getReportManagerRemote().ExecReportQuery(handle,
0403: reportViewId);
0404: } catch (RemoteException e) {
0405: throw new InfoException(
0406: MessageFormat
0407: .format(
0408: (LanguageTraslator.traslate("87")),
0409: new Object[] { "RemoteReportManagerStateful-ExecReportQuery(int handle, String reportViewId)" }),
0410: e);
0411: }
0412: };
0413:
0414: public ReportSpec getReportSpec(String reportDefinitionId,
0415: String reportSourceDefId) throws InfoException {
0416: try {
0417: return getReportManagerRemote().getReportSpec(
0418: reportDefinitionId, reportSourceDefId);
0419: } catch (RemoteException e) {
0420: throw new InfoException(
0421: MessageFormat
0422: .format(
0423: (LanguageTraslator.traslate("87")),
0424: new Object[] { "RemoteReportManagerStateful-getReportSpec(String reportDefinitionId, String reportSourceDefId)" }),
0425: e);
0426: }
0427: }
0428:
0429: public ReportSpec getReportSpec(ReportDefinition reportDefinition,
0430: ReportSourceDefinition reportSourceDef)
0431: throws InfoException {
0432: try {
0433: return getReportManagerRemote().getReportSpec(
0434: reportDefinition, reportSourceDef);
0435: } catch (RemoteException e) {
0436: throw new InfoException(
0437: MessageFormat
0438: .format(
0439: (LanguageTraslator.traslate("87")),
0440: new Object[] { "getReportSpec(ReportDefinition reportDefinition, ReportSourceDefinition reportSourceDef)" }),
0441: e);
0442: }
0443: }
0444:
0445: public ReportSpec getReportSpec(String reportDefinitionId)
0446: throws InfoException {
0447: try {
0448: return getReportManagerRemote().getReportSpec(
0449: reportDefinitionId);
0450: } catch (RemoteException e) {
0451: throw new InfoException(
0452: MessageFormat
0453: .format(
0454: (LanguageTraslator.traslate("87")),
0455: new Object[] { "RemoteReportManagerStateful-getReportSpec(String reportDefinitionId)" }),
0456: e);
0457: }
0458: }
0459:
0460: public ReportView getReportView(String reportViewId)
0461: throws InfoException {
0462: try {
0463: return getReportManagerRemote().getReportView(reportViewId);
0464: } catch (RemoteException e) {
0465: throw new InfoException(
0466: MessageFormat
0467: .format(
0468: (LanguageTraslator.traslate("87")),
0469: new Object[] { "RemoteReportManagerStateful-getReportView(String reportViewId)" }),
0470: e);
0471: }
0472: }
0473:
0474: public void saveReportView(ReportView reportView)
0475: throws InfoException {
0476: try {
0477: getReportManagerRemote().saveReportView(reportView);
0478: } catch (RemoteException e) {
0479: throw new InfoException(
0480: MessageFormat
0481: .format(
0482: (LanguageTraslator.traslate("87")),
0483: new Object[] { "RemoteReportManagerStateful-saveReportView(ReportView reportView)" }),
0484: e);
0485: }
0486: }
0487:
0488: public ReportView getReportViewFromID(String id,
0489: String reportDefinitionId, String userId)
0490: throws InfoException {
0491: try {
0492: return getReportManagerRemote().getReportViewFromID(id,
0493: reportDefinitionId, userId);
0494: } catch (RemoteException e) {
0495: throw new InfoException(
0496: MessageFormat
0497: .format(
0498: (LanguageTraslator.traslate("87")),
0499: new Object[] { "RemoteReportManagerStateful-getReportViewFromID(String id, String reportDefinitionId, String userId)" }),
0500: e);
0501: }
0502: }
0503:
0504: public ReportResult ExecReportQuery(int handle,
0505: ReportView reportView) throws InfoException {
0506: try {
0507: return getReportManagerRemote().ExecReportQuery(handle,
0508: reportView);
0509: } catch (RemoteException e) {
0510: throw new InfoException(
0511: MessageFormat
0512: .format(
0513: (LanguageTraslator.traslate("87")),
0514: new Object[] { "RemoteReportManagerStateful-ExecReportQuery(int handle, ReportView reportView)" }),
0515: e);
0516: }
0517: }
0518:
0519: public void registerDefinitions() throws InfoException {
0520: try {
0521: getReportManagerRemote().registerDefinitions();
0522: } catch (RemoteException e) {
0523: throw new InfoException(
0524: MessageFormat
0525: .format(
0526: (LanguageTraslator.traslate("87")),
0527: new Object[] { "RemoteReportManagerStateful-registerDefinitions()" }),
0528: e);
0529: }
0530: }
0531:
0532: public void deleteAllRepositories() throws InfoException {
0533: try {
0534: getReportManagerRemote().deleteAllRepositories();
0535: } catch (RemoteException e) {
0536: throw new InfoException(
0537: MessageFormat
0538: .format(
0539: (LanguageTraslator.traslate("87")),
0540: new Object[] { "RemoteReportManagerStateful-deleteAllRepositories()" }),
0541: e);
0542: }
0543: }
0544:
0545: public void deleteAllDefinitions() throws InfoException {
0546: try {
0547: getReportManagerRemote().deleteAllDefinitions();
0548: } catch (RemoteException e) {
0549: throw new InfoException(
0550: MessageFormat
0551: .format(
0552: (LanguageTraslator.traslate("87")),
0553: new Object[] { "RemoteReportManagerStateful-deleteAllDefinitions()" }),
0554: e);
0555: }
0556: }
0557:
0558: public void deleteReportSourceRepository() throws InfoException {
0559: try {
0560: getReportManagerRemote().deleteReportSourceRepository();
0561: } catch (RemoteException e) {
0562: throw new InfoException(
0563: MessageFormat
0564: .format(
0565: (LanguageTraslator.traslate("87")),
0566: new Object[] { "RemoteReportManagerStateful-deleteReportSourceRepository()" }),
0567: e);
0568: }
0569: }
0570:
0571: public void deleteReportSourceDefinitionRepository()
0572: throws InfoException {
0573: try {
0574: getReportManagerRemote()
0575: .deleteReportSourceDefinitionRepository();
0576: } catch (RemoteException e) {
0577: throw new InfoException(
0578: MessageFormat
0579: .format(
0580: (LanguageTraslator.traslate("87")),
0581: new Object[] { "RemoteReportManagerStateful-deleteReportSourceDefinitionRepository()" }),
0582: e);
0583: }
0584: }
0585:
0586: public void deleteReportDefinitionRepository() throws InfoException {
0587: try {
0588: getReportManagerRemote().deleteReportDefinitionRepository();
0589: } catch (RemoteException e) {
0590: throw new InfoException(
0591: MessageFormat
0592: .format(
0593: (LanguageTraslator.traslate("87")),
0594: new Object[] { "RemoteReportManagerStateful-deleteReportDefinitionRepository()" }),
0595: e);
0596: }
0597: }
0598:
0599: public void deleteReportViewRepository() throws InfoException {
0600: try {
0601: getReportManagerRemote().deleteReportViewRepository();
0602: } catch (RemoteException e) {
0603: throw new InfoException(
0604: MessageFormat
0605: .format(
0606: (LanguageTraslator.traslate("87")),
0607: new Object[] { "RemoteReportManagerStateful-deleteReportViewRepository()" }),
0608: e);
0609: }
0610: }
0611:
0612: public void deleteReportView(String id, String reportDefinitionId,
0613: String userId) throws InfoException {
0614: try {
0615: getReportManagerRemote().deleteReportView(id,
0616: reportDefinitionId, userId);
0617: } catch (RemoteException e) {
0618: throw new InfoException(
0619: MessageFormat
0620: .format(
0621: (LanguageTraslator.traslate("87")),
0622: new Object[] { "RemoteReportManagerStateful-deleteReportView(String id, String reportDefinitionId, String userId)" }),
0623: e);
0624: }
0625: }
0626:
0627: public void deleteReportSource(String reportSourceDefinitionId)
0628: throws InfoException {
0629: try {
0630: getReportManagerRemote().deleteReportSource(
0631: reportSourceDefinitionId);
0632: } catch (RemoteException e) {
0633: throw new InfoException(
0634: MessageFormat
0635: .format(
0636: (LanguageTraslator.traslate("87")),
0637: new Object[] { "RemoteReportManagerStateful-deleteReportSource(String reportSourceDefinitionId)" }),
0638: e);
0639: }
0640: }
0641:
0642: public void deleteReportSourceDefinition(
0643: String reportSourceDefinitionID) throws InfoException {
0644: try {
0645: getReportManagerRemote().deleteReportSourceDefinition(
0646: reportSourceDefinitionID);
0647: } catch (RemoteException e) {
0648: throw new InfoException(
0649: MessageFormat
0650: .format(
0651: (LanguageTraslator.traslate("87")),
0652: new Object[] { "RemoteReportManagerStateful-deleteReportSourceDefinition(String reportSourceDefinitionID)" }),
0653: e);
0654: }
0655: }
0656:
0657: public void deleteReportDefinition(String reportDefinitionID)
0658: throws InfoException {
0659: try {
0660: getReportManagerRemote().deleteReportDefinition(
0661: reportDefinitionID);
0662: } catch (RemoteException e) {
0663: throw new InfoException(
0664: MessageFormat
0665: .format(
0666: (LanguageTraslator.traslate("87")),
0667: new Object[] { "RemoteReportManagerStateful-deleteReportDefinition(String reportDefinitionID)" }),
0668: e);
0669: }
0670: }
0671:
0672: public void assingDefaultView(String id, String reportDefinitionId,
0673: String userId) throws InfoException {
0674: try {
0675: getReportManagerRemote().assingDefaultView(id,
0676: reportDefinitionId, userId);
0677: } catch (RemoteException e) {
0678: throw new InfoException(
0679: MessageFormat
0680: .format(
0681: (LanguageTraslator.traslate("87")),
0682: new Object[] { "RemoteReportManagerStateful-assingDefaultView(String id, String reportDefinitionId, String userId)" }),
0683: e);
0684: }
0685: }
0686:
0687: public ReportResult ExecReportQuery(MicroReport microReport)
0688: throws InfoException {
0689: try {
0690: return getReportManagerRemote()
0691: .ExecReportQuery(microReport);
0692: } catch (RemoteException e) {
0693: throw new InfoException(
0694: MessageFormat
0695: .format(
0696: (LanguageTraslator.traslate("87")),
0697: new Object[] { "RemoteReportManagerStateful-ExecReportQuery(MicroReport microReport)" }),
0698: e);
0699: }
0700: }
0701:
0702: public int PrepareReport(MicroReport microReport)
0703: throws InfoException {
0704: try {
0705: return getReportManagerRemote().PrepareReport(microReport);
0706: } catch (RemoteException e) {
0707: throw new InfoException(
0708: MessageFormat
0709: .format(
0710: (LanguageTraslator.traslate("87")),
0711: new Object[] { "RemoteReportManagerStateful-PrepareReport(MicroReport microReport)" }),
0712: e);
0713: }
0714:
0715: }
0716:
0717: public String getXML(int handle) throws InfoException {
0718: try {
0719: return getReportManagerRemote().getXML(handle);
0720: } catch (RemoteException e) {
0721: throw new InfoException(
0722: MessageFormat
0723: .format(
0724: (LanguageTraslator.traslate("87")),
0725: new Object[] { "RemoteReportManagerStateful-getXML(int handle)" }),
0726: e);
0727: }
0728:
0729: }
0730:
0731: public String getXML(String reportDefinitionID, Map paramValues)
0732: throws InfoException {
0733: try {
0734: return getReportManagerRemote().getXML(reportDefinitionID,
0735: paramValues);
0736: } catch (RemoteException e) {
0737: throw new InfoException(
0738: MessageFormat
0739: .format(
0740: (LanguageTraslator.traslate("87")),
0741: new Object[] { "RemoteReportManagerStateful-getXML(String reportDefinitionID, Map paramValues)" }),
0742: e);
0743: }
0744: }
0745:
0746: public Set getDimensionValues(int handle, String name)
0747: throws InfoException {
0748: try {
0749: return getReportManagerRemote().getDimensionValues(handle,
0750: name);
0751: } catch (RemoteException e) {
0752: throw new InfoException(
0753: MessageFormat
0754: .format(
0755: (LanguageTraslator.traslate("87")),
0756: new Object[] { "RemoteReportManagerStateful-getDimensionValues(int handle, String name)" }),
0757: e);
0758: }
0759:
0760: }
0761:
0762: public Set getDimensionValues(String reportDefinitionID,
0763: Map paramValues, String name) throws InfoException {
0764: try {
0765: return getReportManagerRemote().getDimensionValues(
0766: reportDefinitionID, paramValues, name);
0767: } catch (RemoteException e) {
0768: throw new InfoException(
0769: MessageFormat
0770: .format(
0771: (LanguageTraslator.traslate("87")),
0772: new Object[] { "RemoteReportManagerStateful-getDimensionValues(String reportDefinitionID, Map paramValues, String name)" }),
0773: e);
0774: }
0775: }
0776:
0777: public Vector getUpdatedDataModel(int handle, int mode, int row,
0778: int col, boolean isDistributed) throws InfoException {
0779: try {
0780: return getReportManagerRemote().getUpdatedDataModel(handle,
0781: mode, row, col, isDistributed);
0782: } catch (RemoteException e) {
0783: throw new InfoException(
0784: MessageFormat
0785: .format(
0786: (LanguageTraslator.traslate("87")),
0787: new Object[] { "RemoteReportManagerStateful-getUpdatedDataModel(int handle, int mode, int row, int col, boolean isDistributed) " }),
0788: e);
0789: }
0790: }
0791:
0792: public Matrix getMatrix(int handle) throws InfoException {
0793: try {
0794: return getReportManagerRemote().getMatrix(handle);
0795: } catch (RemoteException e) {
0796: throw new InfoException(
0797: MessageFormat
0798: .format(
0799: (LanguageTraslator.traslate("87")),
0800: new Object[] { "RemoteReportManagerStateful-getMatrix(int handle) " }),
0801: e);
0802: }
0803:
0804: }
0805:
0806: public ReportDefinition getReportDefinitionFromID(
0807: String reportDefinitionId) throws InfoException {
0808: try {
0809: return getReportManagerRemote().getReportDefinitionFromID(
0810: reportDefinitionId);
0811: } catch (RemoteException e) {
0812: throw new InfoException(
0813: MessageFormat
0814: .format(
0815: (LanguageTraslator.traslate("87")),
0816: new Object[] { "RemoteReportManagerStateful-getReportDefinitionFromID(String reportDefinitionId) " }),
0817: e);
0818: }
0819: }
0820:
0821: public ReportSourceDefinition getReportSourceDefinitionFromID(
0822: String reportSourceDefinitionId) throws InfoException {
0823: try {
0824: return getReportManagerRemote()
0825: .getReportSourceDefinitionFromID(
0826: reportSourceDefinitionId);
0827: } catch (RemoteException e) {
0828: throw new InfoException(
0829: MessageFormat
0830: .format(
0831: (LanguageTraslator.traslate("87")),
0832: new Object[] { "RemoteReportManagerStateful-getReportSourceDefinitionFromID(String reportSourceDefinitionId) " }),
0833: e);
0834: }
0835: }
0836:
0837: public void init(
0838: ReportGeneratorConfiguration reportGeneratorConfiguration)
0839: throws InfoException {
0840: }
0841:
0842: public boolean validateUser(String userName, String password,
0843: String userRepositoryPath) throws InfoException {
0844: try {
0845: return getReportManagerRemote().validateUser(userName,
0846: password, userRepositoryPath);
0847: } catch (RemoteException e) {
0848: throw new InfoException(
0849: MessageFormat
0850: .format(
0851: (LanguageTraslator.traslate("87")),
0852: new Object[] { "RemoteReportManagerStateful-validateUser()) " }),
0853: e);
0854: }
0855: }
0856:
0857: public boolean validateRol(String[] roles, String userName,
0858: String rolRepositoryPath) throws InfoException {
0859: try {
0860: return getReportManagerRemote().validateRol(roles,
0861: userName, rolRepositoryPath);
0862: } catch (RemoteException e) {
0863: throw new InfoException(
0864: MessageFormat
0865: .format(
0866: (LanguageTraslator.traslate("87")),
0867: new Object[] { "RemoteReportManagerStateful-valdateRol()) " }),
0868: e);
0869: }
0870: }
0871:
0872: public void exportReport(String userName, String password,
0873: String userRepositoryPath, String reportDefinitionId,
0874: Map paramValues, boolean isLandscape, int type,
0875: String destinationPath, String name) throws InfoException {
0876: try {
0877: getReportManagerRemote().exportReport(userName, password,
0878: userRepositoryPath, reportDefinitionId,
0879: paramValues, isLandscape, type, destinationPath,
0880: name);
0881: } catch (RemoteException e) {
0882: throw new InfoException(
0883: MessageFormat
0884: .format(
0885: (LanguageTraslator.traslate("87")),
0886: new Object[] { "RemoteReportManagerStateful-exportReport()) " }),
0887: e);
0888: }
0889:
0890: }
0891:
0892: public byte[] exportReport(Map params) throws InfoException {
0893: try {
0894: return getReportManagerRemote().exportReport(params);
0895: } catch (RemoteException e) {
0896: throw new InfoException(
0897: MessageFormat
0898: .format(
0899: (LanguageTraslator.traslate("87")),
0900: new Object[] { "RemoteReportManagerStateful-exportReport()) " }),
0901: e);
0902: }
0903: }
0904:
0905: public boolean addNewUser(String rootPasswd, String userName,
0906: String password, String userRepositoryPath)
0907: throws InfoException {
0908: try {
0909: return getReportManagerRemote().addNewUser(rootPasswd,
0910: userName, password, userRepositoryPath);
0911: } catch (RemoteException e) {
0912: throw new InfoException(
0913: MessageFormat
0914: .format(
0915: (LanguageTraslator.traslate("87")),
0916: new Object[] { "RemoteReportManagerStateful-addNewUser()) " }),
0917: e);
0918: }
0919: }
0920:
0921: public void addUserRol(String userName, String rol,
0922: String rolsRepositoryPath) throws InfoException {
0923: try {
0924: getReportManagerRemote().addUserRol(userName, rol,
0925: rolsRepositoryPath);
0926: } catch (RemoteException e) {
0927: throw new InfoException(
0928: MessageFormat
0929: .format(
0930: (LanguageTraslator.traslate("87")),
0931: new Object[] { "RemoteReportManagerStateful-addUserRol()) " }),
0932: e);
0933: }
0934: }
0935:
0936: public boolean isAcceptedLicence() throws InfoException {
0937: try {
0938: return getReportManagerRemote().isAcceptedLicence();
0939: } catch (RemoteException e) {
0940: throw new InfoException(
0941: MessageFormat
0942: .format(
0943: (LanguageTraslator.traslate("87")),
0944: new Object[] { "RemoteReportManagerStateful-isAcceptedLicence()) " }),
0945: e);
0946: }
0947: }
0948:
0949: public void acceptedLicence(boolean value) throws InfoException {
0950: try {
0951: getReportManagerRemote().acceptedLicence(value);
0952: } catch (RemoteException e) {
0953: throw new InfoException(
0954: MessageFormat
0955: .format(
0956: (LanguageTraslator.traslate("87")),
0957: new Object[] { "RemoteReportManagerStateful-acceptedLicence(value)) " }),
0958: e);
0959: }
0960: }
0961:
0962: public void addUserData(String userName, String name,
0963: String company, String userDataRepositoryPath)
0964: throws InfoException {
0965: try {
0966: getReportManagerRemote().addUserData(userName, name,
0967: company, userDataRepositoryPath);
0968: } catch (RemoteException e) {
0969: throw new InfoException(
0970: MessageFormat
0971: .format(
0972: (LanguageTraslator.traslate("87")),
0973: new Object[] { "RemoteReportManagerStateful-addUserData()) " }),
0974: e);
0975: }
0976: }
0977:
0978: public MicroReport getMicroReport(String fileName)
0979: throws InfoException {
0980: try {
0981: return getReportManagerRemote().getMicroReport(fileName);
0982: } catch (RemoteException e) {
0983: throw new InfoException(
0984: MessageFormat
0985: .format(
0986: (LanguageTraslator.traslate("87")),
0987: new Object[] { "RemoteReportManagerStateful-getMicroReport()) " }),
0988: e);
0989: }
0990: }
0991:
0992: public MicroReport getMicroReport(String reportDefinitionId,
0993: Map param) throws InfoException {
0994: try {
0995: return getReportManagerRemote().getMicroReport(
0996: reportDefinitionId, param);
0997: } catch (RemoteException e) {
0998: throw new InfoException(
0999: MessageFormat
1000: .format(
1001: (LanguageTraslator.traslate("87")),
1002: new Object[] { "RemoteReportManagerStateful-getMicroReport()) " }),
1003: e);
1004: }
1005: }
1006:
1007: public Collection getUserData(String userId,
1008: String userDataRepositoryPath) throws InfoException {
1009: try {
1010: return getReportManagerRemote().getUserData(userId,
1011: userDataRepositoryPath);
1012: } catch (RemoteException e) {
1013: throw new InfoException(
1014: MessageFormat
1015: .format(
1016: (LanguageTraslator.traslate("87")),
1017: new Object[] { "RemoteReportManagerStateful-getUserData()) " }),
1018: e);
1019: }
1020: }
1021:
1022: public void logClientData(String clientData) throws InfoException {
1023: try {
1024: getReportManagerRemote().logClientData(clientData);
1025: } catch (RemoteException e) {
1026: throw new InfoException(
1027: MessageFormat
1028: .format(
1029: (LanguageTraslator.traslate("87")),
1030: new Object[] { "RemoteReportManagerStateful-logClientData()) " }),
1031: e);
1032: }
1033: }
1034:
1035: /* public ZipOutputStream getMicroReport(int reportHandle, ReportView reportView, String userID, String fileName) throws InfoException {
1036: try {
1037: return getReportManagerRemote().getMicroReport(reportHandle,reportView,userID,fileName);
1038: }
1039: catch (RemoteException e) {
1040: throw new InfoException(MessageFormat.format((LanguageTraslator.traslate("87")), new Object[]{"RemoteReportManagerStateful-getMicroReport(int reportHandle, ReportView reportView, String userID, String fileName)"}), e);
1041: }
1042: }
1043: */
1044: public Vector registerReportSourceDefinitions(Vector vector)
1045: throws InfoException {
1046: try {
1047: return getReportManagerRemote()
1048: .registerReportSourceDefinitions(vector);
1049: } catch (RemoteException e) {
1050: throw new InfoException(
1051: MessageFormat
1052: .format(
1053: (LanguageTraslator.traslate("87")),
1054: new Object[] { "RemoteReportManagerStateful-registerReportSourceDefinitions()" }),
1055: e);
1056: }
1057:
1058: }
1059:
1060: public Vector registerReportDefinitions(Vector vector)
1061: throws InfoException {
1062: try {
1063: return getReportManagerRemote().registerReportDefinitions(
1064: vector);
1065: } catch (RemoteException e) {
1066: throw new InfoException(
1067: MessageFormat
1068: .format(
1069: (LanguageTraslator.traslate("87")),
1070: new Object[] { "RemoteReportManagerStateful-registerReportDefinitions()" }),
1071: e);
1072: }
1073: }
1074:
1075: public Vector registerReportViews(Vector vector)
1076: throws InfoException {
1077: try {
1078: return getReportManagerRemote().registerReportViews(vector);
1079: } catch (RemoteException e) {
1080: throw new InfoException(
1081: MessageFormat
1082: .format(
1083: (LanguageTraslator.traslate("87")),
1084: new Object[] { "RemoteReportManagerStateful-registerReportViews()" }),
1085: e);
1086: }
1087:
1088: }
1089:
1090: public String getDefaultReportViewId(String reportDefinitionId,
1091: String userId) throws InfoException {
1092: try {
1093: return getReportManagerRemote().getDefaultReportViewId(
1094: reportDefinitionId, userId);
1095: } catch (RemoteException e) {
1096: throw new InfoException(
1097: MessageFormat
1098: .format(
1099: (LanguageTraslator.traslate("87")),
1100: new Object[] { "RemoteReportManagerStateful-getDefaultReportViewId(String reportDefinitionId, String userId)" }),
1101: e);
1102: }
1103: }
1104:
1105: }
|