result consolidation

classes/Linkedin.py

@@ -38,6 +38,8 @@ class Linkedin:
         except Exception:
             pass
         '''
+        if 'linkedin_upload' not in st.session_state:
+            st.session_state['linkedin_upload'] = ''
 
     def request_model(self, payload_txt):
         response = requests.post(self.model_url, json=payload_txt)
@@ -187,6 +189,7 @@ class Linkedin:
                             }
                             '''
                             collect_telemetry(debug_info)
+                            st.session_state['linkedin_upload'] = 'uploaded'
                             
                             #with st.expander("Debug information", icon="⚙"):
                             #    st.write(debug_info)

classes/Seo.py

@@ -162,7 +162,6 @@ class Seo:
 
         session = st.session_state.analyze
         if ((self.uploaded_file or self.others or self.uploaded_file_seo) or (self.page_index or self.bounce_rate)) and  session == 'clicked':
-                    combined_text = ""
                     seo_keywords = ""
                     traffic_channels = ""
                     traffic_aqcuisition = ""
@@ -196,8 +195,10 @@ class Seo:
                             traffic_channels += f"\nReferral Traffic: {referral_traffic}"
                             traffic_channels += df_traffic.to_csv(index=True)
                             
-                        except KeyError:
+                        except AttributeError:
                             pass
+                        except KeyError:
+                            st.info("Incorrect SEMRush format. Please upload a valid SEMRush file.")
                         
                         try:
                             df_seo = st.session_state['df_seo']
@@ -207,6 +208,8 @@ class Seo:
                             seo_keywords += f"\nKeyword Ranking Top 100: {keyword_ranking['Keyword_top_100']}\n\n"
                             
                             seo_keywords += df_seo.to_csv(index=True)
+                        except AttributeError:
+                            pass
                         except KeyError:
                             pass
                         
@@ -224,6 +227,8 @@ class Seo:
                             traffic_aqcuisition += f"\nPaid Traffic: {ga4_paid_social}\nOrganic Traffic: {ga4_organic_traffic}\nDirect Traffic: {ga4_direct_traffic}\nReferral Traffic: {ga4_referral_traffic}"
                         except KeyError:
                             pass
+                        except TypeError:
+                            st.info("Incorrect GA4 format. Please upload a valid GA4 file.")
 
                         # OUTPUT FOR SEO ANALYST
                         payload_txt_seo_keywords = {"question": seo_keywords}

classes/Social_Media_FB.py

@@ -39,6 +39,8 @@ class Facebook:
         except Exception:
             pass
         '''
+        if 'fb_upload' not in st.session_state:
+            st.session_state['fb_upload'] = ''
     
     def request_model(self, payload_txt):
         response = requests.post(self.model_url, json=payload_txt)
@@ -142,7 +144,7 @@ class Facebook:
     def process(self):  
         start_time = time.time()
         session = st.session_state.analyze
-        if ((self.fb_organic_post and self.fb_organic_post.name) or (self.fb_ads_campaign and self.fb_ads_campaign.name) or self.facebooks or self.facebook_rr) and session == 'clicked':
+        if ((self.fb_organic_post and self.fb_organic_post.name) or (self.fb_ads_campaign and self.fb_ads_campaign.name) or (self.facebooks) or (self.facebook_rr)) and session == 'clicked':
                 try:
                         combined_text = ""
                         with st.spinner('Social Media Analyst...', show_time=True):
@@ -201,7 +203,10 @@ class Facebook:
                                 'result': result,
                             }
                             '''
+                            
+                            st.session_state['fb_upload'] = 'uploaded'
                             collect_telemetry(debug_info)
+                            combined_text = ""
                             
                             #with st.expander("Debug information", icon="⚙"):
                             #    st.write(debug_info)

classes/Social_Media_IG.py

@@ -38,6 +38,8 @@ class Instagram:
         except Exception:
             pass
         '''
+        if 'ig_upload' not in st.session_state:
+            st.session_state['ig_upload'] = ''
 
     def request_model(self, payload_txt):
         response = requests.post(self.model_url, json=payload_txt)
@@ -135,6 +137,8 @@ class Instagram:
                                     }
                                     '''
                                     collect_telemetry(debug_info)
+                                    st.session_state['ig_upload'] = 'uploaded'
+                                    
 
                                     
                         except AttributeError:

classes/Tiktok.py

