github.com/argoproj/argo-cd/v3@v3.2.1/ui/src/app/shared/services/repo-service.ts (about)

     1  import * as models from '../models';
     2  import requests from './requests';
     3  
     4  export interface HTTPSQuery {
     5      type: string;
     6      name: string;
     7      url: string;
     8      username: string;
     9      password: string;
    10      bearerToken: string;
    11      tlsClientCertData: string;
    12      tlsClientCertKey: string;
    13      insecure: boolean;
    14      enableLfs: boolean;
    15      proxy: string;
    16      noProxy: string;
    17      project?: string;
    18      forceHttpBasicAuth?: boolean;
    19      enableOCI: boolean;
    20      useAzureWorkloadIdentity: boolean;
    21      insecureOCIForceHttp: boolean;
    22  }
    23  
    24  export interface SSHQuery {
    25      type: string;
    26      name: string;
    27      url: string;
    28      sshPrivateKey: string;
    29      insecure: boolean;
    30      enableLfs: boolean;
    31      proxy: string;
    32      noProxy: string;
    33      project?: string;
    34  }
    35  
    36  export interface GitHubAppQuery {
    37      type: string;
    38      name: string;
    39      url: string;
    40      githubAppPrivateKey: string;
    41      githubAppId: bigint;
    42      githubAppInstallationId: bigint;
    43      githubAppEnterpriseBaseURL: string;
    44      tlsClientCertData: string;
    45      tlsClientCertKey: string;
    46      insecure: boolean;
    47      enableLfs: boolean;
    48      proxy: string;
    49      noProxy: string;
    50      project?: string;
    51  }
    52  
    53  export interface GoogleCloudSourceQuery {
    54      type: string;
    55      name: string;
    56      url: string;
    57      gcpServiceAccountKey: string;
    58      proxy: string;
    59      noProxy: string;
    60      project?: string;
    61  }
    62  
    63  export class RepositoriesService {
    64      public list(): Promise<models.Repository[]> {
    65          return requests
    66              .get(`/repositories`)
    67              .then(res => res.body as models.RepositoryList)
    68              .then(list => list.items || []);
    69      }
    70  
    71      public listWrite(): Promise<models.Repository[]> {
    72          return requests
    73              .get(`/write-repositories`)
    74              .then(res => res.body as models.RepositoryList)
    75              .then(list => list.items || []);
    76      }
    77  
    78      public listNoCache(): Promise<models.Repository[]> {
    79          return requests
    80              .get(`/repositories?forceRefresh=true`)
    81              .then(res => res.body as models.RepositoryList)
    82              .then(list => list.items || []);
    83      }
    84  
    85      public listWriteNoCache(): Promise<models.Repository[]> {
    86          return requests
    87              .get(`/write-repositories?forceRefresh=true`)
    88              .then(res => res.body as models.RepositoryList)
    89              .then(list => list.items || []);
    90      }
    91  
    92      public createHTTPS(q: HTTPSQuery): Promise<models.Repository> {
    93          return requests
    94              .post('/repositories')
    95              .send({
    96                  type: q.type,
    97                  name: q.name,
    98                  repo: q.url,
    99                  username: q.username,
   100                  password: q.password,
   101                  bearerToken: q.bearerToken,
   102                  tlsClientCertData: q.tlsClientCertData,
   103                  tlsClientCertKey: q.tlsClientCertKey,
   104                  insecure: q.insecure,
   105                  enableLfs: q.enableLfs,
   106                  proxy: q.proxy,
   107                  noProxy: q.noProxy,
   108                  project: q.project,
   109                  forceHttpBasicAuth: q.forceHttpBasicAuth,
   110                  enableOCI: q.enableOCI,
   111                  useAzureWorkloadIdentity: q.useAzureWorkloadIdentity,
   112                  insecureOCIForceHttp: q.insecureOCIForceHttp
   113              })
   114              .then(res => res.body as models.Repository);
   115      }
   116  
   117      public createHTTPSWrite(q: HTTPSQuery): Promise<models.Repository> {
   118          return requests
   119              .post('/write-repositories')
   120              .send({
   121                  type: q.type,
   122                  name: q.name,
   123                  repo: q.url,
   124                  username: q.username,
   125                  password: q.password,
   126                  bearerToken: q.bearerToken,
   127                  tlsClientCertData: q.tlsClientCertData,
   128                  tlsClientCertKey: q.tlsClientCertKey,
   129                  insecure: q.insecure,
   130                  enableLfs: q.enableLfs,
   131                  proxy: q.proxy,
   132                  noProxy: q.noProxy,
   133                  project: q.project,
   134                  forceHttpBasicAuth: q.forceHttpBasicAuth,
   135                  enableOCI: q.enableOCI,
   136                  useAzureWorkloadIdentity: q.useAzureWorkloadIdentity,
   137                  insecureOCIForceHttp: q.insecureOCIForceHttp
   138              })
   139              .then(res => res.body as models.Repository);
   140      }
   141  
   142      public updateHTTPS(q: HTTPSQuery): Promise<models.Repository> {
   143          return requests
   144              .put(`/repositories/${encodeURIComponent(q.url)}`)
   145              .send({
   146                  type: q.type,
   147                  name: q.name,
   148                  repo: q.url,
   149                  username: q.username,
   150                  password: q.password,
   151                  bearerToken: q.bearerToken,
   152                  tlsClientCertData: q.tlsClientCertData,
   153                  tlsClientCertKey: q.tlsClientCertKey,
   154                  insecure: q.insecure,
   155                  enableLfs: q.enableLfs,
   156                  proxy: q.proxy,
   157                  noProxy: q.noProxy,
   158                  project: q.project,
   159                  forceHttpBasicAuth: q.forceHttpBasicAuth,
   160                  enableOCI: q.enableOCI,
   161                  useAzureWorkloadIdentity: q.useAzureWorkloadIdentity,
   162                  insecureOCIForceHttp: q.insecureOCIForceHttp
   163              })
   164              .then(res => res.body as models.Repository);
   165      }
   166  
   167      public updateHTTPSWrite(q: HTTPSQuery): Promise<models.Repository> {
   168          return requests
   169              .put(`/write-repositories/${encodeURIComponent(q.url)}`)
   170              .send({
   171                  type: q.type,
   172                  name: q.name,
   173                  repo: q.url,
   174                  username: q.username,
   175                  password: q.password,
   176                  bearerToken: q.bearerToken,
   177                  tlsClientCertData: q.tlsClientCertData,
   178                  tlsClientCertKey: q.tlsClientCertKey,
   179                  insecure: q.insecure,
   180                  enableLfs: q.enableLfs,
   181                  proxy: q.proxy,
   182                  noProxy: q.noProxy,
   183                  project: q.project,
   184                  forceHttpBasicAuth: q.forceHttpBasicAuth,
   185                  enableOCI: q.enableOCI,
   186                  useAzureWorkloadIdentity: q.useAzureWorkloadIdentity,
   187                  insecureOCIForceHttp: q.insecureOCIForceHttp
   188              })
   189              .then(res => res.body as models.Repository);
   190      }
   191  
   192      public createSSH(q: SSHQuery): Promise<models.Repository> {
   193          return requests
   194              .post('/repositories')
   195              .send({
   196                  type: q.type,
   197                  name: q.name,
   198                  repo: q.url,
   199                  sshPrivateKey: q.sshPrivateKey,
   200                  insecure: q.insecure,
   201                  enableLfs: q.enableLfs,
   202                  proxy: q.proxy,
   203                  noProxy: q.noProxy,
   204                  project: q.project
   205              })
   206              .then(res => res.body as models.Repository);
   207      }
   208  
   209      public createSSHWrite(q: SSHQuery): Promise<models.Repository> {
   210          return requests
   211              .post('/write-repositories')
   212              .send({
   213                  type: q.type,
   214                  name: q.name,
   215                  repo: q.url,
   216                  sshPrivateKey: q.sshPrivateKey,
   217                  insecure: q.insecure,
   218                  enableLfs: q.enableLfs,
   219                  proxy: q.proxy,
   220                  noProxy: q.noProxy,
   221                  project: q.project
   222              })
   223              .then(res => res.body as models.Repository);
   224      }
   225  
   226      public createGitHubApp(q: GitHubAppQuery): Promise<models.Repository> {
   227          return requests
   228              .post('/repositories')
   229              .send({
   230                  type: q.type,
   231                  name: q.name,
   232                  repo: q.url,
   233                  githubAppPrivateKey: q.githubAppPrivateKey,
   234                  githubAppId: q.githubAppId,
   235                  githubAppInstallationId: q.githubAppInstallationId,
   236                  githubAppEnterpriseBaseURL: q.githubAppEnterpriseBaseURL,
   237                  tlsClientCertData: q.tlsClientCertData,
   238                  tlsClientCertKey: q.tlsClientCertKey,
   239                  insecure: q.insecure,
   240                  enableLfs: q.enableLfs,
   241                  proxy: q.proxy,
   242                  noProxy: q.noProxy,
   243                  project: q.project
   244              })
   245              .then(res => res.body as models.Repository);
   246      }
   247  
   248      public createGitHubAppWrite(q: GitHubAppQuery): Promise<models.Repository> {
   249          return requests
   250              .post('/write-repositories')
   251              .send({
   252                  type: q.type,
   253                  name: q.name,
   254                  repo: q.url,
   255                  githubAppPrivateKey: q.githubAppPrivateKey,
   256                  githubAppId: q.githubAppId,
   257                  githubAppInstallationId: q.githubAppInstallationId,
   258                  githubAppEnterpriseBaseURL: q.githubAppEnterpriseBaseURL,
   259                  tlsClientCertData: q.tlsClientCertData,
   260                  tlsClientCertKey: q.tlsClientCertKey,
   261                  insecure: q.insecure,
   262                  enableLfs: q.enableLfs,
   263                  proxy: q.proxy,
   264                  noProxy: q.noProxy,
   265                  project: q.project
   266              })
   267              .then(res => res.body as models.Repository);
   268      }
   269  
   270      public createGoogleCloudSource(q: GoogleCloudSourceQuery): Promise<models.Repository> {
   271          return requests
   272              .post('/repositories')
   273              .send({
   274                  type: q.type,
   275                  name: q.name,
   276                  repo: q.url,
   277                  gcpServiceAccountKey: q.gcpServiceAccountKey,
   278                  proxy: q.proxy,
   279                  noProxy: q.noProxy,
   280                  project: q.project
   281              })
   282              .then(res => res.body as models.Repository);
   283      }
   284  
   285      public createGoogleCloudSourceWrite(q: GoogleCloudSourceQuery): Promise<models.Repository> {
   286          return requests
   287              .post('/write-repositories')
   288              .send({
   289                  type: q.type,
   290                  name: q.name,
   291                  repo: q.url,
   292                  gcpServiceAccountKey: q.gcpServiceAccountKey,
   293                  proxy: q.proxy,
   294                  noProxy: q.noProxy,
   295                  project: q.project
   296              })
   297              .then(res => res.body as models.Repository);
   298      }
   299  
   300      public delete(url: string, project: string): Promise<models.Repository> {
   301          return requests
   302              .delete(`/repositories/${encodeURIComponent(url)}?appProject=${project}`)
   303              .send()
   304              .then(res => res.body as models.Repository);
   305      }
   306  
   307      public deleteWrite(url: string, project: string): Promise<models.Repository> {
   308          return requests
   309              .delete(`/write-repositories/${encodeURIComponent(url)}?appProject=${project}`)
   310              .send()
   311              .then(res => res.body as models.Repository);
   312      }
   313  
   314      public async revisions(repo: string): Promise<models.RefsInfo> {
   315          return requests.get(`/repositories/${encodeURIComponent(repo)}/refs`).then(res => res.body as models.RefsInfo);
   316      }
   317  
   318      public async ociTags(repo: string): Promise<models.RefsInfo> {
   319          return requests.get(`/repositories/${encodeURIComponent(repo)}/oci-tags`).then(res => res.body as models.RefsInfo);
   320      }
   321  
   322      public apps(repo: string, revision: string, appName: string, appProject: string): Promise<models.AppInfo[]> {
   323          return requests
   324              .get(`/repositories/${encodeURIComponent(repo)}/apps`)
   325              .query({revision})
   326              .query({appName})
   327              .query({appProject})
   328              .then(res => (res.body.items as models.AppInfo[]) || []);
   329      }
   330  
   331      public charts(repo: string): Promise<models.HelmChart[]> {
   332          return requests.get(`/repositories/${encodeURIComponent(repo)}/helmcharts`).then(res => (res.body.items as models.HelmChart[]) || []);
   333      }
   334  
   335      public appDetails(source: models.ApplicationSource, appName: string, appProject: string, sourceIndex: number, versionId: number | null): Promise<models.RepoAppDetails> {
   336          return requests
   337              .post(`/repositories/${encodeURIComponent(source.repoURL)}/appdetails`)
   338              .send({source, appName, appProject, sourceIndex, versionId})
   339              .then(res => res.body as models.RepoAppDetails);
   340      }
   341  }