energy-reports-pkg 0.6.14__py3-none-any.whl

mindsett_energy_reports_pkg/libs/fetch_monday_info/__init__.py

@@ -0,0 +1,29 @@
+
+
+from .sync_with_monday import sync_with_monday
+from .load_cf_from_db import load_cf_from_db
+
+def fetch_monday_info(engine, 
+                        monday_token,
+                        table_name_cache, 
+                        table_columns_cache,
+                        monday_board_id,
+                        columns_concerned=None, 
+                        email_prefix=None,
+                        sync_monday=None):
+
+    if sync_monday is None:
+        sync_monday = True
+    
+    # get contacts from db
+    df_monday = load_cf_from_db(engine, table_name_cache, table_columns_cache)
+
+    if sync_monday:
+        df_monday = sync_with_monday(engine, 
+                                    df_monday,
+                                    monday_token, 
+                                    table_name_cache, 
+                                    monday_board_id,
+                                    columns_concerned=columns_concerned, 
+                                    email_prefix=email_prefix)
+    return df_monday

mindsett_energy_reports_pkg/libs/fetch_monday_info/load_cf_from_db/__init__.py

@@ -0,0 +1,17 @@
+
+import pandas as pd
+
+
+def load_cf_from_db(engine, table_name_cache, columns):
+
+    columns_str = ', '.join(columns)
+
+    cache_query = f"""select {columns_str} from {table_name_cache};"""
+
+    with engine.connect() as conn:
+        df_cache = pd.read_sql_query(cache_query, con=conn)
+
+    if df_cache.shape[0] > 0:
+        df_cache.mailing_list = df_cache.mailing_list.apply(lambda x: x[1:-1].split(','))
+
+    return df_cache

mindsett_energy_reports_pkg/libs/fetch_monday_info/sync_with_monday/__init__.py

@@ -0,0 +1,52 @@
+
+from .get_last_update_time import get_last_update_time
+from .cache_cf_to_db import cache_cf_to_db
+from .extract_contacts import extract_contacts
+
+def sync_with_monday(engine, 
+                     df_config,
+                     monday_token, 
+                     table_name_cache, 
+                     monday_board_id,
+                     columns_concerned=None, 
+                     email_prefix=None):
+    
+    print('syncing config with monday board ...')
+
+    # check the activity log from monday
+    last_update_time = get_last_update_time(monday_token, monday_board_id)
+    # print('last_update_time: ', last_update_time)
+
+    # if activity log time > db last updates, then extract contacts from monday and update db
+
+    flag_reload_from_monday = True
+
+    if (df_config.shape[0] > 0) and (not df_config.last_update.isna().all()): # last_update was made null when the last_update_time was not available
+
+        prev_update_time = df_config.last_update.max()
+        print('prev_update_time: ', prev_update_time)
+
+        if not (prev_update_time < last_update_time):
+
+            print('[INFO]: using config from the db cache as it is up-to-date!')
+            flag_reload_from_monday = False
+            
+    if flag_reload_from_monday:
+
+        print('extracting contacts ... (about 3 min 30 secs)')
+        df_config = extract_contacts(monday_token, monday_board_id,
+                                     columns_concerned=columns_concerned, 
+                                     email_prefix=email_prefix,
+                                     # caching=True
+                                    )
+    
+        # cache the result into db for the future usage and efficiency
+
+        df_config['last_update'] = last_update_time
+        # df_config = attach_id_to_buildings(engine, df_config, table_name_org, table_name_building) # df_config has to be the same name, so not renaming it here
+
+        # print('df_config: ', df_config)
+        # quit()
+        cache_cf_to_db(engine, table_name_cache, df_config)
+
+    return df_config

mindsett_energy_reports_pkg/libs/fetch_monday_info/sync_with_monday/cache_cf_to_db/__init__.py

@@ -0,0 +1,11 @@
+
+from .append_df_to_table import append_df_to_table
+from .empty_table import empty_table
+
+def cache_cf_to_db(engine, table_name_cache, df_config):
+
+    empty_table(engine, table_name_cache, with_log=False)
+    append_df_to_table(engine, table_name_cache, df_config)
+
+    return
+

mindsett_energy_reports_pkg/libs/fetch_monday_info/sync_with_monday/cache_cf_to_db/append_df_to_table/__init__.py

