gophish-ruby 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59b79d410ed7e2467c187c89992d394ee71d911da58524ecc3cc4b4eb5fb2a39
-  data.tar.gz: 62ca19b3ecdfb8cc88bfedc2bd4f53fca272db9a9f5de8846398573413daf4ae
+  metadata.gz: ba7f348fc87e10ad752fe1b59ce329357ca0948dc180b5e5912210fc55a82a44
+  data.tar.gz: bbfd2bad8612b3814f04820c9bcb3e13cf21352b2712e13c85a2cce37c3e4cf5
 SHA512:
-  metadata.gz: 78d1964ebcb0d3caba10c53d0f78e819b356b88961af7dfe48dde8611469e4c1919991cf7dec2aae991ccccea30e66a2f0bfea56f51420ebec4e8e0bbb07807e
-  data.tar.gz: 321297b58bdd280855faf6d988bfc9f4d2c062a5569a41316371c501bafabc7c8175e9312f5cb22f10fd0df1452ee439b65fe5c0475f01bd5243125868ab2c28
+  metadata.gz: 697688a9381c1f53c4174e0d3922b4effc5d582dbd56dd0c71d40370126fb287e143ea7ee18fab7856cff52fc19d16ab6514baa04ca8759a3a8e6997cece2b97
+  data.tar.gz: 48965fe82e77390d55df53cbc9c763edc411e055dadcd51fd7852dba49f17ac519b48a7986a021be2b7eb7ca40153a3effee4d5b999887fa400052f31a437d95

data/CHANGELOG.md

@@ -8,16 +8,40 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+- **Template Management System**
+  - `Gophish::Template` class for managing email templates
+  - Full CRUD operations for templates (create, read, update, delete) 
+  - Support for HTML and plain text email content
+  - Comprehensive validations requiring template name and content
+  - Email import functionality with `Template.import_email` class method
+  - Option to convert links during email import for tracking
+
+- **Attachment Management**
+  - Add attachments to templates with `#add_attachment` method
+  - Remove attachments by name with `#remove_attachment` method
+  - Query attachment status with `#has_attachments?` and `#attachment_count`
+  - Automatic Base64 encoding of attachment content
+  - Validation of attachment structure (content, type, name required)
+
+- **Enhanced Change Tracking**
+  - Migrated from custom change tracking to ActiveModel::Dirty
+  - Improved change detection with `#changed?` and `#clear_changes_information`
+  - Better integration with Rails-style attribute tracking
+
 - Comprehensive documentation with getting started guide, API reference, and examples
 - Enhanced README with detailed usage instructions and configuration examples
 
 ### Changed
+- **Breaking Change**: Replaced custom `@changed_attributes` system with ActiveModel::Dirty
+- Updated Base class to use `define_attribute_methods` for proper dirty tracking
+- Modified `#update_record` to include `id` in update payload for proper API calls
 - Improved error messages for validation failures
 - Enhanced CSV import validation with better error reporting
 
 ### Fixed
 - Console script requiring wrong file name (`gophish_ruby` → `gophish-ruby`)
 - Spec helper requiring wrong file name for consistent naming
+- Corrected require statement in main library file for Template class
 
 ## [0.1.0] - 2025-08-29
 

data/README.md

