Nokia geocoder config moved to the config helper

server/extension/sql/0.1.0/15_config_helper.sql

@@ -5,10 +5,19 @@ RETURNS boolean AS $$
   if cache_key in GD:
     return False
   else:
+    import json
     from cartodb_geocoder import config_helper
     plpy.execute("SELECT cdb_geocoder_server._connect_to_redis('{0}')".format(username))
     redis_conn = GD["redis_connection_{0}".format(username)]['redis_metadata_connection']
-    geocoder_config = config_helper.GeocoderConfig(redis_conn, username, orgname)
+    heremaps_conf_json = plpy.execute("SELECT cartodb.CDB_Conf_GetConf('heremaps_conf') as heremaps_conf", 1)[0]['heremaps_conf']
+    if not heremaps_conf_json:
+      heremaps_app_id = None
+      heremaps_app_code = None
+    else:
+      heremaps_conf = json.loads(heremaps_conf_json)
+      heremaps_app_id = heremaps_conf['app_id']
+      heremaps_app_code = heremaps_conf['app_code']
+    geocoder_config = config_helper.GeocoderConfig(redis_conn, username, orgname, heremaps_app_id, heremaps_app_code)
     # --Think about the security concerns with this kind of global cache, it should be only available
     # --for this user session but...
     GD[cache_key] = geocoder_config

server/extension/sql/0.1.0/20_geocode_street.sql

@@ -2,7 +2,6 @@
 DROP FUNCTION IF EXISTS cdb_geocoder_server.cdb_geocode_street_point(TEXT, TEXT, TEXT, TEXT);
 CREATE OR REPLACE FUNCTION cdb_geocoder_server.cdb_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL)
 RETURNS Geometry AS $$
-  import json
   from heremaps import heremapsgeocoder
   from cartodb_geocoder import quota_service
 
@@ -14,13 +13,9 @@ RETURNS Geometry AS $$
   # -- Check the quota
   quota_service = quota_service.QuotaService(user_geocoder_config, redis_conn, username, orgname)
   if not quota_service.check_user_quota():
-    plpy.error('You have reach limit of your quota')
+    plpy.error('You have reach the limit of your quota')
 
-  heremaps_conf = json.loads(plpy.execute("SELECT cdb_geocoder_server._get_conf('heremaps')", 1)[0]['get_conf'])
-  app_id = heremaps_conf['geocoder']['app_id']
-  app_code = heremaps_conf['geocoder']['app_code']
-
-  geocoder = heremapsgeocoder.Geocoder(app_id, app_code)
+  geocoder = heremapsgeocoder.Geocoder(user_geocoder_config.heremaps_app_id, user_geocoder_config.heremaps_app_code)
   results = geocoder.geocode_address(searchtext=searchtext, city=city, state=state_province, country=country)
   coordinates = geocoder.extract_lng_lat_from_result(results[0])
   plan = plpy.prepare("SELECT ST_SetSRID(ST_MakePoint($1, $2), 4326); ", ["double precision", "double precision"])

server/lib/python/cartodb_geocoder/cartodb_geocoder/config_helper.py

@@ -10,9 +10,13 @@ class GeocoderConfig:
 
     GEOCODER_CONFIG_KEYS = ['google_maps_client_id', 'google_maps_api_key',
                             'geocoding_quota', 'soft_geocoding_limit',
-                            'geocoder_type', 'period_end_date']
-    NOKIA_GEOCODER_MANDATORY_KEYS = ['geocoding_quota', 'soft_geocoding_limit']
+                            'geocoder_type', 'period_end_date',
+                            'heremaps_app_id', 'heremaps_app_code']
+    NOKIA_GEOCODER_MANDATORY_KEYS = ['geocoding_quota', 'soft_geocoding_limit',
+                                     'heremaps_app_id', 'heremaps_app_code']
     NOKIA_GEOCODER = 'heremaps'