@@ -0,0 +1,29 @@
+def append_df_to_table(engine, table_name, df):
+    
+    table_schema_name_list = table_name.split(".")
+
+    if len(table_schema_name_list) > 1:
+        table_schema = table_schema_name_list[0]
+        table_non_schema_name = table_schema_name_list[1]
+    else:
+        table_schema = "public"
+        table_non_schema_name = table_name
+        
+    total_records = len(df)
+    
+  
+    with engine.connect() as conn:
+  
+        df.to_sql(
+           name=table_non_schema_name,
+           con=conn,
+           if_exists="append",
+           schema=table_schema,
+           chunksize=5000,
+           index=False
+           )
+
+    print(f'The config cache in database table [{table_name}] is updated with [{total_records}] records.')
+    # print(f'[{total_records}] records have been written to Table [{table_name}] successfully.')
+   
+    return 

mindsett_energy_reports_pkg/libs/fetch_monday_info/sync_with_monday/cache_cf_to_db/empty_table/__init__.py

@@ -0,0 +1,11 @@
+def empty_table(engine, table_name, with_log=True):
+    
+    with engine.connect() as conn:
+
+        # delete data (empty) in the table
+        query_empty_table = f"""DELETE FROM {table_name};"""
+        conn.execute(query_empty_table) 
+
+    if with_log:
+        print(f'The table [{table_name}] is empty now.')
+    return

mindsett_energy_reports_pkg/libs/fetch_monday_info/sync_with_monday/extract_contacts/__init__.py

@@ -0,0 +1,57 @@
+import uuid
+import numpy as np
+
+from cache_return import cache_return
+
+from .load_mailing_list import load_mailing_list
+# from ..cache_result import cache_result
+from .get_mailing_list import get_mailing_list
+
+@cache_return
+def extract_contacts(monday_token, 
+                     board_id,
+                     columns_concerned=None, 
+                     email_prefix=None):
+    
+    # email_columns = [f'email {idx+1}' for idx in range(max_no_email)]
+    # columns = [building_column, *email_columns]
+    # print('columns: ', columns)
+
+    df_contact = load_mailing_list(monday_token, board_id,
+                                    columns_concerned=columns_concerned, 
+                                    email_prefix=email_prefix,
+                                    caching=False)
+
+    # # make the names lower case
+    df_contact.columns = [column.lower() for column in df_contact.columns]
+    df_contact = df_contact.rename(columns={'name': 'item_name'})
+    df_contact['building_id'] = df_contact['building_id'].apply(uuid.UUID)
+
+    # df_contact['review'] = df_contact[role_column].str.contains('Review', na=False)
+    # df_contact['receive'] = df_contact[role_column].str.contains('Receive', na=False)
+
+    # df_receive = df_contact.loc[df_contact['receive']]
+    # df_review = df_contact.loc[df_contact['review']]
+
+    # contacts = {}
+
+    # contacts['receivers'] = df_receive.groupby(name_column)[email_column].apply(list).reset_index().to_dict('records')
+    # contacts['reviewers'] = df_review.groupby(name_column)[email_column].apply(list).reset_index().to_dict('records')
+    
+    # df_contact.publish = (df_contact.publish == 'v')
+    # df_contact.testing = (df_contact.testing == 'v')
+    # df_contact.occupancy_available = (df_contact.occupancy_available == 'v')
+    df_contact.pct_level_tobe_others = df_contact.pct_level_tobe_others.astype('float')
+    df_contact.pct_hide = df_contact.pct_hide.replace('', '0').astype('float')
+    df_contact.conv_mwh_price = df_contact.conv_mwh_price.replace('', '0').astype('float')
+    # df_contact.insight_statements = df_contact.insight_statements.replace('', None)
+    df_contact.floor_sqm = df_contact.floor_sqm.replace('', np.NaN).astype('float')
+
+    df_contact['mailing_list'] = df_contact.apply(get_mailing_list, axis=1)
+
+    monday_columns = df_contact.columns
+    email_columns = [column for column in monday_columns if 'email' in column]
+
+    df_contact = df_contact.drop(columns=email_columns)
+
+    return df_contact

