Integration Guide - SH All-In-One Helpdesk

Complete guide to using helpdesk integrations with Sales, Purchase, Invoicing, CRM, Projects, and Timesheets.

Table of Contents

1. Sales Order Integration
2. Purchase Order Integration
3. Invoice Integration
4. CRM Integration
5. Project Task Integration
6. Timesheet Integration
7. Integration Matrix

Sales Order Integration

Sub-module: sh_helpdesk_so

Overview

Link helpdesk tickets to sales orders bidirectionally:
- Create tickets from sales orders
- Create sales orders from tickets
- View related records from either side

From Sales Order → Ticket

Creating a Ticket from Sales Order

1. Open a sales order
2. Click Create Ticket button (or smart button if exists)
3. Ticket is created with:
4. Customer pre-filled
5. Products from SO linked
6. Reference to SO

Viewing Tickets from Sales Order

1. Open sales order
2. Click Tickets smart button
3. View list of linked tickets

From Ticket → Sales Order

Creating Sales Order from Ticket

1. Open ticket
2. Click Create Sales Order button
3. New SO is created with:
4. Customer from ticket
5. Products from ticket (if any)
6. Reference to ticket

Viewing Sales Orders from Ticket

1. Open ticket
2. Click Sales Orders smart button
3. View list of linked SOs

Technical Details

New Fields on Sale Order:

sh_sale_ticket_ids = fields.Many2many('helpdesk.ticket')
sale_ticket_count = fields.Integer(compute='_compute_sale_ticket_count')

New Fields on Ticket:

sh_sale_order_ids = fields.Many2many('sale.order')
sale_order_count = fields.Integer(compute='_compute_sale_order_count')

Key Methods:

# On sale.order
def action_create_sale_ticket(self):
    """Create ticket from this SO."""

def action_view_sale_tickets(self):
    """Open linked tickets."""

# On helpdesk.ticket
def action_sale_create_order(self):
    """Create SO from this ticket."""

def action_view_sale_orders(self):
    """Open linked SOs."""

Use Cases

Purchase Order Integration

Sub-module: sh_helpdesk_po

Overview

Link helpdesk tickets to purchase orders:
- Report vendor issues via tickets
- Track procurement-related support

From Purchase Order → Ticket

Creating a Ticket from PO

1. Open a purchase order
2. Click Create Ticket button
3. Ticket created with:
4. Vendor as partner (or configure customer)
5. Products linked
6. PO reference

Viewing Tickets from PO

1. Open purchase order
2. Click Tickets smart button
3. View linked tickets

From Ticket → Purchase Order

Creating PO from Ticket

1. Open ticket
2. Click Create Purchase Order button
3. PO created with:
4. Products from ticket
5. Partner reference

Technical Details

New Fields on Purchase Order:

sh_purchase_ticket_ids = fields.Many2many('helpdesk.ticket')
purchase_ticket_count = fields.Integer(compute='_compute_purchase_ticket_count')

New Fields on Ticket:

sh_purchase_order_ids = fields.Many2many('purchase.order')
purchase_order_count = fields.Integer(compute='_compute_purchase_order_count')

Use Cases

Invoice Integration

Sub-module: sh_helpdesk_invoice

Overview

Link tickets to invoices:
- Handle billing disputes
- Track invoice-related support

From Invoice → Ticket

Creating Ticket from Invoice

1. Open invoice (customer or vendor)
2. Click Create Ticket button
3. Ticket created with:
4. Partner from invoice
5. Invoice reference
6. Products linked

From Ticket → Invoice

Creating Invoice from Ticket

1. Open ticket
2. Click Create Invoice button
3. Invoice created with:
4. Customer from ticket
5. Line items from ticket products

Technical Details

New Fields on Account Move:

sh_ticket_ids = fields.Many2many('helpdesk.ticket')
ticket_count = fields.Integer(compute='_compute_ticket_count')

New Fields on Ticket:

sh_invoice_ids = fields.Many2many('account.move')
invoice_count = fields.Integer(compute='_compute_invoice_count')

Use Cases

CRM Integration

Sub-module: sh_helpdesk_crm

Overview

Link tickets to CRM leads and opportunities:
- Convert support to sales opportunities
- Track pre-sales support

From Lead/Opportunity → Ticket

Creating Ticket from Lead

1. Open lead or opportunity
2. Click Create Ticket button
3. Ticket created with:
4. Contact from lead
5. Description from lead
6. Lead reference

From Ticket → Lead/Opportunity

Creating Lead from Ticket

1. Open ticket
2. Click Create Lead button
3. Lead created with:
4. Partner from ticket
5. Description from ticket

Creating Opportunity from Ticket

1. Open ticket
2. Click Create Opportunity button
3. Opportunity created with:
4. Partner from ticket
5. Expected revenue (if applicable)

Technical Details

New Fields on CRM Lead:

sh_ticket_ids = fields.Many2many('helpdesk.ticket')
ticket_count = fields.Integer(compute='_compute_ticket_count')

New Fields on Ticket:

sh_lead_ids = fields.Many2many('crm.lead')
lead_count = fields.Integer(compute='_compute_lead_count')
opportunity_count = fields.Integer(compute='_compute_opportunity_count')

Use Cases

Project Task Integration

Sub-module: sh_helpdesk_task