@@ -38,6 +38,8 @@ class Tiktok:
         except Exception:
             pass
         '''
+        if 'tiktok_upload' not in st.session_state:
+            st.session_state['tiktok_upload'] = ''
 
     def request_model(self, payload_txt):
         response = requests.post(self.model_url, json=payload_txt)
@@ -101,6 +103,7 @@ class Tiktok:
                 except Exception:
                     pass
                 return file_name
+    
     def process(self):
         session = st.session_state.analyze
         if (self.tiktok_f or self.tiktok_er or self.tiktok_pf) and session == 'clicked':
@@ -134,6 +137,7 @@ class Tiktok:
                                 }
                                 '''
                                 collect_telemetry(debug_info)
+                                st.session_state['tiktok_upload'] = 'uploaded'
                                 
                                 #with st.expander("Debug information", icon="⚙"):
                                 #    st.write(debug_info)

classes/Twitter.py

@@ -38,6 +38,8 @@ class Twitter:
         except Exception:
             pass
         '''
+        if 'twitter_upload' not in st.session_state:
+            st.session_state['twitter_upload'] = ''
 
     def request_model(self, payload_txt):
         response = requests.post(self.model_url, json=payload_txt)
@@ -149,7 +151,7 @@ class Twitter:
                                 }
                                 '''
                                 collect_telemetry(debug_info)
-
+                                st.session_state['twitter_upload'] = 'uploaded'
                                 st.session_state['analyzing'] = False 
                     except AttributeError:
                         st.info("Please upload CSV or PDF files first.")

classes/Youtube.py

@@ -38,6 +38,8 @@ class YouTube:
         except Exception:
             pass
         '''
+        if 'youtube_upload' not in st.session_state:
+            st.session_state['youtube_upload'] = ''
 
     def request_model(self, payload_txt):
         response = requests.post(self.model_url, json=payload_txt)
@@ -104,7 +106,7 @@ class YouTube:
         
     def process(self):
         session = st.session_state.analyze
-        if (self.youtube or self.youtube_er or self.youtube_pf) and session == 'clicked':
+        if ((self.youtube or self.youtube_er or self.youtube_pf) and session) == 'clicked':
                     try:
                         combined_text = ""
                         with st.spinner('Youtube...', show_time=True):
@@ -138,6 +140,7 @@ class YouTube:
                                 }
                                 '''
                                 collect_telemetry(debug_info)
+                                st.session_state['youtube_upload'] = 'uploaded'
                                 
                                 #with st.expander("Debug information", icon="⚙"):
                                 #    st.write(debug_info)

classes/response_off.py

@@ -32,6 +32,7 @@ class SeoOffPageAnalyst:
 
         # AGENT NAME
         #st.header(self.analyst_name)
+    
     def request_model(self, payload_txt, headers):
         response = requests.post(self.model_url, json=payload_txt, headers=headers)
         response.raise_for_status()

classes/response_on_page.py

@@ -60,7 +60,13 @@ class SeoOn:
         myclient = MongoClient(mongodb_uri)
         mydb = myclient.get_database()
         mycol = mydb["df_data"]
-        x = mycol.find_one({"data_field": data_field})
+        
+        # Sort by timestamp field in descending order
+        x = mycol.find_one(
+            {"data_field": data_field},
+            sort=[("timestamp", -1)]  
+        )
+        
         x = x["result"]
         return x
 
@@ -68,55 +74,19 @@ class SeoOn:
                 with st.spinner('SEO On Page...', show_time=True):
                         st.write('')
                         # OUTPUT FOR SEO ANALYST
-                        headers = {"Content-Type": "application/json", "x-api-key": f"{os.getenv('x-api-key')}"}
-                        payload = ""
-                        try:
-                             payload += self.fetch_data("First Meaningful Paint")
-                        except Exception as e:
-                            pass
-                        try:
-                             payload += self.fetch_data("Crawl File")
-                        except Exception as e:
-                            pass
-
-                        try:
-                            session_first_meaningful_paint = st.session_state['first_meaningful_paint']
-                            session_crawl_file = st.session_state['crawl_file']
-                            if session_first_meaningful_paint or session_crawl_file == 'uploaded':
-                                payload_txt = {"input_value": payload, "output_type": "text", "input_type": "chat"}
+                        headers = {"Content-Type": "application/json", "x-api-key": f"{os.getenv('x-api-key')}"}                                  
+                        try:                          
+                                payload_txt = {"input_value": self.payload, "output_type": "text", "input_type": "chat"}
                                 payload_txt_model = self.request_model(payload_txt, headers)
                                 debug_info = {'data_field' : 'On Page Analyst', 'result': payload_txt_model}
                                 upload_response(debug_info)
 
                                 st.session_state['first_meaningful_paint'] = ''
                                 st.session_state['crawl_file'] = ''