mindsett_energy_reports_pkg/libs/fetch_monday_info/sync_with_monday/extract_contacts/get_mailing_list/__init__.py

@@ -0,0 +1,25 @@
+
+
+def get_mailing_list(sr_contact_row):
+
+    # df_contact_site = df_contact.loc[(df_contact.name==(site_name).replace("''", "'")) & (df_contact.org==org_name)]
+    
+    monday_columns = sr_contact_row.index
+    email_columns = [column for column in monday_columns if 'email' in column]
+    
+    # df_emails_site = df_contact_site[email_columns]
+
+    ls_emails_site = sr_contact_row[email_columns].tolist()
+
+    # print('ls_emails_site: ', ls_emails_site)
+    
+    ls_emails_site_nona = [i for i in ls_emails_site if i != None]
+
+    # ls_emails_site_nona
+    # print('ls_emails_site_nona: ', ls_emails_site_nona)
+
+    ls_emails_site_nona_with_at = [email_str for email_str in ls_emails_site_nona if '@' in email_str]
+
+    # print('ls_emails_site_nona: ', ls_emails_site_nona)
+
+    return ls_emails_site_nona_with_at

mindsett_energy_reports_pkg/libs/fetch_monday_info/sync_with_monday/extract_contacts/load_mailing_list/__init__.py

@@ -0,0 +1,50 @@
+import pandas as pd
+
+from MondayProcessor import MondayProcessor
+from cache_return import cache_return
+
+@cache_return
+def load_mailing_list(monday_token, board_id, 
+                      columns_concerned=None, 
+                      email_prefix=None):
+    
+    if columns_concerned is None:
+        from .columns_concerned import columns_concerned
+
+
+    email_prefix = email_prefix or 'email'
+
+    mp = MondayProcessor(monday_token)
+
+    groups_dict = mp._fetchGroups(board_id)
+
+    columns_data = mp.monday.boards.fetch_columns_by_board_id(board_ids=board_id)
+
+    columns_all = [column['title'] for column in columns_data['data']['boards'][0]['columns']]
+    len_ep = len(email_prefix)
+    columns_emails = [column for column in columns_all if column[:len_ep]==(email_prefix[:len_ep])]
+
+    missing_columns = []
+    for concerned_column in columns_concerned:
+        if concerned_column not in columns_all:
+            missing_columns.append(concerned_column)
+
+    if len(missing_columns) > 0:
+        raise Exception(f'[ERROR]: There are missing columns: {missing_columns}!')
+    
+    columns_select = columns_concerned + columns_emails # merge the two lists
+    
+
+    # print('columns_all: ', columns_all)
+    # print('columns_select: ', columns_select)
+
+    df_board = pd.DataFrame([])
+    for group_id in groups_dict:
+        
+        board_results = mp._fetchColumnValueByGroup(board_id=board_id, groupId=group_id, columns=columns_select)
+
+        df_group = pd.DataFrame(board_results)
+        df_group['group_name'] = groups_dict[group_id]
+        df_board = pd.concat([df_board, df_group])
+
+    return df_board

mindsett_energy_reports_pkg/libs/fetch_monday_info/sync_with_monday/extract_contacts/load_mailing_list/columns_concerned/__init__.py

@@ -0,0 +1,22 @@
+
+columns_concerned = ['Name', 
+                    'publish', 
+                    'testing', 
+                    'industry', 
+                    'manager_name', 
+                    'currency', 
+                    'occupancy_available', 
+                    'asset_group', 
+                    'fillna_value', 
+                    'insight_statements', 
+                    'group_name_column_exchange', 
+                    'group_name_modification', 
+                    'pct_level_tobe_others', 
+                    'floor_sqm',
+                    'pct_hide', 
+                    'conv_mwh_price', 
+                    'period_freq',
+                    'building_id',
+                    'board_id',
+                    'hvac_board_id'
+                    ]

mindsett_energy_reports_pkg/libs/fetch_monday_info/sync_with_monday/get_last_update_time/__init__.py

