Upload 80 files

src/create_sample_users.py

@@ -0,0 +1,45 @@
+# src/create_sample_users.py
+import sys
+import os
+
+# Add project root to sys.path to allow imports from src
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+from src.main import app, db
+from src.models.user import User
+
+def create_users():
+    """Creates sample users in the database."""
+    with app.app_context():
+        print("Creating sample users...")
+        
+        # Check if users already exist
+        admin_user = User.query.filter_by(username="admin").first()
+        analyst_user = User.query.filter_by(username="analyst").first()
+
+        if not admin_user:
+            admin = User(username="admin", full_name="Admin User", role="Administrator")
+            admin.set_password("password123") # Use a more secure password in production
+            db.session.add(admin)
+            print("Created admin user (password: password123)")
+        else:
+            print("Admin user already exists.")
+
+        if not analyst_user:
+            analyst = User(username="analyst", full_name="Legal Analyst", role="Analyst")
+            analyst.set_password("testpass") # Use a more secure password in production
+            db.session.add(analyst)
+            print("Created analyst user (password: testpass)")
+        else:
+            print("Analyst user already exists.")
+
+        try:
+            db.session.commit()
+            print("Users committed to database.")
+        except Exception as e:
+            db.session.rollback()
+            print(f"Error creating users: {e}")
+
+if __name__ == "__main__":
+    create_users()
+

src/decorators.py

@@ -0,0 +1,15 @@
+# src/decorators.py
+from functools import wraps
+from flask import session, flash, redirect, url_for, request
+
+def login_required(f):
+    """Decorator to ensure user is logged in before accessing a route."""
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if 'user_id' not in session:
+            flash('Please log in to access this page.', 'warning')
+            # Store the intended destination to redirect after login
+            return redirect(url_for('auth.login', next=request.url))
+        return f(*args, **kwargs)
+    return decorated_function
+

src/extensions.py

@@ -0,0 +1,7 @@
+# src/extensions.py
+from flask_sqlalchemy import SQLAlchemy
+from flask_migrate import Migrate
+
+db = SQLAlchemy()
+migrate = Migrate()
+

src/main.py

@@ -0,0 +1,99 @@
+import os
+import sys
+import re # Import re for nl2br filter
+# DON'T CHANGE THIS !!!
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+from flask import Flask, redirect, url_for, session, request, flash, render_template # Added render_template
+from jinja2 import pass_eval_context # Use pass_eval_context
+from markupsafe import Markup, escape # Import Markup and escape from markupsafe
+from src.extensions import db, migrate # Import from extensions
+from src.decorators import login_required # Import from decorators
+
+# --- Custom Jinja Filter --- 
+_paragraph_re = re.compile(r'\r\n|\r|\n')
+
+@pass_eval_context
+def nl2br(eval_ctx, value):
+    """Converts newlines into <p> and <br />s."""
+    # Ensure value is treated as string before splitting
+    value_str = str(escape(value))
+    result = u'\n\n'.join(u'<p>%s</p>' % p.replace('\n', Markup('<br />\n'))
+                          for p in _paragraph_re.split(value_str))
+    if eval_ctx.autoescape:
+        result = Markup(result)
+    return result
+
+def create_app():
+    """Application Factory Pattern"""
+    app = Flask(__name__, 
+                static_folder=os.path.join(os.path.dirname(__file__), 'static'), 
+                template_folder=os.path.join(os.path.dirname(__file__), 'templates'))
+    
+    # --- Configuration ---
+    app.config['SECRET_KEY'] = os.urandom(24)
+    basedir = os.path.abspath(os.path.dirname(os.path.dirname(__file__))) # Base directory is polisage_app
+    app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'polisage.db')
+    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+
+    # --- Initialize Extensions ---
+    db.init_app(app)
+    migrate.init_app(app, db)
+
+    # --- Register Custom Filters ---
+    app.jinja_env.filters['nl2br'] = nl2br
+
+    # --- Import and Register Blueprints ---
+    # Import blueprints inside the factory function to avoid circular imports
+    from src.routes.auth import auth_bp
+    from src.routes.drafting import drafting_bp
+    from src.routes.amendment import amendment_bp
+    from src.routes.monitoring import monitoring_bp
+    from src.routes.analysis import analysis_bp
+    from src.routes.recommendation import recommendation_bp
+    # Import dashboard blueprint later if created
+    # from src.routes.dashboard import dashboard_bp 
+
+    app.register_blueprint(auth_bp)
+    app.register_blueprint(drafting_bp)
+    app.register_blueprint(amendment_bp)
+    app.register_blueprint(monitoring_bp)
+    app.register_blueprint(analysis_bp)
+    app.register_blueprint(recommendation_bp)
+    # app.register_blueprint(dashboard_bp)
+
+    # --- Import Models (Needed for Flask-Migrate context) ---
+    # Although models are used within routes/extensions, importing them here 
+    # ensures they are known to Flask-Migrate when running commands.
+    with app.app_context():
+        from src.models import user, legislation, draft, amendment, monitoring, analysis, recommendation, cross_reference
+
+    # --- Basic Routes ---
+    @app.route('/')
+    @login_required
+    def index():
+        # Redirect to a default page, e.g., drafts list or a future dashboard
+        return redirect(url_for('drafting.list_drafts'))
+        
+    # Add a simple dashboard route placeholder
+    @app.route('/dashboard')
+    @login_required
+    def dashboard():
+        # Placeholder for a real dashboard
+        username = session.get('username', 'Guest')
+        # Query some basic stats later
+        draft_count = draft.Draft.query.count()
+        analysis_count = analysis.ImpactAnalysis.query.count()
+        rec_count = recommendation.Recommendation.query.count()
+        return render_template('dashboard.html', username=username, draft_count=draft_count, analysis_count=analysis_count, rec_count=rec_count)
+
+    return app
+
+# Create the app instance using the factory
+app = create_app()
+
+# --- Main Execution (for running with 'python src/main.py') ---
+if __name__ == '__main__':
+    # Note: Recommended to run using 'flask run' after setting FLASK_APP=src.main:app
+    app.run(host='0.0.0.0', port=5000, debug=True)
+

