gem 'gophish-ruby'

require 'gophish-ruby'

Gophish.configure do |config|
  config.url = "https://your-gophish-server.com"
  config.api_key = "your-api-key-here"
  config.verify_ssl = true  # Set to false for development/self-signed certificates
  config.debug_output = false  # Set to true to see HTTP debug information
end

# Create a new group with targets
group = Gophish::Group.new(
  name: "Marketing Department",
  targets: [
    {
      first_name: "John",
      last_name: "Doe",
      email: "john.doe@company.com",
      position: "Marketing Manager"
    },
    {
      first_name: "Jane",
      last_name: "Smith",
      email: "jane.smith@company.com",
      position: "Marketing Coordinator"
    }
  ]
)

# Save the group to Gophish
if group.save
  puts "Group created successfully with ID: #{group.id}"
else
  puts "Failed to create group: #{group.errors.full_messages}"
end

# CSV format: First Name,Last Name,Email,Position
csv_data = <<~CSV
  First Name,Last Name,Email,Position
  Alice,Johnson,alice@company.com,Developer
  Bob,Wilson,bob@company.com,Designer
  Carol,Brown,carol@company.com,Manager
CSV

group = Gophish::Group.new(name: "Development Team")
group.import_csv(csv_data)

if group.save
  puts "Group created with #{group.targets.length} targets"
end

# Get all groups
groups = Gophish::Group.all
puts "Found #{groups.length} groups"

# Find a specific group by ID
group = Gophish::Group.find(1)
puts "Group: #{group.name} with #{group.targets.length} targets"

# Update group attributes
group = Gophish::Group.find(1)
group.name = "Updated Group Name"

# Add a single target
new_target = {
  first_name: "New",
  last_name: "User",
  email: "new.user@company.com",
  position: "Intern"
}
group.add_target(new_target)

# Remove a specific target
group.remove_target(new_target)

# Remove a target by email address
group.remove_target_by_email("old.user@company.com")

if group.save
  puts "Group updated successfully"
end

group = Gophish::Group.find(1)
if group.destroy
  puts "Group deleted successfully"
end

# Invalid group (missing required fields)
group = Gophish::Group.new(name: "")

unless group.valid?
  puts "Validation errors:"
  group.errors.full_messages.each { |msg| puts "  - #{msg}" }
end

# Invalid email format
group = Gophish::Group.new(
  name: "Test Group",
  targets: [{
    first_name: "John",
    last_name: "Doe",
    email: "invalid-email",  # Invalid email format
    position: "Manager"
  }]
)

unless group.valid?
  puts group.errors.full_messages
  # => ["Targets item at index 0 must have a valid email format"]
end

# Create a new email template
template = Gophish::Template.new(
  name: "Phishing Awareness Test",
  subject: "Security Update Required",
  html: "<h1>Important Security Update</h1><p>Please click <a href='{{.URL}}'>here</a> to update your password.</p>",
  text: "Important Security Update\n\nPlease visit {{.URL}} to update your password."
)

if template.save
  puts "Template created successfully with ID: #{template.id}"
else
  puts "Failed to create template: #{template.errors.full_messages}"
end

template = Gophish::Template.new(
  name: "Invoice Template",
  subject: "Invoice #12345",
  html: "<p>Please find your invoice attached.</p>"
)

# Add an attachment
file_content = File.read("path/to/invoice.pdf")
template.add_attachment(file_content, "application/pdf", "invoice.pdf")

puts "Template has #{template.attachment_count} attachments"

# Check if template has attachments
if template.has_attachments?
  puts "Template has attachments"
end

# Remove an attachment by name
template.remove_attachment("invoice.pdf")
puts "Attachments remaining: #{template.attachment_count}"

# Import an existing email (.eml file content)
email_content = File.read("path/to/email.eml")

imported_data = Gophish::Template.import_email(
  email_content, 
  convert_links: true  # Convert links to Gophish tracking format
)

# Create template from imported data
template = Gophish::Template.new(imported_data)
template.name = "Imported Email Template"
template.save

# Get all templates
templates = Gophish::Template.all
puts "Found #{templates.length} templates"

# Find a specific template by ID
template = Gophish::Template.find(1)
puts "Template: #{template.name}"

