dataflow-core 2.1.15rc1__py3-none-any.whl → 2.1.15rc2__py3-none-any.whl

authenticator/dataflowhubauthenticator.py

@@ -8,7 +8,8 @@ from jupyterhub.auth import Authenticator
 from oauthenticator.google import GoogleOAuthenticator
 from oauthenticator.azuread import AzureAdOAuthenticator
 from dataflow.db import get_db
-from dataflow.models import user as m_user, session as m_session, role as m_role
+from dataflow.models import user as m_user, session as m_session
+from sqlalchemy import or_
 
 class DataflowBaseAuthenticator(Authenticator):
     enable_dataflow_auth = Bool(True, config=True, help="Enable username/password authentication")
@@ -28,7 +29,7 @@ class DataflowBaseAuthenticator(Authenticator):
         return str(uuid.uuid4())
 
     def set_session_cookie(self, handler, session_id):
-        expires = datetime.now(ZoneInfo("UTC")) + timedelta(days=365)
+        expires = datetime.now(ZoneInfo("UTC")) + timedelta(days=60)
         host = handler.request.host
         domain = '.'.join(host.split('.')[-2:]) if len(host.split('.')) >= 2 else host
         handler.set_cookie(
@@ -44,19 +45,12 @@ class DataflowBaseAuthenticator(Authenticator):
         self.log.info(f"Set session cookie: dataflow_session={session_id} for host={host}")
 
     def get_or_create_session(self, user_id):
-        existing_session = (
-            self.db.query(m_session.Session)
-            .filter(m_session.Session.user_id == str(user_id))
-            .first()
-        )
-        if existing_session:
-            self.log.info(f"Reusing existing session: {existing_session.session_id}")
-            return existing_session.session_id
         session_id = self.generate_session_id()
         while self.db.query(m_session.Session).filter(
             m_session.Session.session_id == session_id
         ).first():
             session_id = self.generate_session_id()
+
         db_item = m_session.Session(user_id=user_id, session_id=session_id)
         self.db.add(db_item)
         self.db.commit()
@@ -77,23 +71,6 @@ class DataflowBaseAuthenticator(Authenticator):
 
         return super().check_blocked_users(username, authenticated)
 
-    def get_applicant_role_id(self):
-        """Get the role ID for 'Applicant' role"""
-        try:
-            applicant_role = (
-                self.db.query(m_role.Role)
-                .filter(m_role.Role.name == "Applicant")
-                .first()
-            )
-            if applicant_role:
-                return applicant_role.id
-            else:
-                self.log.warning("Applicant role not found in database")
-                return None
-        except Exception as e:
-            self.log.error(f"Error getting Applicant role: {str(e)}")
-            return None
-
     def extract_username_from_email(self, email):
         """Extract username from email by removing domain"""
         if '@' in email:
@@ -103,16 +80,12 @@ class DataflowBaseAuthenticator(Authenticator):
     def create_new_user(self, email, first_name=None, last_name=None):
         """Create a new user with Applicant role"""
         try:
-            role_id = self.get_applicant_role_id()
-            if not role_id:
-                self.log.error("Cannot create user: Applicant role not found")
-                return None
-
             username = self.extract_username_from_email(email)
             username = re.sub(r'[^a-z0-9]', '', username.lower())
             if not username:
                 self.log.error("Cannot create user: Username is empty")
                 return None
+            
             existing_user = (
                 self.db.query(m_user.User)
                 .filter(m_user.User.user_name == username)
@@ -122,7 +95,7 @@ class DataflowBaseAuthenticator(Authenticator):
                 counter = 1
                 original_username = username
                 while existing_user:
-                    username = f"{original_username}_{counter}"
+                    username = f"{original_username}{counter}"
                     existing_user = (
                         self.db.query(m_user.User)
                         .filter(m_user.User.user_name == username)
@@ -135,8 +108,6 @@ class DataflowBaseAuthenticator(Authenticator):
                 first_name=first_name or username,
                 last_name=last_name or "",
                 email=email,
-                role_id=role_id,
-                password='user@123',
             )
             
             self.db.add(new_user)
@@ -154,22 +125,29 @@ class DataflowBaseAuthenticator(Authenticator):
     async def authenticate_dataflow(self, handler, data):
         if not (self.enable_dataflow_auth and isinstance(data, dict) and data.get("username") and data.get("password")):
             return None
-        username = data["username"]
+        user_name_or_email = data["username"]
         password = data["password"]
-        self.log.info(f"Attempting Dataflow authentication for user: {username}")
+        self.log.info(f"Attempting Dataflow authentication for user: {user_name_or_email}")
         try:
             user = (
                 self.db.query(m_user.User)
-                .filter(m_user.User.user_name == username)
+                .filter(
+                    or_(
+                        m_user.User.email == user_name_or_email,
+                        m_user.User.user_name == user_name_or_email
+                    )
+                )
                 .first()
             )
+
             if not user or user.password != password:
-                self.log.warning(f"Dataflow authentication failed for user: {username}")
+                self.log.warning(f"Dataflow authentication failed for user: {user_name_or_email}")
                 return None
+            
             session_id = self.get_or_create_session(user.user_id)
             self.set_session_cookie(handler, session_id)
-            self.log.info(f"Dataflow authentication successful for user: {username}")
-            return {"name": username, "session_id": session_id, "auth_state": {}}
+            self.log.info(f"Dataflow authentication successful for user: {user.user_name}")
+            return {"name": user.user_name, "session_id": session_id, "auth_state": {}}
         except Exception as e:
             self.log.error(f"Dataflow authentication error: {str(e)}")
             return None

dataflow/dataflow.py

@@ -25,16 +25,13 @@ class Dataflow:
     def _parse_response_data(self, response):
         """Parse response data based on datatype field or fallback to JSON parsing."""
         data = response.json()
+        if not isinstance(data, dict):
+            raise ValueError("Internal Dataflow Error!")
         value = data.get('value', '')
-        if isinstance(data, dict) and 'datatype' in data:
-            value = data.get('value', '')
-            datatype = data.get('datatype')
-            if datatype == 'json':
-                return self._json_parse(value)
-            else:
-                return value
-        else:
+        if data.get('datatype') == 'json':
             return self._json_parse(value)
+        else:
+            return value
 
     def auth(self, session_id: str):
         """
@@ -84,12 +81,19 @@ class Dataflow:
             host_name = os.environ.get("HOSTNAME", "")
             runtime = os.environ.get("RUNTIME")
             slug = os.environ.get("SLUG")
+            org_id = os.environ.get("ORGANIZATION")
 
             dataflow_config = ConfigurationManager('/dataflow/app/auth_config/dataflow_auth.cfg')
+            query_params = {
+                "key": variable_name,
+            }
 
             variable_api = None
             if runtime and slug:
                 variable_api = dataflow_config.get_config_value("auth", "variable_ui_api")
+                query_params["runtime"] = runtime
+                query_params["slug"] = slug
+                query_params["org_id"] = org_id
             elif host_name:
                 variable_api = dataflow_config.get_config_value("auth", "variable_manager_api")
             else:
@@ -98,36 +102,13 @@ class Dataflow:
             if not variable_api:
                 print("[Dataflow.variable] Variable Unreachable")
                 return None
-
-            if runtime:
-                query_params = {
-                    "key": variable_name,
-                    "runtime": runtime,
-                    "slug": slug
-                }
-                response = requests.get(variable_api, params=query_params)
-                if response.status_code == 200:
-                    response_text = response.text.strip().strip('"')
-                    return response_text
-                
-                query_params["slug"] = "global"
-                response = requests.get(variable_api, params=query_params)
-                if response.status_code == 200:
-                    response_text = response.text.strip().strip('"')
-                    return response_text
-                else: 
-                    return None
-
-            query_params = {
-                "key": variable_name,
-            }
+        
             response = requests.get(variable_api, params=query_params)
             
-            # Handle different HTTP status codes gracefully
             if response.status_code == 404:
-                return None  # Variable not found
+                return None
             elif response.status_code >= 500:
-                response.raise_for_status()  # Let server errors propagate
+                response.raise_for_status()
             elif response.status_code >= 400:
                 print(f"[Dataflow.variable] Client error {response.status_code} for variable '{variable_name}'")
                 return None
@@ -158,32 +139,30 @@ class Dataflow:
             host_name = os.environ.get("HOSTNAME", "")
             runtime = os.environ.get("RUNTIME")
             slug = os.environ.get("SLUG")
+            org_id = os.environ.get("ORGANIZATION")
 
             dataflow_config = ConfigurationManager('/dataflow/app/auth_config/dataflow_auth.cfg')
-            if runtime:
-                secret_api = dataflow_config.get_config_value("auth", "secret_ui_api")
-            else:
-                secret_api = dataflow_config.get_config_value("auth", "secret_manager_api")
-            if not secret_api:
-                print("[Dataflow.secret] Secret API Unreachable")
-                return None
-
             query_params = {
                 "key": secret_name
             }
 
             if runtime:
+                secret_api = dataflow_config.get_config_value("auth", "secret_ui_api")
                 query_params["runtime"] = runtime
-            if slug:
                 query_params["slug"] = slug
+                query_params["org_id"] = org_id
+            else:
+                secret_api = dataflow_config.get_config_value("auth", "secret_manager_api")
+            if not secret_api:
+                print("[Dataflow.secret] Secret API Unreachable")
+                return None
 
             response = requests.get(secret_api, params=query_params)
-            
-            # Handle different HTTP status codes gracefully
+
             if response.status_code == 404:
-                return None  # Secret not found
+                return None
             elif response.status_code >= 500:
-                response.raise_for_status()  # Let server errors propagate
+                response.raise_for_status()
             elif response.status_code >= 400:
                 print(f"[Dataflow.secret] Client error {response.status_code} for secret '{secret_name}'")
                 return None
@@ -214,31 +193,29 @@ class Dataflow:
             host_name = os.environ["HOSTNAME"]
             runtime = os.environ.get("RUNTIME")
             slug = os.environ.get("SLUG")
-            
+            org_id = os.environ.get("ORGANIZATION")
+
             dataflow_config = ConfigurationManager('/dataflow/app/auth_config/dataflow_auth.cfg')
-            if runtime:
-                connection_api = dataflow_config.get_config_value("auth", "connection_ui_api")
-            elif host_name:
-                connection_api = dataflow_config.get_config_value("auth", "connection_manager_api")
-            else:
-                raise Exception("Cannot run dataflow methods here! HOSTNAME or RUNTIME env variable not set.")
-            
             query_params = {
                 "conn_id": conn_id
             }
 
             if runtime:
                 query_params["runtime"] = runtime
-            if slug:
+                query_params["org_id"] = org_id
                 query_params["slug"] = slug
+                connection_api = dataflow_config.get_config_value("auth", "connection_ui_api")
+            elif host_name:
+                connection_api = dataflow_config.get_config_value("auth", "connection_manager_api")
+            else:
+                raise Exception("Cannot run dataflow methods here! HOSTNAME or RUNTIME env variable not set.")
 
             response = requests.get(connection_api, params=query_params)
             
-            # Handle different HTTP status codes gracefully
             if response.status_code == 404:
                 raise RuntimeError(f"[Dataflow.connection] Connection '{conn_id}' not found!")
             elif response.status_code >= 500:
-                response.raise_for_status()  # Let server errors propagate
+                response.raise_for_status()
             elif response.status_code >= 400:
                 raise RuntimeError(f"[Dataflow.connection] Client error {response.status_code} for connection '{conn_id}'")
             elif response.status_code != 200:
@@ -306,20 +283,20 @@ class Dataflow:
             host_name = os.environ.get("HOSTNAME", "")
             runtime = os.environ.get("RUNTIME")
             slug = os.environ.get("SLUG")
+            org_id = os.environ.get("ORGANIZATION")
 
             dataflow_config = ConfigurationManager('/dataflow/app/auth_config/dataflow_auth.cfg')
-            if runtime and slug:
-                variableorsecret_api = dataflow_config.get_config_value("auth", "variableorsecret_ui_api")
-                query_params = {
-                    "key": key,
-                    "runtime": runtime,
-                    "slug": slug
+            query_params = {
+                    "key": key
                 }
+            
+            if runtime:
+                variableorsecret_api = dataflow_config.get_config_value("auth", "variableorsecret_ui_api")
+                query_params["runtime"] = runtime
+                query_params["slug"] = slug
+                query_params["org_id"] = org_id
             elif host_name:
                 variableorsecret_api = dataflow_config.get_config_value("auth", "variableorsecret_manager_api")
-                query_params = {
-                    "key": key
-                }
             else:
                 raise Exception("Cannot run dataflow methods here!") 
 
@@ -329,9 +306,8 @@ class Dataflow:
             
             response = requests.get(variableorsecret_api, params=query_params)
             
-            # Handle different HTTP status codes gracefully
             if response.status_code == 404:
-                return None  # Variable/secret not found
+                return None
             elif response.status_code >= 500:
                 response.raise_for_status()  # Let server errors propagate
             elif response.status_code >= 400:

dataflow/environment.py

@@ -6,12 +6,14 @@ from .configuration import ConfigurationManager
 from .utils.logger import CustomLogger
 
 class EnvironmentManager:
-    def __init__(self):
+    def __init__(self, org_id: int = None):
         """Initialize the EnvironmentManager"""
         self.config = ConfigurationManager('/dataflow/app/config/dataflow.cfg')
-        self.env_base_path = self.config.get_config_value('paths', 'env_path')
-        self.env_logs_path = self.config.get_config_value('paths', 'env_logs_path')
-        self.env_version_path = self.config.get_config_value('paths', 'env_versions_path')
+        self.org_id = org_id
+        self.env_sub_path = f"{self.org_id}" if self.org_id is not None else "dataflow"
+        self.env_base_path = os.path.join(self.config.get_config_value('paths', 'env_path'), self.env_sub_path, 'python_envs')
+        self.env_logs_path = os.path.join(self.config.get_config_value('paths', 'env_logs_path'), self.env_sub_path, 'logs')
+        self.env_version_path = os.path.join(self.config.get_config_value('paths', 'env_versions_path'), self.env_sub_path, 'versions')
         self.local_env_logs_path = self.config.get_config_value('paths', 'local_env_logs_path')
         os.makedirs(self.env_version_path, exist_ok=True)
         self.logger = CustomLogger().get_logger(__name__)
@@ -334,10 +336,9 @@ class EnvironmentManager:
         """
         versioned_name = f"{env_name}_v{env_version}"
         log_file_name = f"envlog_{versioned_name}.log"
-        log_file_dir = self.config.get_config_value('paths', 'env_logs_path')
-        os.makedirs(log_file_dir, exist_ok=True)
-        log_file_location = os.path.join(log_file_dir, log_file_name)
-        
+        os.makedirs(self.env_logs_path, exist_ok=True)
+        log_file_location = os.path.join(self.env_logs_path, log_file_name)
+
         # Clear log file if it exists
         if os.path.exists(log_file_location):
             open(log_file_location, "w").close()
@@ -394,8 +395,14 @@ class EnvironmentManager:
         Returns:
             JobLogs: The created or updated job entry
         """
-        job = db.query(JobLogs).filter(JobLogs.log_file_name == log_file_name).first()
-
+        job = (
+            db.query(JobLogs)
+            .filter(
+                JobLogs.log_file_name == log_file_name,
+                JobLogs.org_id == self.org_id if self.org_id is not None else JobLogs.org_id.is_(None)
+            )
+            .first()
+        )
         if job:
             if job.status == "success":
                 self.logger.error(f"Job with log_file_name '{log_file_name}' already completed successfully.")
@@ -409,6 +416,7 @@ class EnvironmentManager:
                 log_file_name=log_file_name,
                 log_file_location=log_file_location,
                 created_by=user_name,
+                org_id=self.org_id if self.org_id else None,
                 status="in_progress"
             )
             db.add(job)
@@ -464,7 +472,8 @@ class EnvironmentManager:
             env_status = "Draft" if status == "success" else "Failed"
 
             db.query(Environment).filter(
-                Environment.short_name == env_short_name
+                Environment.short_name == env_short_name,
+                Environment.org_id == self.org_id if self.org_id is not None else Environment.org_id.is_(None)
             ).update({"version": version, "pip_libraries": pip_libraries, "conda_libraries": conda_libraries, "status": env_status})
             db.commit()
 

dataflow/models/__init__.py

@@ -1,7 +1,7 @@
 # init for loading models in the application
 
 from .role import Role
-from .user import User
+from .user import User, UserOnboarding, OnboardingStatus
 from .team import Team
 from .environment import (Environment, LocalEnvironment, ArchivedEnvironment, JobLogs)
 from .project_details import ProjectDetails
@@ -22,4 +22,6 @@ from .recent_project_studio import RecentProjectStudio
 from .connection import Connection
 from .git_ssh import GitSSH
 from .pod_activity import PodActivity
-from .pod_session_history import PodSessionHistory
+from .pod_session_history import PodSessionHistory
+from .organization import Organization, OrganizationOnboarding
+from .org_associations import OrganizationServer, OrganizationUser, OrganizationAppType

dataflow/models/app_types.py

@@ -1,10 +1,15 @@
 from sqlalchemy import Column, Integer, String, Boolean
+from sqlalchemy.orm import relationship
 from dataflow.db import Base
 
 class AppType(Base):
-    __tablename__ = "RUNTIME_APP_TYPE"
+    __tablename__ = "APP_TYPE"
     
     id = Column(Integer, primary_key=True, autoincrement=True, unique=True)
     name = Column(String, unique=True, nullable=True)
     display_name = Column(String, nullable=False)
-    code_based = Column(Boolean, nullable=False)
+    code_based = Column(Boolean, nullable=False)
+    studio = Column(Boolean, nullable=False, default=False)
+    runtime = Column(Boolean, nullable=False, default=False)
+
+    organizations = relationship("Organization", secondary="ORGANIZATION_APP_TYPE", back_populates="apps")

dataflow/models/connection.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, String, Integer, Boolean, DateTime, UniqueConstraint
+from sqlalchemy import Column, String, Integer, Boolean, DateTime, UniqueConstraint, ForeignKey
 from sqlalchemy.sql import func
 from dataflow.db import Base
 
@@ -10,6 +10,7 @@ class Connection(Base):
 
     id = Column(Integer, primary_key=True, index=True)
     conn_id = Column(String, index=True, nullable=False)
+    org_id = Column(Integer, ForeignKey("ORGANIZATION.id"), index=True, nullable=False)
     description = Column(String, nullable=True)
     conn_type = Column(String, nullable=False)
     runtime = Column(String, nullable=True)
@@ -21,5 +22,5 @@ class Connection(Base):
     is_active = Column(Boolean, default=True)
     
     __table_args__ = (
-        UniqueConstraint('conn_id', 'runtime', 'slug', 'is_active', 'created_by', name='uq_active_conn_with_runtime_slug'),
+        UniqueConstraint('conn_id', 'org_id', 'runtime', 'slug', 'is_active', 'created_by', name='uq_active_conn_with_runtime_slug'),
     )

dataflow/models/dataflow_zone.py

@@ -8,9 +8,8 @@ class DataflowZone(Base):
     id = Column(Integer, primary_key=True, autoincrement=True)
     slug = Column(String, unique=True, nullable=False)
     display_name = Column(String, nullable=False)
-    is_runtime = Column(Boolean, default=False)
+    is_runtime = Column(Boolean, default=False) 
     subdomain = Column(String)
-    spark_enabled = Column(Boolean, default=False)
     display_order = Column(Integer, default=0)
 
     role_zone_assocs = relationship("RoleZone", back_populates="zone")

dataflow/models/environment.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, Integer, String, Boolean, Text, ForeignKey, DateTime
+from sqlalchemy import Column, Integer, String, Boolean, Text, ForeignKey, DateTime, UniqueConstraint
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 from datetime import datetime, timezone
@@ -16,7 +16,7 @@ class EnvironmentAttributes(Base):
     enabled = Column(Boolean, default=True)
     version = Column(String, default=0)
     is_latest = Column(Boolean, default=True)
-    base_env_id = Column(Integer, default=None)
+    base_env_id = Column(Integer, nullable=True)
     short_name = Column(String(5))
     status = Column(String, default="Saved")
     icon = Column(String)
@@ -27,16 +27,15 @@ class EnvironmentAttributes(Base):
     r_requirements = Column(Text)
     created_date = Column(DateTime, server_default=func.now())
     created_by = Column(String)
-
-
+    org_id = Column(Integer, ForeignKey('ORGANIZATION.id'))
 
 class Environment(EnvironmentAttributes): 
     __tablename__ = 'ENVIRONMENT'
-
+    __table_args__ = (UniqueConstraint('short_name', 'org_id', name='_env_short_name_org_uc'),)
     id = Column(Integer, primary_key=True, autoincrement=True)
-    short_name = Column(String(5), unique=True)
 
-    # Relationship with ArchivedEnvironment
+    # Relationships
+    organization = relationship("Organization", back_populates="environments")
     archived_versions = relationship("ArchivedEnvironment", back_populates="original_environment")
 
 class ArchivedEnvironment(EnvironmentAttributes):
@@ -44,23 +43,22 @@ class ArchivedEnvironment(EnvironmentAttributes):
 
     id = Column(Integer, primary_key=True, autoincrement=True)
     original_env_id = Column(Integer, ForeignKey('ENVIRONMENT.id', ondelete='CASCADE'))
-    is_latest = Column(Boolean, default=False) 
 
     # Relationship with Environment
     original_environment = relationship("Environment", back_populates="archived_versions")
 
-
-
 class JobLogs(Base):
     __tablename__ = "JOB_LOG"
+    __table_args__ = (UniqueConstraint('log_file_name', 'org_id', name='_job_log_file_org_uc'),)
 
     id = Column(Integer, primary_key=True, index=True)
     created_at = Column(DateTime, default=datetime.now)
     completed_at = Column(DateTime, nullable=True)
-    log_file_name = Column(String, unique=True, nullable=False)
+    log_file_name = Column(String, nullable=False)
     log_file_location = Column(String, nullable=False)
     status = Column(String)
     created_by = Column(String)
+    org_id = Column(Integer, ForeignKey('ORGANIZATION.id', ondelete='CASCADE'))
 
 
 class LocalEnvironment(Base):
@@ -69,14 +67,15 @@ class LocalEnvironment(Base):
     id = Column(Integer, primary_key=True, autoincrement=True)
     name = Column(String, nullable=False, index=True)
     user_name = Column(String, ForeignKey('USER.user_name', ondelete='CASCADE'), nullable=False, index=True)
+    org_id = Column(Integer, ForeignKey('ORGANIZATION.id', ondelete='CASCADE'), nullable=False, index=True)
     py_version = Column(String)
     pip_libraries = Column(Text)
     conda_libraries = Column(Text)
     status = Column(String, default="Created")
-    cloned_from = Column(String, ForeignKey('ENVIRONMENT.short_name', ondelete='SET NULL'), nullable=True)
+    cloned_from = Column(String, nullable=True)
     updated_at = Column(DateTime, default=datetime.now(timezone.utc), onupdate=datetime.now(timezone.utc))
     need_refresh = Column(Boolean, default=False)
 
 class EnvType(str, Enum):
     dataflow = "dataflow"
-    local = "local"
+    local = "local"

dataflow/models/git_ssh.py

@@ -8,11 +8,12 @@ class GitSSH(Base):
 
     id = Column(Integer, primary_key=True, index=True, autoincrement=True)
     user_name = Column(String, ForeignKey('USER.user_name', ondelete="CASCADE"), nullable=False)
+    org_id = Column(Integer, ForeignKey("ORGANIZATION.id"), index=True, nullable=False)
     description = Column(String)
     key_name = Column(String, nullable=False)
     created_date = Column(DateTime, server_default=func.now(), nullable=False)
     last_used_date = Column(DateTime)
 
     __table_args__ = (
-        UniqueConstraint(user_name, key_name, name='user_name_key_name_unique'),
+        UniqueConstraint(user_name, key_name, org_id, name='user_name_key_name_org_id_unique'),
     )

dataflow/models/org_associations.py

@@ -0,0 +1,38 @@
+from sqlalchemy import Column , Integer, String, Boolean, ForeignKey, UniqueConstraint, Enum
+from sqlalchemy.orm import relationship
+from dataflow.db import Base
+import enum
+from dataflow.models.environment import EnvType
+
+class OrganizationUser(Base):
+    """
+    Association Table between USER, ROLE, and ORGANIZATION
+    """
+    __tablename__ = "ORGANIZATION_USER"
+    __table_args__ = (UniqueConstraint('org_id', 'user_id', name='uq_org_user'),)
+
+    org_id = Column(Integer, ForeignKey('ORGANIZATION.id', ondelete="CASCADE"), primary_key=True, nullable=False)
+    user_id = Column(Integer, ForeignKey('USER.user_id', ondelete="CASCADE"), primary_key=True, nullable=False)
+    role_id = Column(Integer, ForeignKey('ROLE.id', ondelete="SET NULL"))
+    active_env_short_name = Column(String, nullable=True)
+    active_env_type = Column(Enum(EnvType), nullable=True)
+    active_server_id = Column(Integer, ForeignKey('CUSTOM_SERVER.id', ondelete="SET NULL"))
+    show_server_page = Column(Boolean, default=True)
+    monthly_allocation = Column(Integer, default=0)
+
+    # Relationships
+    user = relationship("User", back_populates="org_user_assocs")
+    role = relationship("Role", back_populates="org_user_assocs")
+    organization = relationship("Organization", back_populates="org_user_assocs")
+
+class OrganizationServer(Base):
+    __tablename__ = "ORGANIZATION_SERVER"
+
+    org_id = Column(Integer, ForeignKey('ORGANIZATION.id', ondelete="CASCADE"), primary_key=True, nullable=False)
+    server_id = Column(Integer, ForeignKey('SERVER_CONFIG.id', ondelete="CASCADE"), primary_key=True, nullable=False)
+
+class OrganizationAppType(Base):
+    __tablename__ = "ORGANIZATION_APP_TYPE"
+
+    org_id = Column(Integer, ForeignKey('ORGANIZATION.id', ondelete="CASCADE"), primary_key=True, nullable=False)
+    app_type_id = Column(Integer, ForeignKey('APP_TYPE.id', ondelete="CASCADE"), primary_key=True, nullable=False)

dataflow/models/organization.py

@@ -0,0 +1,79 @@
+from sqlalchemy import (
+    Column, Integer, String, Enum, DateTime, ForeignKey, Index
+)
+import uuid, enum
+from sqlalchemy.dialects.postgresql import JSONB, UUID
+from sqlalchemy.sql import func
+from sqlalchemy.orm import relationship
+from datetime import datetime
+from dataflow.db import Base
+
+
+class Organization(Base):
+    """
+    Organization model for the database.
+    """
+    __tablename__ = "ORGANIZATION"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    uid = Column(UUID(as_uuid=True), default=uuid.uuid4, nullable=False, unique=True) 
+    name = Column(String(255), nullable=False, unique=True)
+    invite_code = Column(String(64), nullable=False, unique=True)
+    email_domain = Column(String(255), nullable=False, unique=True)
+    spark_enabled_zones = Column(JSONB, default=func.json([]))  # List of zone IDs where Spark is enabled
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    # Association object link
+    org_user_assocs = relationship("OrganizationUser", back_populates="organization", cascade="all, delete-orphan")
+    custom_servers = relationship("CustomServerConfig")
+    onboarding_requests = relationship("UserOnboarding", back_populates="organization", cascade="all, delete-orphan")
+    servers = relationship("ServerConfig", secondary="ORGANIZATION_SERVER", back_populates="organizations")
+    apps = relationship("AppType", secondary="ORGANIZATION_APP_TYPE", back_populates="organizations")
+    roles = relationship("Role", cascade="all, delete-orphan")
+    environments = relationship("Environment", back_populates="organization")
+
+class OnboardingStatus(enum.Enum):
+    pending = 'pending'
+    rejected = 'rejected'
+    accepted = 'accepted'
+
+class OrganizationOnboarding(Base):
+    __tablename__ = 'ORGANIZATION_ONBOARDING'
+    # This prevents an org from having more than one active ('pending' or 'accepted') application
+    # while allowing multiple 'rejected' entries.
+    __table_args__ = (
+        Index(
+            'idx_pending_org_application',
+            'name',
+            unique=True,
+            postgresql_where=Column('status').in_([
+                OnboardingStatus.pending.value,
+                OnboardingStatus.accepted.value
+            ])
+        ),
+    )
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+
+    name = Column(String(255), nullable=False)
+    age = Column(Integer, nullable=True)
+    domain = Column(String(255), nullable=True)
+    no_of_employees = Column(String(50), nullable=True)
+    address = Column(String(500), nullable=True)
+
+    admin_first_name = Column(String(100), nullable=False)
+    admin_last_name = Column(String(100), nullable=True)
+    admin_designation = Column(String(100), nullable=False)
+    admin_email = Column(String(255), nullable=False, unique=True)
+    admin_username = Column(String(100), nullable=False, unique=True)
+    admin_password = Column(String(255), nullable=False)
+
+    # New fields
+    discovery_source = Column(String(255), nullable=True)
+    additional_info = Column(String(1000), nullable=True)
+    size_of_data = Column(String(100), nullable=True)
+
+    user_id = Column(Integer, ForeignKey('USER.user_id'), nullable=False)
+    status = Column(Enum(OnboardingStatus), default=OnboardingStatus.pending, nullable=False)
+
+    user = relationship("User", back_populates="organization_onboarding")

dataflow/models/project_details.py

@@ -1,23 +1,25 @@
-from sqlalchemy import Column, String, Enum, DateTime, Integer, func, ForeignKey
+from sqlalchemy import Column, String, Enum, DateTime, Integer, func, ForeignKey, UniqueConstraint
 from sqlalchemy.orm import relationship
 from dataflow.db import Base
 
 class ProjectDetails(Base):
     __tablename__ = "PROJECT_DETAIL"
+    __table_args__ = (UniqueConstraint('org_id', 'slug', name='uq_project_org_slug'),)
     
     project_id = Column(Integer, primary_key=True, autoincrement=True)
     project_name = Column(String, nullable=False)
     git_url = Column(String)
     git_branch = Column(String, nullable=True)
     git_folder = Column(String, nullable=True)
-    type = Column(String, ForeignKey('RUNTIME_APP_TYPE.name', ondelete="CASCADE"), nullable=False)
-    slug = Column(String, nullable=False, unique=True)
+    type = Column(String, ForeignKey('APP_TYPE.name'), nullable=False)
+    slug = Column(String, nullable=False)
     runtime = Column(String, nullable=False)
-    py_env = Column(String, nullable=True)
+    py_env = Column(Integer, nullable=True)
     launch_url = Column(String, nullable=True)  
     status = Column(Enum("pending", "created" ,"deployed", "stopped", "failed", name="deployment_status"), default="created")
     last_deployed = Column(DateTime, nullable=True)
     created_at = Column(DateTime, nullable=False, server_default=func.now())
     created_by = Column(String, nullable=False)
+    org_id = Column(Integer, ForeignKey('ORGANIZATION.id', ondelete='CASCADE'), nullable=False)
 
-    app_type = relationship("AppType")
+    app_type = relationship("AppType")

dataflow/models/role.py

@@ -1,5 +1,5 @@
 """models.py"""
-from sqlalchemy import Column, Integer, String, Enum
+from sqlalchemy import Column, Integer, String, Enum, ForeignKey, UniqueConstraint
 from sqlalchemy.orm import relationship
 from dataflow.db import Base
 import enum
@@ -11,19 +11,25 @@ class BaseRoleField(enum.Enum):
 
 class Role(Base):
     """
-    Table Role
+    Table ROLE
     """
 
     __tablename__='ROLE'
+    __table_args__ = (
+        UniqueConstraint('name', 'org_id', name='uq_role_name_org'),
+    )
 
     id = Column(Integer, primary_key=True, index=True, autoincrement=True, nullable=False)
-    name = Column(String, unique=True, nullable=False)
+    name = Column(String, nullable=False)
+    org_id = Column(Integer, ForeignKey('ORGANIZATION.id'))
     description = Column(String, nullable=True)
     base_role = Column(Enum(BaseRoleField), nullable=False, default=BaseRoleField.user)
 
-    users = relationship("User", back_populates="role_details", cascade="all, delete-orphan")
-    role_server_assocs = relationship("RoleServer", back_populates="role")
+    # Relationships
     role_zone_assocs = relationship("RoleZone", back_populates="role")
+    org_user_assocs = relationship("OrganizationUser", back_populates="role", cascade="all, delete-orphan")
+    organization = relationship("Organization", back_populates="roles")
+    servers = relationship("CustomServerConfig", secondary="ROLE_SERVER", back_populates="roles")
 
     def __repr__(self):
         return f"<Role(id={self.id}, name='{self.name}', base_role='{self.base_role}')>"

dataflow/models/role_server.py

@@ -5,10 +5,7 @@ from dataflow.db import Base
 
 class RoleServer(Base):
     __tablename__ = 'ROLE_SERVER'
-    __table_args__ = (UniqueConstraint('role_id', 'server_id', name='_role_server_uc'),)
+    __table_args__ = (UniqueConstraint('role_id', 'custom_server_id', name='_role_server_uc'),)
 
     role_id = Column(Integer, ForeignKey('ROLE.id', ondelete="CASCADE"), nullable=False, primary_key=True)
-    server_id = Column(Integer, ForeignKey('CUSTOM_SERVER.id', ondelete="CASCADE"), nullable=False, primary_key=True)
-
-    role = relationship("Role", back_populates="role_server_assocs")
-    server = relationship("CustomServerConfig", back_populates="role_server_assocs")
+    custom_server_id = Column(Integer, ForeignKey('CUSTOM_SERVER.id', ondelete="CASCADE"), nullable=False, primary_key=True)

dataflow/models/server_config.py

@@ -19,15 +19,19 @@ class ServerConfig(Base):
     description = Column(Text, nullable=True)
     kubespawner_override = Column(JSONB, default=func.json({}))
 
+    # Relationships
+    organizations = relationship("Organization", secondary="ORGANIZATION_SERVER", back_populates="servers")
 
 class CustomServerConfig(Base):
     __tablename__ = "CUSTOM_SERVER"
 
     id = Column(Integer, primary_key=True, autoincrement=True)
     base_server_id = Column(Integer, ForeignKey(ServerConfig.id, ondelete="CASCADE"), nullable=False)
+    org_id = Column(Integer, ForeignKey('ORGANIZATION.id'), nullable=False)
     display_name = Column(String, nullable=False, unique=True, index=True)
     description = Column(Text, nullable=True)
     
     # Relationship to the server_config table
     server_config = relationship(ServerConfig)
-    role_server_assocs = relationship("RoleServer", back_populates="server", cascade="all, delete-orphan")
+    organization = relationship("Organization", back_populates="custom_servers")
+    roles = relationship("Role", secondary="ROLE_SERVER", back_populates="servers")

dataflow/models/team.py

@@ -1,5 +1,5 @@
 """models.py"""
-from sqlalchemy import Column, Integer, String
+from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint
 from sqlalchemy.orm import relationship
 from dataflow.db import Base
 
@@ -9,9 +9,15 @@ class Team(Base):
     """
 
     __tablename__='TEAM'
+    __table_args__ = (
+        UniqueConstraint('team_name', 'org_id', name='uc_team_name_org_id'),
+    )
 
     team_id = Column(Integer, primary_key=True, index=True, autoincrement=True, nullable=False)
-    team_name = Column(String, unique=True, nullable=False)
+    team_name = Column(String, nullable=False)
+    org_id = Column(Integer, ForeignKey('ORGANIZATION.id', ondelete="CASCADE"), nullable=False)
     description = Column(String, nullable=True)
-    
-    user_team_assocs = relationship("UserTeam", back_populates="team")
+
+    # relationships
+    users = relationship("User", secondary="USER_TEAM", back_populates="teams")
+    organization = relationship("Organization")

dataflow/models/user.py

@@ -1,31 +1,68 @@
 """models.py"""
-from sqlalchemy import Column, Integer, String, Boolean, LargeBinary, ForeignKey
+from sqlalchemy import Column, Integer, String, Boolean, LargeBinary, Enum, ForeignKey, DateTime, func
+from sqlalchemy.dialects.postgresql import ENUM
+from sqlalchemy import Index
 from sqlalchemy.orm import relationship
 from dataflow.db import Base
+import enum
 
 class User(Base):
     """
     Table USER
     """
-
-    __tablename__='USER'
+    __tablename__ = 'USER'
 
     user_id = Column(Integer, primary_key=True, index=True, autoincrement=True, nullable=False)
     user_name = Column(String, unique=True, nullable=False)
     first_name = Column(String)
     last_name = Column(String)
     email = Column(String, unique=True)
-    role_id = Column(Integer, ForeignKey('ROLE.id'), nullable=False)
     image = Column(LargeBinary)
     image_url = Column(String, nullable=True)
     active = Column(Boolean, nullable=False, default=True)
     password = Column(String, nullable=False)
-    active_env = Column(String)
-    active_env_type = Column(String, nullable=True)
-    current_server = Column(String)
-    show_server_page = Column(Boolean, default = True)
-    monthly_allocation = Column(Integer, nullable=True, default=0)
+    active_org_id = Column(Integer, ForeignKey('ORGANIZATION.id'))
+
+    # Relationships
+    org_user_assocs = relationship("OrganizationUser", back_populates="user", cascade="all, delete-orphan")
+    teams = relationship("Team", secondary="USER_TEAM", back_populates="users")
+    onboarding_requests = relationship("UserOnboarding", back_populates="user", cascade="all, delete-orphan")
+    organization_onboarding = relationship("OrganizationOnboarding", back_populates="user", cascade="all, delete-orphan")
+
+
+class OnboardingStatus(enum.Enum):
+    pending = 'pending'
+    rejected = 'rejected'
+    accepted = 'accepted'
+
+class UserOnboarding(Base):
+    """
+    SQLAlchemy model for the "USER_ONBOARDING" table.
+    This table stores user applications to organizations.
+    """
+    __tablename__ = "USER_ONBOARDING"
+    # This prevents a user from having more than one active ('pending' or 'accepted') application
+    # for a given organization, while allowing multiple 'rejected' entries.
+    __table_args__ = (
+        Index(
+            'idx_pending_user_org_application',
+            'user_id',
+            'org_id',
+            unique=True,
+            postgresql_where=Column('status').in_([
+                OnboardingStatus.pending.value,
+                OnboardingStatus.accepted.value
+            ])
+        ),
+    )
 
-    role_details = relationship("Role")
+    id = Column(Integer, primary_key=True, autoincrement=True, nullable=False)
+    user_id = Column(Integer, ForeignKey("USER.user_id", ondelete="CASCADE"), nullable=False)
+    org_id = Column(Integer, ForeignKey("ORGANIZATION.id", ondelete="CASCADE"), nullable=False)
+    status = Column(Enum(OnboardingStatus, name='onboarding_status'), nullable=False, default=OnboardingStatus.pending.value)
+    created_at = Column(DateTime, default=func.now(), nullable=False)
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now(), nullable=False)
 
-    user_team_assocs = relationship("UserTeam", back_populates="user")
+    # Relationships
+    user = relationship("User", back_populates="onboarding_requests")
+    organization = relationship("Organization", back_populates="onboarding_requests")

dataflow/models/user_team.py

@@ -8,7 +8,4 @@ class UserTeam(Base):
     __table_args__ = (UniqueConstraint('user_id', 'team_id', name='_user_team_uc'),)
 
     user_id = Column(Integer, ForeignKey('USER.user_id', ondelete="CASCADE"), nullable=False, primary_key=True)
-    team_id = Column(Integer, ForeignKey('TEAM.team_id', ondelete="CASCADE"), nullable=False, primary_key=True)
-
-    user = relationship("User", back_populates="user_team_assocs")
-    team = relationship("Team", back_populates="user_team_assocs")
+    team_id = Column(Integer, ForeignKey('TEAM.team_id', ondelete="CASCADE"), nullable=False, primary_key=True)

dataflow/models/variables.py

@@ -14,7 +14,8 @@ class Variable(Base):
     __tablename__ = 'VARIABLE'
 
     id = Column(Integer, primary_key=True, index=True, autoincrement=True, nullable=False)
-    key = Column(String, nullable=False)
+    key = Column(String, index=True, nullable=False)
+    org_id = Column(Integer, ForeignKey("ORGANIZATION.id"), index=True, nullable=False)
     value = Column(Text, nullable=False)
     type = Column(String, nullable=False)
     description = Column(Text, nullable=True)
@@ -30,5 +31,5 @@ class Variable(Base):
 
     __table_args__ = (
         CheckConstraint(type.in_(['variable', 'secret']), name='check_variable_type'),
-        UniqueConstraint('key', 'runtime', 'slug', 'created_by', name='unique_key'),
+        UniqueConstraint('key', 'org_id', 'runtime', 'slug', 'created_by', name='unique_key'),
     )

dataflow/secrets_manager/service.py

@@ -117,27 +117,29 @@ class _BaseAccessor(ABC):
 # These classes implement the logic for building the vault path based on the context.
 # --------------------------------------------------------------------------
 class _RuntimeAccessor(_BaseAccessor):
-    def __init__(self, secret_manager: SecretManager, runtime_env: str, slug: str = None):
+    def __init__(self, secret_manager: SecretManager, org_id: str, runtime_env: str, slug: str = None):
         super().__init__(secret_manager)
+        self.org_id = org_id
         self.runtime_env = runtime_env
         self.slug = slug
 
     def _get_vault_path(self, secret_type: str, key: str) -> str:
         # Special case for git-ssh in runtime context
         if secret_type == "git-ssh":
-            return f"{self.runtime_env}-{secret_type}-{self.slug}"
+            return f"{self.org_id}-{self.runtime_env}-{secret_type}-{self.slug}"
 
         # Standard format for all other secret types
         context = self.slug if self.slug else "global"
-        return f"{self.runtime_env}-{context}-{secret_type}-{key}"
+        return f"{self.org_id}-{self.runtime_env}-{context}-{secret_type}-{key}"
 
 class _StudioAccessor(_BaseAccessor):
-    def __init__(self, secret_manager: SecretManager, user_name: str):
+    def __init__(self, secret_manager: SecretManager, org_id: str, user_name: str):
         super().__init__(secret_manager)
+        self.org_id = org_id
         self.user_name = user_name
 
     def _get_vault_path(self, secret_type: str, key: str) -> str:
-        return f"{self.user_name}-{secret_type}-{key}"
+        return f"{self.org_id}-{self.user_name}-{secret_type}-{key}"
 
 # --------------------------------------------------------------------------
 # PUBLIC INTERFACE CLASS
@@ -147,10 +149,10 @@ class SecretsService:
     def __init__(self, secret_manager: SecretManager):
         self._secret_manager = secret_manager
 
-    def runtime(self, env: str, slug: str = None) -> _RuntimeAccessor:
+    def runtime(self, org_id: int, env: str, slug: str = None) -> _RuntimeAccessor:
         """Sets the context to RUNTIME and returns the appropriate accessor."""
-        return _RuntimeAccessor(self._secret_manager, env, slug)
+        return _RuntimeAccessor(self._secret_manager, str(org_id), env, slug)
 
-    def studio(self, user: str) -> _StudioAccessor:
+    def studio(self, org_id: int, user: str) -> _StudioAccessor:
         """Sets the context to STUDIO and returns the appropriate accessor."""
-        return _StudioAccessor(self._secret_manager, user)
+        return _StudioAccessor(self._secret_manager, str(org_id), user)

dataflow/utils/get_current_user.py

@@ -1,37 +1,60 @@
-from fastapi import HTTPException, status
+from fastapi import HTTPException
 from sqlalchemy.orm import Session
-from dataflow.models import user as m_user  
-from dataflow.models import session as m_session
+from sqlalchemy import and_
+from dataflow.models import (
+    user as m_user,
+    session as m_session,
+    org_associations as m_org_associations,
+    role as m_role,
+    organization as m_organization
+)
 
 def get_user_from_session(session_id: str, db: Session):
     """
-    Retrieve a user based on session ID.
-    
-    Args:
-        session_id (str): The unique session identifier
-        db (Session): Database session
-        
-    Returns:
-        User: User object if found
-        
-    Raises:
-        HTTPException: If session is invalid or user not found
+    Retrieve user information based on the session ID.
     """
-    session_record = db.query(m_session.Session).filter(m_session.Session.session_id == session_id).first()
-    if not session_record:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid session")
+    user = (
+        db.query(
+            m_user.User,
+            m_org_associations.OrganizationUser.role_id,
+            m_role.Role.name,
+            m_role.Role.base_role,
+            m_org_associations.OrganizationUser.active_server_id,
+            m_org_associations.OrganizationUser.show_server_page,
+            m_org_associations.OrganizationUser.active_env_short_name,
+            m_org_associations.OrganizationUser.active_env_type,
+            m_org_associations.OrganizationUser.monthly_allocation,
+            m_organization.Organization.uid
+        )
+        .join(m_session.Session, m_session.Session.user_id == m_user.User.user_id)
+        .outerjoin(
+            m_org_associations.OrganizationUser,
+            and_(
+                m_org_associations.OrganizationUser.user_id == m_user.User.user_id,
+                m_org_associations.OrganizationUser.org_id == m_user.User.active_org_id
+            )
+        )
+        .outerjoin(m_role.Role, m_role.Role.id == m_org_associations.OrganizationUser.role_id)
+        .outerjoin(
+            m_organization.Organization,
+            m_organization.Organization.id == m_user.User.active_org_id  # join to Organization
+        )
+        .filter(m_session.Session.session_id == session_id)
+        .first()
+    )
 
-    user = db.query(m_user.User).filter(m_user.User.user_id == session_record.user_id).first()
     if not user:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found")
-
-    base_role = user.role_details.base_role
-    role_id = user.role_details.id
-    role_name = user.role_details.name
-    user.base_role = base_role
-    user.role = role_name
-    user.role_id = role_id
-    
-    return user
+        raise HTTPException(status_code=401, detail="Invalid session")
 
+    user_obj, role_id, role_name, base_role, active_server_id, show_server_page, active_env_short_name, active_env_type, monthly_allocation, uid = user
+    user_obj.role_id = role_id
+    user_obj.role = role_name
+    user_obj.base_role = base_role
+    user_obj.current_server_id = active_server_id
+    user_obj.show_server_page = show_server_page
+    user_obj.active_env = active_env_short_name
+    user_obj.active_env_type = active_env_type
+    user_obj.monthly_allocation = monthly_allocation
+    user_obj.org_uid = str(uid)
 
+    return user_obj

{dataflow_core-2.1.15rc1.dist-info → dataflow_core-2.1.15rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataflow-core
-Version: 2.1.15rc1
+Version: 2.1.15rc2
 Summary: Dataflow core package
 Author: Dataflow
 Author-email: 

{dataflow_core-2.1.15rc1.dist-info → dataflow_core-2.1.15rc2.dist-info}/RECORD

@@ -1,37 +1,38 @@
 authenticator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 authenticator/dataflowairflowauthenticator.py,sha256=gEdCiL2yJQ7lYvAwbrjcAkccVMfehoMJldw9eU7cc2s,2243
-authenticator/dataflowhubauthenticator.py,sha256=wI9S-1pcav_WHUL4ibEn-HLhjOtZebQbqXTkcrXXFAA,13463
+authenticator/dataflowhubauthenticator.py,sha256=drs6M9tp0QFLzmj-eNaa6zefKat9cN0cJvwGLrSeYvQ,12531
 authenticator/dataflowsupersetauthenticator.py,sha256=NkAmDaIc-ui-qEolu4xz_UY7P_2g8111hwNjPvAOW1Q,2839
 dataflow/__init__.py,sha256=WTRg8HMpMWSgxYJ9ZGVldx4k07fAbta3mBmZ1hG9mWE,30
 dataflow/configuration.py,sha256=7To6XwH1eESiYp39eqPcswXWwrdBUdPF6xN6WnazOF0,663
 dataflow/database_manager.py,sha256=tJHMuOZ9Muskrh9t4uLRlTuFU0VkHAzoHlGP5DORIC4,899
-dataflow/dataflow.py,sha256=0kPDIpFgrEcK81QYeLQGb-rQTrAH-83gLpn566yvBGA,14004
+dataflow/dataflow.py,sha256=EzeOMtMCqG0WJ0vld6ArKbKNFAmA9sbjBqVJ8sd2sQw,13026
 dataflow/db.py,sha256=73ojGqpCTRVTlPszD73Ozhjih_BI2KTHmazqxxL6iWk,3780
-dataflow/environment.py,sha256=qiyuRRPpVLVWiYccRHXnGyWMr_ZBPWzixAyDtAzxQYE,28277
-dataflow/models/__init__.py,sha256=5Ai-sUHtT1dtc0l4nL1fuwVbx0GcwaGQg_LXqOzWb4c,981
-dataflow/models/app_types.py,sha256=yE_ZB13lhpK7AZ7PyBwnQlf0RlIHYs_-vdMKx7_RMlY,379
+dataflow/environment.py,sha256=7XiSojSIOnMOz5YVk-k6w1yQCKbBTTvUxv5cnn6cqJg,28830
+dataflow/models/__init__.py,sha256=UKaiCxJJLXvWOqZlHmDWr9fTwBncKbnyjSIsPWKvlVI,1167
+dataflow/models/app_types.py,sha256=NMHUHBoGnxYHbtlBVppNqQ6NW2T6pSedmQ6-T4t2JAc,640
 dataflow/models/blacklist_library.py,sha256=B2oi3Z8GcR_glhLAyinFk0W8c9txXvm3uOER6dY-q7I,991
-dataflow/models/connection.py,sha256=_VJL3KuIrm8t4lJmtunIL3-AXF9Yvi5wUolzdR3tE0E,1017
-dataflow/models/dataflow_zone.py,sha256=yFCvQXos5M1cU7ksbVSO338_RkT3hkdw2wr3kCJ_rec,769
-dataflow/models/environment.py,sha256=3W-Pvkuiufjw0MWy9F6uWSd0HDPjRNNJe3TnhpHxcGg,2920
+dataflow/models/connection.py,sha256=Kv0vo4V5z7EBfJUSnXWxKOB-AXPWIte9ttauNdM5lyk,1127
+dataflow/models/dataflow_zone.py,sha256=ScCM7963Rd5G4e4eFQGF0gNeg6abaWEwIgGOqoezfrg,719
+dataflow/models/environment.py,sha256=Pnma45hzDdr5jQ0k6mSAH6eZQGTQWm87AnebovtVBdU,3263
 dataflow/models/environment_status.py,sha256=lvPDNUsUoTW9D97B07aKqJQHRKp4LvPM28pQDMPH1ac,536
-dataflow/models/git_ssh.py,sha256=W15SDypxzGOz_aZkHEnVZ6DIMVsjAsbSIXVIEt2mPYU,694
+dataflow/models/git_ssh.py,sha256=xRkzK8lZ4Fa25zhE3Y9J78BiWv6xtd10YDBNf1XDKXE,797
+dataflow/models/org_associations.py,sha256=Kw1zK-Rg97GBV6U61O5V57sohPTHSchalMDAelo2hUQ,1915
+dataflow/models/organization.py,sha256=SGonZsaGRPu7Z9VLqFE32l68mwLdlki-OLxqdMpHtyU,3353
 dataflow/models/pinned_projects.py,sha256=I-XMQq7__XJJi2lyOdEvQEfhPRz8D6KHA6Cbavbf05o,606
 dataflow/models/pod_activity.py,sha256=4NQplUtckS4d2Uc-Iyi8PfgciblHiExbXo_VTMaukB8,751
 dataflow/models/pod_session_history.py,sha256=-O8DHtH1AtGLntJ1shI6eiciTJGL_vYvG3gfupvr0zY,778
-dataflow/models/project_details.py,sha256=iNb95L3UGjcC_Ws6FiUTDANCUFhYWpnsKraS6rmCyRU,1098
+dataflow/models/project_details.py,sha256=pjunEIjgFW66N7kP23cVtRU37LVOnKaqT8K7WBekAVg,1260
 dataflow/models/recent_project_studio.py,sha256=m12KGCsv453C1ijHjfVD8E7cJ7Og_0N8uc7_9VlfkYw,812
 dataflow/models/recent_projects.py,sha256=OFd5MSRXVRHs9UbvUNoJBBnh9rgsJ0lwE23wm5_Hc5w,321
-dataflow/models/role.py,sha256=0fgLjCx7aETRwCV5SW0-4PQBWzWddWO9a_ObJA14VOY,962
-dataflow/models/role_server.py,sha256=mMcfjsGX1cY8hOAOBBmrZgw8ozdfuvjKJoBlR6F0Kdc,689
+dataflow/models/role.py,sha256=LQoEWSc_Pm79IjNC1uFKGFfkhaZkhI3JSq6Sj6Xrm_g,1266
+dataflow/models/role_server.py,sha256=Qz9VqGSpVGvfLz9_lKITUfkiuR7pmVc8SIIfYrDPDso,547
 dataflow/models/role_zone.py,sha256=uH8JheWyzUWcRECRzYuzdphUAUXeU5zRVA1Bhuz3h9w,772
-dataflow/models/server_config.py,sha256=8ocKT8tPen9tedO8BLPEfkWxUEIHaqvA2L-qEhrFND0,1385
+dataflow/models/server_config.py,sha256=Npf4xP7zQ6eXp9kqwM9Owsm8C0e8Qw6jei2YX5k0in0,1646
 dataflow/models/session.py,sha256=c8TI6qXsM8utzp5vSQtAOXJSbgasnyu-a0qSAvA-rWs,459
-dataflow/models/team.py,sha256=fjkqF0N4PSwSYTgHjEQl9wuC7yumd0iOb5nNFePI6q4,488
-dataflow/models/user.py,sha256=-XEpulg7UAL-WDMyigPasDS61btna2mKtJPsanWA4lw,1108
-dataflow/models/user_environment.py,sha256=yI9NutULcLiwlycuEin6ROe6o1Sjdv_sgw2MEkJFeYg,568
-dataflow/models/user_team.py,sha256=r_fmKvf6JuGgiiI9TXWjVG2QZ3WOvDrOwYWVQ3r8oWo,659
-dataflow/models/variables.py,sha256=thWqX9KbR2x0oBI-bVcW5TV1eKf0TYNxgGmZWTUs2g4,1414
+dataflow/models/team.py,sha256=u5VKOxi-0wGgxssIhXr1Ydn3X9IEAHNWxz029KaVm5g,780
+dataflow/models/user.py,sha256=XSd3PuqMRzm4qglNaUF0S-9RjH_f016eZX4I0iDtq2Q,2856
+dataflow/models/user_team.py,sha256=vD6BsiMfx1iIMQiT8fpwhsQ8AGuPuBO83F22Cy7j-nU,524
+dataflow/models/variables.py,sha256=v6a1r5OgmKOAlyVdmOFM6Axre7DEBEsgrF4yTV5h3U0,1524
 dataflow/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataflow/schemas/connection.py,sha256=ut2sqz06yOjmFKzHry92FEt7DN09Bj30GYse35__Cuw,2467
 dataflow/schemas/git_ssh.py,sha256=N1O7HM6ZbygIBZn2rKvNR0e7IM3ZJMAH6aJtjaghDr0,1283
@@ -42,17 +43,17 @@ dataflow/scripts/update_environment.sh,sha256=2dtn2xlNi6frpig-sqlGE1_IKRbbkqYOCp
 dataflow/secrets_manager/__init__.py,sha256=idGqIDtYl0De2WIK9Obl-N7SDPSYtVM0D-wXfZjCiy4,559
 dataflow/secrets_manager/factory.py,sha256=LblshkGG9q2C3RHYp0QykianUtpOOQz7sBdlerutyWY,2479
 dataflow/secrets_manager/interface.py,sha256=HhrKpQrprWIbDsVfU_qc59OXmSIuHXv106OXv6-Epqc,506
-dataflow/secrets_manager/service.py,sha256=SSWgTXJTAwVPqMIc76cB2hR6nghNVOoMpIN9M0i7Su0,7241
+dataflow/secrets_manager/service.py,sha256=A4PgiSS1bzlzXPi_GvsiepChULqAa5yONGkaU-d5MLM,7419
 dataflow/secrets_manager/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataflow/secrets_manager/providers/aws_manager.py,sha256=16peXyKeuAjv2RVTMUjrzArPYENK9Zu7jREWVgMfScA,8671
 dataflow/secrets_manager/providers/azure_manager.py,sha256=sWOz-7ALnLt6vyM3lt14GBpzpmDnlH3hkdqtuApqkgU,9430
 dataflow/secrets_manager/providers/gcp_manager.py,sha256=AJgotHZRQraxtmfJX1Z8u2Gcr7KJLRJTN_qbth3A5Xk,13738
 dataflow/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataflow/utils/exceptions.py,sha256=8GRFoYZ5dPGQckVm2znaHpPi0ZAs69fK-RGKukEsapk,4432
-dataflow/utils/get_current_user.py,sha256=4nSO3SPVMZhW-MsIgxR3f9ZzrFaIZIuyrM6hvfyE7PQ,1202
+dataflow/utils/get_current_user.py,sha256=iPyUpEpuxitdmFwvaPiRWIlII8JaaGoxUhQcmNWi0vI,2319
 dataflow/utils/logger.py,sha256=7BFrOq5Oiqn8P4XZbgJzMP5O07d2fpdECbbfsjrUuHw,1213
-dataflow_core-2.1.15rc1.dist-info/METADATA,sha256=aRoxdVVfP0yY6qPtPuSH_RGHqxAQ13HCTjLq0UxRnR0,443
-dataflow_core-2.1.15rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dataflow_core-2.1.15rc1.dist-info/entry_points.txt,sha256=ppj_EIbYrJJwCPg1kfdsZk5q1N-Ejfis1neYrnjhO8o,117
-dataflow_core-2.1.15rc1.dist-info/top_level.txt,sha256=SZsUOpSCK9ntUy-3Tusxzf5A2e8ebwD8vouPb1dPt_8,23
-dataflow_core-2.1.15rc1.dist-info/RECORD,,
+dataflow_core-2.1.15rc2.dist-info/METADATA,sha256=t8vhx-r4NQ9rhkLblo_9sZRH1nvOnaYH7UpkqBPUaCw,443
+dataflow_core-2.1.15rc2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dataflow_core-2.1.15rc2.dist-info/entry_points.txt,sha256=ppj_EIbYrJJwCPg1kfdsZk5q1N-Ejfis1neYrnjhO8o,117
+dataflow_core-2.1.15rc2.dist-info/top_level.txt,sha256=SZsUOpSCK9ntUy-3Tusxzf5A2e8ebwD8vouPb1dPt_8,23
+dataflow_core-2.1.15rc2.dist-info/RECORD,,

dataflow/models/user_environment.py

@@ -1,16 +0,0 @@
-from sqlalchemy import Column, Integer, String, DateTime
-from sqlalchemy.sql.schema import ForeignKey
-from sqlalchemy.sql.expression import func
-from dataflow.db import Base
-
-class UserEnvironment(Base):
-    """
-    Table USER_ENVIRONMENT
-    """
-
-    __tablename__ = 'USER_ENVIRONMENT'
-
-    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
-    user_id = Column(Integer, ForeignKey('USER.user_id', ondelete="CASCADE"), nullable=False)
-    env_name = Column(String)
-    timestamp = Column(DateTime, server_default=func.now(), onupdate=func.now())