+                                count = 0
                         except Exception as e:
                              pass
 
-                        #end_time = time.time()
-                        #time_lapsed = end_time - start_time
-
-                        #debug_info = {'data_field' : 'GT Metrix', 'result': result}
-                        
-                        
-                        '''
-                        debug_info = {#'analyst': self.analyst_name,
-                                      'url_uuid': self.model_url.split("-")[-1],
-                                      'time_lapsed' : time_lapsed, 
-                                    'crawl_file': [file.name for file in self.uploaded_files] if self.uploaded_files else ['Not available'],
-                                      'gt_metrix': [file.name for file in self.gtmetrix] if self.gtmetrix else ['Not available'],
-                                      'payload': payload_txt, 
-                                      'result': result}
-                        
-                        if self.gtmetrix:
-                            collect_telemetry(debug_info)
-                        '''
- 
-                            
-                        #with st.expander("Debug information", icon="⚙"):
-                        #    st.write(debug_info)
-                        
-
                         st.session_state['analyzing'] = False
                         try:
                             self.file_dict.popitem()
@@ -124,13 +94,25 @@ class SeoOn:
                             pass
                         
     def row1(self):
-           
-            #st.write("") # FOR THE HIDE BUTTON
-            #st.write("") # FOR THE HIDE BUTTON
-            #st.write("AI Analyst Output: ")
             st.session_state['analyzing'] = False
-            #st.write("") # FOR THE HIDE BUTTON
-            self.process()
+            self.payload = ""
+            count = 0
+            try:
+                session_first_meaningful_paint = st.session_state['first_meaningful_paint']
+                if session_first_meaningful_paint == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("First Meaningful Paint")
+            except Exception as e:
+                pass
+            try:
+                session_crawl_file = st.session_state['crawl_file']
+                if session_crawl_file == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Crawl File")
+            except Exception as e:
+                pass
+            if count >= 1:
+                self.process()
                  
 
 if __name__ == "__main__":

classes/response_seo.py

@@ -48,6 +48,7 @@ class Seo:
         response = requests.post(self.model_url, json=payload_txt, headers=headers)
         response.raise_for_status()
         output = response.json()
+        #st.write(output)
         text = output["outputs"][0]["outputs"][0]["results"]["text"]["data"]["text"]
         text = json.loads(text)
         #st.write(text)
@@ -67,7 +68,13 @@ class Seo:
         myclient = MongoClient(mongodb_uri)
         mydb = myclient.get_database()
         mycol = mydb["df_data"]
-        x = mycol.find_one({"data_field": data_field})
+        
+        # Sort by timestamp field in descending order
+        x = mycol.find_one(
+            {"data_field": data_field},
+            sort=[("timestamp", -1)]  
+        )
+        
         x = x["result"]
         return x
     
@@ -143,41 +150,9 @@ class Seo:
     def process (self):    
         with st.spinner('Seo Analyst...', show_time=True):
                         st.write('')
-                        headers = {"Content-Type": "application/json", "x-api-key": f"{os.getenv('x-api-key')}"}
-                        payload = ""
-                        try:
-                            payload += self.fetch_data("SEO Keywords")
-                        except Exception as e:
-                            pass
-                        try:
-                            payload += self.fetch_data("Traffic Channels")
-                        except Exception as e:
-                            pass
-                        try:
-                            payload += self.fetch_data("Traffic Acquisition")
-                        except Exception as e:
-                            pass
-                        try:
-                            payload += self.fetch_data("Pages Indexed")
-                        except Exception as e:
-                            pass
-                        try:
-                            payload += self.fetch_data("Bounce Rate")
-                        except Exception as e:
-                            pass
-                        try:
-                            payload += self.fetch_backlinks("Backlinks")
-                        except Exception as e:
-                            pass
-
+                        headers = {"Content-Type": "application/json", "x-api-key": f"{os.getenv('x-api-key')}"}         
                         try:
