1use crate::groups::{Blueprint, CorporationRole, MedalStatus, Standing};
2use crate::prelude::*;
3
4#[derive(Debug, Deserialize, Serialize, Clone)]
5#[allow(missing_docs)]
6pub struct CorporationPublicInfo {
7 pub alliance_id: Option<i64>,
8 pub ceo_id: Option<i64>,
9 pub creator_id: Option<i64>,
10 pub date_founded: Option<String>,
11 pub description: Option<String>,
12 pub enlisted_faction_id: Option<i64>,
13 pub friendly_fire: Option<String>,
15 pub home_station_id: Option<i64>,
16 pub member_count: i64,
17 pub name: String,
18 pub palette: Option<CorporationPalette>,
19 pub shares: Option<i64>,
20 pub state: Option<String>,
22 pub tax_rates: Option<CorporationTaxRates>,
23 pub ticker: Option<String>,
24 #[serde(rename = "type")]
26 pub corporation_type: Option<String>,
27 pub url: Option<String>,
28 pub war_eligible: Option<bool>,
29}
30
31#[derive(Debug, Deserialize, Serialize, Clone)]
33pub struct CorporationTaxRates {
34 pub isk: Option<f64>,
36 pub loyalty_point: Option<f64>,
38}
39
40#[derive(Debug, Deserialize, Serialize, Clone)]
42pub struct CorporationPalette {
43 pub main_color: Option<String>,
45 pub secondary_color: Option<String>,
47 pub tertiary_color: Option<String>,
49}
50
51#[derive(Debug, Deserialize)]
52#[allow(missing_docs)]
53pub struct CorporationHistoryItem {
54 pub alliance_id: Option<i64>,
55 pub is_deleted: Option<bool>,
56 pub record_id: i64,
57 pub start_date: String,
58}
59
60#[derive(Debug, Deserialize, Serialize, Clone)]
62pub struct CorporationIcons {
63 pub px128x128: Option<String>,
65 pub px256x256: Option<String>,
67 pub px64x64: Option<String>,
69}
70
71#[derive(Debug, Deserialize, Serialize, Clone, Copy, PartialEq, Eq)]
73#[serde(rename_all = "snake_case")]
74pub enum ContainerAction {
75 Add,
77 Assemble,
79 Configure,
81 EnterPassword,
83 Lock,
85 Move,
87 Repackage,
89 SetName,
91 SetPassword,
93 Unlock,
95 #[serde(other)]
97 Unrecognized,
98}
99
100#[derive(Debug, Deserialize, Serialize, Clone, Copy, PartialEq, Eq)]
102#[serde(rename_all = "snake_case")]
103pub enum ContainerPasswordType {
104 Config,
106 General,
108 #[serde(other)]
110 Unrecognized,
111}
112
113#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
115pub struct ContainerLogEntry {
116 pub action: ContainerAction,
118 pub character_id: i64,
120 pub container_id: i64,
122 pub container_type_id: i64,
124 pub location_flag: String,
126 pub location_id: i64,
128 pub logged_at: String,
130 pub new_config_bitmask: Option<i64>,
132 pub old_config_bitmask: Option<i64>,
134 pub password_type: ContainerPasswordType,
136 pub quantity: Option<i64>,
138 pub type_id: Option<i64>,
140}
141
142#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
144pub struct Division {
145 pub division: Option<i64>,
147 pub name: Option<String>,
149}
150
151#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
153pub struct CorporationDivisions {
154 #[serde(default)]
156 pub hangar: Vec<Division>,
157 #[serde(default)]
159 pub wallet: Vec<Division>,
160}
161
162#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
164pub struct CorporationFacility {
165 pub facility_id: i64,
167 pub system_id: i64,
169 pub type_id: i64,
171}
172
173#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
175pub struct CorporationMedal {
176 pub created_at: String,
178 pub creator_id: i64,
180 pub description: String,
182 pub medal_id: i64,
184 pub title: String,
186}
187
188#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
190pub struct IssuedMedal {
191 pub character_id: i64,
193 pub issued_at: String,
195 pub issuer_id: i64,
197 pub medal_id: i64,
199 pub reason: String,
201 pub status: MedalStatus,
203}
204
205#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
207pub struct MemberTitles {
208 pub character_id: i64,
210 pub titles: Vec<i64>,
212}
213
214#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
216pub struct MemberTracking {
217 pub base_id: Option<i64>,
219 pub character_id: i64,
221 pub location_id: Option<i64>,
223 pub logoff_date: Option<String>,
225 pub logon_date: Option<String>,
227 pub ship_type_id: Option<i64>,
229 pub start_date: Option<String>,
231}
232
233#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
235pub struct MemberRoles {
236 pub character_id: i64,
238 #[serde(default)]
240 pub grantable_roles: Vec<CorporationRole>,
241 #[serde(default)]
243 pub grantable_roles_at_base: Vec<CorporationRole>,
244 #[serde(default)]
246 pub grantable_roles_at_hq: Vec<CorporationRole>,
247 #[serde(default)]
249 pub grantable_roles_at_other: Vec<CorporationRole>,
250 #[serde(default)]
252 pub roles: Vec<CorporationRole>,
253 #[serde(default)]
255 pub roles_at_base: Vec<CorporationRole>,
256 #[serde(default)]
258 pub roles_at_hq: Vec<CorporationRole>,
259 #[serde(default)]
261 pub roles_at_other: Vec<CorporationRole>,
262}
263
264#[derive(Debug, Deserialize, Serialize, Clone, Copy, PartialEq, Eq)]
266#[serde(rename_all = "snake_case")]
267pub enum RoleType {
268 GrantableRoles,
270 GrantableRolesAtBase,
272 GrantableRolesAtHq,
274 GrantableRolesAtOther,
276 Roles,
278 RolesAtBase,
280 RolesAtHq,
282 RolesAtOther,
284 #[serde(other)]
286 Unrecognized,
287}
288
289#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
291pub struct RoleHistoryEntry {
292 pub changed_at: String,
294 pub character_id: i64,
296 pub issuer_id: i64,
298 pub new_roles: Vec<CorporationRole>,
300 pub old_roles: Vec<CorporationRole>,
302 pub role_type: RoleType,
304}
305
306#[derive(Debug, Deserialize, Serialize, Clone, Copy, PartialEq, Eq)]
308#[serde(rename_all = "snake_case")]
309pub enum ShareholderType {
310 Character,
312 Corporation,
314 #[serde(other)]
316 Unrecognized,
317}
318
319#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
321pub struct Shareholder {
322 pub share_count: i64,
324 pub shareholder_id: i64,
326 pub shareholder_type: ShareholderType,
328}
329
330#[derive(Debug, Deserialize, Serialize, Clone, Copy, PartialEq, Eq)]
332#[serde(rename_all = "snake_case")]
333pub enum StarbaseState {
334 Offline,
336 Online,
338 Onlining,
340 Reinforced,
342 Unanchoring,
344 #[serde(other)]
346 Unrecognized,
347}
348
349#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
351pub struct Starbase {
352 pub moon_id: Option<i64>,
354 pub onlined_since: Option<String>,
356 pub reinforced_until: Option<String>,
358 pub starbase_id: i64,
360 pub state: Option<StarbaseState>,
362 pub system_id: i64,
364 pub type_id: i64,
366 pub unanchor_at: Option<String>,
368}
369
370#[derive(Debug, Deserialize, Serialize, Clone, Copy, PartialEq, Eq)]
372#[serde(rename_all = "snake_case")]
373pub enum StarbasePermission {
374 AllianceMember,
376 ConfigStarbaseEquipmentRole,
378 CorporationMember,
380 StarbaseFuelTechnicianRole,
382 #[serde(other)]
384 Unrecognized,
385}
386
387#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
389pub struct StarbaseFuel {
390 pub quantity: i64,
392 pub type_id: i64,
394}
395
396#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
398pub struct StarbaseDetails {
399 pub allow_alliance_members: bool,
401 pub allow_corporation_members: bool,
403 pub anchor: StarbasePermission,
405 pub attack_if_at_war: bool,
407 pub attack_if_other_security_status_dropping: bool,
409 pub attack_security_status_threshold: Option<f64>,
411 pub attack_standing_threshold: Option<f64>,
413 pub fuel_bay_take: StarbasePermission,
415 pub fuel_bay_view: StarbasePermission,
417 #[serde(default)]
419 pub fuels: Vec<StarbaseFuel>,
420 pub offline: StarbasePermission,
422 pub online: StarbasePermission,
424 pub unanchor: StarbasePermission,
426 pub use_alliance_standings: bool,
428}
429
430#[derive(Debug, Deserialize, Serialize, Clone, Copy, PartialEq, Eq)]
432#[serde(rename_all = "snake_case")]
433pub enum ServiceState {
434 Online,
436 Offline,
438 Cleanup,
440 #[serde(other)]
442 Unrecognized,
443}
444
445#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
447pub struct StructureService {
448 pub name: String,
450 pub state: ServiceState,
452}
453
454#[derive(Debug, Deserialize, Serialize, Clone, Copy, PartialEq, Eq)]
456#[serde(rename_all = "snake_case")]
457pub enum StructureState {
458 AnchorVulnerable,
460 Anchoring,
462 ArmorReinforce,
464 ArmorVulnerable,
466 DeployVulnerable,
468 FittingInvulnerable,
470 HullReinforce,
472 HullVulnerable,
474 OnlineDeprecated,
476 OnliningVulnerable,
478 ShieldVulnerable,
480 Unanchored,
482 Unknown,
484 #[serde(other)]
486 Unrecognized,
487}
488
489#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
491pub struct CorporationStructure {
492 pub corporation_id: i64,
494 pub fuel_expires: Option<String>,
496 pub name: Option<String>,
498 pub next_reinforce_apply: Option<String>,
500 pub next_reinforce_hour: Option<i64>,
502 pub profile_id: i64,
504 pub reinforce_hour: Option<i64>,
506 #[serde(default)]
508 pub services: Vec<StructureService>,
509 pub state: StructureState,
511 pub state_timer_end: Option<String>,
513 pub state_timer_start: Option<String>,
515 pub structure_id: i64,
517 pub system_id: i64,
519 pub type_id: i64,
521 pub unanchors_at: Option<String>,
523}
524
525#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
527pub struct CorporationTitle {
528 #[serde(default)]
530 pub grantable_roles: Vec<CorporationRole>,
531 #[serde(default)]
533 pub grantable_roles_at_base: Vec<CorporationRole>,
534 #[serde(default)]
536 pub grantable_roles_at_hq: Vec<CorporationRole>,
537 #[serde(default)]
539 pub grantable_roles_at_other: Vec<CorporationRole>,
540 pub name: Option<String>,
542 #[serde(default)]
544 pub roles: Vec<CorporationRole>,
545 #[serde(default)]
547 pub roles_at_base: Vec<CorporationRole>,
548 #[serde(default)]
550 pub roles_at_hq: Vec<CorporationRole>,
551 #[serde(default)]
553 pub roles_at_other: Vec<CorporationRole>,
554 pub title_id: Option<i64>,
556}
557
558pub struct CorporationGroup<'a> {
560 pub(crate) esi: &'a Esi,
561}
562
563impl CorporationGroup<'_> {
564 api_get!(
565 get_public_info,
567 "GetCorporationsCorporationId",
568 RequestType::Public,
569 CorporationPublicInfo,
570 (corporation_id: i64) => "{corporation_id}"
571 );
572
573 api_get!(
574 get_history,
576 "GetCorporationsCorporationIdAlliancehistory",
577 RequestType::Public,
578 Vec<CorporationHistoryItem>,
579 (corporation_id: i64) => "{corporation_id}"
580 );
581
582 api_get!(
583 get_members,
587 "GetCorporationsCorporationIdMembers",
588 RequestType::Authenticated,
589 Vec<i64>,
590 (corporation_id: i64) => "{corporation_id}"
591 );
592
593 api_get!(
594 get_npc_corps,
596 "GetCorporationsNpccorps",
597 RequestType::Public,
598 Vec<i64>,
599 );
600
601 api_get!(
602 get_blueprints,
606 "GetCorporationsCorporationIdBlueprints",
607 RequestType::Authenticated,
608 Vec<Blueprint>,
609 (corporation_id: i64) => "{corporation_id}";
610 Optional(page: i32) => "page"
611 );
612
613 api_get!(
614 get_container_logs,
618 "GetCorporationsCorporationIdContainersLogs",
619 RequestType::Authenticated,
620 Vec<ContainerLogEntry>,
621 (corporation_id: i64) => "{corporation_id}";
622 Optional(page: i32) => "page"
623 );
624
625 api_get!(
626 get_divisions,
630 "GetCorporationsCorporationIdDivisions",
631 RequestType::Authenticated,
632 CorporationDivisions,
633 (corporation_id: i64) => "{corporation_id}"
634 );
635
636 api_get!(
637 get_facilities,
641 "GetCorporationsCorporationIdFacilities",
642 RequestType::Authenticated,
643 Vec<CorporationFacility>,
644 (corporation_id: i64) => "{corporation_id}"
645 );
646
647 api_get!(
648 get_icons,
650 "GetCorporationsCorporationIdIcons",
651 RequestType::Public,
652 CorporationIcons,
653 (corporation_id: i64) => "{corporation_id}"
654 );
655
656 api_get!(
657 get_medals,
659 "GetCorporationsCorporationIdMedals",
660 RequestType::Authenticated,
661 Vec<CorporationMedal>,
662 (corporation_id: i64) => "{corporation_id}";
663 Optional(page: i32) => "page"
664 );
665
666 api_get!(
667 get_issued_medals,
671 "GetCorporationsCorporationIdMedalsIssued",
672 RequestType::Authenticated,
673 Vec<IssuedMedal>,
674 (corporation_id: i64) => "{corporation_id}";
675 Optional(page: i32) => "page"
676 );
677
678 api_get!(
679 get_members_limit,
683 "GetCorporationsCorporationIdMembersLimit",
684 RequestType::Authenticated,
685 i64,
686 (corporation_id: i64) => "{corporation_id}"
687 );
688
689 api_get!(
690 get_member_titles,
694 "GetCorporationsCorporationIdMembersTitles",
695 RequestType::Authenticated,
696 Vec<MemberTitles>,
697 (corporation_id: i64) => "{corporation_id}"
698 );
699
700 api_get!(
701 get_member_tracking,
705 "GetCorporationsCorporationIdMembertracking",
706 RequestType::Authenticated,
707 Vec<MemberTracking>,
708 (corporation_id: i64) => "{corporation_id}"
709 );
710
711 api_get!(
712 get_roles,
714 "GetCorporationsCorporationIdRoles",
715 RequestType::Authenticated,
716 Vec<MemberRoles>,
717 (corporation_id: i64) => "{corporation_id}"
718 );
719
720 api_get!(
721 get_roles_history,
725 "GetCorporationsCorporationIdRolesHistory",
726 RequestType::Authenticated,
727 Vec<RoleHistoryEntry>,
728 (corporation_id: i64) => "{corporation_id}";
729 Optional(page: i32) => "page"
730 );
731
732 api_get!(
733 get_shareholders,
737 "GetCorporationsCorporationIdShareholders",
738 RequestType::Authenticated,
739 Vec<Shareholder>,
740 (corporation_id: i64) => "{corporation_id}";
741 Optional(page: i32) => "page"
742 );
743
744 api_get!(
745 get_standings,
747 "GetCorporationsCorporationIdStandings",
748 RequestType::Authenticated,
749 Vec<Standing>,
750 (corporation_id: i64) => "{corporation_id}";
751 Optional(page: i32) => "page"
752 );
753
754 api_get!(
755 get_starbases,
759 "GetCorporationsCorporationIdStarbases",
760 RequestType::Authenticated,
761 Vec<Starbase>,
762 (corporation_id: i64) => "{corporation_id}";
763 Optional(page: i32) => "page"
764 );
765
766 api_get!(
767 get_starbase,
772 "GetCorporationsCorporationIdStarbasesStarbaseId",
773 RequestType::Authenticated,
774 StarbaseDetails,
775 (corporation_id: i64) => "{corporation_id}",
776 (starbase_id: i64) => "{starbase_id}";
777 Required(system_id: i64) => "system_id"
778 );
779
780 api_get!(
781 get_structures,
785 "GetCorporationsCorporationIdStructures",
786 RequestType::Authenticated,
787 Vec<CorporationStructure>,
788 (corporation_id: i64) => "{corporation_id}";
789 Optional(page: i32) => "page"
790 );
791
792 api_get!(
793 get_titles,
797 "GetCorporationsCorporationIdTitles",
798 RequestType::Authenticated,
799 Vec<CorporationTitle>,
800 (corporation_id: i64) => "{corporation_id}"
801 );
802}
803
804#[cfg(test)]
805mod corporation_management_tests {
806 use super::*;
807
808 #[test]
809 fn test_parse_roles_and_history() {
810 let r: Vec<MemberRoles> = serde_json::from_str(
811 r#"[{"character_id": 2124758468, "roles": ["Director", "Brand_New_Role"],
812 "roles_at_hq": ["Trader"]}]"#,
813 )
814 .unwrap();
815 assert_eq!(r[0].roles[0], CorporationRole::Director);
816 assert_eq!(r[0].roles[1], CorporationRole::Unrecognized);
817 assert!(r[0].grantable_roles.is_empty());
818 let h: Vec<RoleHistoryEntry> = serde_json::from_str(
819 r#"[{"changed_at": "t", "character_id": 1, "issuer_id": 2, "new_roles": ["Trader"],
820 "old_roles": [], "role_type": "roles_at_hq"}]"#,
821 )
822 .unwrap();
823 assert_eq!(h[0].role_type, RoleType::RolesAtHq);
824 }
825
826 #[test]
827 fn test_parse_structures_and_starbases() {
828 let s: Vec<CorporationStructure> = serde_json::from_str(
829 r#"[{"corporation_id": 98000001, "profile_id": 1, "state": "shield_vulnerable",
830 "structure_id": 1040000000000, "system_id": 30000142, "type_id": 35832,
831 "services": [{"name": "Market", "state": "online"}]},
832 {"corporation_id": 98000001, "profile_id": 1, "state": "something_new",
833 "structure_id": 1, "system_id": 1, "type_id": 1}]"#,
834 )
835 .unwrap();
836 assert_eq!(s[0].structure_id, 1_040_000_000_000);
837 assert_eq!(s[0].services[0].state, ServiceState::Online);
838 assert_eq!(s[1].state, StructureState::Unrecognized);
839 let d: StarbaseDetails = serde_json::from_str(
840 r#"{"allow_alliance_members": true, "allow_corporation_members": true,
841 "anchor": "alliance_member", "attack_if_at_war": false,
842 "attack_if_other_security_status_dropping": false,
843 "fuel_bay_take": "corporation_member", "fuel_bay_view": "corporation_member",
844 "offline": "starbase_fuel_technician_role", "online": "x", "unanchor": "alliance_member",
845 "use_alliance_standings": false, "fuels": [{"quantity": 4000000000, "type_id": 4247}]}"#,
846 )
847 .unwrap();
848 assert_eq!(d.offline, StarbasePermission::StarbaseFuelTechnicianRole);
849 assert_eq!(d.online, StarbasePermission::Unrecognized);
850 assert_eq!(d.fuels[0].quantity, 4_000_000_000);
851 }
852
853 #[test]
854 fn test_parse_misc() {
855 let d: CorporationDivisions =
856 serde_json::from_str(r#"{"hangar": [{"division": 1, "name": "Main"}]}"#).unwrap();
857 assert_eq!(d.hangar[0].division, Some(1));
858 assert!(d.wallet.is_empty());
859 let l: Vec<ContainerLogEntry> = serde_json::from_str(
860 r#"[{"action": "enter_password", "character_id": 1, "container_id": 1000000000000,
861 "container_type_id": 17366, "location_flag": "CorpSAG1", "location_id": 2,
862 "logged_at": "t", "password_type": "config"}]"#,
863 )
864 .unwrap();
865 assert_eq!(l[0].action, ContainerAction::EnterPassword);
866 let t: Vec<CorporationTitle> =
867 serde_json::from_str(r#"[{"title_id": 1, "name": "CEO", "roles": ["Director"]}]"#)
868 .unwrap();
869 assert_eq!(t[0].roles, vec![CorporationRole::Director]);
870 let sh: Vec<Shareholder> = serde_json::from_str(
871 r#"[{"share_count": 5000000000, "shareholder_id": 1, "shareholder_type": "character"}]"#,
872 )
873 .unwrap();
874 assert_eq!(sh[0].share_count, 5_000_000_000);
875 }
876}