src/models/amendment.py

@@ -0,0 +1,17 @@
+from src.extensions import db
+import datetime
+
+class Amendment(db.Model):
+    __tablename__ = 'amendments'
+    id = db.Column(db.Integer, primary_key=True)
+    legislation_id = db.Column(db.Integer, db.ForeignKey('legislation.id'), nullable=False)
+    proposed_changes = db.Column(db.Text, nullable=False)
+    rationale = db.Column(db.Text)
+    status = db.Column(db.String, default='Proposed') # e.g., 'Proposed', 'Review', 'Approved', 'Rejected'
+    author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
+    created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
+    last_updated = db.Column(db.DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
+
+    def __repr__(self):
+        return f'<Amendment {self.id} for Legislation {self.legislation_id}>'
+

src/models/analysis.py

@@ -0,0 +1,22 @@
+from src.extensions import db
+import datetime
+
+class ImpactAnalysis(db.Model):
+    __tablename__ = 'impact_analyses'
+    id = db.Column(db.Integer, primary_key=True)
+    # Using polymorphic association for document_id might be better, but for simplicity:
+    document_id = db.Column(db.Integer, nullable=False) # Can be legislation_id, draft_id, or amendment_id
+    document_type = db.Column(db.String, nullable=False) # 'Legislation', 'Draft', 'Amendment'
+    analysis_type = db.Column(db.String, nullable=False) # e.g., 'Societal', 'Economic', 'Environmental'
+    predicted_impact = db.Column(db.Text)
+    confidence_score = db.Column(db.Float)
+    rationale = db.Column(db.Text)
+    generated_by_user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
+    generated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
+
+    # Add __table_args__ for potential index or constraints if needed later
+    # Example: db.Index('idx_doc_type_id', 'document_type', 'document_id')
+
+    def __repr__(self):
+        return f'<ImpactAnalysis {self.id} for {self.document_type} {self.document_id}>'
+

src/models/cross_reference.py

@@ -0,0 +1,18 @@
+from src.extensions import db
+import datetime
+
+class CrossReference(db.Model):
+    __tablename__ = 'cross_references'
+    id = db.Column(db.Integer, primary_key=True)
+    source_legislation_id = db.Column(db.Integer, db.ForeignKey('legislation.id'), nullable=False)
+    target_legislation_id = db.Column(db.Integer, db.ForeignKey('legislation.id'), nullable=False)
+    relationship_type = db.Column(db.String, nullable=False) # e.g., 'Cites', 'Amends', 'Conflicts With', 'Related To'
+    details = db.Column(db.Text) # Optional: Specific section or context
+    identified_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
+
+    # Prevent duplicate references
+    __table_args__ = (db.UniqueConstraint('source_legislation_id', 'target_legislation_id', 'relationship_type', name='_source_target_rel_uc'),)
+
+    def __repr__(self):
+        return f'<CrossRef {self.id}: {self.source_legislation_id} {self.relationship_type} {self.target_legislation_id}>'
+

src/models/draft.py

@@ -0,0 +1,18 @@
+from src.extensions import db
+import datetime
+
+class Draft(db.Model):
+    __tablename__ = 'drafts'
+    id = db.Column(db.Integer, primary_key=True)
+    title = db.Column(db.String, nullable=False)
+    content = db.Column(db.Text)
+    policy_intent = db.Column(db.Text)
+    status = db.Column(db.String, default='Draft') # e.g., 'Draft', 'Review', 'Approved', 'Rejected'
+    author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
+    related_legislation_id = db.Column(db.Integer, db.ForeignKey('legislation.id')) # Optional
+    created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
+    last_updated = db.Column(db.DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
+
+    def __repr__(self):
+        return f'<Draft {self.id}: {self.title[:50]}>'
+

src/models/legislation.py

@@ -0,0 +1,28 @@
+from src.extensions import db
+import datetime
+
+class Legislation(db.Model):
+    __tablename__ = 'legislation'
+    id = db.Column(db.Integer, primary_key=True)
+    title = db.Column(db.String, nullable=False)
+    full_text = db.Column(db.Text)
+    jurisdiction = db.Column(db.String) # e.g., 'Federal', 'State - CA'
+    type = db.Column(db.String) # e.g., 'Statute', 'Regulation', 'Policy'
+    status = db.Column(db.String, default='Active') # e.g., 'Active', 'Repealed', 'Amended'
+    effective_date = db.Column(db.Date)
+    enactment_date = db.Column(db.Date)
+    source_url = db.Column(db.String)
+    last_updated = db.Column(db.DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
+    created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
+
+    # Relationships
+    drafts = db.relationship('Draft', backref='related_legislation', lazy=True)
+    amendments = db.relationship('Amendment', backref='legislation', lazy=True)
+    monitored_events = db.relationship('MonitoredEvent', backref='related_legislation', lazy=True)
+    recommendations = db.relationship('Recommendation', backref='related_legislation', lazy=True)
+    source_cross_references = db.relationship('CrossReference', foreign_keys='CrossReference.source_legislation_id', backref='source_legislation', lazy=True)
+    target_cross_references = db.relationship('CrossReference', foreign_keys='CrossReference.target_legislation_id', backref='target_legislation', lazy=True)
+
+    def __repr__(self):
+        return f'<Legislation {self.id}: {self.title[:50]}>'
+

src/models/monitoring.py

@@ -0,0 +1,37 @@
+from src.extensions import db
+import datetime
+
+class MonitoringSource(db.Model):
+    __tablename__ = 'monitoring_sources'
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String, nullable=False)
+    url = db.Column(db.String, unique=True, nullable=False)
+    type = db.Column(db.String, nullable=False) # e.g., 'Official Gazette', 'Court Website', 'News Feed', 'RSS'
+    frequency_minutes = db.Column(db.Integer, default=1440) # Default: daily
+    last_checked = db.Column(db.DateTime)
+    is_active = db.Column(db.Boolean, default=True)
+    created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
+
+    # Relationship
+    events = db.relationship('MonitoredEvent', backref='source', lazy=True)
+
+    def __repr__(self):
+        return f'<MonitoringSource {self.id}: {self.name}>'
+
+class MonitoredEvent(db.Model):
+    __tablename__ = 'monitored_events'
+    id = db.Column(db.Integer, primary_key=True)
+    source_id = db.Column(db.Integer, db.ForeignKey('monitoring_sources.id'), nullable=False)
+    detected_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
+    event_summary = db.Column(db.Text, nullable=False)
+    event_details = db.Column(db.Text)
+    relevance_score = db.Column(db.Float) # Estimated relevance (e.g., 0.0 to 1.0)
+    related_legislation_id = db.Column(db.Integer, db.ForeignKey('legislation.id')) # Optional
+    status = db.Column(db.String, default='New') # e.g., 'New', 'Reviewed', 'Actioned'
+
+    # Relationship
+    recommendations = db.relationship('Recommendation', backref='source_event', lazy=True)
+
+    def __repr__(self):
+        return f'<MonitoredEvent {self.id} from Source {self.source_id}>'
+

src/models/recommendation.py

@@ -0,0 +1,17 @@
+from src.extensions import db
+import datetime
+
+class Recommendation(db.Model):
+    __tablename__ = 'recommendations'
+    id = db.Column(db.Integer, primary_key=True)
+    related_legislation_id = db.Column(db.Integer, db.ForeignKey('legislation.id')) # Optional
+    recommendation_type = db.Column(db.String, nullable=False) # e.g., 'Update', 'Consolidate', 'Remove', 'New'
+    recommendation_text = db.Column(db.Text, nullable=False)
+    rationale = db.Column(db.Text)
+    source_event_id = db.Column(db.Integer, db.ForeignKey('monitored_events.id')) # Optional
+    status = db.Column(db.String, default='New') # e.g., 'New', 'Reviewed', 'Implemented', 'Rejected'
+    generated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
+
+    def __repr__(self):
+        return f'<Recommendation {self.id}: {self.recommendation_type}>'
+

src/models/user.py

@@ -0,0 +1,27 @@
+from src.extensions import db
+from werkzeug.security import generate_password_hash, check_password_hash
+import datetime
+
+class User(db.Model):
+    __tablename__ = 'users'
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(80), unique=True, nullable=False)
+    password_hash = db.Column(db.String(128), nullable=False)
+    full_name = db.Column(db.String(120))
+    role = db.Column(db.String(80)) # e.g., 'Legal Director', 'Analyst'
+    created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
+
+    # Relationships (examples, adjust as needed)
+    drafts = db.relationship('Draft', backref='author', lazy=True)
+    amendments = db.relationship('Amendment', backref='author', lazy=True)
+    analyses = db.relationship('ImpactAnalysis', backref='generator', lazy=True)
+
+    def set_password(self, password):
+        self.password_hash = generate_password_hash(password)
+
+    def check_password(self, password):
+        return check_password_hash(self.password_hash, password)
+
+    def __repr__(self):
+        return f'<User {self.username}>'
+