contact-person-profile-csv-imp-local 0.0.18__py3-none-any.whl → 0.0.21__py3-none-any.whl

contact_person_profile_csv_imp_local/CSVToContactPersonProfile.py

@@ -1,40 +1,36 @@
 import csv
-import sys
 import os
-
 from datetime import datetime
 from zoneinfo import ZoneInfo
 
-from dotenv import load_dotenv
-load_dotenv()
-script_directory = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.join(script_directory, '..'))
-
-from contact_email_address_local.contact_email_addresses_local import ContactEmailAdressesLocal
-from contact_group_local.contact_group import ContactGroups
-from contact_local.contact_local import ContactsLocal
-from contact_location_local.contact_location_local import ContactLocationLocal
-from contact_notes_local.contact_notes_local import ContactNotesLocal
-from contact_persons_local.contact_persons_local import ContactPersonsLocal
-from contact_phone_local.contact_phone_local import ContactPhoneLocal
-from contact_profile_local.contact_profiles_local import ContactProfilesLocal
-from contact_user_external_local.contact_user_external_local import ContactUserExternalLocal
-from database_mysql_local.generic_crud import GenericCRUD
-from database_mysql_local.point import Point
-from importer_local.ImportersLocal import ImportersLocal
-from internet_domain_local.internet_domain_local import DomainLocal
-from location_local.country import Country
-from location_local.location_local_constants import LocationLocalConstants
-from logger_local.MetaLogger import MetaLogger
-from organization_profile_local.organization_profiles_local import OrganizationProfilesLocal
+from .contact_person_profile_csv_imp_local_constants import CSVToContactPersonProfileConstants
+from data_source_local.data_source import DataSources
+# from user_external_local.user_externals_local import UserExternalsLocal
+# from user_context_remote.user_context import UserContext
 from organizations_local.organizations_local import OrganizationsLocal
+from organization_profile_local.organization_profiles_local import OrganizationProfilesLocal
+from logger_local.MetaLogger import MetaLogger
+from location_local.location_local_constants import LocationLocalConstants
+from location_local.country import Country
+from internet_domain_local.internet_domain_local import DomainLocal
+from importer_local.ImportersLocal import ImportersLocal
+from database_mysql_local.point import Point
+from database_mysql_local.generic_crud import GenericCRUD
+from contact_user_external_local.contact_user_external_local import ContactUserExternalLocal
+from contact_profile_local.contact_profiles_local import ContactProfilesLocal
+from contact_phone_local.contact_phone_local import ContactPhoneLocal
+from phones_local.phones_local import PhonesLocal
+from contact_persons_local.contact_persons_local import ContactPersonsLocal
+from contact_notes_local.contact_notes_local import ContactNotesLocal
+from contact_location_local.contact_location_local import ContactLocationLocal
+from contact_local.contact_local import ContactsLocal
+from contact_group_local.contact_group import ContactGroups
+from contact_email_address_local.contact_email_addresses_local import ContactEmailAdressesLocal
+
 # import pycountry
 from phonenumbers import NumberParseException
 from user_context_remote.user_context import UserContext
 from user_external_local.user_externals_local import UserExternalsLocal
-from data_source_local.data_source import DataSources
-
-from .contact_person_profile_csv_imp_local_constants import CSVToContactPersonProfileConstants
 
 # from contact_local.contact_local import ContactsLocal
 # from database_mysql_local.generic_crud import GenericCRUD
@@ -110,7 +106,7 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
         GenericCRUD.__init__(self, default_schema_name="field", default_column_name="field_id",
                              default_table_name="field_table", default_view_table_name="field_view",
                              is_test_data=is_test_data)
