diff --git a/restcomm/restcomm.application/src/main/webapp/WEB-INF/scripts/mariadb/sql/extensions-configuration.xml b/restcomm/restcomm.application/src/main/webapp/WEB-INF/scripts/mariadb/sql/extensions-configuration.xml index 261c3e385b..2903daab09 100644 --- a/restcomm/restcomm.application/src/main/webapp/WEB-INF/scripts/mariadb/sql/extensions-configuration.xml +++ b/restcomm/restcomm.application/src/main/webapp/WEB-INF/scripts/mariadb/sql/extensions-configuration.xml @@ -22,35 +22,35 @@ - - + + INSERT INTO restcomm_extensions_configuration (sid, extension, configuration_data, configuration_type, date_created, date_updated, enabled) VALUES (#{sid}, #{extension}, #{configuration_data}, #{configuration_type}, #{date_created}, #{date_updated}, #{enabled}); - + UPDATE restcomm_extensions_configuration SET configuration_data=#{configuration_data}, configuration_type=#{configuration_type}, date_updated=#{date_updated}, enabled=#{enabled} WHERE sid=#{sid} - SELECT * FROM restcomm_extensions_configuration WHERE extension=#{extension}; - SELECT * FROM restcomm_extensions_configuration WHERE sid=#{sid}; - SELECT * FROM restcomm_extensions_configuration; - + DELETE FROM restcomm_extensions_configuration WHERE sid=#{sid}; - + DELETE FROM restcomm_extensions_configuration WHERE extension=#{extension}; @@ -62,22 +62,22 @@ SELECT date_updated FROM restcomm_extensions_configuration WHERE sid=#{sid}; - SELECT configuration_data, account_sid AS "sid", extension_sid AS "extension" FROM restcomm_accounts_extensions WHERE account_sid=#{account_sid} AND extension_sid=#{extension_sid}; - + INSERT INTO restcomm_accounts_extensions (account_sid, extension_sid, configuration_data) VALUES (#{account_sid}, #{extension_sid}, #{configuration_data}); - + UPDATE restcomm_accounts_extensions SET configuration_data=#{configuration_data} WHERE account_sid=#{account_sid} AND extension_sid=#{extension_sid}; - + DELETE FROM restcomm_accounts_extensions WHERE account_sid=#{account_sid} AND extension_sid=#{extension_sid}; diff --git a/restcomm/restcomm.application/src/main/webapp/WEB-INF/sql/extensions-configuration.xml b/restcomm/restcomm.application/src/main/webapp/WEB-INF/sql/extensions-configuration.xml index b20ac5233b..6010af4ab0 100644 --- a/restcomm/restcomm.application/src/main/webapp/WEB-INF/sql/extensions-configuration.xml +++ b/restcomm/restcomm.application/src/main/webapp/WEB-INF/sql/extensions-configuration.xml @@ -28,35 +28,35 @@ - - + + INSERT INTO "restcomm_extensions_configuration" ("sid", "extension", "configuration_data", "configuration_type", "date_created", "date_updated", "enabled") VALUES (#{sid}, #{extension}, #{configuration_data}, #{configuration_type}, #{date_created}, #{date_updated}, #{enabled}); - + UPDATE "restcomm_extensions_configuration" SET "configuration_data"=#{configuration_data}, "configuration_type"=#{configuration_type}, "date_updated"=#{date_updated}, "enabled"=#{enabled} WHERE "sid"=#{sid} - SELECT * FROM "restcomm_extensions_configuration" WHERE "extension"=#{extension}; - SELECT * FROM "restcomm_extensions_configuration" WHERE "sid"=#{sid}; - SELECT * FROM "restcomm_extensions_configuration"; - + DELETE FROM "restcomm_extensions_configuration" WHERE "sid"=#{sid}; - + DELETE FROM "restcomm_extensions_configuration" WHERE "extension"=#{extension}; @@ -68,22 +68,22 @@ SELECT "date_updated" FROM "restcomm_extensions_configuration" WHERE "sid"=#{sid}; - SELECT "configuration_data", "account_sid" AS "sid", "extension_sid" AS "extension" FROM "restcomm_accounts_extensions" WHERE "account_sid"=#{account_sid} AND "extension_sid"=#{extension_sid}; - + INSERT INTO "restcomm_accounts_extensions" ("account_sid", "extension_sid", "configuration_data") VALUES (#{account_sid}, #{extension_sid}, #{configuration_data}); - + UPDATE "restcomm_accounts_extensions" SET "configuration_data"=#{configuration_data} WHERE "account_sid"=#{account_sid} AND "extension_sid"=#{extension_sid}; - + DELETE FROM "restcomm_accounts_extensions" WHERE "account_sid"=#{account_sid} AND "extension_sid"=#{extension_sid}; diff --git a/restcomm/restcomm.commons/src/main/java/org/restcomm/connect/commons/dao/Sid.java b/restcomm/restcomm.commons/src/main/java/org/restcomm/connect/commons/dao/Sid.java index 6f664d15c5..45f3edf249 100644 --- a/restcomm/restcomm.commons/src/main/java/org/restcomm/connect/commons/dao/Sid.java +++ b/restcomm/restcomm.commons/src/main/java/org/restcomm/connect/commons/dao/Sid.java @@ -31,12 +31,59 @@ */ @Immutable public final class Sid { + + private static String CALL_SID_STRING = "ID[a-zA-Z0-9]{32}-CA[a-zA-Z0-9]{32}"; public static final Pattern pattern = Pattern.compile("[a-zA-Z0-9]{34}"); - public static final Pattern callSidPattern = Pattern.compile("ID[a-zA-Z0-9]{32}-CA[a-zA-Z0-9]{32}"); + public static final Pattern callSidPattern = Pattern.compile(CALL_SID_STRING); + private final String id; public enum Type { - ACCOUNT, APPLICATION, ANNOUNCEMENT, CALL, CLIENT, CONFERENCE, GATEWAY, INVALID, NOTIFICATION, PHONE_NUMBER, RECORDING, REGISTRATION, SHORT_CODE, SMS_MESSAGE, TRANSCRIPTION, INSTANCE, EXTENSION_CONFIGURATION, GEOLOCATION, ORGANIZATION, PROFILE + CALL(null, CALL_SID_STRING), + ACCOUNT("AC"), + APPLICATION("AP"), + ANNOUNCEMENT("AN"), + + CLIENT("CL"), + CONFERENCE("CF"), + GATEWAY("GW"), + + NOTIFICATION("NO"), + PHONE_NUMBER("PN"), + RECORDING("RE"), + REGISTRATION("RG"), + SHORT_CODE("SC"), + SMS_MESSAGE("SM"), + TRANSCRIPTION("TR"), + INSTANCE("ID"), + EXTENSION_CONFIGURATION("EX"), + GEOLOCATION("GL"), + ORGANIZATION("OR"), + PROFILE("PR"), + INVALID("IN"); + + private final String prefix; + private final String regex; + private final Pattern pattern; + private static final String UUID_PATTERN = "[a-zA-Z0-9]{32}"; + private Type(final String prefix) { + this(prefix, null); + } + private Type(final String prefix, String regex) { + this.prefix = prefix; + if(regex==null) { + this.regex = prefix + UUID_PATTERN; + }else{ + this.regex = regex; + } + pattern = Pattern.compile(this.regex); + } + public String getPrefix() { + return prefix; + } + public boolean isType(Sid sid) { + return pattern.matcher(sid.toString()).matches(); + } }; private static final Sid INVALID_SID = new Sid("IN00000000000000000000000000000000"); @@ -51,6 +98,18 @@ public Sid(final String id) throws IllegalArgumentException { } } + public static Type getType(Sid sid) { + Type res = Type.INVALID; + + for(Type type: Type.values()) { + if(type.isType(sid)) { + res = type; + break; + } + } + return res; + } + @Override public boolean equals(Object object) { if (this == object) { @@ -74,7 +133,7 @@ public static Sid generate(final Type type, String string) { String token = new Md5Hash(string).toString(); switch (type) { case ACCOUNT: { - return new Sid("AC" + token); + return new Sid(type.getPrefix() + token); } default: { return generate(type); @@ -85,66 +144,32 @@ public static Sid generate(final Type type, String string) { public static Sid generate(final Type type) { final String uuid = UUID.randomUUID().toString().replace("-", ""); switch (type) { - case ACCOUNT: { - return new Sid("AC" + uuid); - } - case APPLICATION: { - return new Sid("AP" + uuid); - } - case ANNOUNCEMENT: { - return new Sid("AN" + uuid); - } case CALL: { //https://github.com/RestComm/Restcomm-Connect/issues/1907 return new Sid(RestcommConfiguration.getInstance().getMain().getInstanceId() + "-CA" + uuid); } - case CLIENT: { - return new Sid("CL" + uuid); - } - case CONFERENCE: { - return new Sid("CF" + uuid); - } - case GATEWAY: { - return new Sid("GW" + uuid); - } - case INVALID: { + case INVALID:{ return INVALID_SID; } - case NOTIFICATION: { - return new Sid("NO" + uuid); - } - case PHONE_NUMBER: { - return new Sid("PN" + uuid); - } - case RECORDING: { - return new Sid("RE" + uuid); - } - case REGISTRATION: { - return new Sid("RG" + uuid); - } - case SHORT_CODE: { - return new Sid("SC" + uuid); - } - case SMS_MESSAGE: { - return new Sid("SM" + uuid); - } - case TRANSCRIPTION: { - return new Sid("TR" + uuid); - } - case INSTANCE: { - return new Sid("ID" + uuid); - } - case EXTENSION_CONFIGURATION: { - return new Sid("EX" + uuid); - } - case GEOLOCATION: { - return new Sid("GL" + uuid); - } - case ORGANIZATION: { - return new Sid("OR" + uuid); - } - case PROFILE: { - return new Sid("PR" + uuid); + case ACCOUNT: + case APPLICATION: + case ANNOUNCEMENT: + case CLIENT: + case CONFERENCE: + case GATEWAY: + case NOTIFICATION: + case PHONE_NUMBER: + case RECORDING: + case REGISTRATION: + case SHORT_CODE: + case SMS_MESSAGE: + case TRANSCRIPTION: + case INSTANCE: + case EXTENSION_CONFIGURATION: + case GEOLOCATION: + case ORGANIZATION: + case PROFILE:{ + return new Sid(type.getPrefix() + uuid); } default: { return null; @@ -164,4 +189,5 @@ public int hashCode() { public String toString() { return id; } + } diff --git a/restcomm/restcomm.commons/src/test/java/org/restcomm/connect/commons/sid/SidTest.java b/restcomm/restcomm.commons/src/test/java/org/restcomm/connect/commons/sid/SidTest.java index 24e74f6c50..e4aff6a4a7 100644 --- a/restcomm/restcomm.commons/src/test/java/org/restcomm/connect/commons/sid/SidTest.java +++ b/restcomm/restcomm.commons/src/test/java/org/restcomm/connect/commons/sid/SidTest.java @@ -4,6 +4,7 @@ import org.junit.Test; import org.restcomm.connect.commons.dao.Sid; +import org.restcomm.connect.commons.dao.Sid.Type; public class SidTest { @@ -51,4 +52,19 @@ public void testOldCallSid() { } } + @Test + public void testGetType() { + try{ + for(Type t : Sid.Type.values()) { + //TODO: mock static class RestcommConfiguration + if(!t.equals(Type.CALL)) { + Sid s = Sid.generate(t); + Type t2 = Sid.getType(s); + + assertEquals(t, t2); + } + } + }catch(Exception e){ + } + } } diff --git a/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/DaoManager.java b/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/DaoManager.java index 5e6d77c3bb..f61fc802a6 100644 --- a/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/DaoManager.java +++ b/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/DaoManager.java @@ -68,7 +68,7 @@ public interface DaoManager extends Configurable, LifeCycle { MediaResourceBrokerDao getMediaResourceBrokerDao(); - ExtensionsConfigurationDao getExtensionsConfigurationDao(); + ExtensionsRulesDao getExtensionsRulesDao (); GeolocationDao getGeolocationDao(); diff --git a/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/ExtensionsConfigurationDao.java b/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/ExtensionsRulesDao.java similarity index 57% rename from restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/ExtensionsConfigurationDao.java rename to restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/ExtensionsRulesDao.java index a66a4484dc..10e1cb745e 100644 --- a/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/ExtensionsConfigurationDao.java +++ b/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/ExtensionsRulesDao.java @@ -22,57 +22,57 @@ import org.joda.time.DateTime; import org.restcomm.connect.commons.dao.Sid; import org.restcomm.connect.extension.api.ConfigurationException; -import org.restcomm.connect.extension.api.ExtensionConfiguration; +import org.restcomm.connect.extension.api.ExtensionRules; import java.util.List; /** * Created by gvagenas on 11/10/2016. */ -public interface ExtensionsConfigurationDao { +public interface ExtensionsRulesDao { /** - * Add a new ExtensionConfiguration - * @param extensionConfiguration + * Add a new ExtensionRules + * @param extensionRules */ - void addConfiguration(ExtensionConfiguration extensionConfiguration) throws ConfigurationException; + void addExtensionRules (ExtensionRules extensionRules) throws ConfigurationException; /** - * Update an existing ExtensionConfiguration - * @param extensionConfiguration + * Update an existing ExtensionRules + * @param extensionRules */ - void updateConfiguration(ExtensionConfiguration extensionConfiguration) throws ConfigurationException; + void updateExtensionRules (ExtensionRules extensionRules) throws ConfigurationException; /** * Get extension configuration by extension name * @param extensionName - * @return ExtensionConfiguration + * @return ExtensionRules */ - ExtensionConfiguration getConfigurationByName(String extensionName); + ExtensionRules getExtensionRulesByName (String extensionName); /** * Get extension configuration by Sid * @param extensionSid - * @return ExtensionConfiguration + * @return ExtensionRules */ - ExtensionConfiguration getConfigurationBySid(Sid extensionSid); + ExtensionRules getExtensionRulesBySid (Sid extensionSid); /** * Get all extension configuration - * @return List + * @return List */ - List getAllConfiguration(); + List getAllExtensionRules (); /** * Delete extension configuration by extension name * @param extensionName */ - void deleteConfigurationByName(String extensionName); + void deleteExtensionRulesByName (String extensionName); /** * Delete extension configuration by Sid * @param extensionSid */ - void deleteConfigurationBySid(Sid extensionSid); + void deleteExtensionRulesBySid (Sid extensionSid); /** * Check if there is a newer version of the configuration in the DB using extension name @@ -93,37 +93,37 @@ public interface ExtensionsConfigurationDao { /** * Validate extension configuration based on the type of the configuration data - * @param extensionConfiguration + * @param extensionRules * @return */ - boolean validate(ExtensionConfiguration extensionConfiguration); + boolean validate(ExtensionRules extensionRules); /** - * Get account specific ExtensionConfiguration + * Get account specific ExtensionRules * @param accountSid * @param extensionSid - * @return ExtensionConfiguration + * @return ExtensionRules */ - ExtensionConfiguration getAccountExtensionConfiguration(String accountSid, String extensionSid); + ExtensionRules getAccountExtensionRules (String accountSid, String extensionSid); /** - * Add a new account specific ExtensionConfiguration - * @param extensionConfiguration + * Add a new account specific ExtensionRules + * @param extensionRules * @param accountSid */ - void addAccountExtensionConfiguration(ExtensionConfiguration extensionConfiguration, Sid accountSid) throws ConfigurationException; + void addAccountExtensionRules (ExtensionRules extensionRules, Sid accountSid) throws ConfigurationException; /** - * Update an existing account specific ExtensionConfiguration - * @param extensionConfiguration + * Update an existing account specific ExtensionRules + * @param extensionRules * @param accountSid */ - void updateAccountExtensionConfiguration(ExtensionConfiguration extensionConfiguration, Sid accountSid) throws ConfigurationException; + void updateAccountExtensionRules (ExtensionRules extensionRules, Sid accountSid) throws ConfigurationException; /** - * Delete account specific ExtensionConfiguration + * Delete account specific ExtensionRules * @param accountSid * @param extensionSid */ - void deleteAccountExtensionConfiguration(String accountSid, String extensionSid); + void deleteAccountExtensionRules (String accountSid, String extensionSid); } diff --git a/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/mybatis/MybatisDaoManager.java b/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/mybatis/MybatisDaoManager.java index 68327f1209..5ea981cd0f 100644 --- a/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/mybatis/MybatisDaoManager.java +++ b/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/mybatis/MybatisDaoManager.java @@ -37,7 +37,7 @@ import org.restcomm.connect.dao.ClientsDao; import org.restcomm.connect.dao.ConferenceDetailRecordsDao; import org.restcomm.connect.dao.DaoManager; -import org.restcomm.connect.dao.ExtensionsConfigurationDao; +import org.restcomm.connect.dao.ExtensionsRulesDao; import org.restcomm.connect.dao.GatewaysDao; import org.restcomm.connect.dao.GeolocationDao; import org.restcomm.connect.dao.HttpCookiesDao; @@ -90,7 +90,7 @@ public final class MybatisDaoManager implements DaoManager { private InstanceIdDao instanceIdDao; private MediaServersDao mediaServersDao; private MediaResourceBrokerDao mediaResourceBrokerDao; - private ExtensionsConfigurationDao extensionsConfigurationDao; + private ExtensionsRulesDao extensionsRulesDao; private GeolocationDao geolocationDao; private ProfileAssociationsDao profileAssociationsDao; private OrganizationsDao organizationsDao; @@ -216,8 +216,8 @@ public MediaResourceBrokerDao getMediaResourceBrokerDao() { } @Override - public ExtensionsConfigurationDao getExtensionsConfigurationDao() { - return extensionsConfigurationDao; + public ExtensionsRulesDao getExtensionsRulesDao () { + return extensionsRulesDao; } @Override @@ -311,7 +311,7 @@ public void start(final SqlSessionFactory sessions) { instanceIdDao = new MybatisInstanceIdDao(sessions); mediaServersDao = new MybatisMediaServerDao(sessions); mediaResourceBrokerDao = new MybatisMediaResourceBrokerDao(sessions); - extensionsConfigurationDao = new MybatisExtensionsConfigurationDao(sessions); + extensionsRulesDao = new MybatisExtensionsRulesDao(sessions); geolocationDao = new MybatisGeolocationDao(sessions); profileAssociationsDao = new MybatisProfileAssociationsDao(sessions); organizationsDao = new MybatisOrganizationDao(sessions); diff --git a/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/mybatis/MybatisExtensionsConfigurationDao.java b/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/mybatis/MybatisExtensionsRulesDao.java similarity index 62% rename from restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/mybatis/MybatisExtensionsConfigurationDao.java rename to restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/mybatis/MybatisExtensionsRulesDao.java index e5dfb2f6ee..a11e1b764c 100644 --- a/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/mybatis/MybatisExtensionsConfigurationDao.java +++ b/restcomm/restcomm.dao/src/main/java/org/restcomm/connect/dao/mybatis/MybatisExtensionsRulesDao.java @@ -31,9 +31,9 @@ import org.joda.time.DateTimeComparator; import org.restcomm.connect.commons.dao.Sid; import org.restcomm.connect.dao.DaoUtils; -import org.restcomm.connect.dao.ExtensionsConfigurationDao; +import org.restcomm.connect.dao.ExtensionsRulesDao; import org.restcomm.connect.extension.api.ConfigurationException; -import org.restcomm.connect.extension.api.ExtensionConfiguration; +import org.restcomm.connect.extension.api.ExtensionRules; import java.io.InputStream; import java.util.ArrayList; @@ -47,28 +47,28 @@ /** * Created by gvagenas on 11/10/2016. */ -public class MybatisExtensionsConfigurationDao implements ExtensionsConfigurationDao { +public class MybatisExtensionsRulesDao implements ExtensionsRulesDao { - private static Logger logger = Logger.getLogger(MybatisExtensionsConfigurationDao.class); - private static final String namespace = "org.restcomm.connect.dao.ExtensionsConfigurationDao."; + private static Logger logger = Logger.getLogger(MybatisExtensionsRulesDao.class); + private static final String namespace = "org.restcomm.connect.dao.ExtensionsRulesDao."; private final SqlSessionFactory sessions; - public MybatisExtensionsConfigurationDao(final SqlSessionFactory sessions) { + public MybatisExtensionsRulesDao (final SqlSessionFactory sessions) { super(); this.sessions = sessions; } @Override - public void addConfiguration(ExtensionConfiguration extensionConfiguration) throws ConfigurationException { + public void addExtensionRules (ExtensionRules extensionRules) throws ConfigurationException { final SqlSession session = sessions.openSession(); try { - if (extensionConfiguration != null && extensionConfiguration.getConfigurationData() != null) { - if (validate(extensionConfiguration)) { - session.insert(namespace + "addConfiguration", toMap(extensionConfiguration)); + if (extensionRules != null && extensionRules.getConfigurationData() != null) { + if (validate(extensionRules)) { + session.insert(namespace + "addExtensionRules", toMap(extensionRules)); session.commit(); } else { throw new ConfigurationException("Exception trying to add new configuration, validation failed. configuration type: " - + extensionConfiguration.getConfigurationType()); + + extensionRules.getConfigurationType()); } } } finally { @@ -77,15 +77,15 @@ public void addConfiguration(ExtensionConfiguration extensionConfiguration) thro } @Override - public void updateConfiguration(ExtensionConfiguration extensionConfiguration) throws ConfigurationException { + public void updateExtensionRules (ExtensionRules extensionRules) throws ConfigurationException { final SqlSession session = sessions.openSession(); try { - if (extensionConfiguration != null && extensionConfiguration.getConfigurationData() != null) { - if (validate(extensionConfiguration)) { - session.update(namespace + "updateConfiguration", toMap(extensionConfiguration)); + if (extensionRules != null && extensionRules.getConfigurationData() != null) { + if (validate(extensionRules)) { + session.update(namespace + "updateExtensionRules", toMap(extensionRules)); } else { throw new ConfigurationException("Exception trying to update configuration, validation failed. configuration type: " - + extensionConfiguration.getConfigurationType()); + + extensionRules.getConfigurationType()); } } session.commit(); @@ -95,42 +95,42 @@ public void updateConfiguration(ExtensionConfiguration extensionConfiguration) t } @Override - public ExtensionConfiguration getConfigurationByName(String extensionName) { + public ExtensionRules getExtensionRulesByName (String extensionName) { final SqlSession session = sessions.openSession(); - ExtensionConfiguration extensionConfiguration = null; + ExtensionRules extensionRules = null; try { - final Map result = session.selectOne(namespace + "getConfigurationByName", extensionName); + final Map result = session.selectOne(namespace + "getExtensionRulesByName", extensionName); if (result != null) { - extensionConfiguration = toExtensionConfiguration(result); + extensionRules = toExtensionConfiguration(result); } - return extensionConfiguration; + return extensionRules; } finally { session.close(); } } @Override - public ExtensionConfiguration getConfigurationBySid(Sid extensionSid) { + public ExtensionRules getExtensionRulesBySid (Sid extensionSid) { final SqlSession session = sessions.openSession(); - ExtensionConfiguration extensionConfiguration = null; + ExtensionRules extensionRules = null; try { - final Map result = session.selectOne(namespace + "getConfigurationBySid", extensionSid.toString()); + final Map result = session.selectOne(namespace + "getExtensionRulesBySid", extensionSid.toString()); if (result != null) { - extensionConfiguration = toExtensionConfiguration(result); + extensionRules = toExtensionConfiguration(result); } - return extensionConfiguration; + return extensionRules; } finally { session.close(); } } @Override - public List getAllConfiguration() { + public List getAllExtensionRules () { final SqlSession session = sessions.openSession(); - ExtensionConfiguration extensionConfiguration = null; + ExtensionRules extensionRules = null; try { - final List> results = session.selectList(namespace + "getAllConfiguration"); - final List confs = new ArrayList(); + final List> results = session.selectList(namespace + "getAllExtensionRules"); + final List confs = new ArrayList(); if (results != null && !results.isEmpty()) { for (final Map result : results) { confs.add(toExtensionConfiguration(result)); @@ -143,10 +143,10 @@ public List getAllConfiguration() { } @Override - public void deleteConfigurationByName(String extensionName) { + public void deleteExtensionRulesByName (String extensionName) { final SqlSession session = sessions.openSession(); try { - session.delete(namespace + "deleteConfigurationByName", extensionName); + session.delete(namespace + "deleteExtensionRulesByName", extensionName); session.commit(); } finally { session.close(); @@ -154,10 +154,10 @@ public void deleteConfigurationByName(String extensionName) { } @Override - public void deleteConfigurationBySid(Sid extensionSid) { + public void deleteExtensionRulesBySid (Sid extensionSid) { final SqlSession session = sessions.openSession(); try { - session.delete(namespace + "deleteConfigurationBySid", extensionSid.toString()); + session.delete(namespace + "deleteExtensionRulesBySid", extensionSid.toString()); session.commit(); } finally { session.close(); @@ -209,12 +209,12 @@ public boolean isLatestVersionBySid(Sid extensionSid, DateTime dateTime) { } @Override - public boolean validate(ExtensionConfiguration extensionConfiguration) { - ExtensionConfiguration.configurationType configurationType = extensionConfiguration.getConfigurationType(); - if (configurationType.equals(ExtensionConfiguration.configurationType.JSON)) { + public boolean validate(ExtensionRules extensionRules) { + ExtensionRules.configurationType configurationType = extensionRules.getConfigurationType(); + if (configurationType.equals(ExtensionRules.configurationType.JSON)) { Gson gson = new Gson(); try { - Object o = gson.fromJson((String) extensionConfiguration.getConfigurationData(), Object.class); + Object o = gson.fromJson((String) extensionRules.getConfigurationData(), Object.class); String json = new GsonBuilder().setPrettyPrinting().create().toJson(o); return (json != null || !json.isEmpty()); } catch (Exception e) { @@ -224,13 +224,13 @@ public boolean validate(ExtensionConfiguration extensionConfiguration) { } finally { gson = null; } - } else if (configurationType.equals(ExtensionConfiguration.configurationType.XML)) { + } else if (configurationType.equals(ExtensionRules.configurationType.XML)) { Configuration xml = null; try { XMLConfiguration xmlConfiguration = new XMLConfiguration(); xmlConfiguration.setDelimiterParsingDisabled(true); xmlConfiguration.setAttributeSplittingDisabled(true); - InputStream is = IOUtils.toInputStream(extensionConfiguration.getConfigurationData().toString()); + InputStream is = IOUtils.toInputStream(extensionRules.getConfigurationData().toString()); xmlConfiguration.load(is); xml = xmlConfiguration; return (xml != null || !xml.isEmpty()); @@ -245,81 +245,81 @@ public boolean validate(ExtensionConfiguration extensionConfiguration) { return false; } - private ExtensionConfiguration toExtensionConfiguration(final Map map) { + private ExtensionRules toExtensionConfiguration(final Map map) { final Sid sid = new Sid((String)map.get("sid")); final String extension = (String) map.get("extension"); boolean enabled = true; if (readBoolean(map.get("enabled")) != null) enabled = readBoolean(map.get("enabled")); final Object confData = map.get("configuration_data"); - final ExtensionConfiguration.configurationType confType = - ExtensionConfiguration.configurationType.valueOf((String)map.get("configuration_type")); + final ExtensionRules.configurationType confType = + ExtensionRules.configurationType.valueOf((String)map.get("configuration_type")); final DateTime dateCreated = readDateTime(map.get("date_created")); final DateTime dateUpdated = readDateTime(map.get("date_updated")); - return new ExtensionConfiguration(sid, extension, enabled, confData, confType, dateCreated, dateUpdated); + return new ExtensionRules(sid, extension, enabled, confData, confType, dateCreated, dateUpdated); } - private ExtensionConfiguration toAccountsExtensionConfiguration(final Map map) { + private ExtensionRules toAccountsExtensionConfiguration(final Map map) { final Sid sid = new Sid((String)map.get("extension")); final String extension = (String) map.get("extension"); final Object confData = map.get("configuration_data"); - return new ExtensionConfiguration(sid, extension, true, confData, null, null, null); + return new ExtensionRules(sid, extension, true, confData, null, null, null); } - private Map toMap(final ExtensionConfiguration extensionConfiguration) { + private Map toMap(final ExtensionRules extensionRules) { final Map map = new HashMap(); - map.put("sid", DaoUtils.writeSid(extensionConfiguration.getSid())); - map.put("extension", extensionConfiguration.getExtensionName()); + map.put("sid", DaoUtils.writeSid(extensionRules.getSid())); + map.put("extension", extensionRules.getExtensionName()); - if (extensionConfiguration.getConfigurationData() != null) - map.put("configuration_data", extensionConfiguration.getConfigurationData()); - if (extensionConfiguration.getConfigurationType() != null) - map.put("configuration_type", extensionConfiguration.getConfigurationType().toString()); - if (extensionConfiguration.getDateCreated() != null) - map.put("date_created", DaoUtils.writeDateTime(extensionConfiguration.getDateCreated())); - if (extensionConfiguration.getDateUpdated() != null) - map.put("date_updated", DaoUtils.writeDateTime(extensionConfiguration.getDateUpdated())); + if (extensionRules.getConfigurationData() != null) + map.put("configuration_data", extensionRules.getConfigurationData()); + if (extensionRules.getConfigurationType() != null) + map.put("configuration_type", extensionRules.getConfigurationType().toString()); + if (extensionRules.getDateCreated() != null) + map.put("date_created", DaoUtils.writeDateTime(extensionRules.getDateCreated())); + if (extensionRules.getDateUpdated() != null) + map.put("date_updated", DaoUtils.writeDateTime(extensionRules.getDateUpdated())); - map.put("enabled", extensionConfiguration.isEnabled()); + map.put("enabled", extensionRules.isEnabled()); return map; } @Override - public ExtensionConfiguration getAccountExtensionConfiguration(String accountSid, String extensionSid) { + public ExtensionRules getAccountExtensionRules (String accountSid, String extensionSid) { final SqlSession session = sessions.openSession(); - ExtensionConfiguration extensionConfiguration = null; + ExtensionRules extensionRules = null; try { Map params = new HashMap(); params.put("account_sid", accountSid.toString()); params.put("extension_sid", extensionSid.toString()); - final Map result = session.selectOne(namespace + "getAccountExtensionConfiguration", params); + final Map result = session.selectOne(namespace + "getAccountExtensionRules", params); if (result != null) { - extensionConfiguration = toAccountsExtensionConfiguration(result); + extensionRules = toAccountsExtensionConfiguration(result); } - return extensionConfiguration; + return extensionRules; } finally { session.close(); } } @Override - public void addAccountExtensionConfiguration(ExtensionConfiguration extensionConfiguration, Sid accountSid) throws ConfigurationException { + public void addAccountExtensionRules (ExtensionRules extensionRules, Sid accountSid) throws ConfigurationException { final SqlSession session = sessions.openSession(); try { - if (extensionConfiguration != null && extensionConfiguration.getConfigurationData() != null) { - if (validate(extensionConfiguration)) { + if (extensionRules != null && extensionRules.getConfigurationData() != null) { + if (validate(extensionRules)) { final Map map = new HashMap(); map.put("account_sid", DaoUtils.writeSid(accountSid)); - map.put("extension_sid", DaoUtils.writeSid(extensionConfiguration.getSid())); + map.put("extension_sid", DaoUtils.writeSid(extensionRules.getSid())); - if (extensionConfiguration.getConfigurationData() != null) - map.put("configuration_data", extensionConfiguration.getConfigurationData()); + if (extensionRules.getConfigurationData() != null) + map.put("configuration_data", extensionRules.getConfigurationData()); - session.insert(namespace + "addAccountExtensionConfiguration", map); + session.insert(namespace + "addAccountExtensionRules", map); session.commit(); } else { throw new ConfigurationException("Exception trying to add new configuration, validation failed. configuration type: " - + extensionConfiguration.getConfigurationType()); + + extensionRules.getConfigurationType()); } } } finally { @@ -328,22 +328,22 @@ public void addAccountExtensionConfiguration(ExtensionConfiguration extensionCon } @Override - public void updateAccountExtensionConfiguration(ExtensionConfiguration extensionConfiguration, Sid accountSid) + public void updateAccountExtensionRules (ExtensionRules extensionRules, Sid accountSid) throws ConfigurationException { final SqlSession session = sessions.openSession(); try { - if (extensionConfiguration != null && extensionConfiguration.getConfigurationData() != null) { - if (validate(extensionConfiguration)) { + if (extensionRules != null && extensionRules.getConfigurationData() != null) { + if (validate(extensionRules)) { final Map map = new HashMap(); map.put("account_sid", DaoUtils.writeSid(accountSid)); - map.put("extension_sid", DaoUtils.writeSid(extensionConfiguration.getSid())); + map.put("extension_sid", DaoUtils.writeSid(extensionRules.getSid())); - if (extensionConfiguration.getConfigurationData() != null) - map.put("configuration_data", extensionConfiguration.getConfigurationData()); - session.update(namespace + "updateAccountExtensionConfiguration", map); + if (extensionRules.getConfigurationData() != null) + map.put("configuration_data", extensionRules.getConfigurationData()); + session.update(namespace + "updateAccountExtensionRules", map); } else { throw new ConfigurationException("Exception trying to update configuration, validation failed. configuration type: " - + extensionConfiguration.getConfigurationType()); + + extensionRules.getConfigurationType()); } } session.commit(); @@ -353,13 +353,13 @@ public void updateAccountExtensionConfiguration(ExtensionConfiguration extension } @Override - public void deleteAccountExtensionConfiguration(String accountSid, String extensionSid) { + public void deleteAccountExtensionRules (String accountSid, String extensionSid) { final SqlSession session = sessions.openSession(); try { Map params = new HashMap(); params.put("account_sid", accountSid.toString()); params.put("extension_sid", extensionSid.toString()); - session.delete(namespace + "deleteAccountExtensionConfiguration", params); + session.delete(namespace + "deleteAccountExtensionRules", params); session.commit(); } finally { session.close(); diff --git a/restcomm/restcomm.dao/src/main/resources/org/restcomm/connect/dao/mybatis/extensions-configuration.xml b/restcomm/restcomm.dao/src/main/resources/org/restcomm/connect/dao/mybatis/extensions-configuration.xml index b20ac5233b..6010af4ab0 100644 --- a/restcomm/restcomm.dao/src/main/resources/org/restcomm/connect/dao/mybatis/extensions-configuration.xml +++ b/restcomm/restcomm.dao/src/main/resources/org/restcomm/connect/dao/mybatis/extensions-configuration.xml @@ -28,35 +28,35 @@ - - + + INSERT INTO "restcomm_extensions_configuration" ("sid", "extension", "configuration_data", "configuration_type", "date_created", "date_updated", "enabled") VALUES (#{sid}, #{extension}, #{configuration_data}, #{configuration_type}, #{date_created}, #{date_updated}, #{enabled}); - + UPDATE "restcomm_extensions_configuration" SET "configuration_data"=#{configuration_data}, "configuration_type"=#{configuration_type}, "date_updated"=#{date_updated}, "enabled"=#{enabled} WHERE "sid"=#{sid} - SELECT * FROM "restcomm_extensions_configuration" WHERE "extension"=#{extension}; - SELECT * FROM "restcomm_extensions_configuration" WHERE "sid"=#{sid}; - SELECT * FROM "restcomm_extensions_configuration"; - + DELETE FROM "restcomm_extensions_configuration" WHERE "sid"=#{sid}; - + DELETE FROM "restcomm_extensions_configuration" WHERE "extension"=#{extension}; @@ -68,22 +68,22 @@ SELECT "date_updated" FROM "restcomm_extensions_configuration" WHERE "sid"=#{sid}; - SELECT "configuration_data", "account_sid" AS "sid", "extension_sid" AS "extension" FROM "restcomm_accounts_extensions" WHERE "account_sid"=#{account_sid} AND "extension_sid"=#{extension_sid}; - + INSERT INTO "restcomm_accounts_extensions" ("account_sid", "extension_sid", "configuration_data") VALUES (#{account_sid}, #{extension_sid}, #{configuration_data}); - + UPDATE "restcomm_accounts_extensions" SET "configuration_data"=#{configuration_data} WHERE "account_sid"=#{account_sid} AND "extension_sid"=#{extension_sid}; - + DELETE FROM "restcomm_accounts_extensions" WHERE "account_sid"=#{account_sid} AND "extension_sid"=#{extension_sid}; diff --git a/restcomm/restcomm.dao/src/test/java/org/restcomm/connect/dao/mybatis/ExtensionConfigurationDaoTest.java b/restcomm/restcomm.dao/src/test/java/org/restcomm/connect/dao/mybatis/ExtensionRulesDaoTest.java similarity index 50% rename from restcomm/restcomm.dao/src/test/java/org/restcomm/connect/dao/mybatis/ExtensionConfigurationDaoTest.java rename to restcomm/restcomm.dao/src/test/java/org/restcomm/connect/dao/mybatis/ExtensionRulesDaoTest.java index 35e21df964..cfe22e6711 100644 --- a/restcomm/restcomm.dao/src/test/java/org/restcomm/connect/dao/mybatis/ExtensionConfigurationDaoTest.java +++ b/restcomm/restcomm.dao/src/test/java/org/restcomm/connect/dao/mybatis/ExtensionRulesDaoTest.java @@ -12,7 +12,7 @@ import org.restcomm.connect.commons.annotations.UnstableTests; import org.restcomm.connect.commons.dao.Sid; import org.restcomm.connect.extension.api.ConfigurationException; -import org.restcomm.connect.extension.api.ExtensionConfiguration; +import org.restcomm.connect.extension.api.ExtensionRules; import java.io.InputStream; import java.nio.file.Files; @@ -30,9 +30,9 @@ */ @Category(UnstableTests.class) @Ignore -public class ExtensionConfigurationDaoTest { +public class ExtensionRulesDaoTest { private static MybatisDaoManager manager; - private MybatisExtensionsConfigurationDao extensionsConfigurationDao; + private MybatisExtensionsRulesDao extensionsRulesDao; @Rule public TestName name = new TestName(); @@ -146,7 +146,7 @@ public void before() throws Exception{ final SqlSessionFactory factory = builder.build(data,properties); manager = new MybatisDaoManager(); manager.start(factory); - extensionsConfigurationDao = (MybatisExtensionsConfigurationDao) manager.getExtensionsConfigurationDao(); + extensionsRulesDao = (MybatisExtensionsRulesDao) manager.getExtensionsRulesDao(); } @After @@ -156,215 +156,215 @@ public void after() { @Test public void testValidJsonDoc() { - ExtensionConfiguration validExtensionConfiguration = new ExtensionConfiguration(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), - "testExt", true, validJsonObject, ExtensionConfiguration.configurationType.JSON, DateTime.now()); - assertEquals(true, extensionsConfigurationDao.validate(validExtensionConfiguration)); + ExtensionRules validExtensionRules = new ExtensionRules(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), + "testExt", true, validJsonObject, ExtensionRules.configurationType.JSON, DateTime.now()); + assertEquals(true, extensionsRulesDao.validate(validExtensionRules)); } @Test public void testInvalidJsonDoc() { - ExtensionConfiguration invalidExtensionConfiguration = new ExtensionConfiguration(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), - "testExt", true, invalidJsonObject, ExtensionConfiguration.configurationType.JSON, DateTime.now()); - assertEquals(false, extensionsConfigurationDao.validate(invalidExtensionConfiguration)); + ExtensionRules invalidExtensionRules = new ExtensionRules(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), + "testExt", true, invalidJsonObject, ExtensionRules.configurationType.JSON, DateTime.now()); + assertEquals(false, extensionsRulesDao.validate(invalidExtensionRules)); } @Test public void testValidXmlDoc() { - ExtensionConfiguration validExtensionConfiguration = new ExtensionConfiguration(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), - "testExt", true, validXmlDoc, ExtensionConfiguration.configurationType.XML, DateTime.now()); - assertEquals(true, extensionsConfigurationDao.validate(validExtensionConfiguration)); + ExtensionRules validExtensionRules = new ExtensionRules(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), + "testExt", true, validXmlDoc, ExtensionRules.configurationType.XML, DateTime.now()); + assertEquals(true, extensionsRulesDao.validate(validExtensionRules)); } @Test public void testInvalidXmlDoc() { - ExtensionConfiguration invalidExtensionConfiguration = new ExtensionConfiguration(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), - "testExt", true, invalidXmlDoc, ExtensionConfiguration.configurationType.XML, DateTime.now()); - assertEquals(false, extensionsConfigurationDao.validate(invalidExtensionConfiguration)); + ExtensionRules invalidExtensionRules = new ExtensionRules(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), + "testExt", true, invalidXmlDoc, ExtensionRules.configurationType.XML, DateTime.now()); + assertEquals(false, extensionsRulesDao.validate(invalidExtensionRules)); } @Test public void testStoreAndRetrieveConfigurationByNameJson() throws ConfigurationException { String extName = "testExt"; - ExtensionConfiguration validExtensionConfiguration = new ExtensionConfiguration(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), - extName, true, validJsonObject, ExtensionConfiguration.configurationType.JSON, DateTime.now()); - extensionsConfigurationDao.addConfiguration(validExtensionConfiguration); - ExtensionConfiguration retrievedConf = extensionsConfigurationDao.getConfigurationByName(extName); + ExtensionRules validExtensionRules = new ExtensionRules(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), + extName, true, validJsonObject, ExtensionRules.configurationType.JSON, DateTime.now()); + extensionsRulesDao.addExtensionRules(validExtensionRules); + ExtensionRules retrievedConf = extensionsRulesDao.getExtensionRulesByName(extName); assertNotNull(retrievedConf); - assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionConfiguration.getConfigurationData().toString()); - extensionsConfigurationDao.deleteConfigurationByName(extName); + assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionRules.getConfigurationData().toString()); + extensionsRulesDao.deleteExtensionRulesByName(extName); } @Test public void testStoreAndRetrieveConfigurationBySidJson() throws ConfigurationException { Sid sid = Sid.generate(Sid.Type.EXTENSION_CONFIGURATION); - ExtensionConfiguration validExtensionConfiguration = new ExtensionConfiguration(sid, - "testExt", true, validJsonObject, ExtensionConfiguration.configurationType.JSON, DateTime.now()); - extensionsConfigurationDao.addConfiguration(validExtensionConfiguration); - ExtensionConfiguration retrievedConf = extensionsConfigurationDao.getConfigurationBySid(sid); + ExtensionRules validExtensionRules = new ExtensionRules(sid, + "testExt", true, validJsonObject, ExtensionRules.configurationType.JSON, DateTime.now()); + extensionsRulesDao.addExtensionRules(validExtensionRules); + ExtensionRules retrievedConf = extensionsRulesDao.getExtensionRulesBySid(sid); assertNotNull(retrievedConf); - assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionConfiguration.getConfigurationData().toString()); - extensionsConfigurationDao.deleteConfigurationBySid(sid); + assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionRules.getConfigurationData().toString()); + extensionsRulesDao.deleteExtensionRulesBySid(sid); } @Test public void testStoreUpdateAndRetrieveConfigurationByNameJson() throws ConfigurationException { String extName = "testExt"; - ExtensionConfiguration validExtensionConfiguration = new ExtensionConfiguration(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), - extName, true, validJsonObject, ExtensionConfiguration.configurationType.JSON, DateTime.now()); - extensionsConfigurationDao.addConfiguration(validExtensionConfiguration); - ExtensionConfiguration retrievedConf = extensionsConfigurationDao.getConfigurationByName(extName); + ExtensionRules validExtensionRules = new ExtensionRules(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), + extName, true, validJsonObject, ExtensionRules.configurationType.JSON, DateTime.now()); + extensionsRulesDao.addExtensionRules(validExtensionRules); + ExtensionRules retrievedConf = extensionsRulesDao.getExtensionRulesByName(extName); assertNotNull(retrievedConf); - assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionConfiguration.getConfigurationData().toString()); - validExtensionConfiguration.setConfigurationData(updatedJsonObject, ExtensionConfiguration.configurationType.JSON); - extensionsConfigurationDao.updateConfiguration(validExtensionConfiguration); - retrievedConf = extensionsConfigurationDao.getConfigurationByName(extName); + assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionRules.getConfigurationData().toString()); + validExtensionRules.setConfigurationData(updatedJsonObject, ExtensionRules.configurationType.JSON); + extensionsRulesDao.updateExtensionRules(validExtensionRules); + retrievedConf = extensionsRulesDao.getExtensionRulesByName(extName); assertEquals(updatedJsonObject, retrievedConf.getConfigurationData()); - extensionsConfigurationDao.deleteConfigurationByName(extName); + extensionsRulesDao.deleteExtensionRulesByName(extName); } @Test public void testStoreUpdateAndRetrieveConfigurationBySidJson() throws ConfigurationException { Sid sid = Sid.generate(Sid.Type.EXTENSION_CONFIGURATION); - ExtensionConfiguration validExtensionConfiguration = new ExtensionConfiguration(sid, - "testExt", true, validJsonObject, ExtensionConfiguration.configurationType.JSON, DateTime.now()); - extensionsConfigurationDao.addConfiguration(validExtensionConfiguration); - ExtensionConfiguration retrievedConf = extensionsConfigurationDao.getConfigurationBySid(sid); + ExtensionRules validExtensionRules = new ExtensionRules(sid, + "testExt", true, validJsonObject, ExtensionRules.configurationType.JSON, DateTime.now()); + extensionsRulesDao.addExtensionRules(validExtensionRules); + ExtensionRules retrievedConf = extensionsRulesDao.getExtensionRulesBySid(sid); assertNotNull(retrievedConf); - assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionConfiguration.getConfigurationData().toString()); - validExtensionConfiguration.setConfigurationData(updatedJsonObject, ExtensionConfiguration.configurationType.JSON); - extensionsConfigurationDao.updateConfiguration(validExtensionConfiguration); - retrievedConf = extensionsConfigurationDao.getConfigurationBySid(sid); + assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionRules.getConfigurationData().toString()); + validExtensionRules.setConfigurationData(updatedJsonObject, ExtensionRules.configurationType.JSON); + extensionsRulesDao.updateExtensionRules(validExtensionRules); + retrievedConf = extensionsRulesDao.getExtensionRulesBySid(sid); assertEquals(updatedJsonObject, retrievedConf.getConfigurationData()); - extensionsConfigurationDao.deleteConfigurationBySid(sid); + extensionsRulesDao.deleteExtensionRulesBySid(sid); } @Test public void testStoreAndRetrieveConfigurationByNameXml() throws ConfigurationException { String extName = "testExt"; - ExtensionConfiguration validExtensionConfiguration = new ExtensionConfiguration(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), - extName, true, validXmlDoc, ExtensionConfiguration.configurationType.XML, DateTime.now()); - extensionsConfigurationDao.addConfiguration(validExtensionConfiguration); - ExtensionConfiguration retrievedConf = extensionsConfigurationDao.getConfigurationByName(extName); + ExtensionRules validExtensionRules = new ExtensionRules(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), + extName, true, validXmlDoc, ExtensionRules.configurationType.XML, DateTime.now()); + extensionsRulesDao.addExtensionRules(validExtensionRules); + ExtensionRules retrievedConf = extensionsRulesDao.getExtensionRulesByName(extName); assertNotNull(retrievedConf); - assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionConfiguration.getConfigurationData().toString()); - extensionsConfigurationDao.deleteConfigurationByName(extName); + assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionRules.getConfigurationData().toString()); + extensionsRulesDao.deleteExtensionRulesByName(extName); } @Test public void testStoreAndRetrieveConfigurationBySidXml() throws ConfigurationException { Sid sid = Sid.generate(Sid.Type.EXTENSION_CONFIGURATION); - ExtensionConfiguration validExtensionConfiguration = new ExtensionConfiguration(sid, - "testExt", true, validXmlDoc, ExtensionConfiguration.configurationType.XML, DateTime.now()); - extensionsConfigurationDao.addConfiguration(validExtensionConfiguration); - ExtensionConfiguration retrievedConf = extensionsConfigurationDao.getConfigurationBySid(sid); + ExtensionRules validExtensionRules = new ExtensionRules(sid, + "testExt", true, validXmlDoc, ExtensionRules.configurationType.XML, DateTime.now()); + extensionsRulesDao.addExtensionRules(validExtensionRules); + ExtensionRules retrievedConf = extensionsRulesDao.getExtensionRulesBySid(sid); assertNotNull(retrievedConf); - assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionConfiguration.getConfigurationData().toString()); - extensionsConfigurationDao.deleteConfigurationBySid(sid); + assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionRules.getConfigurationData().toString()); + extensionsRulesDao.deleteExtensionRulesBySid(sid); } @Test public void testStoreUpdateAndRetrieveConfigurationByNameXml() throws ConfigurationException { String extName = "testExt"; - ExtensionConfiguration validExtensionConfiguration = new ExtensionConfiguration(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), - extName, true, validXmlDoc, ExtensionConfiguration.configurationType.XML, DateTime.now()); - extensionsConfigurationDao.addConfiguration(validExtensionConfiguration); - ExtensionConfiguration retrievedConf = extensionsConfigurationDao.getConfigurationByName(extName); + ExtensionRules validExtensionRules = new ExtensionRules(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), + extName, true, validXmlDoc, ExtensionRules.configurationType.XML, DateTime.now()); + extensionsRulesDao.addExtensionRules(validExtensionRules); + ExtensionRules retrievedConf = extensionsRulesDao.getExtensionRulesByName(extName); assertNotNull(retrievedConf); - assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionConfiguration.getConfigurationData().toString()); - validExtensionConfiguration.setConfigurationData(updatedXmlDoc, ExtensionConfiguration.configurationType.XML); - extensionsConfigurationDao.updateConfiguration(validExtensionConfiguration); - retrievedConf = extensionsConfigurationDao.getConfigurationByName(extName); + assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionRules.getConfigurationData().toString()); + validExtensionRules.setConfigurationData(updatedXmlDoc, ExtensionRules.configurationType.XML); + extensionsRulesDao.updateExtensionRules(validExtensionRules); + retrievedConf = extensionsRulesDao.getExtensionRulesByName(extName); assertEquals(updatedXmlDoc, retrievedConf.getConfigurationData()); - extensionsConfigurationDao.deleteConfigurationByName(extName); + extensionsRulesDao.deleteExtensionRulesByName(extName); } @Test public void testStoreUpdateAndRetrieveConfigurationBySidXml() throws ConfigurationException { Sid sid = Sid.generate(Sid.Type.EXTENSION_CONFIGURATION); - ExtensionConfiguration validExtensionConfiguration = new ExtensionConfiguration(sid, - "testExt", true, validXmlDoc, ExtensionConfiguration.configurationType.XML, DateTime.now()); - extensionsConfigurationDao.addConfiguration(validExtensionConfiguration); - ExtensionConfiguration retrievedConf = extensionsConfigurationDao.getConfigurationBySid(sid); + ExtensionRules validExtensionRules = new ExtensionRules(sid, + "testExt", true, validXmlDoc, ExtensionRules.configurationType.XML, DateTime.now()); + extensionsRulesDao.addExtensionRules(validExtensionRules); + ExtensionRules retrievedConf = extensionsRulesDao.getExtensionRulesBySid(sid); assertNotNull(retrievedConf); - assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionConfiguration.getConfigurationData().toString()); - validExtensionConfiguration.setConfigurationData(updatedXmlDoc, ExtensionConfiguration.configurationType.XML); - extensionsConfigurationDao.updateConfiguration(validExtensionConfiguration); - retrievedConf = extensionsConfigurationDao.getConfigurationBySid(sid); + assertEquals(retrievedConf.getConfigurationData().toString(), validExtensionRules.getConfigurationData().toString()); + validExtensionRules.setConfigurationData(updatedXmlDoc, ExtensionRules.configurationType.XML); + extensionsRulesDao.updateExtensionRules(validExtensionRules); + retrievedConf = extensionsRulesDao.getExtensionRulesBySid(sid); assertEquals(updatedXmlDoc, retrievedConf.getConfigurationData()); - extensionsConfigurationDao.deleteConfigurationBySid(sid); + extensionsRulesDao.deleteExtensionRulesBySid(sid); } @Test public void testStoreAndGetAllConfiguration() throws ConfigurationException { Sid sid1 = Sid.generate(Sid.Type.EXTENSION_CONFIGURATION); Sid sid2 = Sid.generate(Sid.Type.EXTENSION_CONFIGURATION); - ExtensionConfiguration validExtensionConfigurationXml = new ExtensionConfiguration(sid1, - "testExtXml", true, validXmlDoc, ExtensionConfiguration.configurationType.XML, DateTime.now()); - ExtensionConfiguration validExtensionConfigurationJson = new ExtensionConfiguration(sid2, - "testExtJson", true, validJsonObject, ExtensionConfiguration.configurationType.JSON, DateTime.now()); + ExtensionRules validExtensionRulesXml = new ExtensionRules(sid1, + "testExtXml", true, validXmlDoc, ExtensionRules.configurationType.XML, DateTime.now()); + ExtensionRules validExtensionRulesJson = new ExtensionRules(sid2, + "testExtJson", true, validJsonObject, ExtensionRules.configurationType.JSON, DateTime.now()); - extensionsConfigurationDao.addConfiguration(validExtensionConfigurationXml); - extensionsConfigurationDao.addConfiguration(validExtensionConfigurationJson); + extensionsRulesDao.addExtensionRules(validExtensionRulesXml); + extensionsRulesDao.addExtensionRules(validExtensionRulesJson); - List confs = extensionsConfigurationDao.getAllConfiguration(); + List confs = extensionsRulesDao.getAllExtensionRules(); assertEquals(2, confs.size()); - extensionsConfigurationDao.deleteConfigurationBySid(sid1); - extensionsConfigurationDao.deleteConfigurationBySid(sid2); + extensionsRulesDao.deleteExtensionRulesBySid(sid1); + extensionsRulesDao.deleteExtensionRulesBySid(sid2); - confs = extensionsConfigurationDao.getAllConfiguration(); + confs = extensionsRulesDao.getAllExtensionRules(); assertEquals(0, confs.size()); } @Test public void testStoreUpdateAndRetrieveConfigurationByNameCheckVersionJson() throws ConfigurationException { String extName = "testExt"; - ExtensionConfiguration originalExtensionConfiguration = new ExtensionConfiguration(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), - extName, true, validJsonObject, ExtensionConfiguration.configurationType.JSON, DateTime.now()); - extensionsConfigurationDao.addConfiguration(originalExtensionConfiguration); + ExtensionRules originalExtensionRules = new ExtensionRules(Sid.generate(Sid.Type.EXTENSION_CONFIGURATION), + extName, true, validJsonObject, ExtensionRules.configurationType.JSON, DateTime.now()); + extensionsRulesDao.addExtensionRules(originalExtensionRules); - ExtensionConfiguration retrievedConf = extensionsConfigurationDao.getConfigurationByName(extName); + ExtensionRules retrievedConf = extensionsRulesDao.getExtensionRulesByName(extName); assertNotNull(retrievedConf); - assertEquals(retrievedConf.getConfigurationData().toString(), originalExtensionConfiguration.getConfigurationData().toString()); + assertEquals(retrievedConf.getConfigurationData().toString(), originalExtensionRules.getConfigurationData().toString()); DateTime originalDateUpdated = retrievedConf.getDateUpdated(); - boolean isUpdated = extensionsConfigurationDao.isLatestVersionByName(extName, originalDateUpdated); + boolean isUpdated = extensionsRulesDao.isLatestVersionByName(extName, originalDateUpdated); assertEquals(isUpdated , false); - originalExtensionConfiguration.setConfigurationData(updatedJsonObject, ExtensionConfiguration.configurationType.JSON); - extensionsConfigurationDao.updateConfiguration(originalExtensionConfiguration); + originalExtensionRules.setConfigurationData(updatedJsonObject, ExtensionRules.configurationType.JSON); + extensionsRulesDao.updateExtensionRules(originalExtensionRules); - isUpdated = extensionsConfigurationDao.isLatestVersionByName(extName, originalDateUpdated); + isUpdated = extensionsRulesDao.isLatestVersionByName(extName, originalDateUpdated); assertEquals(isUpdated , true); - extensionsConfigurationDao.deleteConfigurationByName(extName); + extensionsRulesDao.deleteExtensionRulesByName(extName); } @Test public void testStoreUpdateAndRetrieveConfigurationBySidCheckVersionJson() throws ConfigurationException { String extName = "testExt"; Sid sid = Sid.generate(Sid.Type.EXTENSION_CONFIGURATION); - ExtensionConfiguration originalExtensionConfiguration = new ExtensionConfiguration(sid, - extName, true, validJsonObject, ExtensionConfiguration.configurationType.JSON, DateTime.now()); - extensionsConfigurationDao.addConfiguration(originalExtensionConfiguration); + ExtensionRules originalExtensionRules = new ExtensionRules(sid, + extName, true, validJsonObject, ExtensionRules.configurationType.JSON, DateTime.now()); + extensionsRulesDao.addExtensionRules(originalExtensionRules); - ExtensionConfiguration retrievedConf = extensionsConfigurationDao.getConfigurationBySid(sid); + ExtensionRules retrievedConf = extensionsRulesDao.getExtensionRulesBySid(sid); assertNotNull(retrievedConf); - assertEquals(retrievedConf.getConfigurationData().toString(), originalExtensionConfiguration.getConfigurationData().toString()); + assertEquals(retrievedConf.getConfigurationData().toString(), originalExtensionRules.getConfigurationData().toString()); DateTime originalDateUpdated = retrievedConf.getDateUpdated(); - boolean isUpdated = extensionsConfigurationDao.isLatestVersionBySid(sid, originalDateUpdated); + boolean isUpdated = extensionsRulesDao.isLatestVersionBySid(sid, originalDateUpdated); assertEquals(isUpdated , false); - originalExtensionConfiguration.setConfigurationData(updatedJsonObject, ExtensionConfiguration.configurationType.JSON); - extensionsConfigurationDao.updateConfiguration(originalExtensionConfiguration); + originalExtensionRules.setConfigurationData(updatedJsonObject, ExtensionRules.configurationType.JSON); + extensionsRulesDao.updateExtensionRules(originalExtensionRules); - isUpdated = extensionsConfigurationDao.isLatestVersionBySid(sid, originalDateUpdated); + isUpdated = extensionsRulesDao.isLatestVersionBySid(sid, originalDateUpdated); assertEquals(isUpdated , true); - extensionsConfigurationDao.deleteConfigurationBySid(sid); + extensionsRulesDao.deleteExtensionRulesBySid(sid); } } diff --git a/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ApiRequest.java b/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ApiRequest.java index 1ebf7e4023..70e850e91d 100644 --- a/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ApiRequest.java +++ b/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ApiRequest.java @@ -24,7 +24,7 @@ /** * Created by gvagenas on 10/10/2016. */ -public class ApiRequest { +public class ApiRequest extends ExtensionRequest { public static enum Type { AVAILABLEPHONENUMBER,INCOMINGPHONENUMBER, CREATE_SUBACCOUNT }; diff --git a/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ExtensionContext.java b/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ExtensionContext.java new file mode 100755 index 0000000000..41deef3bbb --- /dev/null +++ b/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ExtensionContext.java @@ -0,0 +1,25 @@ +/* + * TeleStax, Open Source Cloud Communications + * Copyright 2011-2013, Telestax Inc and individual contributors + * by the @authors tag. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.restcomm.connect.extension.api; + +public interface ExtensionContext { + ExtensionRules getEffectiveExtensionRules (String extensionSid, String scopeSid); +} diff --git a/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ExtensionRequest.java b/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ExtensionRequest.java index fc79185add..bbd4208b58 100755 --- a/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ExtensionRequest.java +++ b/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ExtensionRequest.java @@ -23,6 +23,8 @@ public class ExtensionRequest implements IExtensionRequest{ private boolean allowed = true; private String accountSid; + private ExtensionContext extensionContext; + public ExtensionRequest() { this("", true); } @@ -58,4 +60,22 @@ public void setAllowed(boolean allowed) { this.allowed = allowed; } + /** + * setExtensionContext + * @param ExtensionContext + */ + @Override + public void setExtensionContext(ExtensionContext ec) { + this.extensionContext = ec; + } + + /** + * getExtensionContext + * @return the current ExtensionContext + */ + @Override + public ExtensionContext getExtensionContext() { + return this.extensionContext; + } + } diff --git a/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ExtensionConfiguration.java b/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ExtensionRules.java similarity index 84% rename from restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ExtensionConfiguration.java rename to restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ExtensionRules.java index 3dec472d49..8b604f20bb 100644 --- a/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ExtensionConfiguration.java +++ b/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/ExtensionRules.java @@ -25,7 +25,7 @@ /** * Created by gvagenas on 12/10/2016. */ -public class ExtensionConfiguration { +public class ExtensionRules { public enum configurationType { XML, JSON } @@ -37,8 +37,8 @@ public enum configurationType { private DateTime dateCreated; private DateTime dateUpdated; - public ExtensionConfiguration(Sid sid, String extensionName, boolean enabled, Object configurationData, - configurationType configurationType, DateTime dateCreated, DateTime dateUpdated) { + public ExtensionRules (Sid sid, String extensionName, boolean enabled, Object configurationData, + configurationType configurationType, DateTime dateCreated, DateTime dateUpdated) { this.sid = sid; this.extensionName = extensionName; this.enabled = enabled; @@ -48,8 +48,8 @@ public ExtensionConfiguration(Sid sid, String extensionName, boolean enabled, Ob this.dateUpdated = dateUpdated; } - public ExtensionConfiguration(Sid sid, String extensionName, boolean enabled, Object configurationData, - configurationType configurationType, DateTime dateCreated) { + public ExtensionRules (Sid sid, String extensionName, boolean enabled, Object configurationData, + configurationType configurationType, DateTime dateCreated) { this(sid, extensionName, enabled, configurationData, configurationType, dateCreated, DateTime.now()); } diff --git a/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/IExtensionRequest.java b/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/IExtensionRequest.java index 0211de62d6..5965067338 100755 --- a/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/IExtensionRequest.java +++ b/restcomm/restcomm.extension.api/src/main/java/org/restcomm/connect/extension/api/IExtensionRequest.java @@ -37,4 +37,14 @@ public interface IExtensionRequest { * @param set to allow/restrict request */ void setAllowed(boolean allowed); + + /** + * @param set ExtensionContext + */ + void setExtensionContext(ExtensionContext ec); + + /** + * @param set ExtensionContext + */ + ExtensionContext getExtensionContext(); } diff --git a/restcomm/restcomm.extension.controller/src/main/java/org/restcomm/connect/extension/configuration/DefaultExtensionConfiguration.java b/restcomm/restcomm.extension.controller/src/main/java/org/restcomm/connect/extension/configuration/DefaultExtensionConfiguration.java index a1306d1cbe..dcef598633 100755 --- a/restcomm/restcomm.extension.controller/src/main/java/org/restcomm/connect/extension/configuration/DefaultExtensionConfiguration.java +++ b/restcomm/restcomm.extension.controller/src/main/java/org/restcomm/connect/extension/configuration/DefaultExtensionConfiguration.java @@ -32,9 +32,9 @@ import org.joda.time.DateTime; import org.restcomm.connect.commons.dao.Sid; import org.restcomm.connect.dao.DaoManager; -import org.restcomm.connect.dao.ExtensionsConfigurationDao; +import org.restcomm.connect.dao.ExtensionsRulesDao; import org.restcomm.connect.extension.api.ConfigurationException; -import org.restcomm.connect.extension.api.ExtensionConfiguration; +import org.restcomm.connect.extension.api.ExtensionRules; import com.google.gson.Gson; import com.google.gson.JsonArray; @@ -55,8 +55,8 @@ private PropertyType(String value) { private static final Logger logger = Logger.getLogger(DefaultExtensionConfiguration.class); private boolean workingWithLocalConf; - private ExtensionsConfigurationDao extensionConfigurationDao; - private ExtensionConfiguration extensionConfiguration; + private ExtensionsRulesDao extensionsRulesDao; + private ExtensionRules extensionRules; private JsonObject configurationJsonObj; private JsonParser jsonParser; private DaoManager daoManager; @@ -84,7 +84,7 @@ public DefaultExtensionConfiguration(final DaoManager daoManager, String extensi public void init(final DaoManager daoManager, String extensionName, String localConfigPath) throws ConfigurationException { try { this.setDaoManager(daoManager); - this.extensionConfigurationDao = daoManager.getExtensionsConfigurationDao(); + this.extensionsRulesDao = daoManager.getExtensionsRulesDao(); if (extensionName.isEmpty() && localConfigPath.isEmpty()) { throw new ConfigurationException("extensionName or local config cant be empty"); @@ -105,26 +105,26 @@ public void init(final DaoManager daoManager, String extensionName, String local } defVersion = new DefaultArtifactVersion(defaultConfigurationJsonObj.get("version").getAsString()); } - // Load extensionConfiguration from DB - extensionConfiguration = extensionConfigurationDao.getConfigurationByName(extensionName); + // Load extensionRules from DB + extensionRules = extensionsRulesDao.getExtensionRulesByName(extensionName); // try fetch sid from name - if (extensionConfiguration == null) { - // If extensionConfiguration from DB is null then add the default values to DB + if (extensionRules == null) { + // If extensionRules from DB is null then add the default values to DB this.sid = Sid.generate(Sid.Type.EXTENSION_CONFIGURATION); - extensionConfiguration = new ExtensionConfiguration(sid, this.extensionName, true, - defaultConfigurationJsonObj.toString(), ExtensionConfiguration.configurationType.JSON, DateTime.now()); - extensionConfigurationDao.addConfiguration(extensionConfiguration); + extensionRules = new ExtensionRules(sid, this.extensionName, true, + defaultConfigurationJsonObj.toString(), ExtensionRules.configurationType.JSON, DateTime.now()); + extensionsRulesDao.addExtensionRules(extensionRules); } else { // Get configuration object - this.sid = extensionConfiguration.getSid(); + this.sid = extensionRules.getSid(); // try get default config data JsonObject dbConfiguration = null; DefaultArtifactVersion currentVersion = null; try { - dbConfiguration = (JsonObject) jsonParser.parse((String) extensionConfiguration.getConfigurationData()); + dbConfiguration = (JsonObject) jsonParser.parse((String) extensionRules.getConfigurationData()); if (dbConfiguration.get("version") != null) { currentVersion = new DefaultArtifactVersion(dbConfiguration.get("version").getAsString()); } @@ -146,10 +146,10 @@ public void init(final DaoManager daoManager, String extensionName, String local } dbConfiguration.addProperty("version", defaultConfigurationJsonObj.get("version").getAsString()); - extensionConfiguration = new ExtensionConfiguration(extensionConfiguration.getSid(), extensionName, - extensionConfiguration.isEnabled(), dbConfiguration.toString(), - ExtensionConfiguration.configurationType.JSON, DateTime.now()); - extensionConfigurationDao.updateConfiguration(extensionConfiguration); + extensionRules = new ExtensionRules(extensionRules.getSid(), extensionName, + extensionRules.isEnabled(), dbConfiguration.toString(), + ExtensionRules.configurationType.JSON, DateTime.now()); + extensionsRulesDao.updateExtensionRules(extensionRules); } configurationJsonObj = dbConfiguration; // Load Specific Configuration Map @@ -193,9 +193,9 @@ public JsonObject loadDefaultConfiguration(String localConfigFilePath) throws IO public void reloadConfiguration() { if (!workingWithLocalConf) { - if (extensionConfigurationDao.isLatestVersionByName(extensionName, extensionConfiguration.getDateUpdated())) { - extensionConfiguration = extensionConfigurationDao.getConfigurationByName(extensionName); - String updatedConf = (String) extensionConfiguration.getConfigurationData(); + if (extensionsRulesDao.isLatestVersionByName(extensionName, extensionRules.getDateUpdated())) { + extensionRules = extensionsRulesDao.getExtensionRulesByName(extensionName); + String updatedConf = (String) extensionRules.getConfigurationData(); configurationJsonObj = (JsonObject) jsonParser.parse(updatedConf); // loadSpecificConfigurationMap(configurationJsonObj); if (logger.isInfoEnabled()) { @@ -207,8 +207,8 @@ public void reloadConfiguration() { public boolean isEnabled() { reloadConfiguration(); - if (extensionConfiguration != null) { - return extensionConfiguration.isEnabled(); + if (extensionRules != null) { + return extensionRules.isEnabled(); } else { return true; } @@ -263,4 +263,8 @@ public void setDaoManager(DaoManager daoManager) { public JsonObject getCurrentConf() { return configurationJsonObj; } + + public boolean isWorkingWithLocalConf() { + return workingWithLocalConf; + } } diff --git a/restcomm/restcomm.extension.controller/src/main/java/org/restcomm/connect/extension/controller/ExtensionBootstrapper.java b/restcomm/restcomm.extension.controller/src/main/java/org/restcomm/connect/extension/controller/ExtensionBootstrapper.java index 2b498a3756..2c98d49b4f 100644 --- a/restcomm/restcomm.extension.controller/src/main/java/org/restcomm/connect/extension/controller/ExtensionBootstrapper.java +++ b/restcomm/restcomm.extension.controller/src/main/java/org/restcomm/connect/extension/controller/ExtensionBootstrapper.java @@ -43,6 +43,7 @@ public class ExtensionBootstrapper { public ExtensionBootstrapper(final ServletContext context, final Configuration configuration) { this.configuration = configuration; this.context = context; + ExtensionController.getInstance().init(this.context); } public void start() throws ClassNotFoundException, IllegalAccessException, InstantiationException { diff --git a/restcomm/restcomm.extension.controller/src/main/java/org/restcomm/connect/extension/controller/ExtensionController.java b/restcomm/restcomm.extension.controller/src/main/java/org/restcomm/connect/extension/controller/ExtensionController.java index df44937801..6dbc4e9340 100644 --- a/restcomm/restcomm.extension.controller/src/main/java/org/restcomm/connect/extension/controller/ExtensionController.java +++ b/restcomm/restcomm.extension.controller/src/main/java/org/restcomm/connect/extension/controller/ExtensionController.java @@ -1,8 +1,19 @@ package org.restcomm.connect.extension.controller; +import org.restcomm.connect.commons.dao.Sid; +import org.restcomm.connect.dao.AccountsDao; +import org.restcomm.connect.dao.ClientsDao; +import org.restcomm.connect.dao.DaoManager; +import org.restcomm.connect.dao.ExtensionsRulesDao; +import org.restcomm.connect.dao.OrganizationsDao; +import org.restcomm.connect.dao.entities.Account; +import org.restcomm.connect.dao.entities.Client; +import org.restcomm.connect.dao.entities.Organization; import org.restcomm.connect.extension.api.ApiRequest; +import org.restcomm.connect.extension.api.ExtensionRules; import org.restcomm.connect.extension.api.ExtensionResponse; import org.restcomm.connect.extension.api.ExtensionType; +import org.restcomm.connect.extension.api.ExtensionContext; import org.restcomm.connect.extension.api.IExtensionRequest; import org.restcomm.connect.extension.api.RestcommExtension; import org.restcomm.connect.extension.api.RestcommExtensionGeneric; @@ -11,10 +22,12 @@ import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; +import javax.servlet.ServletContext; + /** * Created by gvagenas on 21/09/16. */ -public class ExtensionController { +public class ExtensionController implements ExtensionContext{ private static Logger logger = Logger.getLogger(ExtensionController.class); private static ExtensionController instance; @@ -24,6 +37,10 @@ public class ExtensionController { private List restApiExtensions; private List featureAccessControlExtensions; + private DaoManager daoManager; + + private ServletContext context; + private ExtensionController(){ this.callManagerExtensions = new CopyOnWriteArrayList(); this.smsSessionExtensions = new CopyOnWriteArrayList(); @@ -32,6 +49,11 @@ private ExtensionController(){ this.featureAccessControlExtensions = new CopyOnWriteArrayList(); } + public void init(ServletContext context) { + this.context = context; + daoManager = (DaoManager)context.getAttribute(DaoManager.class.getName()); + } + public static ExtensionController getInstance() { if (instance == null) { instance = new ExtensionController(); @@ -108,7 +130,7 @@ public ExtensionResponse executePreOutboundAction(final IExtensionRequest ier, L // extensionResponse ExtensionResponse response = new ExtensionResponse(); if (extensions != null && extensions.size() > 0) { - + ier.setExtensionContext(this); for (RestcommExtensionGeneric extension : extensions) { if(logger.isInfoEnabled()) { logger.info( extension.getName()+" is enabled="+extension.isEnabled()); @@ -138,7 +160,7 @@ public ExtensionResponse executePreOutboundAction(final IExtensionRequest ier, L public ExtensionResponse executePostOutboundAction(final IExtensionRequest er, List extensions) { ExtensionResponse response = new ExtensionResponse(); if (extensions != null && extensions.size() > 0) { - + er.setExtensionContext(this); for (RestcommExtensionGeneric extension : extensions) { if(logger.isInfoEnabled()) { logger.info( extension.getName()+" is enabled="+extension.isEnabled()); @@ -168,6 +190,7 @@ public ExtensionResponse executePostOutboundAction(final IExtensionRequest er, L public ExtensionResponse executePreInboundAction(final IExtensionRequest er, List extensions) { ExtensionResponse response = new ExtensionResponse(); if (extensions != null && extensions.size() > 0) { + er.setExtensionContext(this); for (RestcommExtensionGeneric extension : extensions) { if(logger.isInfoEnabled()) { logger.info( extension.getName()+" is enabled="+extension.isEnabled()); @@ -197,6 +220,7 @@ public ExtensionResponse executePreInboundAction(final IExtensionRequest er, Lis public ExtensionResponse executePostInboundAction(final IExtensionRequest er, List extensions) { ExtensionResponse response = new ExtensionResponse(); if (extensions != null && extensions.size() > 0) { + er.setExtensionContext(this); for (RestcommExtensionGeneric extension : extensions) { if(logger.isInfoEnabled()) { logger.info( extension.getName()+" is enabled="+extension.isEnabled()); @@ -227,6 +251,7 @@ public ExtensionResponse executePreApiAction(final ApiRequest apiRequest, List 0) { + apiRequest.setExtensionContext(this); for (RestcommExtensionGeneric extension : extensions) { if(logger.isInfoEnabled()) { logger.info( extension.getName()+" is enabled="+extension.isEnabled()); @@ -257,6 +282,7 @@ public ExtensionResponse executePostApiAction(final ApiRequest apiRequest, List< ExtensionResponse response = new ExtensionResponse(); if (extensions != null && extensions.size() > 0) { + apiRequest.setExtensionContext(this); for (RestcommExtensionGeneric extension : extensions) { if(logger.isInfoEnabled()) { logger.info( extension.getName()+" is enabled="+extension.isEnabled()); @@ -282,4 +308,73 @@ public ExtensionResponse executePostApiAction(final ApiRequest apiRequest, List< } return response; } + + @Override + public ExtensionRules getEffectiveExtensionRules (String extensionSid, String scopeSid) { + ExtensionsRulesDao erd = daoManager.getExtensionsRulesDao(); + ClientsDao cd = daoManager.getClientsDao(); + AccountsDao ad = daoManager.getAccountsDao(); + OrganizationsDao od = daoManager.getOrganizationsDao(); + + Sid sid = new Sid(scopeSid); + Sid.Type t = Sid.getType(sid); + Client client = null; + Account account = null; + Organization organization = null; + + switch(t) { + case CLIENT: + client = cd.getClient(sid); + break; + case ACCOUNT: + account = ad.getAccount(sid); + break; + case ORGANIZATION: + organization = od.getOrganization(sid); + break; + } + + //FIXME: might not be optimized + //preliminary check for all scopes: client, acc, org + ExtensionRules extRules = erd.getAccountExtensionRules(scopeSid, extensionSid); + + //the scopeSid was a client + if(client!= null && extRules==null) { + account = ad.getAccount(client.getAccountSid()); + } + + //the scopeSid was an account + if(account!=null && extRules==null) { + extRules = erd.getAccountExtensionRules(account.getSid().toString(), extensionSid); + if(extRules==null) { + List lineage = ad.getAccountLineage(sid); + for(String currSid : lineage) { + if(logger.isInfoEnabled()) { + logger.info("checking "+ currSid); + } + extRules = erd.getAccountExtensionRules(currSid, extensionSid); + if(extRules != null) { + break; + } + } + organization = od.getOrganization(account.getOrganizationSid()); + } + } + + //the scopeSid was an org + if(organization!= null && extRules==null) { + //it is assumed that lineage will always have identical org, so we only check the originating account + extRules = erd.getAccountExtensionRules(organization.getSid().toString(), extensionSid); + if(logger.isInfoEnabled()) { + logger.info("checking "+ account.getOrganizationSid().toString()); + } + } + + //check default + if(extRules==null) { + //if no account specific entry is defined, we use the extension config + extRules = erd.getExtensionRulesBySid(new Sid(extensionSid)); + } + return extRules; + } } diff --git a/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/AllowingExtensionMockTest.java b/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/AllowingExtensionMockTest.java index b52c974517..b7e21967e5 100644 --- a/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/AllowingExtensionMockTest.java +++ b/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/AllowingExtensionMockTest.java @@ -26,7 +26,7 @@ import org.mockito.Mockito; import static org.mockito.Mockito.when; import org.restcomm.connect.dao.DaoManager; -import org.restcomm.connect.dao.ExtensionsConfigurationDao; +import org.restcomm.connect.dao.ExtensionsRulesDao; import org.restcomm.connect.extension.api.ApiRequest; import org.restcomm.connect.extension.api.ExtensionRequest; import org.restcomm.connect.extension.api.ExtensionResponse; @@ -45,15 +45,15 @@ class ExtensionCollaborators { ServletContext sCtx = Mockito.mock(ServletContext.class); DaoManager daoMng = Mockito.mock(DaoManager.class); - ExtensionsConfigurationDao extDao = Mockito.mock(ExtensionsConfigurationDao.class); + ExtensionsRulesDao extDao = Mockito.mock(ExtensionsRulesDao.class); public ExtensionCollaborators() { when(sCtx.getAttribute(DaoManager.class.getName())). thenReturn(daoMng); - when(daoMng.getExtensionsConfigurationDao()). + when(daoMng.getExtensionsRulesDao()). thenReturn(extDao); - when(extDao.getConfigurationByName("allowing")).thenReturn(null); + when(extDao.getExtensionRulesByName("allowing")).thenReturn(null); } } @@ -68,7 +68,7 @@ public void testAllowingExtension() throws Exception { Assert.assertTrue(response.isAllowed()); response = extension.postInboundAction(far); Assert.assertTrue(response.isAllowed()); - + response = extension.preOutboundAction(far); Assert.assertTrue(response.isAllowed()); response = extension.postOutboundAction(far); diff --git a/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/BlockingExtensionMockTest.java b/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/BlockingExtensionMockTest.java index afa8f5d683..f1b4bf172c 100644 --- a/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/BlockingExtensionMockTest.java +++ b/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/BlockingExtensionMockTest.java @@ -26,7 +26,7 @@ import org.mockito.Mockito; import static org.mockito.Mockito.when; import org.restcomm.connect.dao.DaoManager; -import org.restcomm.connect.dao.ExtensionsConfigurationDao; +import org.restcomm.connect.dao.ExtensionsRulesDao; import org.restcomm.connect.extension.api.ApiRequest; import org.restcomm.connect.extension.api.ExtensionRequest; import org.restcomm.connect.extension.api.ExtensionResponse; @@ -45,15 +45,15 @@ class ExtensionCollaborators { ServletContext sCtx = Mockito.mock(ServletContext.class); DaoManager daoMng = Mockito.mock(DaoManager.class); - ExtensionsConfigurationDao extDao = Mockito.mock(ExtensionsConfigurationDao.class); + ExtensionsRulesDao extDao = Mockito.mock(ExtensionsRulesDao.class); public ExtensionCollaborators() { when(sCtx.getAttribute(DaoManager.class.getName())). thenReturn(daoMng); - when(daoMng.getExtensionsConfigurationDao()). + when(daoMng.getExtensionsRulesDao()). thenReturn(extDao); - when(extDao.getConfigurationByName("blocking")).thenReturn(null); + when(extDao.getExtensionRulesByName("blocking")).thenReturn(null); } } diff --git a/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/DBExtensionMockTest.java b/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/DBExtensionMockTest.java index 3bf252e3a8..a2a060b1df 100644 --- a/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/DBExtensionMockTest.java +++ b/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/DBExtensionMockTest.java @@ -20,7 +20,6 @@ package org.restcomm.connect.extension.mock; -import java.util.Calendar; import javax.servlet.ServletContext; import org.joda.time.DateTime; import org.junit.Assert; @@ -29,10 +28,10 @@ import static org.mockito.Mockito.when; import org.restcomm.connect.commons.dao.Sid; import org.restcomm.connect.dao.DaoManager; -import org.restcomm.connect.dao.ExtensionsConfigurationDao; +import org.restcomm.connect.dao.ExtensionsRulesDao; import org.restcomm.connect.extension.api.ApiRequest; -import org.restcomm.connect.extension.api.ExtensionConfiguration; -import static org.restcomm.connect.extension.api.ExtensionConfiguration.configurationType.JSON; +import org.restcomm.connect.extension.api.ExtensionRules; +import static org.restcomm.connect.extension.api.ExtensionRules.configurationType.JSON; import org.restcomm.connect.extension.api.ExtensionRequest; import org.restcomm.connect.extension.api.ExtensionResponse; @@ -51,22 +50,22 @@ class ExtensionCollaborators { ServletContext sCtx = Mockito.mock(ServletContext.class); DaoManager daoMng = Mockito.mock(DaoManager.class); - ExtensionsConfigurationDao extDao = Mockito.mock(ExtensionsConfigurationDao.class); + ExtensionsRulesDao extDao = Mockito.mock(ExtensionsRulesDao.class); public ExtensionCollaborators(String confJson) { when(sCtx.getAttribute(DaoManager.class.getName())). thenReturn(daoMng); - when(daoMng.getExtensionsConfigurationDao()). + when(daoMng.getExtensionsRulesDao()). thenReturn(extDao); - ExtensionConfiguration extConf = new ExtensionConfiguration(Sid. + ExtensionRules extConf = new ExtensionRules(Sid. generate(Sid.Type.EXTENSION_CONFIGURATION), "simple_db", true, confJson, JSON, new DateTime(),new DateTime()); - when(extDao.getConfigurationByName("simple_db")).thenReturn(null); + when(extDao.getExtensionRulesByName("simple_db")).thenReturn(null); } } diff --git a/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/OutboundBlockingExtensionMockTest.java b/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/OutboundBlockingExtensionMockTest.java index ffce8ff75a..4e4c9bef8f 100644 --- a/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/OutboundBlockingExtensionMockTest.java +++ b/restcomm/restcomm.extension.controller/src/test/java/org/restcomm/connect/extension/mock/OutboundBlockingExtensionMockTest.java @@ -26,7 +26,7 @@ import org.mockito.Mockito; import static org.mockito.Mockito.when; import org.restcomm.connect.dao.DaoManager; -import org.restcomm.connect.dao.ExtensionsConfigurationDao; +import org.restcomm.connect.dao.ExtensionsRulesDao; import org.restcomm.connect.extension.api.ApiRequest; import org.restcomm.connect.extension.api.ExtensionRequest; import org.restcomm.connect.extension.api.ExtensionResponse; @@ -45,15 +45,15 @@ class ExtensionCollaborators { ServletContext sCtx = Mockito.mock(ServletContext.class); DaoManager daoMng = Mockito.mock(DaoManager.class); - ExtensionsConfigurationDao extDao = Mockito.mock(ExtensionsConfigurationDao.class); + ExtensionsRulesDao extDao = Mockito.mock(ExtensionsRulesDao.class); public ExtensionCollaborators() { when(sCtx.getAttribute(DaoManager.class.getName())). thenReturn(daoMng); - when(daoMng.getExtensionsConfigurationDao()). + when(daoMng.getExtensionsRulesDao()). thenReturn(extDao); - when(extDao.getConfigurationByName("outbound_blocking")).thenReturn(null); + when(extDao.getExtensionRulesByName("outbound_blocking")).thenReturn(null); } } diff --git a/restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/ExtensionsConfigurationEndpoint.java b/restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/ExtensionsRulesEndpoint.java similarity index 64% rename from restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/ExtensionsConfigurationEndpoint.java rename to restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/ExtensionsRulesEndpoint.java index babf5bd528..2478244e05 100644 --- a/restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/ExtensionsConfigurationEndpoint.java +++ b/restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/ExtensionsRulesEndpoint.java @@ -41,34 +41,34 @@ import org.joda.time.DateTime; import org.restcomm.connect.commons.dao.Sid; import org.restcomm.connect.dao.DaoManager; -import org.restcomm.connect.dao.ExtensionsConfigurationDao; +import org.restcomm.connect.dao.ExtensionsRulesDao; import org.restcomm.connect.dao.entities.RestCommResponse; import org.restcomm.connect.extension.api.ConfigurationException; -import org.restcomm.connect.extension.api.ExtensionConfiguration; +import org.restcomm.connect.extension.api.ExtensionRules; import org.restcomm.connect.http.converter.ExtensionConfigurationConverter; import org.restcomm.connect.http.converter.RestCommResponseConverter; /** * Created by gvagenas on 12/10/2016. */ -public class ExtensionsConfigurationEndpoint extends SecuredEndpoint { +public class ExtensionsRulesEndpoint extends SecuredEndpoint { protected Configuration allConfiguration; protected Configuration configuration; protected Gson gson; protected XStream xstream; - protected ExtensionsConfigurationDao extensionsConfigurationDao; + protected ExtensionsRulesDao extensionsRulesDao; - public ExtensionsConfigurationEndpoint() { super(); } + public ExtensionsRulesEndpoint () { super(); } @PostConstruct void init() { allConfiguration = (Configuration) context.getAttribute(Configuration.class.getName()); configuration = allConfiguration.subset("runtime-settings"); super.init(configuration); - extensionsConfigurationDao = ((DaoManager) context.getAttribute(DaoManager.class.getName())).getExtensionsConfigurationDao(); + extensionsRulesDao = ((DaoManager) context.getAttribute(DaoManager.class.getName())).getExtensionsRulesDao(); final ExtensionConfigurationConverter converter = new ExtensionConfigurationConverter(configuration); final GsonBuilder builder = new GsonBuilder(); - builder.registerTypeAdapter(ExtensionConfiguration.class, converter); + builder.registerTypeAdapter(ExtensionRules.class, converter); builder.setPrettyPrinting(); gson = builder.create(); xstream = new XStream(); @@ -84,11 +84,11 @@ void init() { * @param responseType * @return */ - protected Response getConfiguration(final String extensionId, final Sid accountSid, final MediaType responseType) { + protected Response getRules (final String extensionId, final Sid accountSid, final MediaType responseType) { //Parameter "extensionId" could be the extension Sid or extension name. - ExtensionConfiguration extensionConfiguration = null; - ExtensionConfiguration extensionAccountConfiguration = null; + ExtensionRules extensionRules = null; + ExtensionRules extensionAccountRules = null; Sid extensionSid = null; String extensionName = null; @@ -100,13 +100,13 @@ protected Response getConfiguration(final String extensionId, final Sid accountS if (Sid.pattern.matcher(extensionId).matches()) { try { - extensionConfiguration = extensionsConfigurationDao.getConfigurationBySid(extensionSid); + extensionRules = extensionsRulesDao.getExtensionRulesBySid(extensionSid); } catch (Exception e) { return status(NOT_FOUND).build(); } } else { try { - extensionConfiguration = extensionsConfigurationDao.getConfigurationByName(extensionName); + extensionRules = extensionsRulesDao.getExtensionRulesByName(extensionName); } catch (Exception e) { return status(NOT_FOUND).build(); } @@ -114,24 +114,24 @@ protected Response getConfiguration(final String extensionId, final Sid accountS if (accountSid!=null) { if(extensionSid == null ){ - extensionSid = extensionConfiguration.getSid(); + extensionSid = extensionRules.getSid(); } try { - extensionAccountConfiguration = extensionsConfigurationDao.getAccountExtensionConfiguration(accountSid.toString(), extensionSid.toString()); - extensionConfiguration.setConfigurationData(extensionAccountConfiguration.getConfigurationData(), extensionAccountConfiguration.getConfigurationType()); + extensionAccountRules = extensionsRulesDao.getAccountExtensionRules(accountSid.toString(), extensionSid.toString()); + extensionRules.setConfigurationData(extensionAccountRules.getConfigurationData(), extensionAccountRules.getConfigurationType()); } catch (Exception e) { return status(NOT_FOUND).build(); } } - if (extensionConfiguration == null) { + if (extensionRules == null) { return status(NOT_FOUND).build(); } else { if (APPLICATION_XML_TYPE.equals(responseType)) { - final RestCommResponse response = new RestCommResponse(extensionConfiguration); + final RestCommResponse response = new RestCommResponse(extensionRules); return ok(xstream.toXML(response), APPLICATION_XML).build(); } else if (APPLICATION_JSON_TYPE.equals(responseType)) { - return ok(gson.toJson(extensionConfiguration), APPLICATION_JSON).build(); + return ok(gson.toJson(extensionRules), APPLICATION_JSON).build(); } else { return null; } @@ -146,26 +146,26 @@ private void validate(final MultivaluedMap data) throws NullPoin } } - private ExtensionConfiguration createFrom(final MultivaluedMap data, final MediaType responseType) { + private ExtensionRules createFrom(final MultivaluedMap data, final MediaType responseType) { validate(data); Sid sid = Sid.generate(Sid.Type.EXTENSION_CONFIGURATION); String extension = data.getFirst("ExtensionName"); boolean enabled = Boolean.parseBoolean(data.getFirst("Enabled")); Object configurationData = data.getFirst("ConfigurationData"); - ExtensionConfiguration.configurationType configurationType = null; + ExtensionRules.configurationType configurationType = null; if (responseType.equals(APPLICATION_JSON_TYPE)) { - configurationType = ExtensionConfiguration.configurationType.JSON; + configurationType = ExtensionRules.configurationType.JSON; } else if (responseType.equals(APPLICATION_XML_TYPE)) { - configurationType = ExtensionConfiguration.configurationType.XML; + configurationType = ExtensionRules.configurationType.XML; } DateTime dateCreated = DateTime.now(); DateTime dateUpdated = DateTime.now(); - ExtensionConfiguration extensionConfiguration = new ExtensionConfiguration(sid, extension, enabled, configurationData, configurationType, dateCreated, dateUpdated); + ExtensionRules extensionRules = new ExtensionRules(sid, extension, enabled, configurationData, configurationType, dateCreated, dateUpdated); - return extensionConfiguration; + return extensionRules; } - protected Response postConfiguration(final MultivaluedMap data, final MediaType responseType) { + protected Response postRules (final MultivaluedMap data, final MediaType responseType) { Sid accountSid = null; @@ -175,16 +175,16 @@ protected Response postConfiguration(final MultivaluedMap data, } //if extension doesnt exist, add new extension String extensionName = data.getFirst("ExtensionName"); - ExtensionConfiguration extensionConfiguration = extensionsConfigurationDao.getConfigurationByName(extensionName); + ExtensionRules extensionRules = extensionsRulesDao.getExtensionRulesByName(extensionName); - if(extensionConfiguration==null){ + if(extensionRules ==null){ try { - extensionConfiguration = createFrom(data, responseType); + extensionRules = createFrom(data, responseType); } catch (final NullPointerException exception) { return status(BAD_REQUEST).entity(exception.getMessage()).build(); } try { - extensionsConfigurationDao.addConfiguration(extensionConfiguration); + extensionsRulesDao.addExtensionRules(extensionRules); } catch (ConfigurationException exception) { return status(NOT_ACCEPTABLE).entity(exception.getMessage()).build(); } @@ -193,35 +193,35 @@ protected Response postConfiguration(final MultivaluedMap data, try { Object configurationData = data.getFirst("ConfigurationData"); // if accountSid exists, then this configuration is account specific, if it doesnt then its global config - extensionConfiguration.setConfigurationData(configurationData, extensionConfiguration.getConfigurationType()); - extensionsConfigurationDao.addAccountExtensionConfiguration(extensionConfiguration, accountSid); + extensionRules.setConfigurationData(configurationData, extensionRules.getConfigurationType()); + extensionsRulesDao.addAccountExtensionRules(extensionRules, accountSid); } catch (ConfigurationException exception) { return status(NOT_ACCEPTABLE).entity(exception.getMessage()).build(); } } if (APPLICATION_JSON_TYPE.equals(responseType)) { - return ok(gson.toJson(extensionConfiguration), APPLICATION_JSON).build(); + return ok(gson.toJson(extensionRules), APPLICATION_JSON).build(); } else if (APPLICATION_XML_TYPE.equals(responseType)) { - final RestCommResponse response = new RestCommResponse(extensionConfiguration); + final RestCommResponse response = new RestCommResponse(extensionRules); return ok(xstream.toXML(response), APPLICATION_XML).build(); } else { return null; } } - protected Response updateConfiguration(String extensionSid, MultivaluedMap data, MediaType responseType) { + protected Response updateRules (String extensionSid, MultivaluedMap data, MediaType responseType) { if (!Sid.pattern.matcher(extensionSid).matches()) { return status(BAD_REQUEST).build(); } - ExtensionConfiguration extensionConfiguration = extensionsConfigurationDao.getConfigurationBySid(new Sid(extensionSid)); - if (extensionConfiguration == null) { + ExtensionRules extensionRules = extensionsRulesDao.getExtensionRulesBySid(new Sid(extensionSid)); + if (extensionRules == null) { return status(NOT_FOUND).build(); } - ExtensionConfiguration updatedExtensionConfiguration = null; + ExtensionRules updatedExtensionRules = null; Sid accountSid = null; String accountSidQuery = data.getFirst("AccountSid"); if(accountSidQuery != null && !accountSidQuery.isEmpty()){ @@ -229,48 +229,48 @@ protected Response updateConfiguration(String extensionSid, MultivaluedMap data, MediaType responseType) { + private ExtensionRules prepareUpdatedRules (ExtensionRules existingExtensionRules, MultivaluedMap data, MediaType responseType) { validate(data); - Sid existingExtensionSid = existingExtensionConfiguration.getSid(); - String existingExtensionName = existingExtensionConfiguration.getExtensionName(); - boolean enabled = existingExtensionConfiguration.isEnabled(); + Sid existingExtensionSid = existingExtensionRules.getSid(); + String existingExtensionName = existingExtensionRules.getExtensionName(); + boolean enabled = existingExtensionRules.isEnabled(); if (data.getFirst("Enabled") != null) { enabled = Boolean.parseBoolean(data.getFirst("Enabled")); } Object configurationData = data.getFirst("ConfigurationData"); - DateTime dateCreated = existingExtensionConfiguration.getDateCreated(); - ExtensionConfiguration.configurationType configurationType = null; + DateTime dateCreated = existingExtensionRules.getDateCreated(); + ExtensionRules.configurationType configurationType = null; if (responseType.equals(APPLICATION_JSON_TYPE)) { - configurationType = ExtensionConfiguration.configurationType.JSON; + configurationType = ExtensionRules.configurationType.JSON; } else if (responseType.equals(APPLICATION_XML_TYPE)) { - configurationType = ExtensionConfiguration.configurationType.XML; + configurationType = ExtensionRules.configurationType.XML; } - return new ExtensionConfiguration(existingExtensionSid, existingExtensionName, enabled, configurationData, configurationType, dateCreated ,DateTime.now()); + return new ExtensionRules(existingExtensionSid, existingExtensionName, enabled, configurationData, configurationType, dateCreated ,DateTime.now()); } } diff --git a/restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/ExtensionsConfigurationXmlEndpoint.java b/restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/ExtensionsRulesXmlEndpoint.java similarity index 70% rename from restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/ExtensionsConfigurationXmlEndpoint.java rename to restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/ExtensionsRulesXmlEndpoint.java index f5ac408639..71eacd1146 100644 --- a/restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/ExtensionsConfigurationXmlEndpoint.java +++ b/restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/ExtensionsRulesXmlEndpoint.java @@ -40,25 +40,25 @@ @Path("/ExtensionsConfiguration") @RolesAllowed(SUPER_ADMIN_ROLE) -public class ExtensionsConfigurationXmlEndpoint extends ExtensionsConfigurationEndpoint { +public class ExtensionsRulesXmlEndpoint extends ExtensionsRulesEndpoint { @Path("/{extensionId}") @GET @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON}) - public Response getConfigurationAsXml(@PathParam("extensionId") final String extension, @QueryParam("AccountSid") Sid accountSid) { - return getConfiguration(extension, accountSid, retrieveMediaType()); + public Response getRulesAsXml (@PathParam("extensionId") final String extension, @QueryParam("AccountSid") Sid accountSid) { + return getRules(extension, accountSid, retrieveMediaType()); } @POST @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON}) - public Response postConfigurationAsXml(final MultivaluedMap data) { - return postConfiguration(data, retrieveMediaType()); + public Response postRulesAsXml (final MultivaluedMap data) { + return postRules(data, retrieveMediaType()); } @Path("/{extensionSid}") @POST @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON}) - public Response updateConfigurationAsXml(@PathParam("extensionSid") final String extensionSid, - final MultivaluedMap data) { - return updateConfiguration(extensionSid, data, retrieveMediaType()); + public Response updateRulesAsXml (@PathParam("extensionSid") final String extensionSid, + final MultivaluedMap data) { + return updateRules(extensionSid, data, retrieveMediaType()); } } diff --git a/restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/converter/ExtensionConfigurationConverter.java b/restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/converter/ExtensionConfigurationConverter.java index ad8ae17ec9..e53a3a422d 100644 --- a/restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/converter/ExtensionConfigurationConverter.java +++ b/restcomm/restcomm.http/src/main/java/org/restcomm/connect/http/converter/ExtensionConfigurationConverter.java @@ -27,7 +27,7 @@ import org.apache.commons.configuration.Configuration; import org.restcomm.connect.commons.annotations.concurrency.ThreadSafe; import org.restcomm.connect.commons.util.StringUtils; -import org.restcomm.connect.extension.api.ExtensionConfiguration; +import org.restcomm.connect.extension.api.ExtensionRules; import java.lang.reflect.Type; @@ -35,7 +35,7 @@ * @author gvagenas@gmail.com */ @ThreadSafe -public final class ExtensionConfigurationConverter extends AbstractConverter implements JsonSerializer { +public final class ExtensionConfigurationConverter extends AbstractConverter implements JsonSerializer { private final String apiVersion; private final String rootUri; @@ -48,37 +48,37 @@ public ExtensionConfigurationConverter(final Configuration configuration) { @SuppressWarnings("rawtypes") @Override public boolean canConvert(final Class klass) { - return ExtensionConfiguration.class.equals(klass); + return ExtensionRules.class.equals(klass); } @Override public void marshal(final Object object, final HierarchicalStreamWriter writer, final MarshallingContext context) { - final ExtensionConfiguration extensionConfiguration = (ExtensionConfiguration) object; - writer.startNode("ExtensionConfiguration"); - writeSid(extensionConfiguration.getSid(),writer); + final ExtensionRules extensionRules = (ExtensionRules) object; + writer.startNode("ExtensionRules"); + writeSid(extensionRules.getSid(),writer); writer.startNode("Extension"); - writer.setValue(extensionConfiguration.getExtensionName()); + writer.setValue(extensionRules.getExtensionName()); writer.endNode(); writer.startNode("Configuration"); - writer.setValue(extensionConfiguration.getConfigurationData().toString()); + writer.setValue(extensionRules.getConfigurationData().toString()); writer.endNode(); writer.startNode("Configuration Type"); - writer.setValue(extensionConfiguration.getConfigurationType().name()); + writer.setValue(extensionRules.getConfigurationType().name()); writer.endNode(); - writeDateCreated(extensionConfiguration.getDateCreated(),writer); - writeDateCreated(extensionConfiguration.getDateUpdated(), writer); + writeDateCreated(extensionRules.getDateCreated(),writer); + writeDateCreated(extensionRules.getDateUpdated(), writer); writer.endNode(); } @Override - public JsonElement serialize(final ExtensionConfiguration extensionConfiguration, final Type type, final JsonSerializationContext context) { + public JsonElement serialize(final ExtensionRules extensionRules, final Type type, final JsonSerializationContext context) { final JsonObject object = new JsonObject(); - writeSid(extensionConfiguration.getSid(), object); - object.addProperty("extension", extensionConfiguration.getExtensionName()); - object.addProperty("configuration", extensionConfiguration.getConfigurationData().toString()); - object.addProperty("configuration type", extensionConfiguration.getConfigurationType().name()); - writeDateCreated(extensionConfiguration.getDateCreated(), object); - writeDateUpdated(extensionConfiguration.getDateUpdated(), object); + writeSid(extensionRules.getSid(), object); + object.addProperty("extension", extensionRules.getExtensionName()); + object.addProperty("configuration", extensionRules.getConfigurationData().toString()); + object.addProperty("configuration type", extensionRules.getConfigurationType().name()); + writeDateCreated(extensionRules.getDateCreated(), object); + writeDateUpdated(extensionRules.getDateUpdated(), object); return object; } } diff --git a/restcomm/restcomm.sms.api/src/main/java/org/restcomm/connect/sms/api/CreateSmsSession.java b/restcomm/restcomm.sms.api/src/main/java/org/restcomm/connect/sms/api/CreateSmsSession.java index 726d5ed514..a97cb284de 100644 --- a/restcomm/restcomm.sms.api/src/main/java/org/restcomm/connect/sms/api/CreateSmsSession.java +++ b/restcomm/restcomm.sms.api/src/main/java/org/restcomm/connect/sms/api/CreateSmsSession.java @@ -21,12 +21,13 @@ import org.apache.commons.configuration.Configuration; import org.restcomm.connect.commons.annotations.concurrency.Immutable; +import org.restcomm.connect.extension.api.ExtensionRequest; import org.restcomm.connect.extension.api.IExtensionCreateSmsSessionRequest; /** * @author quintana.thomas@gmail.com (Thomas Quintana) */ @Immutable -public final class CreateSmsSession implements IExtensionCreateSmsSessionRequest { +public final class CreateSmsSession extends ExtensionRequest implements IExtensionCreateSmsSessionRequest { private final String from; private final String to; private final String accountSid; diff --git a/restcomm/restcomm.telephony.api/src/main/java/org/restcomm/connect/telephony/api/CreateCall.java b/restcomm/restcomm.telephony.api/src/main/java/org/restcomm/connect/telephony/api/CreateCall.java index 171b16492e..c3d8fcfc45 100644 --- a/restcomm/restcomm.telephony.api/src/main/java/org/restcomm/connect/telephony/api/CreateCall.java +++ b/restcomm/restcomm.telephony.api/src/main/java/org/restcomm/connect/telephony/api/CreateCall.java @@ -23,6 +23,7 @@ import org.restcomm.connect.commons.dao.Sid; import org.restcomm.connect.commons.telephony.CreateCallType; import org.restcomm.connect.dao.entities.MediaAttributes; +import org.restcomm.connect.extension.api.ExtensionRequest; import org.restcomm.connect.extension.api.IExtensionCreateCallRequest; import java.net.URI; @@ -36,7 +37,7 @@ * @author gvagenas@telestax.com */ @Immutable -public final class CreateCall implements IExtensionCreateCallRequest{ +public final class CreateCall extends ExtensionRequest implements IExtensionCreateCallRequest{ private final String from; private final String to; diff --git a/restcomm/restcomm.telephony.api/src/main/java/org/restcomm/connect/telephony/api/FeatureAccessRequest.java b/restcomm/restcomm.telephony.api/src/main/java/org/restcomm/connect/telephony/api/FeatureAccessRequest.java index 820be18661..86b8889436 100644 --- a/restcomm/restcomm.telephony.api/src/main/java/org/restcomm/connect/telephony/api/FeatureAccessRequest.java +++ b/restcomm/restcomm.telephony.api/src/main/java/org/restcomm/connect/telephony/api/FeatureAccessRequest.java @@ -21,9 +21,10 @@ package org.restcomm.connect.telephony.api; import org.restcomm.connect.commons.dao.Sid; +import org.restcomm.connect.extension.api.ExtensionRequest; import org.restcomm.connect.extension.api.IExtensionFeatureAccessRequest; -public class FeatureAccessRequest implements IExtensionFeatureAccessRequest { +public class FeatureAccessRequest extends ExtensionRequest implements IExtensionFeatureAccessRequest { public enum Feature { OUTBOUND_VOICE("outbound-voice"), INBOUND_VOICE("inbound-voice"), OUTBOUND_SMS("outbound-sms"),