378 lines
11 KiB
Go
378 lines
11 KiB
Go
// Copyright (c) All respective contributors to the Peridot Project. All rights reserved.
|
|
// Copyright (c) 2021-2022 Rocky Enterprise Software Foundation, Inc. All rights reserved.
|
|
// Copyright (c) 2021-2022 Ctrl IQ, Inc. All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are met:
|
|
//
|
|
// 1. Redistributions of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
//
|
|
// 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// 3. Neither the name of the copyright holder nor the names of its contributors
|
|
// may be used to endorse or promote products derived from this software without
|
|
// specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
package serverpsql
|
|
|
|
import (
|
|
"github.com/lib/pq"
|
|
"peridot.resf.org/peridot/db/models"
|
|
peridotpb "peridot.resf.org/peridot/pb"
|
|
"peridot.resf.org/utils"
|
|
)
|
|
|
|
func (a *Access) GetPackagesInProject(filters *peridotpb.PackageFilters, projectId string, page int32, limit int32) (models.Packages, error) {
|
|
if filters == nil {
|
|
filters = &peridotpb.PackageFilters{}
|
|
}
|
|
|
|
var p models.Packages
|
|
err := a.query.Select(
|
|
&p,
|
|
`
|
|
select
|
|
p.id,
|
|
p.created_at,
|
|
p.updated_at,
|
|
p.name,
|
|
p.package_type,
|
|
proj_p.package_type_override,
|
|
(
|
|
select
|
|
ir.created_at
|
|
from import_revisions ir
|
|
where package_version_id = (
|
|
select
|
|
proj_pv.package_version_id
|
|
from project_package_versions proj_pv
|
|
where
|
|
proj_pv.package_id = p.id
|
|
and proj_pv.project_id = proj_p.project_id
|
|
and proj_pv.active = true
|
|
order by proj_pv.created_at desc limit 1
|
|
)
|
|
order by ir.created_at desc limit 1
|
|
) as last_import_at,
|
|
(
|
|
select
|
|
b.created_at
|
|
from builds b
|
|
inner join tasks t on t.id = b.task_id
|
|
where
|
|
t.status = 3
|
|
and package_version_id = (
|
|
select package_version_id
|
|
from project_package_versions proj_pv
|
|
where
|
|
proj_pv.package_id = p.id
|
|
and proj_pv.project_id = proj_p.project_id
|
|
and proj_pv.active = true
|
|
order by proj_pv.created_at desc limit 1
|
|
)
|
|
order by b.created_at desc limit 1
|
|
) as last_build_at,
|
|
count(p.*) over() as total
|
|
from packages p
|
|
inner join project_packages proj_p on proj_p.package_id = p.id
|
|
where
|
|
($1 :: uuid is null or p.id = $1 :: uuid)
|
|
and ($2 :: text is null or p.name ~* $2 :: text)
|
|
and ($3 :: bool is null or p.package_type in (6))
|
|
and ($4 :: text is null or p.name = $4 :: text)
|
|
and ($5 :: bool is null or (
|
|
select
|
|
ir.created_at
|
|
from import_revisions ir
|
|
where package_version_id = (
|
|
select
|
|
proj_pv.package_version_id
|
|
from project_package_versions proj_pv
|
|
where
|
|
proj_pv.package_id = p.id
|
|
and proj_pv.project_id = proj_p.project_id
|
|
and proj_pv.active = true
|
|
order by proj_pv.created_at desc limit 1
|
|
)
|
|
order by ir.created_at desc limit 1
|
|
) is null)
|
|
and ($6 :: bool is null or (
|
|
select
|
|
b.created_at
|
|
from builds b
|
|
inner join tasks t on t.id = b.task_id
|
|
where
|
|
t.status = 3
|
|
and package_version_id = (
|
|
select package_version_id
|
|
from project_package_versions proj_pv
|
|
where
|
|
proj_pv.package_id = p.id
|
|
and proj_pv.project_id = proj_p.project_id
|
|
and proj_pv.active = true
|
|
order by proj_pv.created_at desc limit 1
|
|
)
|
|
order by b.created_at desc limit 1
|
|
) is null)
|
|
and proj_p.project_id = $7 :: uuid
|
|
order by created_at desc, id
|
|
limit $8 offset $9
|
|
`,
|
|
utils.StringValueP(filters.Id),
|
|
utils.StringValueP(filters.Name),
|
|
utils.BoolValueP(filters.Modular),
|
|
utils.StringValueP(filters.NameExact),
|
|
utils.BoolValueP(filters.NoImports),
|
|
utils.BoolValueP(filters.NoBuilds),
|
|
projectId,
|
|
utils.UnlimitedLimit(limit),
|
|
utils.GetOffset(page, limit),
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return p, nil
|
|
}
|
|
|
|
func (a *Access) PackageCountInProject(projectId string) (int64, error) {
|
|
var ret int64
|
|
err := a.query.Get(&ret, "select count(*) from project_packages where project_id = $1", projectId)
|
|
return ret, err
|
|
}
|
|
|
|
func (a *Access) GetPackageVersion(packageVersionId string) (*models.PackageVersion, error) {
|
|
var ret models.PackageVersion
|
|
err := a.query.Get(
|
|
&ret,
|
|
`
|
|
select
|
|
pv.id,
|
|
pv.created_at,
|
|
pv.package_id,
|
|
pv.version,
|
|
pv.release
|
|
from package_versions pv
|
|
where pv.id = $1
|
|
`,
|
|
packageVersionId,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &ret, nil
|
|
}
|
|
|
|
func (a *Access) GetPackageVersionId(packageId string, version string, release string) (string, error) {
|
|
var id string
|
|
err := a.query.Get(&id, "select id from package_versions where package_id = $1 and version = $2 and release = $3", packageId, version, release)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return id, nil
|
|
}
|
|
|
|
func (a *Access) CreatePackageVersion(packageId string, version string, release string) (string, error) {
|
|
var id string
|
|
err := a.query.Get(
|
|
&id,
|
|
`
|
|
insert into package_versions (package_id, version, release)
|
|
values ($1, $2, $3)
|
|
returning id
|
|
`,
|
|
packageId,
|
|
version,
|
|
release,
|
|
)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return id, nil
|
|
}
|
|
|
|
func (a *Access) AttachPackageVersion(projectId string, packageId string, packageVersionId string, active bool) error {
|
|
_, err := a.query.Exec("insert into project_package_versions (project_id, package_id, package_version_id, active) values ($1, $2, $3, $4) on conflict do nothing", projectId, packageId, packageVersionId, active)
|
|
return err
|
|
}
|
|
|
|
func (a *Access) GetProjectPackageVersionFromPackageVersionId(packageVersionId string, projectId string) (string, error) {
|
|
var id string
|
|
err := a.query.Get(
|
|
&id,
|
|
`
|
|
select ppv.id
|
|
from project_package_versions ppv
|
|
inner join package_versions pv on pv.id = ppv.package_version_id
|
|
where
|
|
pv.id = $1
|
|
and ppv.project_id = $2
|
|
`,
|
|
packageVersionId,
|
|
projectId,
|
|
)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return id, nil
|
|
}
|
|
|
|
// DeactivateProjectPackageVersionByPackageIdAndProjectId deactivates all package versions for a project
|
|
func (a *Access) DeactivateProjectPackageVersionByPackageIdAndProjectId(packageId string, projectId string) error {
|
|
_, err := a.query.Exec("update project_package_versions set active = false where project_id = $1 and package_id = $2", projectId, packageId)
|
|
return err
|
|
}
|
|
|
|
func (a *Access) MakeActiveInRepoForPackageVersion(packageVersionId string, packageId string) error {
|
|
tx, err := a.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err = tx.Exec("update project_package_versions set active_in_repo = false where package_id = $1", packageId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err = tx.Exec("update project_package_versions set active_in_repo = true where package_version_id = $1", packageVersionId)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return tx.Commit()
|
|
}
|
|
|
|
func (a *Access) CreatePackage(name string, packageType peridotpb.PackageType) (*models.Package, error) {
|
|
ret := models.Package{
|
|
Name: name,
|
|
PackageType: packageType,
|
|
}
|
|
|
|
err := a.query.Get(
|
|
&ret,
|
|
`
|
|
insert into packages (name, package_type)
|
|
values ($1, $2)
|
|
returning id, created_at, updated_at
|
|
`,
|
|
name,
|
|
packageType,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &ret, nil
|
|
}
|
|
|
|
func (a *Access) AddPackageToProject(projectId string, packageId string, packageTypeOverride peridotpb.PackageType) error {
|
|
_, err := a.query.Exec(
|
|
`
|
|
insert into project_packages (project_id, package_id, package_type_override)
|
|
values ($1, $2, $3)
|
|
on conflict on constraint project_packages_unique_entry do
|
|
update set package_type_override = $3
|
|
`,
|
|
projectId,
|
|
packageId,
|
|
packageTypeOverride,
|
|
)
|
|
return err
|
|
}
|
|
|
|
func (a *Access) GetPackageID(name string) (string, error) {
|
|
var id string
|
|
err := a.query.Get(&id, "select id from packages where name = $1", name)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return id, nil
|
|
}
|
|
|
|
func (a *Access) SetExtraOptionsForPackage(projectId string, packageName string, withFlags pq.StringArray, withoutFlags pq.StringArray) error {
|
|
if withFlags == nil {
|
|
withFlags = pq.StringArray{}
|
|
}
|
|
if withoutFlags == nil {
|
|
withoutFlags = pq.StringArray{}
|
|
}
|
|
_, err := a.query.Exec(
|
|
`
|
|
insert into extra_package_options (project_id, package_name, with_flags, without_flags)
|
|
values ($1, $2, $3, $4)
|
|
on conflict on constraint extra_package_options_uniq do
|
|
update set with_flags = $3, without_flags = $4, updated_at = now()
|
|
`,
|
|
projectId,
|
|
packageName,
|
|
withFlags,
|
|
withoutFlags,
|
|
)
|
|
return err
|
|
}
|
|
|
|
func (a *Access) GetExtraOptionsForPackage(projectId string, packageName string) (*models.ExtraOptions, error) {
|
|
var ret models.ExtraOptions
|
|
err := a.query.Get(
|
|
&ret,
|
|
"select id, created_at, updated_at, project_id, package_name, with_flags, without_flags, depends_on from extra_package_options where project_id = $1 and package_name = $2",
|
|
projectId,
|
|
packageName,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ret, nil
|
|
}
|
|
|
|
func (a *Access) SetGroupInstallOptionsForPackage(projectId string, packageName string, dependsOn pq.StringArray) error {
|
|
if dependsOn == nil {
|
|
dependsOn = pq.StringArray{}
|
|
}
|
|
_, err := a.query.Exec(
|
|
`
|
|
insert into extra_package_options (project_id, package_name, depends_on)
|
|
values ($1, $2, $3)
|
|
on conflict on constraint extra_package_options_uniq do
|
|
update set depends_on = $3, updated_at = now()
|
|
`,
|
|
projectId,
|
|
packageName,
|
|
dependsOn,
|
|
)
|
|
return err
|
|
}
|
|
|
|
func (a *Access) SetPackageType(projectId string, packageName string, packageType peridotpb.PackageType) error {
|
|
_, err := a.query.Exec(
|
|
`
|
|
update project_packages set package_type_override = $3
|
|
where project_id = $1 and package_id = (select id from packages where name = $2)
|
|
`,
|
|
projectId,
|
|
packageName,
|
|
packageType,
|
|
)
|
|
return err
|
|
}
|