@@ -11,9 +11,11 @@ A Ruby SDK for the [Gophish](https://getgophish.com/) phishing simulation platfo
 - **ActiveModel Integration**: Familiar Rails-like attributes, validations, and callbacks
 - **Automatic Authentication**: Built-in API key authentication for all requests
 - **CSV Import Support**: Easy bulk import of targets from CSV files
+- **Email Template Management**: Create, modify, and manage email templates with attachment support
+- **Email Import**: Import existing emails and convert them to templates
 - **SSL Configuration**: Configurable SSL verification for development environments
 - **Debug Support**: Built-in debugging capabilities for API interactions
-- **Change Tracking**: Automatic tracking of attribute changes
+- **Change Tracking**: Automatic tracking of attribute changes with ActiveModel::Dirty
 - **Comprehensive Validation**: Built-in validations for all data models
 
 ## Installation
@@ -184,9 +186,110 @@ unless group.valid?
 end
 ```
 
+### Templates Management
+
+Templates define the email content for your phishing campaigns, including HTML/text content and attachments.
+
+#### Creating a Template
+
+```ruby
+# 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
+```
+
+#### Adding Attachments
+
+```ruby
+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"
+```
+
+#### Managing Attachments
+
+```ruby
+# 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}"
+```
+
+#### Importing Email Content
+
+```ruby
+# 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
+```
+
+#### Retrieving Templates
+
+```ruby
+# 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}"
+```
+
+#### Updating a Template
+
+```ruby
+template = Gophish::Template.find(1)
+template.subject = "Updated Subject Line"
+template.html = "<h1>Updated Content</h1>"
+
+if template.save
+  puts "Template updated successfully"
+end
+```
+
+#### Deleting a Template
+
+```ruby
+template = Gophish::Template.find(1)
+if template.destroy
+  puts "Template deleted successfully"
+end
+```
+
 ### Change Tracking
 
-The SDK automatically tracks changes to attributes:
+The SDK automatically tracks changes to attributes using ActiveModel::Dirty:
 
 ```ruby
 group = Gophish::Group.find(1)
@@ -258,6 +361,44 @@ Each target in the `targets` array should have:
 
 - `#import_csv(csv_data)` - Import targets from CSV data
 
+#### `Gophish::Template`
+
+Represents a Gophish email template.
+
+**Attributes:**
+
+- `id` (Integer) - Unique template identifier
+- `name` (String) - Template name (required)
+- `subject` (String) - Email subject line
+- `text` (String) - Plain text email content
+- `html` (String) - HTML email content
+- `modified_date` (String) - Last modification timestamp
+- `attachments` (Array) - Array of attachment hashes
+
+**Attachment Structure:**
+Each attachment in the `attachments` array should have:
+
+- `content` (String) - Base64 encoded file content (required)
+- `type` (String) - MIME type of the attachment (required)
+- `name` (String) - Filename of the attachment (required)
+
+**Class Methods:**
+
+- `.import_email(content, convert_links: false)` - Import email content and return template data
+
+**Instance Methods:**
+
+- `#add_attachment(content, type, name)` - Add an attachment to the template
+- `#remove_attachment(name)` - Remove an attachment by filename
+- `#has_attachments?` - Check if template has any attachments
+- `#attachment_count` - Get the number of attachments
+
+**Validations:**
+
+- Template must have a name
+- Template must have either text or HTML content (or both)
+- All attachments must have content, type, and name
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/docs/API_REFERENCE.md

@@ -7,6 +7,7 @@ This document provides detailed API reference for the Gophish Ruby SDK.
 - [Configuration](#configuration)
 - [Base Class](#base-class)
 - [Group Class](#group-class)
+- [Template Class](#template-class)
 - [Error Handling](#error-handling)
 - [Examples](#examples)
 
@@ -125,7 +126,7 @@ Create or update the resource on the server.
 **Side Effects:**
 
 - Sets `@persisted` to true on success
-- Clears `@changed_attributes` on success
+- Clears change tracking information on success
 - Adds errors to `#errors` on failure
 
 **Example:**
@@ -207,7 +208,7 @@ group = Gophish::Group.new
 puts group.new_record?  # => true
 ```
 
-##### `#changed_attributes`
+##### `#changed`
 
 Get array of attribute names that have changed.
 
@@ -218,7 +219,23 @@ Get array of attribute names that have changed.
 ```ruby
 group = Gophish::Group.find(1)
 group.name = "New Name"
-puts group.changed_attributes  # => ["name"]
+puts group.changed  # => ["name"]
+```
+
+##### `#changed?`
+
+Check if any attributes have changed.
+
+**Returns:** Boolean
+
+**Example:**
+
+```ruby
+group = Gophish::Group.find(1)
+puts group.changed?  # => false
+
+group.name = "New Name"
+puts group.changed?  # => true
 ```
 
 ##### `#attribute_changed?(attr)`
@@ -236,8 +253,8 @@ Check if a specific attribute has changed.
 ```ruby
 group = Gophish::Group.find(1)
 group.name = "New Name"
+puts group.name_changed?  # => true (using dynamic method)
 puts group.attribute_changed?(:name)  # => true
-puts group.attribute_changed?("targets")  # => false
 ```
 
 ##### `#attribute_was(attr)`
@@ -256,6 +273,7 @@ Get the previous value of a changed attribute.
 group = Gophish::Group.find(1)
 original_name = group.name
 group.name = "New Name"
+puts group.name_was  # => original_name (using dynamic method)
 puts group.attribute_was(:name)  # => original_name
 ```
 
@@ -376,6 +394,236 @@ group.import_csv(csv_content)
 group.save
 ```
 
+## Template Class
+
+The `Gophish::Template` class represents an email template in Gophish.
+
+### Class: `Gophish::Template < Gophish::Base`
+
+#### Attributes
+
+| Attribute | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `id` | Integer | No | Unique template identifier (set by server) |
+| `name` | String | Yes | Template name |
+| `subject` | String | No | Email subject line |
+| `text` | String | No | Plain text email content |
+| `html` | String | No | HTML email content |
+| `modified_date` | String | No | Last modification timestamp (set by server) |
+| `attachments` | Array | No | Array of attachment hashes |
+
+#### Attachment Structure
+
+Each attachment in the `attachments` array must have:
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `content` | String | Yes | Base64 encoded file content |
+| `type` | String | Yes | MIME type (e.g., "application/pdf") |
+| `name` | String | Yes | Filename |
+
+#### Validations
+
+- `name` must be present
+- Must have either `text` or `html` content (or both)
+- Each attachment must be a Hash with required fields (`content`, `type`, `name`)
+
+#### Class Methods
+
+##### `.import_email(content, convert_links: false)`
+
+Import email content and return template data.
+
+**Parameters:**
+
+- `content` (String) - Raw email content (.eml format)
+- `convert_links` (Boolean) - Whether to convert links for Gophish tracking (default: false)
+
+**Returns:** Hash of template attributes
+
+**Raises:**
+
+- `StandardError` if import fails
+
+**Example:**
+
+```ruby
+email_content = File.read("sample.eml")
+template_data = Gophish::Template.import_email(email_content, convert_links: true)
+
+template = Gophish::Template.new(template_data)
+template.name = "Imported Template"
+template.save
+```
+
+#### Instance Methods
+
+##### `#add_attachment(content, type, name)`
+
+Add an attachment to the template.
+
+**Parameters:**
+
+- `content` (String) - File content (will be Base64 encoded automatically)
+- `type` (String) - MIME type
+- `name` (String) - Filename
+
+**Returns:** Void
+
+**Side Effects:**
+
+- Adds attachment to `attachments` array
+- Marks `attachments` attribute as changed
+
+**Example:**
+
+```ruby
+template = Gophish::Template.new(name: "Test", html: "<p>Test</p>")
+file_content = File.read("document.pdf")
+template.add_attachment(file_content, "application/pdf", "document.pdf")
+```
+
+##### `#remove_attachment(name)`
+
+Remove an attachment by filename.
+
+**Parameters:**
+
+- `name` (String) - Filename of attachment to remove
+
+**Returns:** Void
+
+**Side Effects:**
+
+- Removes matching attachment(s) from `attachments` array
+- Marks `attachments` attribute as changed if any were removed
+
+**Example:**
+
+```ruby
+template.remove_attachment("document.pdf")
+```
+
+##### `#has_attachments?`
+
+Check if template has any attachments.
+
+**Returns:** Boolean
+
+**Example:**
+
+```ruby
+if template.has_attachments?
+  puts "Template has #{template.attachment_count} attachments"
+end
+```
+
+##### `#attachment_count`
+
+Get the number of attachments.
+
+**Returns:** Integer
+
+**Example:**
+
+```ruby
+puts "Attachments: #{template.attachment_count}"
+```
+
+#### Usage Examples
+
+##### Create a Template
+
+```ruby
+template = Gophish::Template.new(
+  name: "Phishing Test Template",
+  subject: "Important Security Update",
+  html: "<h1>Security Update Required</h1><p>Please click <a href='{{.URL}}'>here</a> to update.</p>",
+  text: "Security Update Required\n\nPlease visit {{.URL}} to update your credentials."
+)
+
+if template.save
+  puts "Template created with ID: #{template.id}"
+end
+```
+
+##### Template with Attachments
+
+```ruby
+template = Gophish::Template.new(
+  name: "Invoice Template",
+  subject: "Invoice #{{.RId}}",
+  html: "<p>Please find your invoice attached.</p>"
+)
+
+# Add PDF attachment
+pdf_content = File.read("invoice.pdf")
+template.add_attachment(pdf_content, "application/pdf", "invoice.pdf")
+
+# Add image attachment
+image_content = File.read("logo.png")
+template.add_attachment(image_content, "image/png", "logo.png")
+
+template.save
+```
+
+##### Import from Email
+
+```ruby
+# Import existing email
+email_content = File.read("phishing_template.eml")
+imported_data = Gophish::Template.import_email(
+  email_content,
+  convert_links: true  # Convert links for tracking
+)
+
+template = Gophish::Template.new(imported_data)
+template.name = "Imported Phishing Template"
+template.save
+```
+
+##### Update Template
+
+```ruby
+template = Gophish::Template.find(1)
+template.subject = "Updated Subject"
+template.html = "<h1>Updated Content</h1>"
+
+# Add new attachment
+template.add_attachment(File.read("new_doc.pdf"), "application/pdf", "new_doc.pdf")
+
+# Remove old attachment
+template.remove_attachment("old_doc.pdf")
+
+template.save
+```
+
+##### Template Validation
+
+```ruby
+# Invalid template (no content)
+template = Gophish::Template.new(name: "Test Template")
+
+unless template.valid?
+  puts "Validation errors:"
+  template.errors.full_messages.each { |msg| puts "  - #{msg}" }
+  # => ["Need to specify at least plaintext or HTML content"]
+end
+
+# Invalid attachment
+template = Gophish::Template.new(
+  name: "Test",
+  html: "<p>Test</p>",
+  attachments: [{ name: "file.pdf" }]  # Missing content and type
+)
+
+unless template.valid?
+  puts template.errors.full_messages
+  # => ["Attachments item at index 0 must have a content", 
+  #     "Attachments item at index 0 must have a type"]
+end
+```
+
 ## Error Handling
 
 ### Validation Errors

data/docs/EXAMPLES.md

@@ -6,6 +6,7 @@ This document contains practical examples for common use cases with the Gophish
 
 - [Basic Operations](#basic-operations)
 - [CSV Operations](#csv-operations)
+- [Template Operations](#template-operations)
 - [Error Handling](#error-handling)
 - [Advanced Scenarios](#advanced-scenarios)
 - [Production Examples](#production-examples)
@@ -252,6 +253,347 @@ end
 group = import_large_csv("large_employee_list.csv", "All Company Employees")
 ```
 
+## Template Operations
+
+### Basic Template Creation
+
+```ruby
+# Simple text and HTML template
+template = Gophish::Template.new(
+  name: "Security Awareness Training",
+  subject: "Important Security Update - Action Required",
+  html: <<~HTML,
+    <h1>Security Update Required</h1>
+    <p>Dear {{.FirstName}},</p>
+    <p>We have detected suspicious activity on your account. Please click <a href="{{.URL}}">here</a> to verify your account immediately.</p>
+    <p>This link will expire in 24 hours.</p>
+    <p>Best regards,<br>IT Security Team</p>
+  HTML
+  text: <<~TEXT
+    Security Update Required
+
+    Dear {{.FirstName}},
+
+    We have detected suspicious activity on your account. Please visit {{.URL}} to verify your account immediately.
+
+    This link will expire in 24 hours.
+
+    Best regards,
+    IT Security Team
+  TEXT
+)
+
+if template.save
+  puts "✓ Template '#{template.name}' created with ID: #{template.id}"
+else
+  puts "✗ Failed to create template: #{template.errors.full_messages}"
+end
+```
+
+### Template with Attachments
+
+```ruby
+# Create template with multiple attachments
+template = Gophish::Template.new(
+  name: "Invoice Phishing Template",
+  subject: "Invoice #{{.RId}} - Payment Due",
+  html: "<h1>Invoice Attached</h1><p>Dear {{.FirstName}},</p><p>Please find your invoice attached for immediate payment.</p>"
+)
+
+# Add PDF invoice attachment
+pdf_content = File.read("sample_invoice.pdf")
+template.add_attachment(pdf_content, "application/pdf", "invoice_#{Time.now.strftime('%Y%m%d')}.pdf")
+
+# Add company logo
+logo_content = File.read("company_logo.png")
+template.add_attachment(logo_content, "image/png", "logo.png")
+
+# Add fake Excel spreadsheet
+excel_content = File.read("expense_report.xlsx")
+template.add_attachment(excel_content, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Q4_expenses.xlsx")
+
+puts "Template has #{template.attachment_count} attachments"
+
+if template.save
+  puts "✓ Template with attachments created successfully"
+end
+```
+
+### Email Import from .EML Files
+
+```ruby
+# Import existing phishing email
+def import_phishing_template(eml_file_path, template_name)
+  unless File.exist?(eml_file_path)
+    puts "✗ EML file not found: #{eml_file_path}"
+    return nil
+  end
+
+  email_content = File.read(eml_file_path)
+
+  # Import with link conversion for tracking
+  begin
+    imported_data = Gophish::Template.import_email(email_content, convert_links: true)
+  rescue StandardError => e
+    puts "✗ Email import failed: #{e.message}"
+    return nil
+  end
+
+  # Create template from imported data
+  template = Gophish::Template.new(imported_data)
+  template.name = template_name
+
+  if template.valid?
+    if template.save
+      puts "✓ Successfully imported template '#{template.name}'"
+      puts "  Subject: #{template.subject}"
+      puts "  Has HTML: #{!template.html.nil?}"
+      puts "  Has Text: #{!template.text.nil?}"
+      puts "  Attachments: #{template.attachment_count}"
+      return template
+    else
+      puts "✗ Save failed: #{template.errors.full_messages}"
+    end
+  else
+    puts "✗ Validation failed: #{template.errors.full_messages}"
+  end
+
+  nil
+end
+
+# Usage
+template = import_phishing_template("phishing_email.eml", "Imported Phishing Template")
+```
+
+### Template Management Operations
+
+```ruby
+# List all existing templates
+def list_templates
+  templates = Gophish::Template.all
+  puts "Found #{templates.length} templates:"
+
+  templates.each do |template|
+    attachment_info = template.has_attachments? ? " (#{template.attachment_count} attachments)" : ""
+    puts "  #{template.id}: #{template.name}#{attachment_info}"
+    puts "    Subject: #{template.subject}" if template.subject
+    puts "    Modified: #{template.modified_date}" if template.modified_date
+  end
+end
+
+# Update existing template
+def update_template(template_id, new_subject = nil, new_html = nil)
+  begin
+    template = Gophish::Template.find(template_id)
+  rescue StandardError
+    puts "✗ Template #{template_id} not found"
+    return false
+  end
+
+  puts "Updating template '#{template.name}'"
+
+  template.subject = new_subject if new_subject
+  template.html = new_html if new_html
+
+  if template.save
+    puts "✓ Template updated successfully"
+    true
+  else
+    puts "✗ Update failed: #{template.errors.full_messages}"
+    false
+  end
+end
+
+# Clone template with modifications
+def clone_template(original_id, new_name, modifications = {})
+  begin
+    original = Gophish::Template.find(original_id)
+  rescue StandardError
+    puts "✗ Original template #{original_id} not found"
+    return nil
+  end
+
+  # Create new template with same content
+  new_template = Gophish::Template.new(
+    name: new_name,
+    subject: original.subject,
+    html: original.html,
+    text: original.text
+  )
+
+  # Apply modifications
+  modifications.each do |field, value|
+    new_template.send("#{field}=", value) if new_template.respond_to?("#{field}=")
+  end
+
+  # Copy attachments
+  if original.has_attachments?
+    original.attachments.each do |attachment|
+      new_template.attachments << attachment.dup
+    end
+  end
+
+  if new_template.save
+    puts "✓ Template cloned as '#{new_name}' (ID: #{new_template.id})"
+    new_template
+  else
+    puts "✗ Clone failed: #{new_template.errors.full_messages}"
+    nil
+  end
+end
+
+# Usage examples
+list_templates
+update_template(1, "Updated Subject Line", "<h1>Updated HTML content</h1>")
+clone_template(1, "Modified Version", { subject: "Modified Subject" })
+```
+
+### Template Validation and Error Handling
+
+```ruby
+# Comprehensive template validation
+def validate_template_thoroughly(template)
+  puts "Validating template '#{template.name}'"
+
+  # Basic validation
+  unless template.valid?
+    puts "✗ Basic validation failed:"
+    template.errors.full_messages.each { |error| puts "    - #{error}" }
+    return false
+  end
+
+  # Content validation
+  has_html = !template.html.nil? && !template.html.strip.empty?
+  has_text = !template.text.nil? && !template.text.strip.empty?
+
+  unless has_html || has_text
+    puts "✗ Template has no content (neither HTML nor text)"
+    return false
+  end
+
+  # Gophish template variable validation
+  content = "#{template.html} #{template.text} #{template.subject}"
+  
+  # Check for common Gophish template variables
+  variables_found = content.scan(/\{\{\.(\w+)\}\}/).flatten.uniq
+  puts "  Found template variables: #{variables_found.join(', ')}" if variables_found.any?
+
+  # Warn about missing tracking URL
+  unless content.include?('{{.URL}}')
+    puts "  ⚠ Warning: No {{.URL}} tracking variable found"
+  end
+
+  # Attachment validation
+  if template.has_attachments?
+    puts "  Validating #{template.attachment_count} attachments:"
+    template.attachments.each_with_index do |attachment, index|
+      name = attachment[:name] || attachment['name']
+      type = attachment[:type] || attachment['type']
+      content = attachment[:content] || attachment['content']
+
+      puts "    #{index + 1}. #{name} (#{type})"
+
+      if content.nil? || content.empty?
+        puts "      ✗ Missing content"
+        return false
+      end
+
+      # Validate Base64 encoding
+      begin
+        Base64.strict_decode64(content)
+        puts "      ✓ Valid Base64 encoding"
+      rescue ArgumentError
+        puts "      ✗ Invalid Base64 encoding"
+        return false
+      end
+    end
+  end
+
+  puts "✓ Template validation passed"
+  true
+end
+
+# Test various template scenarios
+def test_template_scenarios
+  # Valid template
+  valid_template = Gophish::Template.new(
+    name: "Valid Template",
+    subject: "Test {{.FirstName}}",
+    html: "<p>Click {{.URL}} to continue</p>",
+    text: "Visit {{.URL}} to continue"
+  )
+  validate_template_thoroughly(valid_template)
+
+  # Invalid template (no content)
+  invalid_template = Gophish::Template.new(
+    name: "Invalid Template",
+    subject: "Test"
+  )
+  validate_template_thoroughly(invalid_template)
+
+  # Template with attachment
+  template_with_attachment = Gophish::Template.new(
+    name: "Attachment Template",
+    html: "<p>See attachment</p>"
+  )
+  template_with_attachment.add_attachment("Hello World", "text/plain", "test.txt")
+  validate_template_thoroughly(template_with_attachment)
+end
+
+test_template_scenarios
+```
+
+### Bulk Template Operations
+
+```ruby
+# Create multiple templates from a configuration
+def create_template_suite(campaign_name)
+  templates = [
+    {
+      name: "#{campaign_name} - Initial Email",
+      subject: "Important Account Update Required",
+      html: "<h1>Account Update</h1><p>Dear {{.FirstName}}, please update your account by clicking <a href='{{.URL}}'>here</a>.</p>",
+      text: "Dear {{.FirstName}}, please update your account by visiting {{.URL}}"
+    },
+    {
+      name: "#{campaign_name} - Follow-up",
+      subject: "URGENT: Account Suspension Notice",
+      html: "<h1 style='color: red;'>URGENT</h1><p>Your account will be suspended in 24 hours. Verify immediately: {{.URL}}</p>",
+      text: "URGENT: Your account will be suspended in 24 hours. Verify at {{.URL}}"
+    },
+    {
+      name: "#{campaign_name} - Final Warning",
+      subject: "Final Warning - Account Closure",
+      html: "<h1>Final Warning</h1><p>This is your last chance to save your account: {{.URL}}</p>",
+      text: "Final Warning: Last chance to save your account at {{.URL}}"
+    }
+  ]
+
+  created_templates = []
+
+  templates.each_with_index do |template_data, index|
+    puts "Creating template #{index + 1}/#{templates.length}: #{template_data[:name]}"
+
+    template = Gophish::Template.new(template_data)
+
+    if template.save
+      puts "  ✓ Created with ID: #{template.id}"
+      created_templates << template
+    else
+      puts "  ✗ Failed: #{template.errors.full_messages}"
+    end
+  end
+
+  puts "\nTemplate suite '#{campaign_name}' creation completed"
+  puts "Successfully created: #{created_templates.length}/#{templates.length} templates"
+
+  created_templates
+end
+
+# Usage
+suite = create_template_suite("Q4 Security Training")
+```
+
 ## Error Handling
 
 ### Comprehensive Error Handling

data/docs/GETTING_STARTED.md

@@ -84,6 +84,27 @@ else
 end
 ```
 
+### 4. Create Your First Template
+
+Templates define the email content for your phishing campaigns:
+
+```ruby
+# Create a basic email template
+template = Gophish::Template.new(
+  name: "Security Awareness Test",
+  subject: "Important Security Update Required",
+  html: "<h1>Security Update</h1><p>Please click <a href='{{.URL}}'>here</a> to update your password.</p>",
+  text: "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.each { |error| puts "  - #{error}" }
+end
+```
+
 ## Common Workflows
 
 ### Importing Targets from CSV
@@ -125,6 +146,68 @@ else
 end
 ```
 
+### Working with Templates
+
+#### Creating Templates with Attachments
+
+```ruby
+# Create template with file attachments
+template = Gophish::Template.new(
+  name: "Invoice Template",
+  subject: "Your Invoice #{{.RId}}",
+  html: "<p>Dear {{.FirstName}},</p><p>Please find your invoice attached.</p>"
+)
+
+# Add PDF attachment
+pdf_content = File.read("sample_invoice.pdf")
+template.add_attachment(pdf_content, "application/pdf", "invoice.pdf")
+
+# Check attachments
+puts "Template has #{template.attachment_count} attachments" if template.has_attachments?
+
+template.save
+```
+
+#### Importing Email Templates
+
+```ruby
+# Import an existing email (.eml file)
+email_content = File.read("phishing_template.eml")
+
+imported_data = Gophish::Template.import_email(
+  email_content, 
+  convert_links: true  # Convert links for Gophish tracking
+)
+
+template = Gophish::Template.new(imported_data)
+template.name = "Imported Email Template"
+template.save
+
+puts "Imported template: #{template.name}"
+```
+
+#### Managing Existing Templates
+
+```ruby
+# List all templates
+puts "Existing templates:"
+Gophish::Template.all.each do |template|
+  attachment_info = template.has_attachments? ? " (#{template.attachment_count} attachments)" : ""
+  puts "  #{template.id}: #{template.name}#{attachment_info}"
+end
+
+# Update a template
+template = Gophish::Template.find(1)
+template.subject = "Updated Subject Line"
+template.html = "<h1>Updated Content</h1><p>New message content here.</p>"
+
+# Add or remove attachments
+template.add_attachment(File.read("new_file.pdf"), "application/pdf", "new_file.pdf")
+template.remove_attachment("old_file.pdf")
+
+template.save
+```
+
 ### Managing Existing Groups
 
 ```ruby

data/lib/gophish/base.rb

@@ -13,12 +13,13 @@ module Gophish
     include ActiveModel::Model
     include ActiveModel::Attributes
     include ActiveModel::Validations
+    include ActiveModel::Dirty
     include ActiveRecord::Callbacks
 
     def initialize(attributes = {})
       @persisted = false
-      @changed_attributes = {}
       super(attributes)
+      clear_changes_information
     end
 
     def self.configuration
@@ -125,7 +126,7 @@ module Gophish
         send "#{key}=", value if respond_to? "#{key}="
       end
       @persisted = true
-      @changed_attributes.clear
+      clear_changes_information
     end
 
     def handle_error_response(response)
@@ -145,9 +146,9 @@ module Gophish
 
     def update_record
       return false if id.nil?
-      return true if @changed_attributes.empty?
+      return true unless changed?
 
-      response = self.class.put "#{self.class.resource_path}/#{id}/", request_options(body_for_update)
+      response = self.class.put "#{self.class.resource_path}/#{id}", request_options(body_for_update)
       return handle_error_response response unless response.success?
 
       update_attributes_from_response response.parsed_response
@@ -177,29 +178,10 @@ module Gophish
     end
 
     def body_for_update
-      body_for_create
-    end
-
-    def attribute_changed?(attribute)
-      @changed_attributes.key? attribute.to_s
-    end
-
-    def changed_attributes
-      @changed_attributes.keys
-    end
-
-    def attribute_was(attribute)
-      @changed_attributes[attribute.to_s]
+      body_for_create.merge id:
     end
 
     def []=(attribute, value)
-      attribute_str = attribute.to_s
-      current_value = send attribute if respond_to? attribute
-
-      unless current_value == value
-        @changed_attributes[attribute_str] = current_value
-      end
-
       send "#{attribute}=", value if respond_to? "#{attribute}="
     end
   end

data/lib/gophish/group.rb

@@ -9,6 +9,8 @@ module Gophish
     attribute :modified_date, :string
     attribute :targets
 
+    define_attribute_methods :id, :name, :modified_date, :targets
+
     validates :name, presence: true
     validates :targets, presence: true
     validate :validate_targets_structure

data/lib/gophish/template.rb

@@ -0,0 +1,94 @@
+require_relative 'base'
+require 'active_support/core_ext/object/blank'
+require 'base64'
+
+module Gophish
+  class Template < Base
+    attribute :id, :integer
+    attribute :name, :string
+    attribute :subject, :string
+    attribute :text, :string
+    attribute :html, :string
+    attribute :modified_date, :string
+    attribute :attachments, default: -> { [] }
+
+    define_attribute_methods :id, :name, :subject, :text, :html, :modified_date, :attachments
+
+    validates :name, presence: true
+    validate :validate_content_presence
+    validate :validate_attachments_structure
+
+    def body_for_create
+      { name:, subject:, text:, html:, attachments: }
+    end
+
+    def self.import_email(content, convert_links: false)
+      options = build_import_options content, convert_links
+      response = post '/import/email', options
+      raise StandardError, 'Failed to import email' unless response.success?
+
+      response.parsed_response
+    end
+
+    def self.build_import_options(content, convert_links)
+      {
+        body: { content:, convert_links: }.to_json,
+        headers: { 'Content-Type' => 'application/json' }
+      }
+    end
+
+    def add_attachment(content, type, name)
+      encoded_content = encode_content content
+      attachments << { content: encoded_content, type:, name: }
+      attachments_will_change!
+    end
+
+    def remove_attachment(name)
+      original_size = attachments.size
+      attachments.reject! { |attachment| attachment[:name] == name || attachment['name'] == name }
+      attachments_will_change! if attachments.size != original_size
+    end
+
+    def has_attachments?
+      !attachments.empty?
+    end
+
+    def attachment_count
+      attachments.length
+    end
+
+    private
+
+    def encode_content(content)
+      content.is_a?(String) ? Base64.strict_encode64(content) : content
+    end
+
+    def validate_content_presence
+      return unless text.blank? && html.blank?
+
+      errors.add :base, 'Need to specify at least plaintext or HTML content'
+    end
+
+    def validate_attachments_structure
+      return if attachments.blank?
+      return errors.add :attachments, 'must be an array' unless attachments.is_a? Array
+
+      attachments.each_with_index { |attachment, index| validate_attachment attachment, index }
+    end
+
+    def validate_attachment(attachment, index)
+      return errors.add :attachments, "item at index #{index} must be a hash" unless attachment.is_a? Hash
+
+      validate_attachment_field attachment, index, :content
+      validate_attachment_field attachment, index, :type
+      validate_attachment_field attachment, index, :name
+    end
+
+    def validate_attachment_field(attachment, index, field)
+      value = attachment[field] || attachment[field.to_s]
+      return unless value.blank?
+
+      errors.add :attachments, "item at index #{index} must have a #{field}"
+    end
+  end
+end

data/lib/gophish/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gophish
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/gophish-ruby.rb

@@ -1,7 +1,7 @@
 require_relative 'gophish/version'
 require_relative 'gophish/configuration'
-require_relative 'gophish/base'
 require_relative 'gophish/group'
+require_relative 'gophish/template'
 
 module Gophish
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gophish-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Eli Sebastian Herrera Aguilar
@@ -105,6 +105,7 @@ files:
 - lib/gophish/base.rb
 - lib/gophish/configuration.rb
 - lib/gophish/group.rb
+- lib/gophish/template.rb
 - lib/gophish/version.rb
 - sig/gophish/ruby.rbs
 homepage: https://github.com/EliSebastian/gopish-ruby