-                            session_bounce_rate = st.session_state['bounce_rate']
-                            session_page_index = st.session_state['pages_index']
-                            session_others = st.session_state['others']
-                            session_traffic_channels = st.session_state['df_traffic']
-                            session_traffic_aqcuisition = st.session_state['df_seo']
-                            if session_bounce_rate or session_page_index or session_others or session_traffic_aqcuisition or session_traffic_channels == 'uploaded':
-                                payload_txt = {"input_value": payload, "output_type": "text", "input_type": "chat"}
+                                payload_txt = {"input_value": self.payload, "output_type": "text", "input_type": "chat"}
                                 payload_txt_model = self.request_model(payload_txt, headers)
                                 debug_info = {'data_field' : 'SEO Analyst', 'result': payload_txt_model}
                                 upload_response(debug_info)
@@ -187,6 +162,7 @@ class Seo:
                                 st.session_state['others'] = ''
                                 st.session_state['df_traffic'] = ''
                                 st.session_state['df_seo'] = ''
+                                count = 0
                         except Exception as e:
                             pass
                         st.session_state['analyzing'] = False    
@@ -195,8 +171,57 @@ class Seo:
             st.session_state['analyzing'] = False
             #st.write("") # FOR THE HIDE BUTTON
             #analyze_button = st.button("Analyze", disabled=initialize_analyze_session())
+            self.payload = ""  
+            count = 0
+            try:
+                session_traffic_aqcuisition = st.session_state['df_seo']
+                if session_traffic_aqcuisition == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("SEO Keywords")
+                
+            except Exception as e:
+                pass
+            try:
+                session_traffic_channels = st.session_state['df_traffic']
+                if session_traffic_channels == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Traffic Channels")
+            except Exception as e:
+                pass
+            try:
+                session_others = st.session_state['others']
+                if session_others == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Traffic Acquisition")
+                
+            except Exception as e:
+                pass
+            try:
+                session_page_index = st.session_state['pages_index']
+                if session_page_index == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Pages Indexed")            
+            except Exception as e:
+                pass
+            try:
+                session_bounce_rate = st.session_state['bounce_rate']
+                if session_bounce_rate == 'uploaded':
+                    print("run")
+                    count += 1
+                    self.payload += self.fetch_data("Bounce Rate")                 
+            except Exception as e:
+                pass
+            try:
+                session_backlinks = st.session_state["off_page_file_uploaded"] 
+                if session_backlinks == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_backlinks("Backlinks") 
+            except Exception as e:
+                pass
+
+            if count >= 1:
+                self.process()
             
-            self.process()
 
 if __name__ == "__main__":
     st.set_page_config(layout="wide")

classes/response_social_media.py