@@ -0,0 +1,26 @@
+
+import pandas as pd
+from MondayProcessor import MondayProcessor
+
+def get_last_update_time(monday_token, board_id):
+
+    mp = MondayProcessor(monday_token)
+
+    js_logs = mp._fetchBoardLogsById(board_id)
+    
+    dct_records = js_logs['data']['boards'][0]['activity_logs']
+
+    # print('dct_records: ', dct_records)
+
+    if dct_records == None: # it happened on 11 Nov 24 that the activity log is not available and returned None
+
+        print('js_logs: ', js_logs)
+        print('[WARN]: using time now as last_update_time because the Monday ACTIVITY LOG is NOT AVAILABLE !')
+        last_update_time = pd.Timestamp.now(tz='UTC').ceil(freq='s')
+        return last_update_time
+    else:
+        df_logs = pd.DataFrame.from_records(dct_records)
+        df_logs['created_at'] = pd.to_datetime(df_logs['created_at'].astype('int').div(10), unit='us', utc=True).dt.ceil(freq='s') 
+        last_update_time = df_logs.created_at.max()
+
+        return last_update_time

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/__init__.py

@@ -0,0 +1,27 @@
+
+from .load_cf_from_db import load_cf_from_db
+from .sync_with_sharepoint import sync_with_sharepoint
+
+def fetch_sharepoint_info(engine, 
+                          sharepoint, 
+                          table_name_cache, 
+                          table_columns_cache,
+                          sync_source=None):
+
+    if sync_source is None:
+        sync_source = True
+
+    # get contacts/configs from the db
+    df_cfg_db = load_cf_from_db(engine, table_name_cache, table_columns_cache)
+
+    # print(f'{df_cfg_db.info()=}')
+
+    if sync_source:
+        df_cfg = sync_with_sharepoint(engine, 
+                                    df_cfg_db, 
+                                    sharepoint, 
+                                    table_name_cache)
+    else:
+        df_cfg = df_cfg_db
+
+    return df_cfg

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/load_cf_from_db/__init__.py

@@ -0,0 +1,17 @@
+
+import pandas as pd
+
+
+def load_cf_from_db(engine, table_name_cache, columns):
+
+    columns_str = ', '.join(columns)
+
+    cache_query = f"""select {columns_str} from {table_name_cache};"""
+
+    with engine.connect() as conn:
+        df_cache = pd.read_sql_query(cache_query, con=conn)
+
+    if df_cache.shape[0] > 0:
+        df_cache.mailing_list = df_cache.mailing_list.apply(lambda x: x[1:-1].split(','))
+
+    return df_cache

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/sync_with_sharepoint/__init__.py

@@ -0,0 +1,28 @@
+
+from .extract_contacts import extract_contacts
+from .cache_cf_to_db import cache_cf_to_db
+
+def sync_with_sharepoint(engine, df_cfg_db, sharepoint, table_name_cache):
+
+    df_cfg_shp = extract_contacts(sharepoint) # currently, we are getting the last_update time by directly querying the file, as it is relative quick
+    # if needed in the future, a dedicated lighter get_last_update_time function can be designed, and the actual extraction processing can be conditional
+
+    flag_reload_from_sharepoint = True
+
+    if (df_cfg_db.shape[0] > 0) and (not df_cfg_db.last_update.isna().all()): # last_update was make null when the last_update_time was not available
+
+        last_update_db  = df_cfg_db['last_update'].max()
+        last_update_shp = df_cfg_shp['last_update'].max()
+        # print(f'{last_update_shp=}')
+
+        if last_update_db == last_update_shp: # here some efforts of writing to db can be saved if the cached data is already up-to-date.
+            
+            print('[INFO]: using config from the db cache as it is up-to-date!')
+            flag_reload_from_sharepoint = False
+        
+    if flag_reload_from_sharepoint:
+
+        # pass
+        cache_cf_to_db(engine, table_name_cache, df_cfg_shp)
+
+    return df_cfg_shp

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/sync_with_sharepoint/cache_cf_to_db/__init__.py

@@ -0,0 +1,11 @@
+
+from .append_df_to_table import append_df_to_table
+from .empty_table import empty_table
+
+def cache_cf_to_db(engine, table_name_cache, df_config):
+
+    empty_table(engine, table_name_cache, with_log=False)
+    append_df_to_table(engine, table_name_cache, df_config)
+
+    return
+

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/sync_with_sharepoint/cache_cf_to_db/append_df_to_table/__init__.py

