5ec77aca64
The index is already added in production.
Adds a new reporting API that returns conversation counts grouped by
channel type and first response time buckets (0-1h, 1-4h, 4-8h, 8-24h,
24h+).
- GET /api/v2/accounts/:id/reports/first_response_time_distribution
- Uses SQL aggregation to handle large datasets efficiently
- Adds composite index on reporting_events for query performance
Tested on production workload.
Request: GET
`/api/v2/accounts/1/reports/first_response_time_distribution?since=<since>&until=<until>`
Response payload:
```
{
"Channel::WebWidget": {
"0-1h": 120,
"1-4h": 85,
"4-8h": 32,
"8-24h": 12,
"24h+": 3
},
"Channel::Email": {
"0-1h": 12,
"1-4h": 28,
"4-8h": 45,
"8-24h": 35,
"24h+": 10
},
"Channel::FacebookPage": {
"0-1h": 50,
"1-4h": 30,
"4-8h": 15,
"8-24h": 8,
"24h+": 2
}
}
```
---------
Co-authored-by: Muhsin Keloth <muhsinkeramam@gmail.com>
299 lines
12 KiB
Ruby
299 lines
12 KiB
Ruby
require 'rails_helper'
|
|
|
|
RSpec.describe Api::V2::Accounts::ReportsController, type: :request do
|
|
let(:account) { create(:account) }
|
|
let(:admin) { create(:user, account: account, role: :administrator) }
|
|
let(:agent) { create(:user, account: account, role: :agent) }
|
|
let(:inbox) { create(:inbox, account: account) }
|
|
|
|
describe 'GET /api/v2/accounts/{account.id}/reports' do
|
|
context 'when authenticated and authorized' do
|
|
before do
|
|
# Create conversations across 24 hours at different times
|
|
base_time = Time.utc(2024, 1, 14, 23, 0) # Start at 23:00 to span 2 days
|
|
|
|
# Create conversations every 4 hours across 24 hours
|
|
6.times do |i|
|
|
time = base_time + (i * 4).hours
|
|
travel_to time do
|
|
conversation = create(:conversation, account: account, inbox: inbox, assignee: agent)
|
|
create(:message, account: account, conversation: conversation, message_type: :outgoing)
|
|
end
|
|
end
|
|
end
|
|
|
|
it 'timezone_offset affects data grouping and timestamps correctly' do
|
|
travel_to Time.utc(2024, 1, 15, 12, 0) do
|
|
Time.use_zone('UTC') do
|
|
base_time = Time.utc(2024, 1, 14, 23, 0) # Start at 23:00 to span 2 days
|
|
base_params = {
|
|
metric: 'conversations_count',
|
|
type: 'account',
|
|
since: (base_time - 1.day).to_i.to_s,
|
|
until: (base_time + 2.days).to_i.to_s,
|
|
group_by: 'day'
|
|
}
|
|
|
|
responses = [0, -8, 9].map do |offset|
|
|
get "/api/v2/accounts/#{account.id}/reports",
|
|
params: base_params.merge(timezone_offset: offset),
|
|
headers: admin.create_new_auth_token, as: :json
|
|
response.parsed_body
|
|
end
|
|
|
|
data_entries = responses.map { |r| r.select { |e| e['value'] > 0 } }
|
|
totals = responses.map { |r| r.sum { |e| e['value'] } }
|
|
timestamps = responses.map { |r| r.map { |e| e['timestamp'] } }
|
|
|
|
# Data conservation and redistribution
|
|
expect(totals.uniq).to eq([6])
|
|
expect(data_entries[0].map { |e| e['value'] }).to eq([1, 5])
|
|
expect(data_entries[1].map { |e| e['value'] }).to eq([3, 3])
|
|
expect(data_entries[2].map { |e| e['value'] }).to eq([4, 2])
|
|
|
|
# Timestamp differences
|
|
expect(timestamps.uniq.size).to eq(3)
|
|
timestamps[0].zip(timestamps[1]).each { |utc, pst| expect(utc - pst).to eq(-28_800) }
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'timezone_offset does not affect summary report totals' do
|
|
let(:base_time) { Time.utc(2024, 1, 15, 12, 0) }
|
|
let(:summary_params) do
|
|
{
|
|
type: 'account',
|
|
since: (base_time - 1.day).to_i.to_s,
|
|
until: (base_time + 1.day).to_i.to_s
|
|
}
|
|
end
|
|
|
|
let(:jst_params) do
|
|
# For JST: User wants "Jan 15 JST" which translates to:
|
|
# Jan 14 15:00 UTC to Jan 15 15:00 UTC (event NOT included)
|
|
{
|
|
type: 'account',
|
|
since: (Time.utc(2024, 1, 15, 0, 0) - 9.hours).to_i.to_s, # Jan 14 15:00 UTC
|
|
until: (Time.utc(2024, 1, 16, 0, 0) - 9.hours).to_i.to_s # Jan 15 15:00 UTC
|
|
}
|
|
end
|
|
let(:utc_params) do
|
|
# For UTC: Jan 15 00:00 UTC to Jan 16 00:00 UTC (event included)
|
|
{
|
|
type: 'account',
|
|
since: Time.utc(2024, 1, 15, 0, 0).to_i.to_s,
|
|
until: Time.utc(2024, 1, 16, 0, 0).to_i.to_s
|
|
}
|
|
end
|
|
|
|
it 'returns identical conversation counts across timezones' do
|
|
Time.use_zone('UTC') do
|
|
summaries = [-8, 0, 9].map do |offset|
|
|
get "/api/v2/accounts/#{account.id}/reports/summary",
|
|
params: summary_params.merge(timezone_offset: offset),
|
|
headers: admin.create_new_auth_token, as: :json
|
|
response.parsed_body
|
|
end
|
|
|
|
conversation_counts = summaries.map { |s| s['conversations_count'] }
|
|
expect(conversation_counts.uniq).to eq([6])
|
|
end
|
|
end
|
|
|
|
it 'returns identical message counts across timezones' do
|
|
Time.use_zone('UTC') do
|
|
get "/api/v2/accounts/#{account.id}/reports/summary",
|
|
params: summary_params.merge(timezone_offset: 0),
|
|
headers: admin.create_new_auth_token, as: :json
|
|
utc_summary = response.parsed_body
|
|
|
|
get "/api/v2/accounts/#{account.id}/reports/summary",
|
|
params: summary_params.merge(timezone_offset: -8),
|
|
headers: admin.create_new_auth_token, as: :json
|
|
pst_summary = response.parsed_body
|
|
|
|
expect(utc_summary['incoming_messages_count']).to eq(pst_summary['incoming_messages_count'])
|
|
expect(utc_summary['outgoing_messages_count']).to eq(pst_summary['outgoing_messages_count'])
|
|
end
|
|
end
|
|
|
|
it 'returns consistent resolution counts across timezones' do
|
|
Time.use_zone('UTC') do
|
|
get "/api/v2/accounts/#{account.id}/reports/summary",
|
|
params: summary_params.merge(timezone_offset: 0),
|
|
headers: admin.create_new_auth_token, as: :json
|
|
utc_summary = response.parsed_body
|
|
|
|
get "/api/v2/accounts/#{account.id}/reports/summary",
|
|
params: summary_params.merge(timezone_offset: 9),
|
|
headers: admin.create_new_auth_token, as: :json
|
|
jst_summary = response.parsed_body
|
|
|
|
expect(utc_summary['resolutions_count']).to eq(jst_summary['resolutions_count'])
|
|
end
|
|
end
|
|
|
|
it 'returns consistent previous period data across timezones' do
|
|
Time.use_zone('UTC') do
|
|
get "/api/v2/accounts/#{account.id}/reports/summary",
|
|
params: summary_params.merge(timezone_offset: 0),
|
|
headers: admin.create_new_auth_token, as: :json
|
|
utc_summary = response.parsed_body
|
|
|
|
get "/api/v2/accounts/#{account.id}/reports/summary",
|
|
params: summary_params.merge(timezone_offset: -8),
|
|
headers: admin.create_new_auth_token, as: :json
|
|
pst_summary = response.parsed_body
|
|
|
|
expect(utc_summary['previous']['conversations_count']).to eq(pst_summary['previous']['conversations_count']) if utc_summary['previous']
|
|
end
|
|
end
|
|
|
|
it 'summary reports work when frontend sends correct timezone boundaries' do
|
|
Time.use_zone('UTC') do
|
|
# Create a resolution event right at timezone boundary
|
|
boundary_time = Time.utc(2024, 1, 15, 23, 30) # 11:30 PM UTC on Jan 15
|
|
gravatar_url = 'https://www.gravatar.com'
|
|
stub_request(:get, /#{gravatar_url}.*/).to_return(status: 404)
|
|
|
|
travel_to boundary_time do
|
|
perform_enqueued_jobs do
|
|
conversation = create(:conversation, account: account, inbox: inbox, assignee: agent)
|
|
conversation.resolved!
|
|
end
|
|
end
|
|
|
|
get "/api/v2/accounts/#{account.id}/reports/summary",
|
|
params: jst_params.merge(timezone_offset: 9),
|
|
headers: admin.create_new_auth_token, as: :json
|
|
jst_summary = response.parsed_body
|
|
|
|
get "/api/v2/accounts/#{account.id}/reports/summary",
|
|
params: utc_params.merge(timezone_offset: 0),
|
|
headers: admin.create_new_auth_token, as: :json
|
|
utc_summary = response.parsed_body
|
|
|
|
expect(jst_summary['resolutions_count']).to eq(0)
|
|
expect(utc_summary['resolutions_count']).to eq(1)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when unauthenticated' do
|
|
it 'returns unauthorized' do
|
|
get "/api/v2/accounts/#{account.id}/reports"
|
|
expect(response).to have_http_status(:unauthorized)
|
|
end
|
|
end
|
|
|
|
context 'when authenticated but not authorized' do
|
|
it 'returns forbidden' do
|
|
get "/api/v2/accounts/#{account.id}/reports",
|
|
headers: agent.create_new_auth_token,
|
|
as: :json
|
|
expect(response).to have_http_status(:unauthorized)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'GET /api/v2/accounts/{account.id}/reports/inbox_label_matrix' do
|
|
let!(:inbox_one) { create(:inbox, account: account, name: 'Email Support') }
|
|
let!(:label_one) { create(:label, account: account, title: 'bug') }
|
|
|
|
context 'when unauthenticated' do
|
|
it 'returns unauthorized' do
|
|
get "/api/v2/accounts/#{account.id}/reports/inbox_label_matrix"
|
|
expect(response).to have_http_status(:unauthorized)
|
|
end
|
|
end
|
|
|
|
context 'when authenticated as agent' do
|
|
it 'returns unauthorized' do
|
|
get "/api/v2/accounts/#{account.id}/reports/inbox_label_matrix",
|
|
headers: agent.create_new_auth_token, as: :json
|
|
expect(response).to have_http_status(:unauthorized)
|
|
end
|
|
end
|
|
|
|
context 'when authenticated as admin' do
|
|
before do
|
|
c1 = create(:conversation, account: account, inbox: inbox_one, created_at: 2.days.ago)
|
|
c1.update(label_list: [label_one.title])
|
|
end
|
|
|
|
it 'returns the inbox label matrix' do
|
|
get "/api/v2/accounts/#{account.id}/reports/inbox_label_matrix",
|
|
params: { since: 1.week.ago.to_i.to_s, until: Time.current.to_i.to_s },
|
|
headers: admin.create_new_auth_token, as: :json
|
|
|
|
expect(response).to have_http_status(:success)
|
|
|
|
body = response.parsed_body
|
|
expect(body['inboxes']).to be_an(Array)
|
|
expect(body['labels']).to be_an(Array)
|
|
expect(body['matrix']).to be_an(Array)
|
|
end
|
|
|
|
it 'filters by inbox_ids and label_ids' do
|
|
get "/api/v2/accounts/#{account.id}/reports/inbox_label_matrix",
|
|
params: { inbox_ids: [inbox_one.id], label_ids: [label_one.id] },
|
|
headers: admin.create_new_auth_token, as: :json
|
|
|
|
expect(response).to have_http_status(:success)
|
|
|
|
body = response.parsed_body
|
|
expect(body['inboxes'].length).to eq(1)
|
|
expect(body['labels'].length).to eq(1)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'GET /api/v2/accounts/{account.id}/reports/first_response_time_distribution' do
|
|
let!(:web_widget_inbox) { create(:inbox, account: account, channel: create(:channel_widget, account: account)) }
|
|
|
|
context 'when unauthenticated' do
|
|
it 'returns unauthorized' do
|
|
get "/api/v2/accounts/#{account.id}/reports/first_response_time_distribution"
|
|
expect(response).to have_http_status(:unauthorized)
|
|
end
|
|
end
|
|
|
|
context 'when authenticated as agent' do
|
|
it 'returns unauthorized' do
|
|
get "/api/v2/accounts/#{account.id}/reports/first_response_time_distribution",
|
|
headers: agent.create_new_auth_token, as: :json
|
|
expect(response).to have_http_status(:unauthorized)
|
|
end
|
|
end
|
|
|
|
context 'when authenticated as admin' do
|
|
before do
|
|
create(:reporting_event, account: account, inbox: web_widget_inbox, name: 'first_response',
|
|
value: 1_800, created_at: 2.days.ago)
|
|
end
|
|
|
|
it 'returns the first response time distribution' do
|
|
get "/api/v2/accounts/#{account.id}/reports/first_response_time_distribution",
|
|
params: { since: 1.week.ago.to_i.to_s, until: Time.current.to_i.to_s },
|
|
headers: admin.create_new_auth_token, as: :json
|
|
|
|
expect(response).to have_http_status(:success)
|
|
|
|
body = response.parsed_body
|
|
expect(body).to be_a(Hash)
|
|
expect(body['Channel::WebWidget']).to include('0-1h', '1-4h', '4-8h', '8-24h', '24h+')
|
|
end
|
|
|
|
it 'returns correct counts in buckets' do
|
|
get "/api/v2/accounts/#{account.id}/reports/first_response_time_distribution",
|
|
params: { since: 1.week.ago.to_i.to_s, until: Time.current.to_i.to_s },
|
|
headers: admin.create_new_auth_token, as: :json
|
|
|
|
body = response.parsed_body
|
|
expect(body['Channel::WebWidget']['0-1h']).to eq(1)
|
|
end
|
|
end
|
|
end
|
|
end
|