template = Gophish::Template.find(1)
template.subject = "Updated Subject Line"
template.html = "<h1>Updated Content</h1>"

if template.save
  puts "Template updated successfully"
end

template = Gophish::Template.find(1)
if template.destroy
  puts "Template deleted successfully"
end

group = Gophish::Group.find(1)
group.name = "New Name"

# Check if attributes have changed
puts group.changed_attributes  # => ["name"]
puts group.attribute_changed?(:name)  # => true
puts group.attribute_was(:name)  # => "Original Name"

# Create a simple landing page
page = Gophish::Page.new(
  name: "Microsoft Login Page",
  html: <<~HTML
    <!DOCTYPE html>
    <html>
    <head>
      <title>Microsoft Account Login</title>
      <style>
        body { font-family: Arial, sans-serif; margin: 0; padding: 40px; background-color: #f5f5f5; }
        .login-container { max-width: 400px; margin: 0 auto; background: white; padding: 40px; border-radius: 8px; }
        .form-group { margin-bottom: 20px; }
        input { width: 100%; padding: 12px; border: 1px solid #ddd; border-radius: 4px; }
        button { width: 100%; padding: 12px; background: #0078d4; color: white; border: none; border-radius: 4px; }
      </style>
    </head>
    <body>
      <div class="login-container">
        <h2>Sign in to your account</h2>
        <form method="post">
          <div class="form-group">
            <input type="email" name="email" placeholder="Email" required>
          </div>
          <div class="form-group">
            <input type="password" name="password" placeholder="Password" required>
          </div>
          <button type="submit">Sign in</button>
        </form>
      </div>
    </body>
    </html>
  HTML
)

# Save the page to Gophish
if page.save
  puts "Page created successfully with ID: #{page.id}"
else
  puts "Failed to create page: #{page.errors.full_messages}"
end

# Create a page that captures login credentials
page = Gophish::Page.new(
  name: "Banking Login - Credential Capture",
  html: <<~HTML
    <html>
    <body>
      <h1>Online Banking</h1>
      <form method="post">
        <input type="text" name="username" placeholder="Username" required>
        <input type="password" name="password" placeholder="Password" required>
        <button type="submit">Login</button>
      </form>
    </body>
    </html>
  HTML,
  capture_credentials: true,
  capture_passwords: true,
  redirect_url: "https://www.realbank.com/login"
)

if page.save
  puts "Page created with credential capture enabled"
  puts "Captures credentials: #{page.captures_credentials?}"
  puts "Captures passwords: #{page.captures_passwords?}"
  puts "Has redirect: #{page.has_redirect?}"
end

# Import an existing website as a landing page template
begin
  imported_data = Gophish::Page.import_site(
    "https://login.microsoft.com", 
    include_resources: true  # Include CSS, JS, and images
  )
  
  # Create a page from the imported data
  page = Gophish::Page.new(imported_data)
  page.name = "Imported Microsoft Login Page"
  page.capture_credentials = true
  
  if page.save
    puts "Successfully imported and created page from website"
  end
rescue StandardError => e
  puts "Failed to import site: #{e.message}"
end

# Get all pages
pages = Gophish::Page.all
puts "Found #{pages.length} pages"

# Find a specific page by ID
page = Gophish::Page.find(1)
puts "Page: #{page.name}"
puts "HTML length: #{page.html.length} characters"

# Update page content and settings
page = Gophish::Page.find(1)
page.name = "Updated Page Name"
page.capture_credentials = true
page.redirect_url = "https://example.com/success"

# Update HTML content
page.html = page.html.gsub("Sign in", "Login")

if page.save
  puts "Page updated successfully"
end

page = Gophish::Page.find(1)
if page.destroy
  puts "Page deleted successfully"
end

# Invalid page (missing required fields)
page = Gophish::Page.new(name: "", html: "")

unless page.valid?
  puts "Validation errors:"
  page.errors.full_messages.each { |msg| puts "  - #{msg}" }
  # => ["Name can't be blank", "Html can't be blank"]
end

# Check page configuration
page = Gophish::Page.new(
  name: "Test Page",
  html: "<html><body>Test</body></html>",
  capture_credentials: true
)

if page.captures_credentials?
  puts "This page will capture submitted credentials"
end

# Create a basic SMTP profile
smtp = Gophish::Smtp.new(
  name: "Company Mail Server",
  host: "smtp.company.com",
  from_address: "security@company.com"
)

# Save the SMTP profile to Gophish
if smtp.save
  puts "SMTP profile created successfully with ID: #{smtp.id}"
else
  puts "Failed to create SMTP profile: #{smtp.errors.full_messages}"
end

# Create an SMTP profile with username/password authentication
smtp = Gophish::Smtp.new(
  name: "Gmail SMTP",
  host: "smtp.gmail.com",
  from_address: "phishing@company.com",
  username: "smtp_username",
  password: "smtp_password",
  ignore_cert_errors: false
)

if smtp.save
  puts "SMTP profile created with authentication"
  puts "Has authentication: #{smtp.has_authentication?}"
  puts "Ignores cert errors: #{smtp.ignores_cert_errors?}"
end

# Add custom headers to the SMTP profile
smtp = Gophish::Smtp.new(
  name: "Custom Headers SMTP",
  host: "mail.company.com",
  from_address: "security@company.com"
)

# Add headers for email routing and identification
smtp.add_header("X-Mailer", "Company Security Tool")
smtp.add_header("X-Campaign-Type", "Phishing Simulation")
smtp.add_header("Return-Path", "bounces@company.com")

puts "Header count: #{smtp.header_count}"
puts "Has headers: #{smtp.has_headers?}"

# Remove a specific header
smtp.remove_header("X-Campaign-Type")
puts "Headers after removal: #{smtp.header_count}"

# Get all SMTP profiles
smtp_profiles = Gophish::Smtp.all
puts "Found #{smtp_profiles.length} SMTP profiles"

# Find a specific SMTP profile by ID
smtp = Gophish::Smtp.find(1)
puts "SMTP Profile: #{smtp.name} (#{smtp.host})"

# Update SMTP profile settings
smtp = Gophish::Smtp.find(1)
smtp.name = "Updated SMTP Server"
smtp.ignore_cert_errors = true

# Add new headers
smtp.add_header("X-Priority", "1")

if smtp.save
  puts "SMTP profile updated successfully"
end

smtp = Gophish::Smtp.find(1)
if smtp.destroy
  puts "SMTP profile deleted successfully"
end

# Invalid SMTP profile (missing required fields)
smtp = Gophish::Smtp.new(name: "", host: "", from_address: "")

unless smtp.valid?
  puts "Validation errors:"
  smtp.errors.full_messages.each { |msg| puts "  - #{msg}" }
  # => ["Name can't be blank", "Host can't be blank", "From address can't be blank"]
end

# Invalid email format
smtp = Gophish::Smtp.new(
  name: "Test SMTP",
  host: "smtp.test.com",
  from_address: "invalid-email-format"
)

unless smtp.valid?
  puts smtp.errors.full_messages
  # => ["From address must be a valid email format (email@domain.com)"]
end

# Check SMTP configuration
if smtp.has_authentication?
  puts "SMTP uses authentication"
end

if smtp.ignores_cert_errors?
  puts "SMTP ignores certificate errors (not recommended for production)"
end

# Create a basic phishing campaign
campaign = Gophish::Campaign.new(
  name: "Q1 Security Awareness Training",
  template: { name: "Phishing Template" },  # Reference existing template
  page: { name: "Login Page" },             # Reference existing landing page
  groups: [{ name: "Marketing Team" }],     # Reference existing groups
  smtp: { name: "Company SMTP" },           # Reference existing SMTP profile
  url: "https://phishing.company.com"       # Base URL for campaign
)

# Save the campaign to Gophish
if campaign.save
  puts "Campaign created successfully with ID: #{campaign.id}"
  puts "Campaign status: #{campaign.status}"
else
  puts "Failed to create campaign: #{campaign.errors.full_messages}"
end

# Create a campaign with launch and send-by dates
campaign = Gophish::Campaign.new(
  name: "Scheduled Phishing Test",
  template: { name: "Email Template" },
  page: { name: "Landing Page" },
  groups: [{ name: "HR Department" }],
  smtp: { name: "SMTP Profile" },
  url: "https://training.company.com",
  launch_date: "2024-01-15T09:00:00Z",      # When to start sending
  send_by_date: "2024-01-15T17:00:00Z"      # Deadline for sending all emails
)

if campaign.save
  puts "Scheduled campaign created"
  puts "Launched? #{campaign.launched?}"
  puts "Has send by date? #{campaign.has_send_by_date?}"
end

# Check campaign status and progress
campaign = Gophish::Campaign.find(1)

puts "Campaign: #{campaign.name}"
puts "Status: #{campaign.status}"
puts "In progress? #{campaign.in_progress?}"
puts "Completed? #{campaign.completed?}"

# Get campaign results
results = campaign.get_results
puts "Total results: #{results.length}"

# Get campaign summary
summary = campaign.get_summary
puts "Campaign summary: #{summary}"

# Access detailed campaign results
campaign = Gophish::Campaign.find(1)

campaign.results.each do |result|
  puts "Target: #{result.email}"
  puts "  Status: #{result.status}"
  puts "  Clicked: #{result.clicked?}"
  puts "  Opened: #{result.opened?}"
  puts "  Submitted data: #{result.submitted_data?}"
  puts "  Reported: #{result.reported?}"
  puts "  IP: #{result.ip}" if result.ip
  puts ""
end

# Filter results by status
clicked_results = campaign.results.select(&:clicked?)
puts "#{clicked_results.length} users clicked the link"

reported_results = campaign.results.select(&:reported?)
puts "#{reported_results.length} users reported the email"

# Access campaign timeline events
campaign = Gophish::Campaign.find(1)

campaign.timeline.each do |event|
  puts "#{event.time}: #{event.message}"
  puts "  Email: #{event.email}"
  
  # Check for additional details (JSON data)
  if event.has_details?
    details = event.parsed_details
    puts "  Details: #{details}"
  end
  puts ""
end

# Manually complete a running campaign
campaign = Gophish::Campaign.find(1)

if campaign.in_progress?
  result = campaign.complete!
  
  if result['success']
    puts "Campaign completed successfully"
    puts "Final status: #{campaign.status}"
  else
    puts "Failed to complete campaign: #{result['message']}"
  end
else
  puts "Campaign is not in progress"
end

# Get all campaigns
campaigns = Gophish::Campaign.all
puts "Found #{campaigns.length} campaigns"

campaigns.each do |campaign|
  puts "#{campaign.name}: #{campaign.status}"
end

# Find a specific campaign by ID
campaign = Gophish::Campaign.find(1)
puts "Campaign: #{campaign.name}"
puts "Groups: #{campaign.groups.map(&:name).join(', ')}"

# Get results without loading full campaign
results = Gophish::Campaign.get_results(1)
puts "Campaign has #{results.length} results"

# Get summary without loading full campaign
summary = Gophish::Campaign.get_summary(1)
puts "Campaign summary stats: #{summary['stats']}"

# Complete campaign without loading it
Gophish::Campaign.complete(1)

# Invalid campaign (missing required components)
campaign = Gophish::Campaign.new(name: "Incomplete Campaign")

unless campaign.valid?
  puts "Validation errors:"
  campaign.errors.full_messages.each { |msg| puts "  - #{msg}" }
  # => ["Template can't be blank", "Page can't be blank", "Groups can't be blank", 
  #     "Smtp can't be blank", "Url can't be blank"]
end

# Campaign with invalid group structure
campaign = Gophish::Campaign.new(
  name: "Test Campaign",
  template: { name: "Template" },
  page: { name: "Page" },
  groups: [{}],  # Invalid: group missing name
  smtp: { name: "SMTP" },
  url: "https://test.com"
)

unless campaign.valid?
  puts campaign.errors.full_messages
  # => ["Groups item at index 0 must have a name"]
end

# Create a template with envelope sender
template = Gophish::Template.new(
  name: "Corporate Phishing Test",
  envelope_sender: "noreply@company.com",  # Envelope sender address
  subject: "IT Security Update Required",
  html: "<h1>Please update your credentials</h1><p>Click <a href='{{.URL}}'>here</a></p>"
)

if template.save
  puts "Template created with envelope sender"
  puts "Has envelope sender: #{template.has_envelope_sender?}"
  puts "Envelope sender: #{template.envelope_sender}"
end