+    NOKIA_GEOCODER_APP_ID_KEY = 'heremaps_app_id'
+    NOKIA_GEOCODER_APP_CODE_KEY = 'heremaps_app_code'
     GOOGLE_GEOCODER = 'google'
     GOOGLE_GEOCODER_API_KEY = 'google_maps_api_key'
     GOOGLE_GEOCODER_CLIENT_ID = 'google_maps_client_id'
@@ -21,16 +25,21 @@ class GeocoderConfig:
     SOFT_LIMIT_KEY = 'soft_geocoding_limit'
     PERIOD_END_DATE = 'period_end_date'
 
-    def __init__(self, redis_connection, username, orgname=None):
+    def __init__(self, redis_connection, username, orgname=None,
+                 heremaps_app_id=None, heremaps_app_code=None):
         self._redis_connection = redis_connection
-        config = self.__get_user_config(username, orgname)
+        config = self.__get_user_config(username, orgname, heremaps_app_id,
+                                        heremaps_app_code)
         filtered_config = {key: config[key] for key in self.GEOCODER_CONFIG_KEYS if key in config.keys()}
         self.__check_config(filtered_config)
         self.__parse_config(filtered_config)
 
-    def __get_user_config(self, username, orgname=None):
+    def __get_user_config(self, username, orgname=None, heremaps_app_id=None,
+                          heremaps_app_code=None):
         user_config = self._redis_connection.hgetall(
             "rails:users:{0}".format(username))
+        user_config[self.NOKIA_GEOCODER_APP_ID_KEY] = heremaps_app_id
+        user_config[self.NOKIA_GEOCODER_APP_CODE_KEY] = heremaps_app_code
         if orgname:
             org_config = self._redis_connection.hgetall(
                 "rails:orgs:{0}".format(orgname))
@@ -44,10 +53,13 @@ class GeocoderConfig:
     def __check_config(self, filtered_config):
         if filtered_config[self.GEOCODER_TYPE].lower() == self.NOKIA_GEOCODER:
             if not set(self.NOKIA_GEOCODER_MANDATORY_KEYS).issubset(set(filtered_config.keys())):
-                raise ConfigException("""Nokia geocoder needs the mandatory parameters '' and 'nokia_soft_geocoder_limit'""")
+                raise ConfigException("""Some mandatory parameter/s for Nokia geocoder are missing. Check it please""")
+            if not filtered_config[self.NOKIA_GEOCODER_APP_ID_KEY] or not filtered_config[self.NOKIA_GEOCODER_APP_CODE_KEY]:
+                raise ConfigException("""Nokia geocoder configuration is missing. Check it please""")
         elif filtered_config[self.GEOCODER_TYPE].lower() == self.GOOGLE_GEOCODER:
             if self.GOOGLE_GEOCODER_API_KEY not in filtered_config.keys():
-                raise ConfigException("Google geocoder need the mandatory parameter 'google_maps_private_key'")
+                raise ConfigException("""Google geocoder need the mandatory
+                                      parameter 'google_maps_private_key'""")
 
         return True
 
@@ -62,6 +74,8 @@ class GeocoderConfig:
             self._google_maps_client_id = filtered_config[self.GOOGLE_GEOCODER_CLIENT_ID]
         elif self.NOKIA_GEOCODER == self._geocoder_type:
             self._geocoding_quota = float(filtered_config[self.QUOTA_KEY])
+            self._heremaps_app_id = filtered_config[self.NOKIA_GEOCODER_APP_ID_KEY]
+            self._heremaps_app_code = filtered_config[self.NOKIA_GEOCODER_APP_CODE_KEY]
             if filtered_config[self.SOFT_LIMIT_KEY] == 'true':
                 self._soft_geocoding_limit = True
             else:
@@ -101,3 +115,11 @@ class GeocoderConfig:
     @property
     def period_end_date(self):
         return self._period_end_date
+
+    @property
+    def heremaps_app_id(self):
+        return self._heremaps_app_id
+
+    @property
+    def heremaps_app_code(self):
+        return self._heremaps_app_code