codoseo-core 0.1.0-rc.1

Shared types for CodoSEO, the open-source SEO crawler and monitor.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//! Plans and their limits. `None` means unlimited.

use std::time::Duration;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Plan {
    Free,
    Pro,
    Agency,
    SelfHosted,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Schedule {
    Weekly,
    Daily,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ManualAllowance {
    PerWeek(u32),
    PerDay(u32),
    Unlimited,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct PlanLimits {
    pub max_sites: Option<u32>,
    pub max_pages: Option<u32>,
    pub max_duration: Option<Duration>,
    /// The most frequent schedule allowed; `None` means no scheduled crawls.
    pub fastest_schedule: Option<Schedule>,
    pub manual_crawls: ManualAllowance,
    pub history_days: Option<u32>,
    pub api_calls_per_day: Option<u32>,
    pub email_alerts_only: bool,
}

const HOUR: u64 = 3600;

impl PlanLimits {
    pub fn for_plan(plan: Plan) -> PlanLimits {
        match plan {
            Plan::Free => PlanLimits {
                max_sites: Some(1),
                max_pages: Some(500),
                max_duration: Some(Duration::from_secs(600)),
                fastest_schedule: Some(Schedule::Weekly),
                manual_crawls: ManualAllowance::PerWeek(1),
                history_days: Some(30),
                api_calls_per_day: Some(100),
                email_alerts_only: true,
            },
            Plan::Pro => PlanLimits {
                max_sites: Some(5),
                max_pages: Some(10_000),
                max_duration: Some(Duration::from_secs(2 * HOUR)),
                fastest_schedule: Some(Schedule::Daily),
                manual_crawls: ManualAllowance::PerDay(1),
                history_days: Some(365),
                api_calls_per_day: Some(2_000),
                email_alerts_only: false,
            },
            Plan::Agency => PlanLimits {
                max_sites: Some(25),
                max_pages: Some(50_000),
                max_duration: Some(Duration::from_secs(6 * HOUR)),
                fastest_schedule: Some(Schedule::Daily),
                manual_crawls: ManualAllowance::Unlimited,
                history_days: Some(365),
                api_calls_per_day: Some(10_000),
                email_alerts_only: false,
            },
            // No plan caps, but finite defaults so a calendar or faceted search
            // can't crawl forever. Self-hosters can raise them in config.
            Plan::SelfHosted => PlanLimits {
                max_sites: None,
                max_pages: Some(100_000),
                max_duration: Some(Duration::from_secs(24 * HOUR)),
                fastest_schedule: Some(Schedule::Daily),
                manual_crawls: ManualAllowance::Unlimited,
                history_days: Some(365),
                api_calls_per_day: None,
                email_alerts_only: false,
            },
        }
    }

    /// The no-signup audit: one 100-page crawl, nothing else.
    pub fn quick_audit() -> PlanLimits {
        PlanLimits {
            max_sites: Some(0),
            max_pages: Some(100),
            max_duration: Some(Duration::from_secs(120)),
            fastest_schedule: None,
            manual_crawls: ManualAllowance::PerWeek(0),
            history_days: Some(7),
            api_calls_per_day: Some(0),
            email_alerts_only: true,
        }
    }
}