@@ -0,0 +1,29 @@
+def append_df_to_table(engine, table_name, df):
+    
+    table_schema_name_list = table_name.split(".")
+
+    if len(table_schema_name_list) > 1:
+        table_schema = table_schema_name_list[0]
+        table_non_schema_name = table_schema_name_list[1]
+    else:
+        table_schema = "public"
+        table_non_schema_name = table_name
+        
+    total_records = len(df)
+    
+  
+    with engine.connect() as conn:
+  
+        df.to_sql(
+           name=table_non_schema_name,
+           con=conn,
+           if_exists="append",
+           schema=table_schema,
+           chunksize=5000,
+           index=False
+           )
+
+    print(f'The config cache in database table [{table_name}] is updated with [{total_records}] records.')
+    # print(f'[{total_records}] records have been written to Table [{table_name}] successfully.')
+   
+    return 

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/sync_with_sharepoint/cache_cf_to_db/empty_table/__init__.py

@@ -0,0 +1,11 @@
+def empty_table(engine, table_name, with_log=True):
+    
+    with engine.connect() as conn:
+
+        # delete data (empty) in the table
+        query_empty_table = f"""DELETE FROM {table_name};"""
+        conn.execute(query_empty_table) 
+
+    if with_log:
+        print(f'The table [{table_name}] is empty now.')
+    return

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/sync_with_sharepoint/extract_contacts/__init__.py

@@ -0,0 +1,13 @@
+
+from .load_mailing_list import load_mailing_list
+from .format_contacts import format_contacts
+
+def extract_contacts(sharepoint):
+
+    df_contact_raw = load_mailing_list(sharepoint)
+
+    df_contact = format_contacts(df_contact_raw, 
+                                 columns_concerned=sharepoint.excel.columns_concerned
+                                 )
+
+    return df_contact

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/sync_with_sharepoint/extract_contacts/format_contacts/__init__.py

@@ -0,0 +1,57 @@
+
+import uuid
+
+from .uuid_for_nona import uuid_for_nona
+from .extract_id import extract_id
+from .get_mailing_list import get_mailing_list
+
+def format_contacts(df_contact, 
+                    columns_concerned=None):
+
+    if columns_concerned is None:
+        from .columns_concerned import columns_concerned
+
+    pct_level_tobe_others_default = 0.03
+    pct_hide_default = 4
+    conv_mwh_price_default = 190
+
+    # standardize the column names
+    df_contact.columns = [column.lower() for column in df_contact.columns]
+    df_contact = df_contact.rename(columns={'building_name': 'item_name', 'org': 'group_name'})
+
+    # fill the names for null values
+    df_contact['group_name'] = df_contact['group_name'].ffill()
+    df_contact['insight_statements'] = df_contact['insight_statements'].fillna('')
+    df_contact['group_name_column_exchange'] = df_contact['group_name_column_exchange'].fillna('')
+    df_contact['group_name_modification'] = df_contact['group_name_modification'].fillna('')
+    df_contact['manager_name'] = df_contact['manager_name'].fillna('')
+
+    # columns type formatting
+    df_contact['publish'] = (df_contact['publish'] == 'v')
+    df_contact['testing'] = (df_contact['testing'] == 'v')
+    df_contact['occupancy_available'] = (df_contact['occupancy_available'] == 'v')
+    df_contact['building_id'] = df_contact['building_id'].apply(uuid_for_nona)
+
+    df_contact['pct_level_tobe_others'] = df_contact['pct_level_tobe_others'].fillna(pct_level_tobe_others_default).astype('float')
+    df_contact['floor_sqm'] = df_contact['floor_sqm'].astype('float')
+
+    df_contact['pct_hide'] = df_contact['pct_hide'].fillna(pct_hide_default).astype('float')
+
+    df_contact['conv_mwh_price'] = df_contact['conv_mwh_price'].fillna(conv_mwh_price_default).astype('float')
+
+    # format the monday board ids
+    df_contact['board_id'] = df_contact['board_id'].apply(extract_id)
+    df_contact['hvac_board_id'] = df_contact['hvac_board_id'].apply(extract_id)
+
+    # get_mailing_list
+    df_contact['mailing_list'] = df_contact.apply(get_mailing_list, axis=1)
+
+    # drop the email related columns
+    monday_columns = df_contact.columns
+    email_columns = [column for column in monday_columns if 'email' in column]
+    df_contact = df_contact.drop(columns=email_columns)
+
+    # select the concerned columns
+    df_contact_sel = df_contact[columns_concerned]
+
+    return df_contact_sel

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/sync_with_sharepoint/extract_contacts/format_contacts/columns_concerned/__init__.py

