org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException Java Examples

/**
 * Creates an HTTPS server with self-signed certificate to receive webhook request
 * @param keyStore KeyStore for the server
 * @param keyStorePassword Key store password for the server
 * @param externalUrl External base url for the webhook
 * @param internalUrl Internal base url for the webhook
 * @param pathToCertificate Full path until .pem public certificate keys
 */
public TelegramBotsApi(String keyStore, String keyStorePassword, String externalUrl, String internalUrl, String pathToCertificate) throws TelegramApiRequestException {
    if (externalUrl == null || externalUrl.isEmpty()) {
        throw new TelegramApiRequestException("Parameter externalUrl can not be null or empty");
    }
    if (internalUrl == null || internalUrl.isEmpty()) {
        throw new TelegramApiRequestException("Parameter internalUrl can not be null or empty");
    }
    if (keyStore == null || keyStore.isEmpty()) {
        throw new TelegramApiRequestException("Parameter keyStore can not be null or empty");
    }
    if (keyStorePassword == null || keyStorePassword.isEmpty()) {
        throw new TelegramApiRequestException("Parameter keyStorePassword can not be null or empty");
    }
    if (pathToCertificate == null || pathToCertificate.isEmpty()) {
        throw new TelegramApiRequestException("Parameter pathToCertificate can not be null or empty");
    }

    this.useWebhook = true;
    this.externalUrl = fixExternalUrl(externalUrl);
    this.pathToCertificate = pathToCertificate;
    webhook = ApiContext.getInstance(Webhook.class);
    webhook.setInternalUrl(internalUrl);
    webhook.setKeyStore(keyStore, keyStorePassword);
    webhook.startServer();
}
 

/**
 * Creates an HTTPS server to receive webhook request
 * @param keyStore KeyStore for the server
 * @param keyStorePassword Key store password for the server
 * @param externalUrl External base url for the webhook
 * @param internalUrl Internal base url for the webhook
 */
public TelegramBotsApi(String keyStore, String keyStorePassword, String externalUrl, String internalUrl) throws TelegramApiRequestException {
    if (externalUrl == null || externalUrl.isEmpty()) {
        throw new TelegramApiRequestException("Parameter externalUrl can not be null or empty");
    }
    if (internalUrl == null || internalUrl.isEmpty()) {
        throw new TelegramApiRequestException("Parameter internalUrl can not be null or empty");
    }
    if (keyStore == null || keyStore.isEmpty()) {
        throw new TelegramApiRequestException("Parameter keyStore can not be null or empty");
    }
    if (keyStorePassword == null || keyStorePassword.isEmpty()) {
        throw new TelegramApiRequestException("Parameter keyStorePassword can not be null or empty");
    }

    this.useWebhook = true;
    this.externalUrl = fixExternalUrl(externalUrl);
    webhook = ApiContext.getInstance(Webhook.class);
    webhook.setInternalUrl(internalUrl);
    webhook.setKeyStore(keyStore, keyStorePassword);
    webhook.startServer();
}
 

public void startServer() throws TelegramApiRequestException {
    ResourceConfig rc = new ResourceConfig();
    rc.register(restApi);
    rc.register(JacksonFeature.class);

    final HttpServer grizzlyServer;
    if (keystoreServerFile != null && keystoreServerPwd != null) {
        SSLContextConfigurator sslContext = new SSLContextConfigurator();

        // set up security context
        sslContext.setKeyStoreFile(keystoreServerFile); // contains server keypair
        sslContext.setKeyStorePass(keystoreServerPwd);

        grizzlyServer = GrizzlyHttpServerFactory.createHttpServer(getBaseURI(), rc, true,
                new SSLEngineConfigurator(sslContext).setClientMode(false).setNeedClientAuth(false));
    } else {
        grizzlyServer = GrizzlyHttpServerFactory.createHttpServer(getBaseURI(), rc);
    }

    try {
        grizzlyServer.start();
    } catch (IOException e) {
        throw new TelegramApiRequestException("Error starting webhook server", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error restricting chat member", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error setting chat description", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error setting chat description", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public ChatMember deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<ChatMember> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<ChatMember>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error getting chat member", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public ArrayList<GameHighScore> deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<ArrayList<GameHighScore>> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<ArrayList<GameHighScore>>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error getting game high scores", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error answering pre-checkout query", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error deleting chat sticker set", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public UserProfilePhotos deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<UserProfilePhotos> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<UserProfilePhotos>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error getting user profile photos", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error setting chat sticker set", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error setting chat photo", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error unbanning chat member", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error setting chat description", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Chat deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Chat> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Chat>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error getting chat", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error kicking chat member", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error setting chat title", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public String deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<String> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<String>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error exporting invite link", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error answering shipping query", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error setting passport data errors", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error unpinning chat message", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error pinning chat message", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Message deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Message> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Message>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error sending contact", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Message deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Message> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Message>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error sending photo", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Message deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Message> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Message>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error sending invoice", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Message deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Message> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Message>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error sending message", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Test
void TestTelegramApiMustBeInitializableForWebhookWithSelfSignedCertificate() {
    try {
        new TelegramBotsApi("keyStore", "keyStorePassword", "externalUrl", "internalUrl", "selfSignedPath");
    } catch (TelegramApiRequestException e) {
        fail();
    }
}
 

@Override
public Message deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Message> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Message>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error sending dice", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

@Override
public Message deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Message> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Message>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error sending location", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}