argo-cd

1
import requests from './requests';
2

3
import * as models from '../models';
4

5
export interface CreateJWTTokenParams {
6
    project: string;
7
    role: string;
8
    expiresIn: number;
9
}
10

11
export interface DeleteJWTTokenParams {
12
    project: string;
13
    role: string;
14
    iat: number;
15
}
16

17
export interface JWTTokenResponse {
18
    token: string;
19
}
20

21
export interface ProjectSyncWindowsParams {
22
    projName: string;
23
    id: number;
24
    window: models.SyncWindow;
25
    deleteWindow: boolean;
26
}
27

28
export interface ProjectRoleParams {
29
    projName: string;
30
    roleName: string;
31
    description: string;
32
    policies: string[] | string;
33
    jwtTokens: models.JwtToken[];
34
    groups: string[];
35
    deleteRole: boolean;
36
    expiresIn: string;
37
}
38

39
function paramsToProjRole(params: ProjectRoleParams): models.ProjectRole {
40
    let newPolicies = [] as string[];
41
    if (typeof params.policies === 'string') {
42
        if (params.policies !== '') {
43
            newPolicies = params.policies.split('\n');
44
        }
45
    } else {
46
        newPolicies = params.policies;
47
    }
48
    return {
49
        name: params.roleName,
50
        description: params.description,
51
        policies: newPolicies,
52
        groups: params.groups
53
    };
54
}
55

56
export class ProjectsService {
57
    public list(...fields: string[]): Promise<models.Project[]> {
58
        return requests
59
            .get('/projects')
60
            .query({fields: fields.join(',')})
61
            .then(res => res.body as models.ProjectList)
62
            .then(list => list.items || []);
63
    }
64

65
    public get(name: string): Promise<models.Project> {
66
        return requests.get(`/projects/${name}`).then(res => res.body as models.Project);
67
    }
68

69
    public getDetailed(name: string): Promise<models.DetailedProjectsResponse> {
70
        return requests.get(`/projects/${name}/detailed`).then(res => res.body as models.DetailedProjectsResponse);
71
    }
72

73
    public getGlobalProjects(name: string): Promise<models.Project[]> {
74
        return requests.get(`/projects/${name}/globalprojects`).then(res => res.body.items as models.Project[]);
75
    }
76

77
    public delete(name: string): Promise<boolean> {
78
        return requests.delete(`/projects/${name}`).then(() => true);
79
    }
80

81
    public create(project: models.Project): Promise<models.Project> {
82
        return requests
83
            .post('/projects')
84
            .send({project})
85
            .then(res => res.body as models.Project);
86
    }
87

88
    public async update(project: models.Project): Promise<models.Project> {
89
        return requests
90
            .put(`/projects/${project.metadata.name}`)
91
            .send({project})
92
            .then(res => res.body as models.Project);
93
    }
94

95
    public getSyncWindows(name: string): Promise<models.SyncWindowsState> {
96
        return requests
97
            .get(`/projects/${name}/syncwindows`)
98
            .query({name})
99
            .then(res => res.body as models.SyncWindowsState);
100
    }
101

102
    public async updateWindow(params: ProjectSyncWindowsParams): Promise<models.Project> {
103
        const proj = await this.get(params.projName);
104
        const updatedSpec = proj.spec;
105
        if (proj.spec.syncWindows === undefined) {
106
            updatedSpec.syncWindows = [];
107
        }
108
        if (params.id === undefined || !(params.id in proj.spec.syncWindows)) {
109
            updatedSpec.syncWindows = updatedSpec.syncWindows.concat(params.window);
110
        } else {
111
            if (params.deleteWindow) {
112
                updatedSpec.syncWindows.splice(params.id, 1);
113
            } else {
114
                updatedSpec.syncWindows[params.id] = params.window;
115
            }
116
        }
117

118
        return requests
119
            .put(`/projects/${params.projName}`)
120
            .send({project: {...proj, spec: updatedSpec}})
121
            .then(res => res.body as models.Project);
122
    }
123

124
    public async updateRole(params: ProjectRoleParams): Promise<models.Project> {
125
        const proj = await this.get(params.projName);
126
        const updatedRole = paramsToProjRole(params);
127
        let roleExist = false;
128
        if (proj.spec.roles === undefined) {
129
            proj.spec.roles = [];
130
        }
131
        const updatedSpec = proj.spec;
132

133
        for (let i = 0; i < proj.spec.roles.length; i++) {
134
            if (proj.spec.roles[i].name === params.roleName) {
135
                roleExist = true;
136
                if (params.deleteRole) {
137
                    updatedSpec.roles.splice(i, 1);
138
                    break;
139
                }
140
                updatedSpec.roles[i] = updatedRole;
141
            }
142
        }
143
        if (!roleExist) {
144
            if (updatedSpec.roles === undefined) {
145
                updatedSpec.roles = [];
146
            }
147
            updatedSpec.roles = updatedSpec.roles.concat(updatedRole);
148
        }
149
        return requests
150
            .put(`/projects/${params.projName}`)
151
            .send({project: {...proj, spec: updatedSpec}})
152
            .then(res => res.body as models.Project);
153
    }
154

155
    public async createJWTToken(params: CreateJWTTokenParams): Promise<JWTTokenResponse> {
156
        return requests
157
            .post(`/projects/${params.project}/roles/${params.role}/token`)
158
            .send(params)
159
            .then(res => res.body as JWTTokenResponse);
160
    }
161

162
    public async deleteJWTToken(params: DeleteJWTTokenParams): Promise<boolean> {
163
        return requests
164
            .delete(`/projects/${params.project}/roles/${params.role}/token/${params.iat}`)
165
            .send()
166
            .then(() => true);
167
    }
168

169
    public events(projectName: string): Promise<models.Event[]> {
170
        return requests
171
            .get(`/projects/${projectName}/events`)
172
            .send()
173
            .then(res => (res.body as models.EventList).items || []);
174
    }
175

176
    public getLinks(projectName: string): Promise<models.LinksResponse> {
177
        return requests
178
            .get(`/projects/${projectName}/links`)
179
            .send()
180
            .then(res => res.body as models.LinksResponse);
181
    }
182
}
183