@@ -0,0 +1,8 @@
+
+
+columns_concerned = ['last_update', 'building_id', 'item_name', 'group_name', 'board_id',
+                                'hvac_board_id', 'publish', 'testing', 'industry', 'manager_name',
+                                'currency', 'occupancy_available', 'asset_group', 'fillna_value',
+                                'insight_statements', 'group_name_column_exchange',
+                                'group_name_modification', 'pct_level_tobe_others', 'floor_sqm', 'pct_hide',
+                                'conv_mwh_price', 'period_freq', 'mailing_list']

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/sync_with_sharepoint/extract_contacts/format_contacts/extract_id/# __init__.py

@@ -0,0 +1,11 @@
+
+
+def extract_id(x):
+
+    # example value : '5515593330 - https://cloudfmgroup-company.monday.com/boards/5515593330'
+    
+    str_x = str(x)
+    if ' - ' in str_x:
+        return str_x.split(' - ')[0]
+    else:
+        return x

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/sync_with_sharepoint/extract_contacts/format_contacts/extract_id/__init__.py

@@ -0,0 +1,19 @@
+
+
+def extract_id(x):
+
+    # example value : '5515593330 - https://cloudfmgroup-company.monday.com/boards/5515593330'
+
+    # if isinstance(x, float):
+    #     x = int(x)
+
+    str_x = str(x)
+    if ' - ' in str_x:
+        id_str = str_x.split(' - ')[0]
+    else:
+        id_str =  str_x
+    
+    if id_str == 'nan':
+        return None
+    else:
+        return id_str.split('.')[0] # there might be the case that it's converted from float with . e.g. 8370787257.0

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/sync_with_sharepoint/extract_contacts/format_contacts/get_mailing_list/__init__.py

@@ -0,0 +1,10 @@
+
+def get_mailing_list(sr_contact_row):
+    
+    monday_columns = sr_contact_row.index
+    email_columns = [column for column in monday_columns if 'email' in column]
+    ls_emails_site = sr_contact_row[email_columns].tolist()
+    ls_emails_site_nona = [i for i in ls_emails_site if isinstance(i, str)]
+    ls_emails_site_nona_with_at = [email_str for email_str in ls_emails_site_nona if '@' in email_str]
+
+    return ls_emails_site_nona_with_at

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/sync_with_sharepoint/extract_contacts/format_contacts/uuid_for_nona/__init__.py

@@ -0,0 +1,12 @@
+
+import uuid
+
+def uuid_for_nona(value):
+    
+    if isinstance(value, str):
+        if value == ' ':
+            return None
+        else:
+            return uuid.UUID(value)
+    else:
+        return None

mindsett_energy_reports_pkg/libs/fetch_sharepoint_info/sync_with_sharepoint/extract_contacts/load_mailing_list/__init__.py

@@ -0,0 +1,30 @@
+
+from office365.sharepoint.client_context import ClientContext
+from office365.runtime.auth.client_credential import ClientCredential
+
+from .get_excel_file_from_link import get_excel_file_from_link
+from .load_excel_as_df import load_excel_as_df
+
+
+def load_mailing_list(sharepoint):
+
+    # get sharepoint context
+    ctx = ClientContext(sharepoint.site_url).with_credentials(ClientCredential(sharepoint.client_id, sharepoint.client_secret))
+
+    file_name = getattr(sharepoint.excel, 'file_name', None)
+    sheet_name = getattr(sharepoint.excel, 'sheet', None)
+
+    if file_name is None:
+        raise Exception('[ERROR]: Please specify the excel file name!')
+
+    sharepoint_link = sharepoint.folder_url + '/' + file_name 
+
+    excel_file = get_excel_file_from_link(ctx, sharepoint_link)
+
+    # sheet_name = sharepoint.excel.sheet
+    
+    df_contact = load_excel_as_df(ctx, excel_file, 
+                                  sheet_name=sheet_name)
+
+    return df_contact
+