@@ -0,0 +1,154 @@
+import streamlit as st
+import requests
+from dotenv import load_dotenv
+import os
+import pandas as pd
+import time
+import chardet
+from helper.telemetry import collect_telemetry
+from helper.upload_File import uploadFile
+from helper.button_behaviour import hide_button
+from helper.initialize_analyze_session import initialize_analyze_session
+from pymongo import MongoClient
+import json
+from helper.data_field import data_field
+from helper.upload_response import upload_response
+
+class SocialMedia:
+    def __init__(self, model_url):
+        self.file_dict = {}
+        self.model_url = model_url
+        #self.analyst_name = analyst_name
+        #self.data_src = data_src
+        #self.analyst_description = analyst_description
+        self.initialize()
+        self.row1()
+
+    def initialize(self):
+        # FOR ENV
+        load_dotenv()
+
+        # AGENT NAME
+        #st.header(self.analyst_name)
+
+        # EVALUATION FORM LINK
+        '''
+        url = os.getenv('Link')
+        st.write('Evaluation Form: [Link](%s)' % url)
+
+        # RETURN BUTTON
+        try:
+            if st.button("Return", type='primary'):
+                st.switch_page("./pages/home.py")
+        except Exception:
+            pass
+        '''
+        if 'fb_upload' not in st.session_state:
+            st.session_state['fb_upload'] = ''
+    
+    def request_model(self, payload_txt, headers):
+        response = requests.post(self.model_url, json=payload_txt, headers=headers)
+        response.raise_for_status()
+        output = response.json()
+        #st.write(output)
+        text = output["outputs"][0]["outputs"][0]["results"]["text"]["data"]["text"]
+        text = json.loads(text)
+        #st.write(text)
+        return text
+    
+    def terminate_session(self, session):
+        try:
+            del st.session_state[session]
+        except KeyError:
+            pass
+
+    def fetch_data(self, data_field):
+        mongodb_uri = os.getenv("MONGODB_URI")
+        myclient = MongoClient(mongodb_uri)
+        mydb = myclient.get_database()
+        mycol = mydb["df_data"]
+        
+        # Sort by timestamp field in descending order
+        x = mycol.find_one(
+            {"data_field": data_field},
+            sort=[("timestamp", -1)]  
+        )
+        
+        x = x["result"]
+        return x
+    
+    def process(self):  
+                    with st.spinner('Social Media Analyst...', show_time=True):
+                            st.write('')
+
+                            headers = {"Content-Type": "application/json", "x-api-key": f"{os.getenv('x-api-key')}"}              
+                            try:
+                                        payload_txt = {"input_value": self.payload, "output_type": "text", "input_type": "chat"}
+                                        payload_txt_model = self.request_model(payload_txt, headers)
+                                        debug_info = {'data_field' : 'Social Media Analyst', 'result': payload_txt_model}
+                                        upload_response(debug_info)
+
+                                        st.session_state['fb_upload'] = ''
+                                        st.session_state['ig_upload'] = ''
+                                        st.session_state['twitter_upload'] = ''
+                                        st.session_state['youtube_upload'] = ''
+                                        st.session_state['linkedin_upload'] = ''
+                                        st.session_state['tiktok_upload'] = ''
+                                        count = 0
+                                        
+                            except Exception as e:
+                                 pass
+                                                         
+    def row1(self):
+            self.payload = ""
+            count = 0                           
+            try:
+                session_fb = st.session_state['fb_upload']
+                if session_fb == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Facebook")        
+            except Exception as e:
+                pass
+            try:
+                session_ig = st.session_state['ig_upload']
+                if session_ig == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Instagram")
+            except Exception as e:
+                pass
+            try:
+                session_twitter = st.session_state['twitter_upload']
+                if session_twitter == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Twitter")
+            except Exception as e:
+                pass
+            try:
+                session_yt = st.session_state['youtube_upload']
+                if session_yt == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("YouTube")
+            except Exception as e:
+                pass
+            try:
+                session_linkedin = st.session_state['linkedin_upload']
+                if session_linkedin == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Linkedin")           
+            except Exception as e:
+                pass
+            try:
+                session_tiktok = st.session_state['tiktok_upload']
+                if session_tiktok == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Tiktok")
+            except Exception as e:
+                pass
+            if count >= 1:
+                self.process()
+            
+
+if __name__ == "__main__":
+    st.set_page_config(layout="wide")
+
+upload = uploadFile()

classes/response_website_and_tools.py

@@ -59,118 +59,23 @@ class WebsiteAndTools:
         myclient = MongoClient(mongodb_uri)
         mydb = myclient.get_database()
         mycol = mydb["df_data"]
-        x = mycol.find_one({"data_field": data_field})
+        
+        # Sort by timestamp field in descending order
+        x = mycol.find_one(
+            {"data_field": data_field},
+            sort=[("timestamp", -1)]  
+        )
+        
         x = x["result"]
         return x
 
     def process(self):
                 with st.spinner('Website and Tools...', show_time=True):
-                        st.write('')
-                        '''
-                        # OUTPUT FOR WEBSITE RESPONSIVENESS
-                        payload_txt_website_responsiveness = {"result": website_responsiveness}
-                        result_website_responsiveness = self.request_model(payload_txt_website_responsiveness)
-
-                        # OUTPUT FOR CONTENT MANAGEMENT SYSTEM
-                        payload_txt_content_management_system = {"question": content_management_system}
-                        #result_content_management_system = self.request_model(content_management_system)
-
-                        # OUTPUT FOR SSL CERTIFICATE
-                        payload_txt_SSL_certificate = {"question": SSL_certificate}
-                        #result_SSL_certificate = self.request_model(SSL_certificate)
-
-                        # OUTPUT FOR WEB ANALYTICS
-                        payload_txt_web_analytics = {"question": web_analytics}
-                        #result_web_analytics = self.request_model(web_analytics)
-
-                        # OUTPUT FOR CLIENT RELATIONS MANAGEMENT SYSTEM
-                        payload_txt_client_relations_management_system = {"question": client_relations_management_system}
-                        #result_client_relations_management_system = self.request_model(client_relations_management_system)
-                        
-                        # OUTPUT FOR LEAD GENERATION MECHANISM
-                        payload_txt_lead_generation_mechanism = {"question": lead_generation_mechanism}
-                        #result_lead_generation_mechanism = self.request_model(lead_generation_mechanism)
-                        '''
-                        # OUTPUT FOR SEO ANALYST
-                      
-                        #print(x)
+                        st.write('')       
                         headers = {"Content-Type": "application/json", "x-api-key": f"{os.getenv('x-api-key')}"}