Overview

Link tickets to project tasks:
- Convert tickets to development tasks
- Track implementation work
- Link fixes to tickets

From Ticket → Task

Creating Task from Ticket

1. Open ticket
2. Click Create Task button
3. Task created with:
4. Name from ticket
5. Description from ticket
6. Assigned user from ticket
7. Attachments copied

From Task → Ticket

Viewing Tickets from Task

1. Open project task
2. Click Tickets smart button
3. View linked tickets

Technical Details

New Fields on Project Task:

sh_ticket_ids = fields.Many2many('helpdesk.ticket')
ticket_count = fields.Integer(compute='_compute_ticket_count')

New Fields on Ticket:

task_ids = fields.Many2many('project.task')
task_count = fields.Integer(compute='_compute_task_count')

Workflow Example

Ticket Created (Bug Report)
        ↓
Triage and Prioritize
        ↓
Create Task (Development Work)
        ↓
Task Completed
        ↓
Update Ticket
        ↓
Ticket Resolved

Use Cases

Timesheet Integration

Sub-module: sh_helpdesk_timesheet

Overview

Track time spent on tickets:
- Start/stop timer on tickets
- Auto-create timesheet entries
- Link to analytics/projects

Using Time Tracking

Starting Timer

1. Open ticket
2. Click Start button (play icon)
3. Timer begins

What happens:
- Start time recorded
- Timesheet entry created
- Ticket marked as "running"

Stopping Timer

1. Click Stop button
2. Enter work description (if configured)
3. Click End Ticket

What happens:
- End time recorded
- Duration calculated
- Timesheet entry completed

Configuration

Company Settings:
| Setting | Purpose |
|---------|---------|
| Default Project | Project for timesheet entries |
| Allow Multiple Tickets | Track multiple tickets simultaneously |
| Show Description on End | Prompt for description when stopping |

Technical Details

New Fields on Ticket:

start_time = fields.Datetime('Start Time')
end_time = fields.Datetime('End Time')
total_time = fields.Char('Total Time')
duration = fields.Float(compute='_compute_duration')
ticket_running = fields.Boolean('Is Running')
timesheet_ids = fields.One2many('account.analytic.line', 'ticket_id')

New Fields on Analytic Line:

ticket_id = fields.Many2one('helpdesk.ticket')
start_date = fields.Datetime('Start')
end_date = fields.Datetime('End')

Key Methods:

def action_ticket_start(self):
    """Start time tracking."""

def action_ticket_end(self):
    """Stop time tracking and record time."""

def get_duration(self, ticket):
    """Get elapsed time in milliseconds."""

Frontend Timer Widget

The timesheet integration includes a JavaScript timer widget:
- Real-time duration display
- Start/Stop controls
- Persists across page navigation

Files:
- static/src/helpdesk_timesheet/js/time_track.js
- static/src/helpdesk_timesheet/xml/time_track.xml
- static/src/helpdesk_timesheet/scss/time_track.scss

Use Cases

Integration Matrix

Quick Reference: What Creates What

Data Flow Summary

                    ┌──────────────┐
                    │   TICKET     │
                    └──────┬───────┘
                           │
        ┌──────────────────┼──────────────────┐
        │                  │                  │
        ▼                  ▼                  ▼
┌───────────────┐  ┌───────────────┐  ┌───────────────┐
│  Sales Order  │  │ Purchase Ord. │  │    Invoice    │
└───────────────┘  └───────────────┘  └───────────────┘
        │
        ▼
┌───────────────┐
│   CRM Lead    │
└───────────────┘
        │
        ▼
┌───────────────┐
│  Project Task │
└───────────────┘
        │
        ▼
┌───────────────┐
│   Timesheet   │
└───────────────┘

Integration Fields Summary

Best Practices

When to Use Integrations

integration_guidelines:
  sales_orders:
    use_when:
      - "Customer reports issue with purchased item"
      - "Need to quote support services"
      - "Tracking warranty support"
    avoid_when:
      - "Generic questions unrelated to purchases"

  purchase_orders:
    use_when:
      - "Reporting vendor/supplier issues"
      - "Tracking procurement problems"
      - "Parts needed for support"
    avoid_when:
      - "Customer-facing issues"

  invoices:
    use_when:
      - "Billing disputes"
      - "Payment issues"
      - "Charging for support"
    avoid_when:
      - "Technical issues unrelated to billing"

  crm:
    use_when:
      - "Pre-sales technical questions"
      - "Support reveals upsell opportunity"
      - "Prospect evaluation support"
    avoid_when:
      - "Existing customer routine support"

  tasks:
    use_when:
      - "Bug requires development fix"
      - "Feature request accepted"
      - "Custom work needed"
    avoid_when:
      - "Standard support resolvable by team"

  timesheet:
    use_when:
      - "Billable support"
      - "Time tracking for analysis"
      - "Project-based support"
    avoid_when:
      - "Quick interactions < 5 minutes"

Reporting Across Integrations

To analyze cross-functional data:

1. Tickets by Sales Revenue
2. Join tickets to sales orders

3. Group by SO amount

4. Support Cost vs Sales

5. Timesheet hours × rate

6. Compare to linked SO value

7. Lead Conversion from Support

8. Track leads created from tickets
9. Monitor opportunity win rate

Next: Troubleshooting