-        self.contact_entity_type_id = self.select_one_value_by_id(
+        self.contact_entity_type_id = self.select_one_value_by_column_and_value(
             schema_name="entity_type", view_table_name="entity_type_ml_en_view",
             select_clause_value="entity_type_id", column_name="title", column_value="Contact")
         self.user_context = UserContext()
@@ -137,25 +133,25 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
     #     :param data_source_type_id: The data source ID
     #     :return: The field name
     #     """
-    #     
+    #
     #                  'data_source_type_id': data_source_type_id})
 
     #     self.set_schema(schema_name="data_source_field")
-    #     data_source_field_tuples = self.select_multi_tuple_by_where(view_table_name="data_source_field_view",  
-    #                                             select_clause_value="external_field_name",  
-    #                                             where="data_source_type_id = %s AND field_id = %s",  
-    #                                             params=(data_source_type_id, field_id))  
+    #     data_source_field_tuples = self.select_multi_tuple_by_where(view_table_name="data_source_field_view",
+    #                                             select_clause_value="external_field_name",
+    #                                             where="data_source_type_id = %s AND field_id = %s",
+    #                                             params=(data_source_type_id, field_id))
 
     #     if data_source_field_tuples:
-    #         
+    #
     #         return data_source_field_tuples[0][0]
     #     return
 
     # TODO what are the diff between csv_path and directory_name?
-    # ans: csv_path is the full path to the csv file, directory_name is the directory where the csv file is located 
+    # ans: csv_path is the full path to the csv file, directory_name is the directory where the csv file is located
 
     # TODO I think file name should be after directory_name and csv_path
-    # ans: it cannot be after directory_name and csv_path because it is a required parameter 
+    # ans: it cannot be after directory_name and csv_path because it is a required parameter
 
     # TODO: break this function into smaller functions
     def insert_update_contact_from_csv(
@@ -176,8 +172,8 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
 
         # TODO Please explain
         # if csv_path is provided then we will use the full path
-        # if csv_path is not provided then we will use the directory_name and file_name to create the full path 
-        # if directory_name is not provided the assumption is that the file is in the same directory as the script and not in a folder 
+        # if csv_path is not provided then we will use the directory_name and file_name to create the full path
+        # if directory_name is not provided the assumption is that the file is in the same directory as the script and not in a folder
         if csv_path is not None:
             csv_file_path = csv_path
         else:
@@ -198,7 +194,7 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
         # We create a new data_source_instance_id everytime we import a new csv file
         data_source_instance_id = self.__get_data_source_instance_id(
             data_source_type_id=data_source_type_id, csv_file_path=csv_file_path,
-            user_external_id=user_external_id, file_name=file_name, 
+            user_external_id=user_external_id, file_name=file_name,
             user_external_username=user_external_username,
             start_index=start_index, end_index=end_index
         )
@@ -211,16 +207,16 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
                 if end_index is not None and not start_index <= row_index <= end_index:
                     continue
                 csv_keys = list(row.keys())
-                contact_data = {}
+                contact_dict = {}
                 '''
                 # Old version
                 for fields in keys:
                     if fields_dictonary[fields] not in csv_keys:
                         continue
                     if fields_dictonary[fields] is not None and isinstance(fields_dictonary[fields], str):
-                        contact_data[fields] = row[fields_dictonary[fields]]
+                        contact_dict[fields] = row[fields_dictonary[fields]]
                     else:
-                        contact_data[fields] = None
+                        contact_dict[fields] = None
                 '''
                 splitter = ' ::: '
                 for field in keys:
@@ -233,77 +229,78 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
                             values_list = row[field_value].split(splitter)
                             for index, value in enumerate(values_list):
                                 current_field = field.replace('1', str(index + 1))
-                                if not contact_data.get(current_field):
-                                    contact_data[current_field] = value
-                        elif not contact_data.get(field):
-                            contact_data[field] = row[field_value]
+                                if not contact_dict.get(current_field):
+                                    contact_dict[current_field] = value
+                        elif not contact_dict.get(field):
+                            contact_dict[field] = row[field_value]
                     else:
-                        contact_data[field] = None
+                        contact_dict[field] = None
 
-                contact_data = {key: contact_data.get(key) or None for key in contact_fields_to_keep}
-                if (not contact_data.get('first_name')
-                    and not contact_data.get('last_name')
-                    and not contact_data.get('organization')):
+                contact_dict = {key: contact_dict.get(
+                    key) or None for key in contact_fields_to_keep}
+                if (not contact_dict.get('first_name')
+                        and not contact_dict.get('last_name')
+                        and not contact_dict.get('organization')):
                     continue
-                contact_data['is_test_data'] = self.is_test_data
+                contact_dict['is_test_data'] = self.is_test_data
 
                 # TODO Please call get_display_name(first_name, last_name, organization) if display_as is empty
 
                 # for phone in ['phone1', 'phone2', 'phone3']:
-                #     if contact_data[phone] is None:
+                #     if contact_dict[phone] is None:
                 #         continue
-                #     phone_data = process_phone(original_phone_number=contact_data[phone])
+                #     phone_data = process_phone(original_phone_number=contact_dict[phone])
                 #     if phone_data is None:
                 #         continue
                 #     else:
-                #         contact_data[phone] = phone_data['normalized_phone_number']
+                #         contact_dict[phone] = phone_data['normalized_phone_number']
 
-                # contact_data['first_name'] = process_first_name(
-                #     original_first_name=contact_data['first_name'])
-                # contact_data['last_name'] = process_last_name(
-                #     original_last_name=contact_data['last_name'])
+                # contact_dict['first_name'] = process_first_name(
+                #     original_first_name=contact_dict['first_name'])
+                # contact_dict['last_name'] = process_last_name(
+                #     original_last_name=contact_dict['last_name'])
 
                 # TODO This should be executed also by Google Contact Sync (please make sure it is in people-local-python-package
                 #   i.e. get_display_name(first_name, last_name, organization) -> str
-                if contact_data.get('display_as') is None:
-                    contact_data['display_as'] = contact_data.get('first_name') or ""  # prevent None
-                    if (contact_data.get('last_name')
-                            and not contact_data.get('last_name').isdigit()):
-                        contact_data['display_as'] += " " + contact_data['last_name']
-                    if not contact_data['display_as'] and contact_data.get('organization'):
-                        contact_data['display_as'] += " " + contact_data['organization']
+                if contact_dict.get('display_as') is None:
+                    contact_dict['display_as'] = contact_dict.get(
+                        'first_name') or ""  # prevent None
+                    if (contact_dict.get('last_name')
+                            and not contact_dict.get('last_name').isdigit()):
+                        contact_dict['display_as'] += " " + contact_dict['last_name']
+                    if not contact_dict['display_as'] and contact_dict.get('organization'):
+                        contact_dict['display_as'] += " " + contact_dict['organization']
 
-                    # TODO if contact_data['display_as'] still empty raise?
+                    # TODO if contact_dict['display_as'] still empty raise?
 
-                # TODO process_notes( contact_data[notes] )
+                # TODO process_notes( contact_dict[notes] )
 
                 # TODO We should take care of situation which the contact already exists and we need to update it
-                contact_data["data_source_instance_id"] = data_source_instance_id
-                contact_data["source"] = "Import"
-                contact_id = self.contacts_local.upsert_contact_dict(contact_dict=contact_data)
+                contact_dict["data_source_instance_id"] = data_source_instance_id
+                contact_dict["source"] = "Import"
+                contact_id = self.contacts_local.upsert_contact_dict(contact_dict=contact_dict)
                 if contact_id:
                     self.__insert_contact_details_to_db(
-                        contact_id=contact_id, contact_dict=contact_data, user_external_id=user_external_id,
+                        contact_id=contact_id, contact_dict=contact_dict, user_external_id=user_external_id,
                         data_source_instance_id=data_source_instance_id,
                         data_source_type_id=data_source_type_id)
-                    contact_data_by_contact_id_dict[contact_id] = contact_data
-                # groups_linked_by_job_title = process_job_title(contact_id=contact_id, job_title=contact_data['job_title'])
+                    contact_data_by_contact_id_dict[contact_id] = contact_dict
+                # groups_linked_by_job_title = process_job_title(contact_id=contact_id, job_title=contact_dict['job_title'])
                 # if groups_linked_by_job_title is None:
                 #     logger.info("No groups linked by job title to contact " + str(contact_id))
 
-
         return contact_data_by_contact_id_dict
 
-
     # TODO def insert_update_contact_groups_from_contact_notes( contact_notes: str) -> int:
     # TODO Add contact_group with seq, attribute, is_sure using group-local-python-package
 
     # TODO def process_people_url( people_url ) -> str:
     # TODO Use regex to extract the data from the URL
     # TODO add to user_external using user-external-python-package
+
     @staticmethod
     def process_url(original_url: str) -> str:
-        prefixes = ['http://', 'https://']
+        prefixes = ['http://', 'https://']  # noqa
         for prefix in prefixes:
             if original_url.startswith(prefix):
                 original_url = original_url[len(prefix):]
@@ -313,7 +310,7 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
 
         return original_url
 
-    # TODO: add a method to add notes to text_block process them to retrieve the groups and create and link the groups to the user 
+    # TODO: add a method to add notes to text_block process them to retrieve the groups and create and link the groups to the user
 
     def process_notes(self, contact_note: str) -> None:
         # TODO number_of_system_recommednded_groups_identified_in_contact_notes = get_system_recommended_groups_from_contact_notes( contact_notes: str)
@@ -338,14 +335,14 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
         :param location_type_name: The location type name
         :return: The location type ID    
         """
-        location_type_id = self.select_one_value_by_id(
+        location_type_id = self.select_one_value_by_column_and_value(
             schema_name="location", view_table_name="location_type_ml_view",
             select_clause_value="location_type_id", column_name="title", column_value=location_type_name)
         return location_type_id
 
-    def __insert_contact_details_to_db(self, contact_id: int, contact_dict: dict, user_external_id: int,
+    def __insert_contact_details_to_db(self, *, contact_id: int, contact_dict: dict, user_external_id: int,
                                        data_source_instance_id: int, data_source_type_id: int) -> int:
-        
+
         location_id = DEFAULT_LOCATION_ID
         # insert organization
         organization_id = self.__insert_organization(contact_dict=contact_dict)
@@ -353,29 +350,25 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
         # insert link contact_location
         # The location is in contact_dict
         location_results = self.__insert_link_contact_location(
-            contact_dict=contact_dict, contact_id=contact_id)
-        if location_results:
-            location_id = location_results[0].get(
-                "location_id") or DEFAULT_LOCATION_ID
+            contact_dict=contact_dict, contact_id=contact_id) or [{}]
+        location_id = location_results[0].get(
+            "location_id") or DEFAULT_LOCATION_ID
+        country_id = location_results[0].get("country_id")
 
         # insert link contact_group
         self.__insert_link_contact_groups(
             contact_dict=contact_dict, contact_id=contact_id)
 
         # insert link contact_persons
-        self.__insert_link_contact_persons(
-            contact_dict=contact_dict, contact_id=contact_id)
+        contact_person_result_dict = self.__insert_link_contact_persons(
+            contact_dict=contact_dict, contact_id=contact_id) or {}
+        person_id = contact_person_result_dict.get("person_id")
 
         # insert link contact_profiles
-        contact_profile_info = (
-            self.__insert_contact_profiles(
-                contact_dict=contact_dict, contact_id=contact_id)
-        )
-        if contact_profile_info is not None:
-            profile_id = contact_profile_info.get(
-                "profile_id") or DEFAULT_PROFILE_ID
-        else:
-            profile_id = DEFAULT_PROFILE_ID
+        contact_profile_info = self.__insert_contact_profiles(
+            contact_dict=contact_dict, contact_id=contact_id, person_id=person_id) or {}
+
+        profile_id = contact_profile_info.get("profile_id")
 
         # insert organization-profile
         self.__insert_organization_profile(
@@ -383,16 +376,16 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
 
         # insert link contact_email_addresses
         self.__insert_link_contact_email_addresses(
-            contact_dict=contact_dict, contact_id=contact_id)
+            contact_dict=contact_dict, contact_id=contact_id, person_id=person_id, profile_id=profile_id)
 
         # insert link contact_notes
-        self.__insert_link_contact_notes_and_text_blocks(contact_dict=contact_dict,
-                                                         contact_id=contact_id,
-                                                         profile_id=profile_id)
+        self.__insert_link_contact_notes_and_text_blocks(
+            contact_dict=contact_dict, contact_id=contact_id, profile_id=profile_id)
 
         # insert link contact_phones
         self.__insert_link_contact_phones(
-            contact_dict=contact_dict, contact_id=contact_id)
+            contact_dict=contact_dict, contact_id=contact_id, profile_id=profile_id,
+            person_id=person_id, location_id=location_id, country_id=country_id)
 
         # inset link contact_user_externals
         self.__insert_link_contact_user_external(
@@ -410,9 +403,9 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
             data_source_type_id=data_source_type_id
         )
         return importer_id
-        
+
     def __insert_organization(self, contact_dict: dict) -> int or None:
-        
+
         if not contact_dict.get("organization"):
             return
         organization_dict = self.__create_organization_dict(
@@ -421,11 +414,11 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
             organization_dict=organization_dict)
         organization_id = organization_upsert_result.get("organization_id")
         organization_ml_ids_list = organization_upsert_result.get("organization_ml_ids_list")  # noqa
-        
+
         return organization_id
 
     def __create_organization_dict(self, organization_name: str) -> dict:
-        
+
         organization_dict = {
             "is_approved": 0,
             "is_main": 1,
@@ -452,22 +445,21 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
             "is_name_approved": 0,
             "is_description_approved": 0
         }
-        
+
         return organization_dict
 
     def __insert_organization_profile(self, organization_id: int, profile_id: int) -> int or None:
-        
+
         if not organization_id or not profile_id:
-            
-            return
+            return None
 
         organization_profile_id = self.organization_profiles.insert_mapping_if_not_exists(
             organization_id=organization_id, profile_id=profile_id)
-        
+
         return organization_profile_id
 
     def __insert_link_contact_groups(self, contact_dict: dict, contact_id: int) -> list:
-        
+
         groups = []
         groups_linked = None
         if contact_dict.get("organization"):
@@ -476,23 +468,30 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
             groups.append(contact_dict.get("job_title"))
         if len(groups) > 0:
             groups_linked = self.contact_groups.insert_link_contact_group_with_group_local(
-                contact_id=contact_id, groups=groups)
-        
+                contact_id=contact_id, groups_names=groups)
+
         return groups_linked
 
-    def __insert_link_contact_persons(self, contact_dict: dict, contact_id: int) -> int:
-        
+    def __insert_link_contact_persons(self, contact_dict: dict, contact_id: int) -> dict:
+        phones_local = PhonesLocal(is_test_data=self.is_test_data)
+        contact_phone_number = contact_dict.get("phone1")
+        if contact_phone_number:
+            result_dict = phones_local.normalize_phone_number(original_number=contact_phone_number, region=None)
+            if result_dict:
+                contact_normalized_phone_number = result_dict.get("full_number_normalized")
+        else:
+            contact_normalized_phone_number = None
         contact_person_results_dict = self.contact_persons.insert_contact_and_link_to_existing_or_new_person(
             contact_dict=contact_dict,
             contact_email_address=contact_dict["email1"],
+            contact_normalized_phone_number=contact_normalized_phone_number,
             contact_id=contact_id
         )
-        contact_person_id = contact_person_results_dict.get("contact_person_id")
-        
-        return contact_person_id
 
-    def __insert_link_contact_email_addresses(self, contact_dict, contact_id) -> list[int]:
-        
+        return contact_person_results_dict
+
+    def __insert_link_contact_email_addresses(self, contact_dict: dict, contact_id: int, person_id: int = None,
+                                              profile_id: int = None) -> list[int]:
         email_addresses = self.contacts_local.get_contact_email_addresses_from_contact_dict(
             contact_dict=contact_dict)
         contact_email_addresses = self.contact_email_addresses
@@ -501,10 +500,12 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
             contact_email_address_id = contact_email_addresses.insert_contact_and_link_to_email_address(
                 contact_dict=contact_dict,
                 contact_email_address_str=email_address,
-                contact_id=contact_id
+                contact_id=contact_id,
+                person_id=person_id,
+                profile_id=profile_id
             )
             contact_email_address_ids.append(contact_email_address_id)
-        
+
         return contact_email_address_ids
 
     @staticmethod
@@ -513,47 +514,59 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
         if not contact_dict.get("notes"):
             return
         # TODO: I think we should change ContactNotesLocal - send the args to the method and not the class
-        contact_notes = ContactNotesLocal(contact_dict=contact_dict, contact_id=contact_id, profile_id=profile_id)
+        if profile_id is None:
+            # TODO: check if this method works with profile_id = None
+            profile_id = DEFAULT_PROFILE_ID
+        contact_notes = ContactNotesLocal(
+            contact_dict=contact_dict, contact_id=contact_id, profile_id=profile_id)
         insert_information = contact_notes.insert_contact_notes_text_block()
         contact_note_id = insert_information.get("contact_note_id")
         return contact_note_id
 
-    def __insert_link_contact_phones(self, contact_dict: dict, contact_id: int) -> list[int]:
-        
-        phone_numbers = self.contacts_local.get_contact_phone_numbers_from_contact_dict(contact_dict=contact_dict)
+    def __insert_link_contact_phones(self, contact_dict: dict, contact_id: int, profile_id: int, person_id: int,
+                                     location_id: int, country_id: int) -> list[int]:
+        if location_id == DEFAULT_LOCATION_ID:
+            location_id = None
+        phone_numbers = self.contacts_local.get_contact_phone_numbers_from_contact_dict(
+            contact_dict=contact_dict)
         contact_phone_ids = []
         for phone_number in phone_numbers:
             contact_phone_id = self.contact_phone.insert_contact_and_link_to_existing_or_new_phone(
                 contact_dict=contact_dict,
                 phone_number=phone_number,
-                contact_id=contact_id
+                contact_id=contact_id,
+                profile_id=profile_id,
+                person_id=person_id,
+                location_id=location_id,
+                country_id=country_id
             )
-            contact_phone_ids.append(contact_phone_id)
-        
+            contact_phone_ids.append(contact_phone_id.get("contact_phone_id"))
+
         return contact_phone_ids
 
     def __insert_link_contact_user_external(self, contact_dict: dict, contact_id: int) -> int:
-        
+
         contact_user_external_id = self.contact_user_external.insert_contact_and_link_to_existing_or_new_user_external(
             contact_dict=contact_dict,
             contact_email_address=contact_dict["email1"],
             contact_id=contact_id,
             user_external_dict={"username": contact_dict["email1"]}
         )
-        
+
         return contact_user_external_id
 
-    def __insert_contact_profiles(self, contact_dict: dict, contact_id: int) -> dict:
-        
+    def __insert_contact_profiles(self, contact_dict: dict, contact_id: int, person_id: int = None) -> dict:
+
         insert_information = self.contact_profiles.insert_and_link_contact_profile(
             contact_dict=contact_dict,
-            contact_id=contact_id
+            contact_id=contact_id,
+            person_id=person_id
         )
-        
+
         return insert_information
 
     def __insert_link_contact_domains(self, contact_dict: dict, contact_id: int) -> list[dict]:
-        
+
         website_count = 1
         website_url = contact_dict.get("website" + str(website_count))
         domain_insert_information_list = []
@@ -563,11 +576,11 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
             domain_insert_information_list.append(domain_insert_information)
             website_count += 1
             website_url = contact_dict.get("website" + str(website_count))
-        
+
         return domain_insert_information_list
 
     def __insert_link_contact_location(self, contact_dict: dict, contact_id: int) -> list[dict] or None:
-        
+
         location_dicts = self.__procces_location_of_contact(contact_dict)
         if not location_dicts:
             return
@@ -598,7 +611,7 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
             user_external_id=user_external_id,
             google_people_api_resource_name=google_people_api_resource_name
         )
-        
+
         return importer_id
 
     def __procces_location_of_contact(self, contact_dict: dict) -> dict or None:
@@ -607,7 +620,7 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
         :param contact_dict: location_dict
         :return: location_dict
         """
-        
+
         address_street1 = contact_dict.get("address1_street")
         address_city1 = contact_dict.get("address1_city")
         address_state1 = contact_dict.get("address1_state")
@@ -625,9 +638,10 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
 
         phone_numbers_list = self.__get_phone_numbers_list(contact_dict)
         email_addresses_list = self.__get_email_addresses_list(contact_dict)
-        if (not is_contact_location1 
+        if (not is_contact_location1
                 and not is_contact_location2
-                and not phone_numbers_list 
+                and not phone_numbers_list
+                and not phone_numbers_list
                 and not email_addresses_list):
             return
         # TODO: How can we add location type?
@@ -655,11 +669,11 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
                 country = Country.get_country_name_by_phone_number(phone_number)
             except NumberParseException as number_parse_exception:
                 self.logger.error("Error while parsing phone number",
-                                 object={"number_parse_exception": number_parse_exception})
+                                  object={"number_parse_exception": number_parse_exception})
                 continue
             except Exception as exception:
                 self.logger.error("Error while getting country name by phone number",
-                                 object=exception)
+                                  object=exception)
                 continue
             currect_location_dict = {
                 "address_local_language": None,
@@ -687,7 +701,7 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
                 "region": LocationLocalConstants.DEFAULT_REGION_NAME,
             }
             proccessed_location_dicts.append(currect_location_dict)
-        
+
         return proccessed_location_dicts
 
     @staticmethod
@@ -704,23 +718,25 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
             "state": address_state or LocationLocalConstants.DEFAULT_STATE_NAME,
             "region": LocationLocalConstants.DEFAULT_REGION_NAME,
         }