+                                         
                         try:
-                            payload = ""
-                            session_website_responsiveness = st.session_state['website_responsiveness']
-                            if session_website_responsiveness == 'uploaded':
-                                payload += self.fetch_data("Website Responsiveness")
-                        except Exception as e:
-                             pass
-                        try:
-                            session_content_management_system = st.session_state['content_management_system']
-                            if session_content_management_system == 'uploaded':
-                                payload += self.fetch_data("Content Management System")
-                        except Exception as e:
-                             pass
-                        try:
-                            session_SSL_certificate = st.session_state['SSL_certificate']
-                            if session_SSL_certificate == 'uploaded':
-                                payload += self.fetch_data("SSL Certificate")
-                                
-                        except Exception as e:
-                             pass
-                        try:
-                            session_mobile_responsiveness = st.session_state['mobile_responsiveness']
-                            if session_mobile_responsiveness == 'uploaded':
-                                payload += self.fetch_data("Mobile Responsiveness")
-                        except Exception as e:
-                             pass
-                        try:
-                            session_desktop_loading_speed = st.session_state['desktop_loading_speed']
-                            if session_desktop_loading_speed == 'uploaded':
-                                payload += self.fetch_data("Desktop Loading Speed")
-                        except Exception as e:
-                             pass
-                        try:
-                            session_mobile_loading_speed = st.session_state['mobile_loading_speed']
-                            if session_mobile_loading_speed == 'uploaded':
-                                payload += self.fetch_data("Mobile Loading Speed")
-                        except Exception as e:
-                             pass
-                        try:
-                            session_first_meaningful_paint = st.session_state['first_meaningful_paint']
-                            if session_first_meaningful_paint == 'uploaded':
-                                payload += self.fetch_data("First Meaningful Paint")
-                        except Exception as e:
-                             pass
-                        try:
-                            session_web_analytics = st.session_state['web_analytics']
-                            if session_web_analytics == 'uploaded':
-                                payload += self.fetch_data("Web Analytics")
-                        except Exception as e:
-                             pass
-                        try:
-                            session_client_relations_management_system = st.session_state['client_relations_management_system']
-                            if session_client_relations_management_system == 'uploaded':
-                                payload += self.fetch_data("Client Relations Management System")
-                        except Exception as e:
-                             pass
-                        try:
-                            session_lead_generation_mechanism = st.session_state['lead_generation_mechanism']
-                            if session_lead_generation_mechanism == 'uploaded':
-                                payload += self.fetch_data("Lead Generation Mechanism")
-                        except Exception as e:
-                             pass
-                        
-                        try:
-                            session_website_responsiveness = st.session_state['website_responsiveness']
-                            session_client_relations_management_system = st.session_state['client_relations_management_system']
-                            session_lead_generation_mechanism = st.session_state['lead_generation_mechanism']
-                            session_web_analytics = st.session_state['web_analytics']
-                            session_mobile_responsiveness = st.session_state['mobile_responsiveness']
-                            session_desktop_loading_speed = st.session_state['desktop_loading_speed']
-                            session_mobile_loading_speed = st.session_state['mobile_loading_speed']
-                            session_SSL_certificate = st.session_state['SSL_certificate']
-                            session_content_management_system = st.session_state['content_management_system']
-
-                            if session_website_responsiveness or session_client_relations_management_system or session_lead_generation_mechanism or session_web_analytics or session_mobile_responsiveness or session_desktop_loading_speed or session_mobile_loading_speed or session_content_management_system or session_SSL_certificate == 'uploaded':
-                                payload_txt = {"input_value": payload, "output_type": "text", "input_type": "chat"}
+                                payload_txt = {"input_value": self.payload, "output_type": "text", "input_type": "chat"}
                                 payload_txt_model = self.request_model(payload_txt, headers)
                                 debug_info = {'data_field' : 'Website and Tools Analyst', 'result': payload_txt_model}
                                 upload_response(debug_info)
@@ -184,6 +89,7 @@ class WebsiteAndTools:
                                 st.session_state['web_analytics'] = ''
                                 st.session_state['client_relations_management_system'] = ''
                                 st.session_state['lead_generation_mechanism'] = ''
+                                count = 0
                         except Exception as e:
                              pass
                         #end_time = time.time()
@@ -217,15 +123,84 @@ class WebsiteAndTools:
                             pass
                         
     def row1(self):
-           
-            #st.write("") # FOR THE HIDE BUTTON
-            #st.write("") # FOR THE HIDE BUTTON
-            #st.write("AI Analyst Output: ")
             st.session_state['analyzing'] = False
-            #st.write("") # FOR THE HIDE BUTTON
-            self.process()
+            self.payload = ""
+            count = 0
+            try:
+                payload = ""
+                session_website_responsiveness = st.session_state['website_responsiveness']
+                if session_website_responsiveness == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Website Responsiveness")
+            except Exception as e:
+                pass
+            try:
+                session_content_management_system = st.session_state['content_management_system']
+                if session_content_management_system == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Content Management System")
+            except Exception as e:
+                pass
+            try:
+                session_SSL_certificate = st.session_state['SSL_certificate']
+                if session_SSL_certificate == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("SSL Certificate")
+                                
+            except Exception as e:
+                pass
+            try:
+                session_mobile_responsiveness = st.session_state['mobile_responsiveness']
+                if session_mobile_responsiveness == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Mobile Responsiveness")
+            except Exception as e:
+                pass
+            try:
+                session_desktop_loading_speed = st.session_state['desktop_loading_speed']
+                if session_desktop_loading_speed == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Desktop Loading Speed")
+            except Exception as e:
+                pass
+            try:
+                session_mobile_loading_speed = st.session_state['mobile_loading_speed']
+                if session_mobile_loading_speed == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Mobile Loading Speed")
+            except Exception as e:
+                pass
+            try:
+                session_first_meaningful_paint = st.session_state['first_meaningful_paint']
+                if session_first_meaningful_paint == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("First Meaningful Paint")
+            except Exception as e:
+                pass
+            try:
+                session_web_analytics = st.session_state['web_analytics']
+                if session_web_analytics == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Web Analytics")
+            except Exception as e:
+                pass
+            try:
+                session_client_relations_management_system = st.session_state['client_relations_management_system']
+                if session_client_relations_management_system == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Client Relations Management System")
+            except Exception as e:
+                pass
+            try:
+                session_lead_generation_mechanism = st.session_state['lead_generation_mechanism']
+                if session_lead_generation_mechanism == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Lead Generation Mechanism")
+            except Exception as e:
+                pass
+            if count >= 1:
+                self.process()
                  
-
 if __name__ == "__main__":
     st.set_page_config(layout="wide")
 

classes/website_and_tools.py

@@ -277,7 +277,7 @@ class WebsiteAndTools:
             self.mobile_responsiveness = st.text_input("Mobile Responsiveness - GTMetrix:", placeholder='Enter Mobile Responsiveness')
             self.desktop_loading_speed = st.text_input("Desktop Loading Speed - GTMetrix:", placeholder='Enter Desktop Loading Speed')
             self.mobile_loading_speed = st.text_input("Mobile Loading Speed - GTMetrix:", placeholder='Enter Mobile Loading Speed')
-            self.web_analytics = st.text_input("Web Analytics - BuiltWith:", placeholder='Enter Web Analytics')
+            self.web_analytics = st.text_input("Web Analytics - BuiltWith (GA4):", placeholder='Enter Web Analytics')
             self.client_relations_management_system = st.text_input("Client Relations Management System - BuiltWith:", placeholder='Enter Client Relations Management System')
             self.lead_generation_mechanism = st.text_input("Lead Generation Mechanism - Business Context (Lead Generation & Lead Nurturing):", placeholder='Enter Lead Generation Mechanism')
 

helper/telemetry.py

@@ -19,7 +19,7 @@ def collect_telemetry(data):
         return
 
     try:
-        '''
+        
         # Get the current UTC time
         utc_now = datetime.now(timezone.utc)
 
@@ -29,7 +29,7 @@ def collect_telemetry(data):
         # Convert the UTC time to GMT+8
         timestamp = utc_now.astimezone(gmt_plus_8).isoformat()
         data['timestamp'] = timestamp
-        '''
+        
         client = MongoClient(mongodb_uri)
         db = client.get_database()  # Use the default database specified in the URI
         collection = db["df_data"]  # Replace "telemetry" with your desired collection name

pages/analyzing_page.py

@@ -6,18 +6,15 @@ from classes.response_off import SeoOffPageAnalyst
 from classes.response_on_page import SeoOn
 from classes.response_website_and_tools import WebsiteAndTools
 from classes.response_seo import Seo