-        
+
         return location_dict
 
     @staticmethod
     def __get_phone_numbers_list(contact_dict: dict) -> list:
-        phones_list = [contact_dict.get(f"phone{i}") for i in range(1, 4) if contact_dict.get(f"phone{i}")]
+        phones_list = [contact_dict.get(f"phone{i}")
+                       for i in range(1, 4) if contact_dict.get(f"phone{i}")]
         return phones_list
 
     @staticmethod
     def __get_email_addresses_list(contact_dict: dict) -> list:
-        emails_list = [contact_dict.get(f"email{i}") for i in range(1, 4) if contact_dict.get(f"email{i}")]
+        emails_list = [contact_dict.get(f"email{i}")
+                       for i in range(1, 4) if contact_dict.get(f"email{i}")]
         # TODO use enum const for "email1" ....
         return emails_list
 
     def __get_user_external_id(self, user_external_username: str) -> int or None:
-        
-        user_external_id = self.user_externals_local.select_one_value_by_id(
+
+        user_external_id = self.user_externals_local.select_one_value_by_column_and_value(
             select_clause_value="user_external_id", column_name="username",
             column_value=user_external_username, order_by="user_external_id DESC")
         if user_external_id is None:
@@ -730,17 +746,19 @@ class CSVToContactPersonProfile(GenericCRUD, metaclass=MetaLogger,
                 system_id=CONTACT_PERSON_PROFILE_CSV_SYSTEM_ID,
                 access_token=""
             )
-            user_external_id = self.user_externals_local.select_one_value_by_id(
+            user_external_id = self.user_externals_local.select_one_value_by_column_and_value(
                 select_clause_value="user_external_id", column_name="username",
                 column_value=user_external_username, order_by="user_external_id DESC")
 
         return user_external_id
 
-    def __get_data_source_instance_id(self, data_source_type_id: int, csv_file_path: str, user_external_id: int, file_name: str,
+    def __get_data_source_instance_id(self, data_source_type_id: int, csv_file_path: str, user_external_id: int,
+                                      file_name: str,
                                       user_external_username: str, start_index: int, end_index: int) -> int:
         name = datetime.now(ZoneInfo("UTC")).strftime("%y%m%d %H%M%S") + " " + \
-            user_external_username + " 'Google Contact- Google Contact CSV'"
-        data_source_instance_id = self.insert(
+               user_external_username + " 'Google Contact- Google Contact CSV'"
+        # TODO: move to data_source
+        data_source_instance_id = super().insert(
             schema_name="data_source_instance",
             table_name="data_source_instance_table",
             data_dict={

{contact_person_profile_csv_imp_local-0.0.18.dist-info → contact_person_profile_csv_imp_local-0.0.21.dist-info}/METADATA

@@ -1,7 +1,8 @@
 Metadata-Version: 2.1
 Name: contact-person-profile-csv-imp-local
-Version: 0.0.18
+Version: 0.0.21
 Summary: PyPI Package for Circles CSVToContactPersonProfile-local Local/Remote Python
+Home-page: https://github.com/circles-zone/contact-person-profile-csv-imp-local-python-package
 Author: Circles
 Author-email: info@circles.ai
 Classifier: Programming Language :: Python :: 3

{contact_person_profile_csv_imp_local-0.0.18.dist-info → contact_person_profile_csv_imp_local-0.0.21.dist-info}/RECORD

@@ -1,7 +1,7 @@
-contact_person_profile_csv_imp_local/CSVToContactPersonProfile.py,sha256=5R0FOKpPvYU6-WmsCCQuIzVX_t2hCQKuFZ-OODPTfZE,40120
+contact_person_profile_csv_imp_local/CSVToContactPersonProfile.py,sha256=ClFAP6ntBayUJuH-k4dgJkrml8-Wy55E4mJc3a0YHeg,41424
 contact_person_profile_csv_imp_local/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 contact_person_profile_csv_imp_local/contact_person_profile_csv_imp_local_constants.py,sha256=eE0Bg2dCPrmG72K20k0_KOckc61C9cGSgH0Zgae_lbk,957
-contact_person_profile_csv_imp_local-0.0.18.dist-info/METADATA,sha256=s9JiYztD5uT7ma1qqIz9NH50rkbXvj8EEObTqSP5s2I,1355
-contact_person_profile_csv_imp_local-0.0.18.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-contact_person_profile_csv_imp_local-0.0.18.dist-info/top_level.txt,sha256=at6BnVzULDB109KZx9Cl9ClCHU4c0ykfV38WX-QR71U,37
-contact_person_profile_csv_imp_local-0.0.18.dist-info/RECORD,,
+contact_person_profile_csv_imp_local-0.0.21.dist-info/METADATA,sha256=2yl92Bd2snQzELayCR4qIbBIMPypqqU4PvZy5EBXAUM,1450
+contact_person_profile_csv_imp_local-0.0.21.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+contact_person_profile_csv_imp_local-0.0.21.dist-info/top_level.txt,sha256=at6BnVzULDB109KZx9Cl9ClCHU4c0ykfV38WX-QR71U,37
+contact_person_profile_csv_imp_local-0.0.21.dist-info/RECORD,,