+from classes.response_social_media import SocialMedia
 
 def run_analysis():
-    # Retrieve uploaded files from session state
-    off_page_file = st.session_state.get('off_page_file_uploaded')
-    gt_file = st.session_state.get('GT_file_uploaded')
-    website_and_tools = st.session_state.get('website_and_tools')
-    seo = st.session_state.get('seo')
     # Placeholders for status updates
     off_page_status = st.empty()
     on_page_status = st.empty()
     website_and_tools_status = st.empty()
     seo_status = st.empty()
+    social_media_status = st.empty()
     # Function to run SEO Off Page Analysis
     def run_off_page_analysis():
         try:
@@ -59,29 +56,52 @@ def run_analysis():
             seo_status.error(f"SEO Analysis failed: {e}")
             return None
         
+    def run_social_media_analysis():
+        try:
+            social_media_status.info("Starting Social Media Analysis...")
+            result = SocialMedia(os.getenv('MODEL_Social_Media_Analyst'))
+            social_media_status.success("Social Media Analysis completed successfully.")
+            return result
+        except Exception as e:
+            social_media_status.error(f"Social Media Analysis failed: {e}")
+            return None
+        
     # Create threads for concurrent execution
     off_page_thread = threading.Thread(target=run_off_page_analysis)
     on_page_thread = threading.Thread(target=run_on_page_analysis)
     website_and_tools_thread = threading.Thread(target=run_website_and_tools_analysis)
     seo_thread = threading.Thread(target=run_seo_analysis)
+    social_media_thread = threading.Thread(target=run_social_media_analysis)
 
     # Attach Streamlit context to threads
     add_script_run_ctx(off_page_thread)
     add_script_run_ctx(on_page_thread)
     add_script_run_ctx(website_and_tools_thread)
     add_script_run_ctx(seo_thread)
+    add_script_run_ctx(social_media_thread)
 
     # Start threads
     off_page_thread.start()
     on_page_thread.start()
     website_and_tools_thread.start()
     seo_thread.start()
+    social_media_thread.start()
 
     # Wait for threads to complete
     off_page_thread.join()
     on_page_thread.join()
     website_and_tools_thread.join()
     seo_thread.join()
+    st.success("🎉 All analyses completed!") # Final success message
+    # --- Display Button After Completion ---
+    if st.button("View Results"):
+        st.switch_page("pages/output.py")
+   
+    
+
+
 
 # Execute the analysis
+if st.button("Back"):
+        st.switch_page("pages/home.py")
 run_analysis()

pages/output.py

@@ -0,0 +1,30 @@
+import os
+import streamlit as st
+
+import time
+
+def display_outputs():
+    client_name = "RMX Creatives"
+    overview = f"""**{client_name}** is a financial services company based in Auckland, New Zealand, specializing in providing quick and flexible loan solutions for businesses and individuals. Represented by Paul Stone, LoansOne has enlisted ShoreMarketing to perform a deep dive into their digital footprint to have a view of the holistic status of their digital properties and determine how each property can play part in implementing a stronger digital marketing plan.\n
+The Digital Marketing Footprint consists of deep-dive research by ShoreMarketing specialists to help the business leaders of LoansOne understand the effectiveness of their existing digital initiatives with the view of giving them an insight to developing a strategy and effectively allocating business resources to digital properties that will give them the best results.\n
+This document represents the results of our audit of LoansOne’s digital marketing and management practices. Our audit covered reviews of key digital areas: Website and Tools, PPC/SEM, SEO, Social Media, and Market Places."""
+
+    # (off_page_thread)
+    # (on_page_thread)
+    # (website_and_tools_thread)
+    # (seo_thread)
+    # (social_media_thread)
+    st.markdown("## Digital Marketing Audit")
+    st.markdown(f"### {client_name}")
+    
+    st.markdown("## DIGITAL FOOTPRINT OVERVIEW")
+    st.markdown(f"{overview}")
+    
+    st.markdown("## WEBSITE AND TOOLS")
+    st.markdown(f"""In today’s digital age, scaling a business is simply impossible without a website. Websites primarily serve as the center for all online conversions, which makes it equally important to guarantee that all pages are optimised to educate all traffic about the brand and ultimately to usher them into conversion. \n
+In line with this, we have looked into the technology used by **{client_name}** as well as the different digital channels currently in place to see how they are structured and how they are performing.""")
+    
+
+if st.button("Back to Dashboard"):
+        st.switch_page("pages/home.py")
+display_outputs()