code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
package config
import (
"github.com/mitchellh/go-homedir"
"github.com/spf13/viper"
"path/filepath"
)
var HomeDirPath, _ = homedir.Dir()
const configDirName = ".crawlab"
const configName = "config.json"
func GetConfigPath() string {
if viper.GetString("metadata") != "" {
MetadataPath := viper.GetString("metadata")
return filepath.Join(MetadataPath, configName)
}
return filepath.Join(HomeDirPath, configDirName, configName)
}
|
2302_79757062/crawlab
|
core/config/base.go
|
Go
|
bsd-3-clause
| 442
|
package config
import (
"bytes"
"github.com/apex/log"
"github.com/crawlab-team/crawlab/trace"
"github.com/fsnotify/fsnotify"
"github.com/spf13/viper"
"strings"
)
func init() {
// config instance
c := Config{Name: ""}
// init config file
if err := c.Init(); err != nil {
log.Warn("unable to init config")
return
}
// watch config change and load responsively
c.WatchConfig()
// init log level
c.initLogLevel()
}
type Config struct {
Name string
}
type InitConfigOptions struct {
Name string
}
func (c *Config) WatchConfig() {
viper.WatchConfig()
viper.OnConfigChange(func(e fsnotify.Event) {
log.Infof("Config file changed: %s", e.Name)
})
}
func (c *Config) Init() (err error) {
// config
if c.Name != "" {
viper.SetConfigFile(c.Name) // if config file is set, load it accordingly
} else {
viper.AddConfigPath("./conf") // if no config file is set, load by default
viper.SetConfigName("config")
}
// config type as yaml
viper.SetConfigType("yaml") // default yaml
// auto env
viper.AutomaticEnv() // load matched environment variables
// env prefix
viper.SetEnvPrefix("CRAWLAB") // environment variable prefix as CRAWLAB
// replacer
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
// read default config
defaultConfBuf := bytes.NewBufferString(DefaultConfigYaml)
if err := viper.ReadConfig(defaultConfBuf); err != nil {
return trace.TraceError(err)
}
// merge config
if err := viper.MergeInConfig(); err != nil { // viper parsing config file
return err
}
return nil
}
func (c *Config) initLogLevel() {
// set log level
logLevel := viper.GetString("log.level")
l, err := log.ParseLevel(logLevel)
if err != nil {
l = log.InfoLevel
}
log.SetLevel(l)
}
|
2302_79757062/crawlab
|
core/config/config.go
|
Go
|
bsd-3-clause
| 1,759
|
package config
var DefaultConfigYaml = `
info:
version: v0.6.3
edition: global.edition.community
mongo:
host: localhost
port: 27017
db: crawlab_test
username: ""
password: ""
authSource: "admin"
server:
host: 0.0.0.0
port: 8000
spider:
fs: "/spiders"
workspace: "/workspace"
repo: "/repo"
task:
workers: 16
cancelWaitSeconds: 30
grpc:
address: localhost:9666
server:
address: 0.0.0.0:9666
authKey: Crawlab2021!
fs:
filer:
proxy: http://localhost:8888
url: http://localhost:8000/filer
authKey: Crawlab2021!
node:
master: Y
api:
endpoint: http://localhost:8000
log:
path: /var/log/crawlab
`
|
2302_79757062/crawlab
|
core/config/default_config.go
|
Go
|
bsd-3-clause
| 650
|
package config
import (
"github.com/crawlab-team/crawlab/core/interfaces"
)
type PathService struct {
cfgPath string
}
func (svc *PathService) GetConfigPath() (path string) {
return svc.cfgPath
}
func (svc *PathService) SetConfigPath(path string) {
svc.cfgPath = path
}
func NewConfigPathService() (svc interfaces.WithConfigPath) {
svc = &PathService{}
svc.SetConfigPath(GetConfigPath())
return svc
}
|
2302_79757062/crawlab
|
core/config/path.go
|
Go
|
bsd-3-clause
| 413
|
package config
import "strings"
const Version = "v0.6.3"
func GetVersion() (v string) {
if strings.HasPrefix(Version, "v") {
return Version
}
return "v" + Version
}
|
2302_79757062/crawlab
|
core/config/version.go
|
Go
|
bsd-3-clause
| 173
|
package constants
const (
ActionTypeVisit = "visit"
ActionTypeInstallDep = "install_dep"
ActionTypeInstallLang = "install_lang"
ActionTypeViewDisclaimer = "view_disclaimer"
)
|
2302_79757062/crawlab
|
core/constants/action.go
|
Go
|
bsd-3-clause
| 196
|
package constants
const (
AnchorStartStage = "START_STAGE"
AnchorStartUrl = "START_URL"
AnchorItems = "ITEMS"
AnchorParsers = "PARSERS"
)
|
2302_79757062/crawlab
|
core/constants/anchor.go
|
Go
|
bsd-3-clause
| 153
|
package constants
const (
OwnerTypeAll = "all"
OwnerTypeMe = "me"
OwnerTypePublic = "public"
)
|
2302_79757062/crawlab
|
core/constants/auth.go
|
Go
|
bsd-3-clause
| 106
|
package constants
const (
CacheColName = "cache"
CacheColKey = "k"
CacheColValue = "v"
CacheColTime = "t"
)
|
2302_79757062/crawlab
|
core/constants/cache.go
|
Go
|
bsd-3-clause
| 117
|
package constants
const (
ChannelAllNode = "nodes:public"
ChannelWorkerNode = "nodes:"
ChannelMasterNode = "nodes:master"
)
|
2302_79757062/crawlab
|
core/constants/channels.go
|
Go
|
bsd-3-clause
| 130
|
package constants
const (
ASCENDING = "asc"
DESCENDING = "dsc"
)
|
2302_79757062/crawlab
|
core/constants/common.go
|
Go
|
bsd-3-clause
| 69
|
package constants
const (
EngineScrapy = "scrapy"
EngineColly = "colly"
)
|
2302_79757062/crawlab
|
core/constants/config_spider.go
|
Go
|
bsd-3-clause
| 78
|
package constants
const (
DataCollectionKey = "_col"
)
|
2302_79757062/crawlab
|
core/constants/data_collection.go
|
Go
|
bsd-3-clause
| 57
|
package constants
const (
DataFieldTypeGeneral = "general"
DataFieldTypeNumeric = "numeric"
DataFieldTypeDate = "date"
DataFieldTypeCurrency = "currency"
DataFieldTypeUrl = "url"
DataFieldTypeImage = "image"
DataFieldTypeAudio = "audio"
DataFieldTypeVideo = "video"
)
|
2302_79757062/crawlab
|
core/constants/data_field.go
|
Go
|
bsd-3-clause
| 297
|
package constants
const (
ColJob = "jobs"
)
|
2302_79757062/crawlab
|
core/constants/database.go
|
Go
|
bsd-3-clause
| 46
|
package constants
|
2302_79757062/crawlab
|
core/constants/delegate.go
|
Go
|
bsd-3-clause
| 18
|
package constants
const (
DataSourceTypeMongo = "mongo"
DataSourceTypeMysql = "mysql"
DataSourceTypePostgresql = "postgresql"
DataSourceTypeMssql = "mssql"
DataSourceTypeSqlite = "sqlite"
DataSourceTypeCockroachdb = "cockroachdb"
DataSourceTypeElasticSearch = "elasticsearch"
DataSourceTypeKafka = "kafka"
)
const (
DefaultHost = "localhost"
)
const (
DefaultMongoPort = "27017"
DefaultMysqlPort = "3306"
DefaultPostgresqlPort = "5432"
DefaultMssqlPort = "1433"
DefaultCockroachdbPort = "26257"
DefaultElasticsearchPort = "9200"
DefaultKafkaPort = "9092"
)
const (
DataSourceStatusOnline = "on"
DataSourceStatusOffline = "off"
)
|
2302_79757062/crawlab
|
core/constants/ds.go
|
Go
|
bsd-3-clause
| 733
|
package constants
const (
DefaultEncryptServerKey = "0123456789abcdef"
)
|
2302_79757062/crawlab
|
core/constants/encrypt.go
|
Go
|
bsd-3-clause
| 75
|
package constants
import (
"errors"
)
var (
//ErrorMongoError = e.NewSystemOPError(1001, "system error:[mongo]%s", http.StatusInternalServerError)
//ErrorUserNotFound = e.NewBusinessError(10001, "user not found.", http.StatusUnauthorized)
//ErrorUsernameOrPasswordInvalid = e.NewBusinessError(11001, "username or password invalid", http.StatusUnauthorized)
ErrAlreadyExists = errors.New("already exists")
ErrNotExists = errors.New("not exists")
ErrForbidden = errors.New("forbidden")
ErrInvalidOperation = errors.New("invalid operation")
ErrInvalidOptions = errors.New("invalid options")
ErrNoTasksAvailable = errors.New("no tasks available")
ErrInvalidType = errors.New("invalid type")
ErrInvalidSignal = errors.New("invalid signal")
ErrEmptyValue = errors.New("empty value")
ErrTaskError = errors.New("task error")
ErrTaskLost = errors.New("task lost")
ErrTaskCancelled = errors.New("task cancelled")
ErrUnableToCancel = errors.New("unable to cancel")
ErrUnableToDispose = errors.New("unable to dispose")
ErrAlreadyDisposed = errors.New("already disposed")
ErrStopped = errors.New("stopped")
ErrMissingCol = errors.New("missing col")
ErrInvalidValue = errors.New("invalid value")
ErrInvalidCronSpec = errors.New("invalid cron spec")
)
|
2302_79757062/crawlab
|
core/constants/errors.go
|
Go
|
bsd-3-clause
| 1,365
|
package constants
const (
GrpcEventServiceTypeRegister = "register"
GrpcEventServiceTypeSend = "send"
)
|
2302_79757062/crawlab
|
core/constants/event.go
|
Go
|
bsd-3-clause
| 111
|
package constants
const (
ExportTypeCsv = "csv"
ExportTypeJson = "json"
)
|
2302_79757062/crawlab
|
core/constants/export.go
|
Go
|
bsd-3-clause
| 78
|
package constants
const EmptyFileData = " "
const FsKeepFileName = ".gitkeep"
|
2302_79757062/crawlab
|
core/constants/file.go
|
Go
|
bsd-3-clause
| 80
|
package constants
const (
DefaultFilerAuthKey = "Crawlab2021!"
)
|
2302_79757062/crawlab
|
core/constants/filer.go
|
Go
|
bsd-3-clause
| 67
|
package constants
const (
FilterQueryFieldConditions = "conditions"
FilterQueryFieldAll = "all"
)
const (
FilterObjectTypeString = "string"
FilterObjectTypeNumber = "number"
FilterObjectTypeBoolean = "boolean"
)
const (
FilterOpNotSet = "ns"
FilterOpContains = "c"
FilterOpNotContains = "nc"
FilterOpRegex = "r"
FilterOpEqual = "eq"
FilterOpNotEqual = "ne"
FilterOpIn = "in"
FilterOpNotIn = "nin"
FilterOpGreaterThan = "gt"
FilterOpLessThan = "lt"
FilterOpGreaterThanEqual = "gte"
FilterOpLessThanEqual = "lte"
FilterOpSearch = "s"
)
|
2302_79757062/crawlab
|
core/constants/filter.go
|
Go
|
bsd-3-clause
| 668
|
package constants
const (
GitAuthTypeHttp = "http"
GitAuthTypeSsh = "ssh"
)
const (
GitRemoteNameUpstream = "upstream"
GitRemoteNameOrigin = "origin"
)
const (
GitBranchMaster = "master"
GitBranchMain = "main"
)
|
2302_79757062/crawlab
|
core/constants/git.go
|
Go
|
bsd-3-clause
| 226
|
package constants
const (
DefaultGrpcServerHost = ""
DefaultGrpcServerPort = "9666"
DefaultGrpcClientRemoteHost = "localhost"
DefaultGrpcClientRemotePort = DefaultGrpcServerPort
DefaultGrpcAuthKey = "Crawlab2021!"
)
const (
GrpcHeaderAuthorization = "authorization"
)
const (
GrpcSubscribeTypeNode = "node"
)
|
2302_79757062/crawlab
|
core/constants/grpc.go
|
Go
|
bsd-3-clause
| 340
|
package constants
const (
HttpResponseStatusOk = "ok"
HttpResponseMessageSuccess = "success"
HttpResponseMessageError = "error"
)
const (
HttpContentTypeApplicationJson = "application/json"
)
|
2302_79757062/crawlab
|
core/constants/http.go
|
Go
|
bsd-3-clause
| 206
|
package constants
const (
ErrorRegexPattern = "(?:[ :,.]|^)((?:error|exception|traceback)s?)(?:[ :,.]|$)"
)
|
2302_79757062/crawlab
|
core/constants/log.go
|
Go
|
bsd-3-clause
| 110
|
package constants
const (
MsgTypeGetLog = "get-log"
MsgTypeGetSystemInfo = "get-sys-info"
MsgTypeCancelTask = "cancel-task"
MsgTypeRemoveLog = "remove-log"
MsgTypeRemoveSpider = "remove-spider"
)
|
2302_79757062/crawlab
|
core/constants/message.go
|
Go
|
bsd-3-clause
| 217
|
package constants
const (
NodeStatusUnregistered = "u"
NodeStatusRegistered = "r"
NodeStatusOnline = "on"
NodeStatusOffline = "off"
)
|
2302_79757062/crawlab
|
core/constants/node.go
|
Go
|
bsd-3-clause
| 152
|
package constants
const (
NotificationTriggerTaskFinish = "task_finish"
NotificationTriggerTaskError = "task_error"
NotificationTriggerTaskEmptyResults = "task_empty_results"
NotificationTriggerTaskNever = "task_never"
)
|
2302_79757062/crawlab
|
core/constants/notification.go
|
Go
|
bsd-3-clause
| 246
|
package constants
var PaginationDefaultPage = 1
var PaginationDefaultSize = 10
|
2302_79757062/crawlab
|
core/constants/pagination.go
|
Go
|
bsd-3-clause
| 80
|
package constants
const (
RegisterTypeMac = "mac"
RegisterTypeIp = "ip"
RegisterTypeHostname = "hostname"
RegisterTypeCustomName = "customName"
)
|
2302_79757062/crawlab
|
core/constants/register.go
|
Go
|
bsd-3-clause
| 168
|
package constants
const (
HashKey = "_h"
)
const (
DedupTypeIgnore = "ignore"
DedupTypeOverwrite = "overwrite"
)
|
2302_79757062/crawlab
|
core/constants/results.go
|
Go
|
bsd-3-clause
| 121
|
package constants
const (
RpcInstallLang = "install_lang"
RpcInstallDep = "install_dep"
RpcUninstallDep = "uninstall_dep"
RpcGetInstalledDepList = "get_installed_dep_list"
RpcGetLang = "get_lang"
RpcCancelTask = "cancel_task"
RpcGetSystemInfoService = "get_system_info"
RpcRemoveSpider = "remove_spider"
)
|
2302_79757062/crawlab
|
core/constants/rpc.go
|
Go
|
bsd-3-clause
| 374
|
package constants
const (
ScheduleStatusStop = "stopped"
ScheduleStatusRunning = "running"
ScheduleStatusError = "error"
ScheduleStatusErrorNotFoundNode = "Not Found Node"
ScheduleStatusErrorNotFoundSpider = "Not Found Spider"
)
|
2302_79757062/crawlab
|
core/constants/schedule.go
|
Go
|
bsd-3-clause
| 243
|
package constants
const ScrapyProtectedStageNames = ""
const ScrapyProtectedFieldNames = "_id,task_id,ts"
|
2302_79757062/crawlab
|
core/constants/scrapy.go
|
Go
|
bsd-3-clause
| 108
|
package constants
const (
SignalQuit = iota
)
|
2302_79757062/crawlab
|
core/constants/signal.go
|
Go
|
bsd-3-clause
| 48
|
package constants
const (
SortQueryField = "sort"
)
|
2302_79757062/crawlab
|
core/constants/sort.go
|
Go
|
bsd-3-clause
| 54
|
package constants
const (
Windows = "windows"
Linux = "linux"
Darwin = "darwin"
)
const (
Python = "python"
Nodejs = "node"
Java = "java"
)
const (
InstallStatusNotInstalled = "not-installed"
InstallStatusInstalling = "installing"
InstallStatusInstallingOther = "installing-other"
InstallStatusInstalled = "installed"
)
const (
LangTypeLang = "lang"
LangTypeWebDriver = "webdriver"
)
|
2302_79757062/crawlab
|
core/constants/system.go
|
Go
|
bsd-3-clause
| 424
|
package constants
const (
TaskStatusPending = "pending"
TaskStatusRunning = "running"
TaskStatusFinished = "finished"
TaskStatusError = "error"
TaskStatusCancelled = "cancelled"
TaskStatusAbnormal = "abnormal"
)
const (
RunTypeAllNodes = "all-nodes"
RunTypeRandom = "random"
RunTypeSelectedNodes = "selected-nodes"
)
const (
TaskTypeSpider = "spider"
TaskTypeSystem = "system"
)
type TaskSignal int
const (
TaskSignalFinish TaskSignal = iota
TaskSignalCancel
TaskSignalError
TaskSignalLost
)
const (
TaskListQueuePrefixPublic = "tasks:public"
TaskListQueuePrefixNodes = "tasks:nodes"
)
const (
TaskKey = "_tid"
)
|
2302_79757062/crawlab
|
core/constants/task.go
|
Go
|
bsd-3-clause
| 661
|
package constants
const (
RoleAdmin = "admin"
RoleNormal = "normal"
)
const (
DefaultAdminUsername = "admin"
DefaultAdminPassword = "admin"
)
const (
UserContextKey = "user"
)
|
2302_79757062/crawlab
|
core/constants/user.go
|
Go
|
bsd-3-clause
| 185
|
package constants
const (
String = "string"
Number = "number"
Boolean = "boolean"
Array = "array"
Object = "object"
)
|
2302_79757062/crawlab
|
core/constants/variable.go
|
Go
|
bsd-3-clause
| 129
|
package container
import (
"go.uber.org/dig"
)
var c = dig.New()
func GetContainer() *dig.Container {
return c
}
|
2302_79757062/crawlab
|
core/container/container.go
|
Go
|
bsd-3-clause
| 118
|
package controllers
import "github.com/gin-gonic/gin"
const (
ControllerIdNode = iota << 1
ControllerIdProject
ControllerIdSpider
ControllerIdTask
ControllerIdJob
ControllerIdSchedule
ControllerIdUser
ControllerIdSetting
ControllerIdToken
ControllerIdVariable
ControllerIdTag
ControllerIdLogin
ControllerIdColor
ControllerIdDataSource
ControllerIdDataCollection
ControllerIdResult
ControllerIdStats
ControllerIdFiler
ControllerIdGit
ControllerIdRole
ControllerIdPermission
ControllerIdExport
ControllerIdNotification
ControllerIdFilter
ControllerIdEnvironment
ControllerIdSync
ControllerIdVersion
ControllerIdI18n
ControllerIdSystemInfo
ControllerIdDemo
)
type ControllerId int
type BasicController interface {
Get(c *gin.Context)
Post(c *gin.Context)
Put(c *gin.Context)
Delete(c *gin.Context)
}
type ListController interface {
BasicController
GetList(c *gin.Context)
PutList(c *gin.Context)
PostList(c *gin.Context)
DeleteList(c *gin.Context)
}
type Action struct {
Method string
Path string
HandlerFunc gin.HandlerFunc
}
type ActionController interface {
Actions() (actions []Action)
}
type ListActionController interface {
ListController
ActionController
}
|
2302_79757062/crawlab
|
core/controllers/base.go
|
Go
|
bsd-3-clause
| 1,227
|
package controllers
import (
"errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
)
type BaseControllerV2[T any] struct {
modelSvc *service.ModelServiceV2[T]
actions []Action
}
func (ctr *BaseControllerV2[T]) GetById(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
model, err := ctr.modelSvc.GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, model)
}
func (ctr *BaseControllerV2[T]) GetList(c *gin.Context) {
// get all if query field "all" is set true
all := MustGetFilterAll(c)
if all {
ctr.getAll(c)
return
}
// get list
ctr.getList(c)
}
func (ctr *BaseControllerV2[T]) Post(c *gin.Context) {
var model T
if err := c.ShouldBindJSON(&model); err != nil {
HandleErrorBadRequest(c, err)
return
}
u := GetUserFromContextV2(c)
m := any(&model).(interfaces.ModelV2)
m.SetId(primitive.NewObjectID())
m.SetCreated(u.Id)
m.SetUpdated(u.Id)
col := ctr.modelSvc.GetCol()
res, err := col.GetCollection().InsertOne(col.GetContext(), m)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
result, err := ctr.modelSvc.GetById(res.InsertedID.(primitive.ObjectID))
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, result)
}
func (ctr *BaseControllerV2[T]) PutById(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
var model T
if err := c.ShouldBindJSON(&model); err != nil {
HandleErrorBadRequest(c, err)
return
}
u := GetUserFromContextV2(c)
m := any(&model).(interfaces.ModelV2)
m.SetId(primitive.NewObjectID())
m.SetUpdated(u.Id)
if err := ctr.modelSvc.ReplaceById(id, model); err != nil {
HandleErrorInternalServerError(c, err)
return
}
result, err := ctr.modelSvc.GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, result)
}
func (ctr *BaseControllerV2[T]) PatchList(c *gin.Context) {
type Payload struct {
Ids []primitive.ObjectID `json:"ids"`
Update bson.M `json:"update"`
}
var payload Payload
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
// query
query := bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}
// update
if err := ctr.modelSvc.UpdateMany(query, bson.M{"$set": payload.Update}); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctr *BaseControllerV2[T]) DeleteById(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := ctr.modelSvc.DeleteById(id); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctr *BaseControllerV2[T]) DeleteList(c *gin.Context) {
type Payload struct {
Ids []primitive.ObjectID `json:"ids"`
}
var payload Payload
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := ctr.modelSvc.DeleteMany(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctr *BaseControllerV2[T]) getAll(c *gin.Context) {
models, err := ctr.modelSvc.GetMany(nil, &mongo.FindOptions{
Sort: bson.D{{"_id", -1}},
})
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
total, err := ctr.modelSvc.Count(nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithListData(c, models, total)
}
func (ctr *BaseControllerV2[T]) getList(c *gin.Context) {
// params
pagination := MustGetPagination(c)
query := MustGetFilterQuery(c)
sort := MustGetSortOption(c)
// get list
models, err := ctr.modelSvc.GetMany(query, &mongo.FindOptions{
Sort: sort,
Skip: pagination.Size * (pagination.Page - 1),
Limit: pagination.Size,
})
if err != nil {
if errors.Is(err, mongo2.ErrNoDocuments) {
HandleSuccessWithListData(c, nil, 0)
} else {
HandleErrorInternalServerError(c, err)
}
return
}
// total count
total, err := ctr.modelSvc.Count(query)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// response
HandleSuccessWithListData(c, models, total)
}
func NewControllerV2[T any](actions ...Action) *BaseControllerV2[T] {
ctr := &BaseControllerV2[T]{
modelSvc: service.NewModelServiceV2[T](),
actions: actions,
}
return ctr
}
|
2302_79757062/crawlab
|
core/controllers/base_v2.go
|
Go
|
bsd-3-clause
| 4,825
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/gin-gonic/gin"
)
type BinderInterface interface {
Bind(c *gin.Context) (res interfaces.Model, err error)
BindList(c *gin.Context) (res []interfaces.Model, err error)
BindBatchRequestPayload(c *gin.Context) (payload entity.BatchRequestPayload, err error)
BindBatchRequestPayloadWithStringData(c *gin.Context) (payload entity.BatchRequestPayloadWithStringData, res interfaces.Model, err error)
}
|
2302_79757062/crawlab
|
core/controllers/binder.go
|
Go
|
bsd-3-clause
| 540
|
package controllers
import (
"encoding/json"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/gin-gonic/gin"
)
func NewJsonBinder(id ControllerId) (b *JsonBinder) {
return &JsonBinder{
id: id,
}
}
type JsonBinder struct {
id ControllerId
}
func (b *JsonBinder) Bind(c *gin.Context) (res interfaces.Model, err error) {
// declare
m := models.NewModelMap()
switch b.id {
case ControllerIdNode:
err = c.ShouldBindJSON(&m.Node)
return &m.Node, err
case ControllerIdProject:
err = c.ShouldBindJSON(&m.Project)
return &m.Project, err
case ControllerIdSpider:
err = c.ShouldBindJSON(&m.Spider)
return &m.Spider, err
case ControllerIdTask:
err = c.ShouldBindJSON(&m.Task)
return &m.Task, err
case ControllerIdJob:
err = c.ShouldBindJSON(&m.Job)
return &m.Job, err
case ControllerIdSchedule:
err = c.ShouldBindJSON(&m.Schedule)
return &m.Schedule, err
case ControllerIdUser:
err = c.ShouldBindJSON(&m.User)
return &m.User, nil
case ControllerIdSetting:
err = c.ShouldBindJSON(&m.Setting)
return &m.Setting, nil
case ControllerIdToken:
err = c.ShouldBindJSON(&m.Token)
return &m.Token, nil
case ControllerIdVariable:
err = c.ShouldBindJSON(&m.Variable)
return &m.Variable, nil
case ControllerIdTag:
err = c.ShouldBindJSON(&m.Tag)
return &m.Tag, nil
case ControllerIdDataSource:
err = c.ShouldBindJSON(&m.DataSource)
return &m.DataSource, nil
case ControllerIdDataCollection:
err = c.ShouldBindJSON(&m.DataCollection)
return &m.DataCollection, nil
case ControllerIdGit:
err = c.ShouldBindJSON(&m.Git)
return &m.Git, nil
case ControllerIdRole:
err = c.ShouldBindJSON(&m.Role)
return &m.Role, nil
case ControllerIdPermission:
err = c.ShouldBindJSON(&m.Permission)
return &m.Permission, nil
case ControllerIdEnvironment:
err = c.ShouldBindJSON(&m.Environment)
return &m.Environment, nil
default:
return nil, errors.ErrorControllerInvalidControllerId
}
}
func (b *JsonBinder) BindList(c *gin.Context) (res interface{}, err error) {
// declare
m := models.NewModelListMap()
// bind
switch b.id {
case ControllerIdNode:
err = c.ShouldBindJSON(&m.Nodes)
return m.Nodes, err
case ControllerIdProject:
err = c.ShouldBindJSON(&m.Projects)
return m.Projects, err
case ControllerIdSpider:
err = c.ShouldBindJSON(&m.Spiders)
return m.Spiders, err
case ControllerIdTask:
err = c.ShouldBindJSON(&m.Tasks)
return m.Tasks, err
case ControllerIdJob:
err = c.ShouldBindJSON(&m.Jobs)
return m.Jobs, err
case ControllerIdSchedule:
err = c.ShouldBindJSON(&m.Schedules)
return m.Schedules, err
case ControllerIdUser:
err = c.ShouldBindJSON(&m.Users)
return m.Users, nil
case ControllerIdSetting:
err = c.ShouldBindJSON(&m.Settings)
return m.Settings, nil
case ControllerIdToken:
err = c.ShouldBindJSON(&m.Tokens)
return m.Tokens, nil
case ControllerIdVariable:
err = c.ShouldBindJSON(&m.Variables)
return m.Variables, nil
case ControllerIdTag:
err = c.ShouldBindJSON(&m.Tags)
return m.Tags, nil
case ControllerIdDataSource:
err = c.ShouldBindJSON(&m.DataSources)
return m.DataSources, nil
case ControllerIdDataCollection:
err = c.ShouldBindJSON(&m.DataCollections)
return m.DataCollections, nil
case ControllerIdGit:
err = c.ShouldBindJSON(&m.Gits)
return m.Gits, nil
case ControllerIdRole:
err = c.ShouldBindJSON(&m.Roles)
return m.Roles, nil
case ControllerIdEnvironment:
err = c.ShouldBindJSON(&m.Environments)
return m.Environments, nil
default:
return nil, errors.ErrorControllerInvalidControllerId
}
}
func (b *JsonBinder) BindBatchRequestPayload(c *gin.Context) (payload entity.BatchRequestPayload, err error) {
if err := c.ShouldBindJSON(&payload); err != nil {
return payload, err
}
return payload, nil
}
func (b *JsonBinder) BindBatchRequestPayloadWithStringData(c *gin.Context) (payload entity.BatchRequestPayloadWithStringData, res interfaces.Model, err error) {
// declare
m := models.NewModelMap()
// bind
if err := c.ShouldBindJSON(&payload); err != nil {
return payload, nil, err
}
// validate
if len(payload.Ids) == 0 ||
len(payload.Fields) == 0 {
return payload, nil, errors.ErrorControllerRequestPayloadInvalid
}
// unmarshall
switch b.id {
case ControllerIdNode:
err = json.Unmarshal([]byte(payload.Data), &m.Node)
return payload, &m.Node, err
case ControllerIdProject:
err = json.Unmarshal([]byte(payload.Data), &m.Project)
return payload, &m.Project, err
case ControllerIdSpider:
err = json.Unmarshal([]byte(payload.Data), &m.Spider)
return payload, &m.Spider, err
case ControllerIdTask:
err = json.Unmarshal([]byte(payload.Data), &m.Task)
return payload, &m.Task, err
case ControllerIdJob:
err = json.Unmarshal([]byte(payload.Data), &m.Job)
return payload, &m.Job, err
case ControllerIdSchedule:
err = json.Unmarshal([]byte(payload.Data), &m.Schedule)
return payload, &m.Schedule, err
case ControllerIdUser:
err = json.Unmarshal([]byte(payload.Data), &m.User)
return payload, &m.User, err
case ControllerIdSetting:
err = json.Unmarshal([]byte(payload.Data), &m.Setting)
return payload, &m.Setting, err
case ControllerIdToken:
err = json.Unmarshal([]byte(payload.Data), &m.Token)
return payload, &m.Token, err
case ControllerIdVariable:
err = json.Unmarshal([]byte(payload.Data), &m.Variable)
return payload, &m.Variable, err
case ControllerIdDataSource:
err = json.Unmarshal([]byte(payload.Data), &m.DataSource)
return payload, &m.DataSource, err
case ControllerIdDataCollection:
err = json.Unmarshal([]byte(payload.Data), &m.DataCollection)
return payload, &m.DataCollection, err
case ControllerIdEnvironment:
err = json.Unmarshal([]byte(payload.Data), &m.Environment)
return payload, &m.Environment, err
default:
return payload, nil, errors.ErrorControllerInvalidControllerId
}
}
|
2302_79757062/crawlab
|
core/controllers/binder_json.go
|
Go
|
bsd-3-clause
| 6,022
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"net/http"
)
var DataCollectionController *dataCollectionController
func getDataCollectionActions() []Action {
ctx := newDataCollectionContext()
return []Action{
{
Method: http.MethodPost,
Path: "/:id/indexes",
HandlerFunc: ctx.postIndexes,
},
}
}
type dataCollectionController struct {
ListActionControllerDelegate
d ListActionControllerDelegate
ctx *dataCollectionContext
}
type dataCollectionContext struct {
modelSvc service.ModelService
resultSvc interfaces.ResultService
}
func (ctx *dataCollectionContext) postIndexes(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
dc, err := ctx.modelSvc.GetDataCollectionById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
for _, f := range dc.Fields {
if err := mongo.GetMongoCol(dc.Name).CreateIndex(mongo2.IndexModel{
Keys: f.Key,
}); err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
HandleSuccess(c)
}
var _dataCollectionCtx *dataCollectionContext
func newDataCollectionContext() *dataCollectionContext {
if _dataCollectionCtx != nil {
return _dataCollectionCtx
}
// context
ctx := &dataCollectionContext{}
// dependency injection
if err := container.GetContainer().Invoke(func(
modelSvc service.ModelService,
) {
ctx.modelSvc = modelSvc
}); err != nil {
panic(err)
}
_dataCollectionCtx = ctx
return ctx
}
func newDataCollectionController() *dataCollectionController {
actions := getDataCollectionActions()
modelSvc, err := service.GetService()
if err != nil {
panic(err)
}
ctr := NewListPostActionControllerDelegate(ControllerIdDataCollection, modelSvc.GetBaseService(interfaces.ModelIdDataCollection), actions)
d := NewListPostActionControllerDelegate(ControllerIdDataCollection, modelSvc.GetBaseService(interfaces.ModelIdDataCollection), actions)
ctx := newDataCollectionContext()
return &dataCollectionController{
ListActionControllerDelegate: *ctr,
d: *d,
ctx: ctx,
}
}
|
2302_79757062/crawlab
|
core/controllers/data_collection.go
|
Go
|
bsd-3-clause
| 2,456
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/ds"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
interfaces2 "github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/crawlab-team/crawlab/trace"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"net/http"
)
var DataSourceController *dataSourceController
func getDataSourceActions() []Action {
ctx := newDataSourceContext()
return []Action{
{
Path: "/:id/change-password",
Method: http.MethodPost,
HandlerFunc: ctx.changePassword,
},
}
}
type dataSourceController struct {
ListActionControllerDelegate
d ListActionControllerDelegate
ctx *dataSourceContext
}
func (ctr *dataSourceController) Post(c *gin.Context) {
// data source
var _ds models.DataSource
if err := c.ShouldBindJSON(&_ds); err != nil {
HandleErrorBadRequest(c, err)
return
}
// add data source to db
if err := mongo.RunTransaction(func(ctx mongo2.SessionContext) error {
if err := delegate.NewModelDelegate(&_ds).Add(); err != nil {
return trace.TraceError(err)
}
pwd, err := utils.EncryptAES(_ds.Password)
if err != nil {
return trace.TraceError(err)
}
p := models.Password{Id: _ds.Id, Password: pwd}
if err := delegate.NewModelDelegate(&p).Add(); err != nil {
return trace.TraceError(err)
}
return nil
}); err != nil {
HandleErrorInternalServerError(c, err)
return
}
// check data source status
go func() { _ = ctr.ctx.dsSvc.CheckStatus(_ds.Id) }()
HandleSuccess(c)
}
func (ctr *dataSourceController) Put(c *gin.Context) {
// data source
var _ds models.DataSource
if err := c.ShouldBindJSON(&_ds); err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := delegate.NewModelDelegate(&_ds).Save(); err != nil {
HandleErrorInternalServerError(c, err)
return
}
// check data source status
go func() { _ = ctr.ctx.dsSvc.CheckStatus(_ds.Id) }()
}
type dataSourceContext struct {
dsSvc interfaces.DataSourceService
}
var _dataSourceCtx *dataSourceContext
func newDataSourceContext() *dataSourceContext {
if _dataSourceCtx != nil {
return _dataSourceCtx
}
dsSvc, err := ds.GetDataSourceService()
if err != nil {
panic(err)
}
_dataSourceCtx = &dataSourceContext{
dsSvc: dsSvc,
}
return _dataSourceCtx
}
func (ctx *dataSourceContext) changePassword(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
var payload map[string]string
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
password, ok := payload["password"]
if !ok {
HandleErrorBadRequest(c, errors.ErrorDataSourceMissingRequiredFields)
return
}
if err := ctx.dsSvc.ChangePassword(id, password); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func newDataSourceController() *dataSourceController {
actions := getDataSourceActions()
modelSvc, err := service.GetService()
if err != nil {
panic(err)
}
ctr := NewListPostActionControllerDelegate(ControllerIdDataSource, modelSvc.GetBaseService(interfaces2.ModelIdDataSource), actions)
d := NewListPostActionControllerDelegate(ControllerIdDataSource, modelSvc.GetBaseService(interfaces2.ModelIdDataSource), actions)
ctx := newDataSourceContext()
return &dataSourceController{
ListActionControllerDelegate: *ctr,
d: *d,
ctx: ctx,
}
}
|
2302_79757062/crawlab
|
core/controllers/data_source.go
|
Go
|
bsd-3-clause
| 3,823
|
package controllers
func NewActionControllerDelegate(id ControllerId, actions []Action) (d *ActionControllerDelegate) {
return &ActionControllerDelegate{
id: id,
actions: actions,
}
}
type ActionControllerDelegate struct {
id ControllerId
actions []Action
}
func (ctr *ActionControllerDelegate) Actions() (actions []Action) {
return ctr.actions
}
|
2302_79757062/crawlab
|
core/controllers/delegate_action.go
|
Go
|
bsd-3-clause
| 369
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
delegate2 "github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
)
func NewBasicControllerDelegate(id ControllerId, svc interfaces.ModelBaseService) (d *BasicControllerDelegate) {
return &BasicControllerDelegate{
id: id,
svc: svc,
}
}
type BasicControllerDelegate struct {
id ControllerId
svc interfaces.ModelBaseService
}
func (d *BasicControllerDelegate) Get(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
doc, err := d.svc.GetById(id)
if err == mongo2.ErrNoDocuments {
HandleErrorNotFound(c, err)
return
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, doc)
}
func (d *BasicControllerDelegate) Post(c *gin.Context) {
doc, err := NewJsonBinder(d.id).Bind(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := delegate2.NewModelDelegate(doc, GetUserFromContext(c)).Add(); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, doc)
}
func (d *BasicControllerDelegate) Put(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
doc, err := NewJsonBinder(d.id).Bind(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if doc.GetId() != id {
HandleErrorBadRequest(c, errors.ErrorHttpBadRequest)
return
}
_, err = d.svc.GetById(id)
if err != nil {
HandleErrorNotFound(c, err)
return
}
if err := delegate2.NewModelDelegate(doc, GetUserFromContext(c)).Save(); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, doc)
}
func (d *BasicControllerDelegate) Delete(c *gin.Context) {
id := c.Param("id")
oid, err := primitive.ObjectIDFromHex(id)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
doc, err := d.svc.GetById(oid)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
if err := delegate2.NewModelDelegate(doc, GetUserFromContext(c)).Delete(); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
|
2302_79757062/crawlab
|
core/controllers/delegate_basic.go
|
Go
|
bsd-3-clause
| 2,369
|
package controllers
import (
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/crawlab-team/crawlab/trace"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"reflect"
"time"
)
func NewListControllerDelegate(id ControllerId, svc interfaces.ModelBaseService) (d *ListControllerDelegate) {
if svc == nil {
panic(errors.ErrorControllerNoModelService)
}
return &ListControllerDelegate{
id: id,
svc: svc,
bc: NewBasicControllerDelegate(id, svc),
}
}
type ListControllerDelegate struct {
id ControllerId
svc interfaces.ModelBaseService
bc BasicController
}
func (d *ListControllerDelegate) Get(c *gin.Context) {
d.bc.Get(c)
}
func (d *ListControllerDelegate) Post(c *gin.Context) {
d.bc.Post(c)
}
func (d *ListControllerDelegate) Put(c *gin.Context) {
d.bc.Put(c)
}
func (d *ListControllerDelegate) Delete(c *gin.Context) {
d.bc.Delete(c)
}
func (d *ListControllerDelegate) GetList(c *gin.Context) {
// get all if query field "all" is set true
all := MustGetFilterAll(c)
if all {
d.getAll(c)
return
}
// get list and total
l, total, err := d.getList(c)
if err != nil {
return
}
// response
HandleSuccessWithListData(c, l, total)
}
func (d *ListControllerDelegate) PostList(c *gin.Context) {
// bind
docs, err := NewJsonBinder(d.id).BindList(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// success ids
var ids []primitive.ObjectID
// reflect
switch reflect.TypeOf(docs).Kind() {
case reflect.Slice, reflect.Array:
s := reflect.ValueOf(docs)
for i := 0; i < s.Len(); i++ {
item := s.Index(i)
if !item.CanAddr() {
HandleErrorInternalServerError(c, errors.ErrorModelInvalidType)
return
}
ptr := item.Addr()
doc, ok := ptr.Interface().(interfaces.Model)
if !ok {
HandleErrorInternalServerError(c, errors.ErrorModelInvalidType)
return
}
if err := delegate.NewModelDelegate(doc, GetUserFromContext(c)).Add(); err != nil {
_ = trace.TraceError(err)
continue
}
ids = append(ids, doc.GetId())
}
}
// check
items, err := utils.GetArrayItems(docs)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
if len(ids) < len(items) {
HandleErrorInternalServerError(c, errors.ErrorControllerAddError)
return
}
// success
HandleSuccessWithData(c, docs)
}
func (d *ListControllerDelegate) PutList(c *gin.Context) {
payload, doc, err := NewJsonBinder(d.id).BindBatchRequestPayloadWithStringData(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// query
query := bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}
// update
if err := d.svc.UpdateDoc(query, doc, payload.Fields); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (d *ListControllerDelegate) DeleteList(c *gin.Context) {
payload, err := NewJsonBinder(d.id).BindBatchRequestPayload(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := d.svc.DeleteList(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (d *ListControllerDelegate) getAll(c *gin.Context) {
// get list
tic := time.Now()
log.Debugf("getAll -> d.svc.GetMany:start")
list, err := d.svc.GetList(nil, &mongo.FindOptions{
Sort: bson.D{{"_id", -1}},
})
if err != nil {
if err == mongo2.ErrNoDocuments {
HandleErrorNotFound(c, err)
} else {
HandleErrorInternalServerError(c, err)
}
return
}
log.Debugf("getAll -> d.svc.GetMany:end. elapsed: %d ms", time.Now().Sub(tic).Milliseconds())
tic = time.Now()
// total count
tic = time.Now()
log.Debugf("getAll -> d.svc.Count:start")
total, err := d.svc.Count(nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
log.Debugf("getAll -> d.svc.Count:end. elapsed: %d ms", time.Now().Sub(tic).Milliseconds())
// response
HandleSuccessWithListData(c, list, total)
}
func (d *ListControllerDelegate) getList(c *gin.Context) (l interfaces.List, total int, err error) {
// params
pagination := MustGetPagination(c)
query := MustGetFilterQuery(c)
sort := MustGetSortOption(c)
// get list
l, err = d.svc.GetList(query, &mongo.FindOptions{
Sort: sort,
Skip: pagination.Size * (pagination.Page - 1),
Limit: pagination.Size,
})
if err != nil {
if err.Error() == mongo2.ErrNoDocuments.Error() {
HandleSuccessWithListData(c, nil, 0)
} else {
HandleErrorInternalServerError(c, err)
}
return
}
// total count
total, err = d.svc.Count(query)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
return l, total, nil
}
|
2302_79757062/crawlab
|
core/controllers/delegate_list.go
|
Go
|
bsd-3-clause
| 4,943
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/interfaces"
)
func NewListPostActionControllerDelegate(id ControllerId, svc interfaces.ModelBaseService, actions []Action) (d *ListActionControllerDelegate) {
return &ListActionControllerDelegate{
NewListControllerDelegate(id, svc),
NewActionControllerDelegate(id, actions),
}
}
type ListActionControllerDelegate struct {
ListController
ActionController
}
|
2302_79757062/crawlab
|
core/controllers/delegate_list_action.go
|
Go
|
bsd-3-clause
| 435
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/trace"
"github.com/gin-gonic/gin"
"net/http"
)
func getDemoActions() []Action {
ctx := newDemoContext()
return []Action{
{
Method: http.MethodGet,
Path: "/import",
HandlerFunc: ctx.import_,
},
{
Method: http.MethodGet,
Path: "/reimport",
HandlerFunc: ctx.reimport,
},
{
Method: http.MethodGet,
Path: "/cleanup",
HandlerFunc: ctx.cleanup,
},
}
}
type demoContext struct {
}
func (ctx *demoContext) import_(c *gin.Context) {
if err := utils.ImportDemo(); err != nil {
trace.PrintError(err)
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *demoContext) reimport(c *gin.Context) {
if err := utils.ReimportDemo(); err != nil {
trace.PrintError(err)
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *demoContext) cleanup(c *gin.Context) {
if err := utils.ReimportDemo(); err != nil {
trace.PrintError(err)
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
var _demoCtx *demoContext
func newDemoContext() *demoContext {
if _demoCtx != nil {
return _demoCtx
}
_demoCtx = &demoContext{}
return _demoCtx
}
var DemoController ActionController
|
2302_79757062/crawlab
|
core/controllers/demo.go
|
Go
|
bsd-3-clause
| 1,339
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/service"
)
var EnvironmentController *environmentController
var EnvironmentActions []Action
type environmentController struct {
ListActionControllerDelegate
d ListActionControllerDelegate
ctx *environmentContext
}
type environmentContext struct {
modelSvc service.ModelService
userSvc interfaces.UserService
}
func newEnvironmentContext() *environmentContext {
// context
ctx := &environmentContext{}
// dependency injection
if err := container.GetContainer().Invoke(func(
modelSvc service.ModelService,
userSvc interfaces.UserService,
) {
ctx.modelSvc = modelSvc
ctx.userSvc = userSvc
}); err != nil {
panic(err)
}
return ctx
}
func newEnvironmentController() *environmentController {
modelSvc, err := service.GetService()
if err != nil {
panic(err)
}
ctr := NewListPostActionControllerDelegate(ControllerIdEnvironment, modelSvc.GetBaseService(interfaces.ModelIdEnvironment), EnvironmentActions)
d := NewListPostActionControllerDelegate(ControllerIdEnvironment, modelSvc.GetBaseService(interfaces.ModelIdEnvironment), EnvironmentActions)
ctx := newEnvironmentContext()
return &environmentController{
ListActionControllerDelegate: *ctr,
d: *d,
ctx: ctx,
}
}
|
2302_79757062/crawlab
|
core/controllers/environment.go
|
Go
|
bsd-3-clause
| 1,439
|
package controllers
import (
"errors"
"fmt"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/export"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/gin-gonic/gin"
"net/http"
)
var ExportController ActionController
func getExportActions() []Action {
ctx := newExportContext()
return []Action{
{
Method: http.MethodPost,
Path: "/:type",
HandlerFunc: ctx.postExport,
},
{
Method: http.MethodGet,
Path: "/:type/:id",
HandlerFunc: ctx.getExport,
},
{
Method: http.MethodGet,
Path: "/:type/:id/download",
HandlerFunc: ctx.getExportDownload,
},
}
}
type exportContext struct {
csvSvc interfaces.ExportService
jsonSvc interfaces.ExportService
}
func (ctx *exportContext) postExport(c *gin.Context) {
exportType := c.Param("type")
exportTarget := c.Query("target")
exportFilter, _ := GetFilter(c)
var exportId string
var err error
switch exportType {
case constants.ExportTypeCsv:
exportId, err = ctx.csvSvc.Export(exportType, exportTarget, exportFilter)
case constants.ExportTypeJson:
exportId, err = ctx.jsonSvc.Export(exportType, exportTarget, exportFilter)
default:
HandleErrorBadRequest(c, errors.New(fmt.Sprintf("invalid export type: %s", exportType)))
return
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, exportId)
}
func (ctx *exportContext) getExport(c *gin.Context) {
exportType := c.Param("type")
exportId := c.Param("id")
var exp interfaces.Export
var err error
switch exportType {
case constants.ExportTypeCsv:
exp, err = ctx.csvSvc.GetExport(exportId)
case constants.ExportTypeJson:
exp, err = ctx.jsonSvc.GetExport(exportId)
default:
HandleErrorBadRequest(c, errors.New(fmt.Sprintf("invalid export type: %s", exportType)))
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, exp)
}
func (ctx *exportContext) getExportDownload(c *gin.Context) {
exportType := c.Param("type")
exportId := c.Param("id")
var exp interfaces.Export
var err error
switch exportType {
case constants.ExportTypeCsv:
exp, err = ctx.csvSvc.GetExport(exportId)
case constants.ExportTypeJson:
exp, err = ctx.jsonSvc.GetExport(exportId)
default:
HandleErrorBadRequest(c, errors.New(fmt.Sprintf("invalid export type: %s", exportType)))
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
switch exportType {
case constants.ExportTypeCsv:
c.Header("Content-Type", "text/csv")
case constants.ExportTypeJson:
c.Header("Content-Type", "text/plain")
default:
HandleErrorBadRequest(c, errors.New(fmt.Sprintf("invalid export type: %s", exportType)))
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", exp.GetDownloadPath()))
c.File(exp.GetDownloadPath())
}
func newExportContext() *exportContext {
return &exportContext{
csvSvc: export.GetCsvService(),
jsonSvc: export.GetJsonService(),
}
}
|
2302_79757062/crawlab
|
core/controllers/export.go
|
Go
|
bsd-3-clause
| 3,091
|
package controllers
import (
"errors"
"fmt"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/export"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/gin-gonic/gin"
)
func PostExport(c *gin.Context) {
exportType := c.Param("type")
exportTarget := c.Query("target")
exportFilter, _ := GetFilter(c)
var exportId string
var err error
switch exportType {
case constants.ExportTypeCsv:
exportId, err = export.GetCsvService().Export(exportType, exportTarget, exportFilter)
case constants.ExportTypeJson:
exportId, err = export.GetJsonService().Export(exportType, exportTarget, exportFilter)
default:
HandleErrorBadRequest(c, errors.New(fmt.Sprintf("invalid export type: %s", exportType)))
return
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, exportId)
}
func GetExport(c *gin.Context) {
exportType := c.Param("type")
exportId := c.Param("id")
var exp interfaces.Export
var err error
switch exportType {
case constants.ExportTypeCsv:
exp, err = export.GetCsvService().GetExport(exportId)
case constants.ExportTypeJson:
exp, err = export.GetJsonService().GetExport(exportId)
default:
HandleErrorBadRequest(c, errors.New(fmt.Sprintf("invalid export type: %s", exportType)))
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, exp)
}
func GetExportDownload(c *gin.Context) {
exportType := c.Param("type")
exportId := c.Param("id")
var exp interfaces.Export
var err error
switch exportType {
case constants.ExportTypeCsv:
exp, err = export.GetCsvService().GetExport(exportId)
case constants.ExportTypeJson:
exp, err = export.GetJsonService().GetExport(exportId)
default:
HandleErrorBadRequest(c, errors.New(fmt.Sprintf("invalid export type: %s", exportType)))
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
switch exportType {
case constants.ExportTypeCsv:
c.Header("Content-Type", "text/csv")
case constants.ExportTypeJson:
c.Header("Content-Type", "text/plain")
default:
HandleErrorBadRequest(c, errors.New(fmt.Sprintf("invalid export type: %s", exportType)))
}
c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", exp.GetDownloadPath()))
c.File(exp.GetDownloadPath())
}
|
2302_79757062/crawlab
|
core/controllers/export_v2.go
|
Go
|
bsd-3-clause
| 2,331
|
package controllers
import (
"bufio"
"fmt"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/gin-gonic/gin"
"github.com/imroc/req"
"github.com/spf13/viper"
"net/http"
"strings"
)
var FilerController ActionController
func getFilerActions() []Action {
filerCtx := newFilerContext()
return []Action{
{
Method: http.MethodGet,
Path: "*path",
HandlerFunc: filerCtx.do,
},
{
Method: http.MethodPost,
Path: "*path",
HandlerFunc: filerCtx.do,
},
{
Method: http.MethodPut,
Path: "*path",
HandlerFunc: filerCtx.do,
},
{
Method: http.MethodDelete,
Path: "*path",
HandlerFunc: filerCtx.do,
},
}
}
type filerContext struct {
endpoint string
}
func (ctx *filerContext) do(c *gin.Context) {
// request path
requestPath := strings.Replace(c.Request.URL.Path, "/filer", "", 1)
// request url
requestUrl := fmt.Sprintf("%s%s", ctx.endpoint, requestPath)
if c.Request.URL.RawQuery != "" {
requestUrl += "?" + c.Request.URL.RawQuery
}
// request body
bufR := bufio.NewScanner(c.Request.Body)
requestBody := req.BodyJSON(bufR.Bytes())
// request file uploads
var requestFileUploads []req.FileUpload
form, err := c.MultipartForm()
if err == nil {
for k, v := range form.File {
for _, fh := range v {
f, err := fh.Open()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
requestFileUploads = append(requestFileUploads, req.FileUpload{
FileName: fh.Filename,
FieldName: k,
File: f,
})
}
}
}
// request header
requestHeader := req.Header{}
for k, v := range c.Request.Header {
if len(v) > 0 {
requestHeader[k] = v[0]
}
}
// perform request
res, err := req.Do(c.Request.Method, requestUrl, requestHeader, requestBody, requestFileUploads)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// status code check
statusCode := res.Response().StatusCode
if statusCode == http.StatusNotFound {
HandleErrorNotFoundNoPrint(c, errors.ErrorControllerFilerNotFound)
return
}
// response
for k, v := range res.Response().Header {
if len(v) > 0 {
c.Header(k, v[0])
}
}
_, _ = c.Writer.Write(res.Bytes())
c.AbortWithStatus(statusCode)
}
var _filerCtx *filerContext
func newFilerContext() *filerContext {
if _filerCtx != nil {
return _filerCtx
}
ctx := &filerContext{
endpoint: "http://localhost:8888",
}
if viper.GetString("fs.filer.proxy") != "" {
ctx.endpoint = viper.GetString("fs.filer.proxy")
}
_filerCtx = ctx
return ctx
}
|
2302_79757062/crawlab
|
core/controllers/filer.go
|
Go
|
bsd-3-clause
| 2,585
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"net/http"
)
var FilterController ActionController
func getFilterActions() []Action {
ctx := newFilterContext()
return []Action{
{
Method: http.MethodGet,
Path: "/:col",
HandlerFunc: ctx.getColFieldOptions,
},
{
Method: http.MethodGet,
Path: "/:col/:value",
HandlerFunc: ctx.getColFieldOptions,
},
{
Method: http.MethodGet,
Path: "/:col/:value/:label",
HandlerFunc: ctx.getColFieldOptions,
},
}
}
type filterContext struct {
}
func (ctx *filterContext) getColFieldOptions(c *gin.Context) {
colName := c.Param("col")
value := c.Param("value")
if value == "" {
value = "_id"
}
label := c.Param("label")
if label == "" {
label = "name"
}
query := MustGetFilterQuery(c)
pipelines := mongo2.Pipeline{}
if query != nil {
pipelines = append(pipelines, bson.D{{"$match", query}})
}
pipelines = append(
pipelines,
bson.D{
{
"$group",
bson.M{
"_id": bson.M{
"value": "$" + value,
"label": "$" + label,
},
},
},
},
)
pipelines = append(
pipelines,
bson.D{
{
"$project",
bson.M{
"value": "$_id.value",
"label": bson.M{"$toString": "$_id.label"},
},
},
},
)
pipelines = append(
pipelines,
bson.D{
{
"$sort",
bson.D{
{"value", 1},
},
},
},
)
var options []entity.FilterSelectOption
if err := mongo.GetMongoCol(colName).Aggregate(pipelines, nil).All(&options); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, options)
}
func newFilterContext() *filterContext {
return &filterContext{}
}
|
2302_79757062/crawlab
|
core/controllers/filter.go
|
Go
|
bsd-3-clause
| 1,864
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
mongo2 "go.mongodb.org/mongo-driver/mongo"
)
func GetFilterColFieldOptions(c *gin.Context) {
colName := c.Param("col")
value := c.Param("value")
if value == "" {
value = "_id"
}
label := c.Param("label")
if label == "" {
label = "name"
}
query := MustGetFilterQuery(c)
pipelines := mongo2.Pipeline{}
if query != nil {
pipelines = append(pipelines, bson.D{{"$match", query}})
}
pipelines = append(
pipelines,
bson.D{
{
"$group",
bson.M{
"_id": bson.M{
"value": "$" + value,
"label": "$" + label,
},
},
},
},
)
pipelines = append(
pipelines,
bson.D{
{
"$project",
bson.M{
"value": "$_id.value",
"label": bson.M{"$toString": "$_id.label"},
},
},
},
)
pipelines = append(
pipelines,
bson.D{
{
"$sort",
bson.D{
{"value", 1},
},
},
},
)
var options []entity.FilterSelectOption
if err := mongo.GetMongoCol(colName).Aggregate(pipelines, nil).All(&options); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, options)
}
|
2302_79757062/crawlab
|
core/controllers/filter_v2.go
|
Go
|
bsd-3-clause
| 1,273
|
package controllers
var GitController ListController
|
2302_79757062/crawlab
|
core/controllers/git.go
|
Go
|
bsd-3-clause
| 54
|
package controllers
type Response[T any] struct {
Status string `json:"status"`
Message string `json:"message"`
Data T `json:"data"`
Error string `json:"error"`
}
type ListResponse[T any] struct {
Status string `json:"status"`
Message string `json:"message"`
Total int `json:"total"`
Data []T `json:"data"`
Error string `json:"error"`
}
|
2302_79757062/crawlab
|
core/controllers/http.go
|
Go
|
bsd-3-clause
| 373
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/service"
)
func InitControllers() (err error) {
modelSvc, err := service.GetService()
if err != nil {
return err
}
NodeController = newNodeController()
ProjectController = newProjectController()
SpiderController = newSpiderController()
TaskController = newTaskController()
UserController = newUserController()
TagController = NewListControllerDelegate(ControllerIdTag, modelSvc.GetBaseService(interfaces.ModelIdTag))
SettingController = newSettingController()
LoginController = NewActionControllerDelegate(ControllerIdLogin, getLoginActions())
DataCollectionController = newDataCollectionController()
ResultController = NewActionControllerDelegate(ControllerIdResult, getResultActions())
ScheduleController = newScheduleController()
StatsController = NewActionControllerDelegate(ControllerIdStats, getStatsActions())
TokenController = newTokenController()
FilerController = NewActionControllerDelegate(ControllerIdFiler, getFilerActions())
GitController = NewListControllerDelegate(ControllerIdGit, modelSvc.GetBaseService(interfaces.ModelIdGit))
VersionController = NewActionControllerDelegate(ControllerIdVersion, getVersionActions())
SystemInfoController = NewActionControllerDelegate(ControllerIdSystemInfo, getSystemInfoActions())
DemoController = NewActionControllerDelegate(ControllerIdDemo, getDemoActions())
RoleController = NewListControllerDelegate(ControllerIdRole, modelSvc.GetBaseService(interfaces.ModelIdRole))
PermissionController = NewListControllerDelegate(ControllerIdPermission, modelSvc.GetBaseService(interfaces.ModelIdPermission))
ExportController = NewActionControllerDelegate(ControllerIdExport, getExportActions())
NotificationController = NewActionControllerDelegate(ControllerIdNotification, getNotificationActions())
FilterController = NewActionControllerDelegate(ControllerIdFilter, getFilterActions())
SyncController = NewActionControllerDelegate(ControllerIdSync, getSyncActions())
DataSourceController = newDataSourceController()
EnvironmentController = newEnvironmentController()
return nil
}
|
2302_79757062/crawlab
|
core/controllers/init.go
|
Go
|
bsd-3-clause
| 2,190
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/gin-gonic/gin"
"net/http"
)
var LoginController ActionController
func getLoginActions() []Action {
loginCtx := newLoginContext()
return []Action{
{Method: http.MethodPost, Path: "/login", HandlerFunc: loginCtx.login},
{Method: http.MethodPost, Path: "/logout", HandlerFunc: loginCtx.logout},
}
}
type loginContext struct {
userSvc interfaces.UserService
}
func (ctx *loginContext) login(c *gin.Context) {
var u models.User
if err := c.ShouldBindJSON(&u); err != nil {
HandleErrorBadRequest(c, err)
return
}
token, loggedInUser, err := ctx.userSvc.Login(&interfaces.UserLoginOptions{
Username: u.Username,
Password: u.Password,
})
if err != nil {
HandleErrorUnauthorized(c, errors.ErrorUserUnauthorized)
return
}
c.Set(constants.UserContextKey, loggedInUser)
HandleSuccessWithData(c, token)
}
func (ctx *loginContext) logout(c *gin.Context) {
c.Set(constants.UserContextKey, nil)
HandleSuccess(c)
}
func newLoginContext() *loginContext {
// context
ctx := &loginContext{}
// dependency injection
if err := container.GetContainer().Invoke(func(
userSvc interfaces.UserService,
) {
ctx.userSvc = userSvc
}); err != nil {
panic(err)
}
return ctx
}
|
2302_79757062/crawlab
|
core/controllers/login.go
|
Go
|
bsd-3-clause
| 1,493
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/user"
"github.com/gin-gonic/gin"
)
func PostLogin(c *gin.Context) {
var payload struct {
Username string `json:"username"`
Password string `json:"password"`
}
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
userSvc, err := user.GetUserServiceV2()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
token, loggedInUser, err := userSvc.Login(payload.Username, payload.Password)
if err != nil {
HandleErrorUnauthorized(c, errors.ErrorUserUnauthorized)
return
}
c.Set(constants.UserContextKey, loggedInUser)
HandleSuccessWithData(c, token)
}
func PostLogout(c *gin.Context) {
c.Set(constants.UserContextKey, nil)
HandleSuccess(c)
}
|
2302_79757062/crawlab
|
core/controllers/login_v2.go
|
Go
|
bsd-3-clause
| 882
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/trace"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
"go.mongodb.org/mongo-driver/bson/primitive"
)
var NodeController *nodeController
type nodeController struct {
ListControllerDelegate
}
func (ctr *nodeController) Post(c *gin.Context) {
var n models.Node
if err := c.ShouldBindJSON(&n); err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := ctr._post(c, &n); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctr *nodeController) PostList(c *gin.Context) {
// bind
var docs []models.Node
if err := c.ShouldBindJSON(&docs); err != nil {
HandleErrorBadRequest(c, err)
return
}
// success ids
var ids []primitive.ObjectID
// iterate nodes
for _, n := range docs {
if err := ctr._post(c, &n); err != nil {
trace.PrintError(err)
continue
}
ids = append(ids, n.Id)
}
// success
HandleSuccessWithData(c, docs)
}
func (ctr *nodeController) _post(c *gin.Context, n *models.Node) (err error) {
// set default key
if n.Key == "" {
id, err := uuid.NewUUID()
if err != nil {
return trace.TraceError(err)
}
n.Key = id.String()
}
// set default status
if n.Status == "" {
n.Status = constants.NodeStatusUnregistered
}
// add
if err := delegate.NewModelDelegate(n, GetUserFromContext(c)).Add(); err != nil {
return trace.TraceError(err)
}
return nil
}
func newNodeController() *nodeController {
modelSvc, err := service.GetService()
if err != nil {
panic(err)
}
ctr := NewListControllerDelegate(ControllerIdNode, modelSvc.GetBaseService(interfaces.ModelIdNode))
return &nodeController{
ListControllerDelegate: *ctr,
}
}
|
2302_79757062/crawlab
|
core/controllers/node.go
|
Go
|
bsd-3-clause
| 1,982
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/notification"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
"net/http"
)
var NotificationController ActionController
func getNotificationActions() []Action {
ctx := newNotificationContext()
return []Action{
{
Method: http.MethodGet,
Path: "/settings",
HandlerFunc: ctx.GetSettingList,
},
{
Method: http.MethodGet,
Path: "/settings/:id",
HandlerFunc: ctx.GetSetting,
},
{
Method: http.MethodPost,
Path: "/settings",
HandlerFunc: ctx.PostSetting,
},
{
Method: http.MethodPut,
Path: "/settings/:id",
HandlerFunc: ctx.PutSetting,
},
{
Method: http.MethodDelete,
Path: "/settings/:id",
HandlerFunc: ctx.DeleteSetting,
},
{
Method: http.MethodPost,
Path: "/settings/:id/enable",
HandlerFunc: ctx.EnableSetting,
},
{
Method: http.MethodPost,
Path: "/settings/:id/disable",
HandlerFunc: ctx.DisableSetting,
},
}
}
type notificationContext struct {
svc *notification.Service
}
func (ctx *notificationContext) GetSettingList(c *gin.Context) {
query := MustGetFilterQuery(c)
pagination := MustGetPagination(c)
sort := MustGetSortOption(c)
res, total, err := ctx.svc.GetSettingList(query, pagination, sort)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithListData(c, res, total)
}
func (ctx *notificationContext) GetSetting(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
res, err := ctx.svc.GetSetting(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, res)
}
func (ctx *notificationContext) PostSetting(c *gin.Context) {
var s notification.NotificationSetting
if err := c.ShouldBindJSON(&s); err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := ctx.svc.PosSetting(&s); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *notificationContext) PutSetting(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
var s notification.NotificationSetting
if err := c.ShouldBindJSON(&s); err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := ctx.svc.PutSetting(id, s); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *notificationContext) DeleteSetting(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := ctx.svc.DeleteSetting(id); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *notificationContext) EnableSetting(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := ctx.svc.EnableSetting(id); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *notificationContext) DisableSetting(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := ctx.svc.DisableSetting(id); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func newNotificationContext() *notificationContext {
ctx := ¬ificationContext{
svc: notification.GetService(),
}
return ctx
}
|
2302_79757062/crawlab
|
core/controllers/notification.go
|
Go
|
bsd-3-clause
| 3,599
|
package controllers
var PermissionController ListController
|
2302_79757062/crawlab
|
core/controllers/permission.go
|
Go
|
bsd-3-clause
| 61
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
var ProjectController *projectController
type projectController struct {
ListControllerDelegate
}
func (ctr *projectController) GetList(c *gin.Context) {
// get all if query field "all" is set true
all := MustGetFilterAll(c)
if all {
ctr.getAll(c)
return
}
// get list
list, total, err := ctr.getList(c)
if err != nil {
return
}
data := list.GetModels()
// check empty list
if len(list.GetModels()) == 0 {
HandleSuccessWithListData(c, nil, 0)
return
}
// project ids
var ids []primitive.ObjectID
// count cache
cache := map[primitive.ObjectID]int{}
// iterate
for _, d := range data {
p, ok := d.(*models.Project)
if !ok {
HandleErrorInternalServerError(c, errors.ErrorControllerInvalidType)
return
}
ids = append(ids, p.Id)
cache[p.Id] = 0
}
// spiders
modelSvc, err := service.NewService()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
spiders, err := modelSvc.GetSpiderList(bson.M{
"project_id": bson.M{
"$in": ids,
},
}, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
for _, s := range spiders {
_, ok := cache[s.ProjectId]
if !ok {
HandleErrorInternalServerError(c, errors.ErrorControllerMissingInCache)
return
}
cache[s.ProjectId]++
}
// assign
var projects []models.Project
for _, d := range data {
p := d.(*models.Project)
p.Spiders = cache[p.Id]
projects = append(projects, *p)
}
HandleSuccessWithListData(c, projects, total)
}
func newProjectController() *projectController {
modelSvc, err := service.GetService()
if err != nil {
panic(err)
}
ctr := NewListControllerDelegate(ControllerIdProject, modelSvc.GetBaseService(interfaces.ModelIdProject))
return &projectController{
ListControllerDelegate: *ctr,
}
}
|
2302_79757062/crawlab
|
core/controllers/project.go
|
Go
|
bsd-3-clause
| 2,129
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/result"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/db/generic"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"net/http"
)
var ResultController ActionController
func getResultActions() []Action {
var resultCtx = newResultContext()
return []Action{
{
Method: http.MethodGet,
Path: "/:id",
HandlerFunc: resultCtx.getList,
},
}
}
type resultContext struct {
modelSvc service.ModelService
}
func (ctx *resultContext) getList(c *gin.Context) {
// data collection id
dcId, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// data source id
var dsId primitive.ObjectID
dsIdStr := c.Query("data_source_id")
if dsIdStr != "" {
dsId, err = primitive.ObjectIDFromHex(dsIdStr)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
}
// data collection
dc, err := ctx.modelSvc.GetDataCollectionById(dcId)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// data source
ds, err := ctx.modelSvc.GetDataSourceById(dsId)
if err != nil {
if err.Error() == mongo2.ErrNoDocuments.Error() {
ds = &models.DataSource{}
} else {
HandleErrorInternalServerError(c, err)
return
}
}
// spider
sq := bson.M{
"col_id": dc.Id,
"data_source_id": ds.Id,
}
s, err := ctx.modelSvc.GetSpider(sq, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// service
svc, err := result.GetResultService(s.Id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// params
pagination := MustGetPagination(c)
query := ctx.getListQuery(c)
// get results
data, err := svc.List(query, &generic.ListOptions{
Sort: []generic.ListSort{{"_id", generic.SortDirectionDesc}},
Skip: pagination.Size * (pagination.Page - 1),
Limit: pagination.Size,
})
if err != nil {
if err.Error() == mongo2.ErrNoDocuments.Error() {
HandleSuccessWithListData(c, nil, 0)
return
}
HandleErrorInternalServerError(c, err)
return
}
// validate results
if len(data) == 0 {
HandleSuccessWithListData(c, nil, 0)
return
}
// total count
total, err := svc.Count(query)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// response
HandleSuccessWithListData(c, data, total)
}
func (ctx *resultContext) getListQuery(c *gin.Context) (q generic.ListQuery) {
f, err := GetFilter(c)
if err != nil {
return q
}
for _, cond := range f.Conditions {
q = append(q, generic.ListQueryCondition{
Key: cond.Key,
Op: cond.Op,
Value: utils.NormalizeObjectId(cond.Value),
})
}
return q
}
func newResultContext() *resultContext {
// context
ctx := &resultContext{}
var err error
ctx.modelSvc, err = service.NewService()
if err != nil {
panic(err)
}
return ctx
}
|
2302_79757062/crawlab
|
core/controllers/result.go
|
Go
|
bsd-3-clause
| 3,106
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/result"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/db/generic"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
)
func GetResultList(c *gin.Context) {
// data collection id
dcId, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// data source id
var dsId primitive.ObjectID
dsIdStr := c.Query("data_source_id")
if dsIdStr != "" {
dsId, err = primitive.ObjectIDFromHex(dsIdStr)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
}
// data collection
dc, err := service.NewModelServiceV2[models.DataCollectionV2]().GetById(dcId)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// data source
ds, err := service.NewModelServiceV2[models.DataSourceV2]().GetById(dsId)
if err != nil {
if err.Error() == mongo2.ErrNoDocuments.Error() {
ds = &models.DataSourceV2{}
} else {
HandleErrorInternalServerError(c, err)
return
}
}
// spider
sq := bson.M{
"col_id": dc.Id,
"data_source_id": ds.Id,
}
s, err := service.NewModelServiceV2[models.SpiderV2]().GetOne(sq, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// service
svc, err := result.GetResultService(s.Id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// params
pagination := MustGetPagination(c)
query := getResultListQuery(c)
// get results
data, err := svc.List(query, &generic.ListOptions{
Sort: []generic.ListSort{{"_id", generic.SortDirectionDesc}},
Skip: pagination.Size * (pagination.Page - 1),
Limit: pagination.Size,
})
if err != nil {
if err.Error() == mongo2.ErrNoDocuments.Error() {
HandleSuccessWithListData(c, nil, 0)
return
}
HandleErrorInternalServerError(c, err)
return
}
// validate results
if len(data) == 0 {
HandleSuccessWithListData(c, nil, 0)
return
}
// total count
total, err := svc.Count(query)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// response
HandleSuccessWithListData(c, data, total)
}
func getResultListQuery(c *gin.Context) (q generic.ListQuery) {
f, err := GetFilter(c)
if err != nil {
return q
}
for _, cond := range f.Conditions {
q = append(q, generic.ListQueryCondition{
Key: cond.Key,
Op: cond.Op,
Value: utils.NormalizeObjectId(cond.Value),
})
}
return q
}
|
2302_79757062/crawlab
|
core/controllers/result_v2.go
|
Go
|
bsd-3-clause
| 2,668
|
package controllers
var RoleController ListController
|
2302_79757062/crawlab
|
core/controllers/role.go
|
Go
|
bsd-3-clause
| 55
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/middlewares"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/gin-gonic/gin"
"net/http"
)
type RouterGroups struct {
AuthGroup *gin.RouterGroup
AnonymousGroup *gin.RouterGroup
}
func NewRouterGroups(app *gin.Engine) (groups *RouterGroups) {
return &RouterGroups{
AuthGroup: app.Group("/", middlewares.AuthorizationMiddlewareV2()),
AnonymousGroup: app.Group("/"),
}
}
func RegisterController[T any](group *gin.RouterGroup, basePath string, ctr *BaseControllerV2[T]) {
actionPaths := make(map[string]bool)
for _, action := range ctr.actions {
group.Handle(action.Method, basePath+action.Path, action.HandlerFunc)
path := basePath + action.Path
key := action.Method + " - " + path
actionPaths[key] = true
}
registerBuiltinHandler(group, http.MethodGet, basePath+"", ctr.GetList, actionPaths)
registerBuiltinHandler(group, http.MethodGet, basePath+"/:id", ctr.GetById, actionPaths)
registerBuiltinHandler(group, http.MethodPost, basePath+"", ctr.Post, actionPaths)
registerBuiltinHandler(group, http.MethodPut, basePath+"/:id", ctr.PutById, actionPaths)
registerBuiltinHandler(group, http.MethodPatch, basePath+"", ctr.PatchList, actionPaths)
registerBuiltinHandler(group, http.MethodDelete, basePath+"/:id", ctr.DeleteById, actionPaths)
registerBuiltinHandler(group, http.MethodDelete, basePath+"", ctr.DeleteList, actionPaths)
}
func RegisterActions(group *gin.RouterGroup, basePath string, actions []Action) {
for _, action := range actions {
group.Handle(action.Method, basePath+action.Path, action.HandlerFunc)
}
}
func registerBuiltinHandler(group *gin.RouterGroup, method, path string, handlerFunc gin.HandlerFunc, existingActionPaths map[string]bool) {
key := method + " - " + path
_, ok := existingActionPaths[key]
if ok {
return
}
group.Handle(method, path, handlerFunc)
}
func InitRoutes(app *gin.Engine) (err error) {
// routes groups
groups := NewRouterGroups(app)
RegisterController(groups.AuthGroup, "/data/collections", NewControllerV2[models.DataCollectionV2]())
RegisterController(groups.AuthGroup, "/data-sources", NewControllerV2[models.DataSourceV2]())
RegisterController(groups.AuthGroup, "/environments", NewControllerV2[models.EnvironmentV2]())
RegisterController(groups.AuthGroup, "/gits", NewControllerV2[models.GitV2]())
RegisterController(groups.AuthGroup, "/nodes", NewControllerV2[models.NodeV2]())
RegisterController(groups.AuthGroup, "/notifications/settings", NewControllerV2[models.SettingV2]())
RegisterController(groups.AuthGroup, "/permissions", NewControllerV2[models.PermissionV2]())
RegisterController(groups.AuthGroup, "/projects", NewControllerV2[models.ProjectV2]())
RegisterController(groups.AuthGroup, "/roles", NewControllerV2[models.RoleV2]())
RegisterController(groups.AuthGroup, "/schedules", NewControllerV2[models.ScheduleV2](
Action{
Method: http.MethodPost,
Path: "",
HandlerFunc: PostSchedule,
},
Action{
Method: http.MethodPut,
Path: "/:id",
HandlerFunc: PutScheduleById,
},
Action{
Method: http.MethodPost,
Path: "/:id/enable",
HandlerFunc: PostScheduleEnable,
},
Action{
Method: http.MethodPost,
Path: "/:id/disable",
HandlerFunc: PostScheduleDisable,
},
))
RegisterController(groups.AuthGroup, "/spiders", NewControllerV2[models.SpiderV2](
Action{
Method: http.MethodGet,
Path: "/:id",
HandlerFunc: GetSpiderById,
},
Action{
Method: http.MethodGet,
Path: "",
HandlerFunc: GetSpiderList,
},
Action{
Method: http.MethodPost,
Path: "",
HandlerFunc: PostSpider,
},
Action{
Method: http.MethodPut,
Path: "/:id",
HandlerFunc: PutSpiderById,
},
Action{
Method: http.MethodDelete,
Path: "/:id",
HandlerFunc: DeleteSpiderById,
},
Action{
Method: http.MethodDelete,
Path: "",
HandlerFunc: DeleteSpiderList,
},
Action{
Method: http.MethodGet,
Path: "/:id/files/list",
HandlerFunc: GetSpiderListDir,
},
Action{
Method: http.MethodGet,
Path: "/:id/files/get",
HandlerFunc: GetSpiderFile,
},
Action{
Method: http.MethodGet,
Path: "/:id/files/info",
HandlerFunc: GetSpiderFileInfo,
},
Action{
Method: http.MethodPost,
Path: "/:id/files/save",
HandlerFunc: PostSpiderSaveFile,
},
Action{
Method: http.MethodPost,
Path: "/:id/files/save/batch",
HandlerFunc: PostSpiderSaveFiles,
},
Action{
Method: http.MethodPost,
Path: "/:id/files/save/dir",
HandlerFunc: PostSpiderSaveDir,
},
Action{
Method: http.MethodPost,
Path: "/:id/files/rename",
HandlerFunc: PostSpiderRenameFile,
},
Action{
Method: http.MethodDelete,
Path: "/:id/files",
HandlerFunc: DeleteSpiderFile,
},
Action{
Method: http.MethodPost,
Path: "/:id/files/copy",
HandlerFunc: PostSpiderCopyFile,
},
Action{
Method: http.MethodPost,
Path: "/:id/files/export",
HandlerFunc: PostSpiderExport,
},
Action{
Method: http.MethodPost,
Path: "/:id/run",
HandlerFunc: PostSpiderRun,
},
Action{
Method: http.MethodGet,
Path: "/:id/git",
HandlerFunc: GetSpiderGit,
},
Action{
Method: http.MethodGet,
Path: "/:id/git/remote-refs",
HandlerFunc: GetSpiderGitRemoteRefs,
},
Action{
Method: http.MethodPost,
Path: "/:id/git/checkout",
HandlerFunc: PostSpiderGitCheckout,
},
Action{
Method: http.MethodPost,
Path: "/:id/git/pull",
HandlerFunc: PostSpiderGitPull,
},
Action{
Method: http.MethodPost,
Path: "/:id/git/commit",
HandlerFunc: PostSpiderGitCommit,
},
Action{
Method: http.MethodGet,
Path: "/:id/data-source",
HandlerFunc: GetSpiderDataSource,
},
Action{
Method: http.MethodPost,
Path: "/:id/data-source/:ds_id",
HandlerFunc: PostSpiderDataSource,
},
))
RegisterController(groups.AuthGroup, "/tasks", NewControllerV2[models.TaskV2](
Action{
Method: http.MethodGet,
Path: "/:id",
HandlerFunc: GetTaskById,
},
Action{
Method: http.MethodGet,
Path: "",
HandlerFunc: GetTaskList,
},
Action{
Method: http.MethodDelete,
Path: "/:id",
HandlerFunc: DeleteTaskById,
},
Action{
Method: http.MethodDelete,
Path: "",
HandlerFunc: DeleteList,
},
Action{
Method: http.MethodPost,
Path: "/run",
HandlerFunc: PostTaskRun,
},
Action{
Method: http.MethodPost,
Path: "/:id/restart",
HandlerFunc: PostTaskRestart,
},
Action{
Method: http.MethodPost,
Path: "/:id/cancel",
HandlerFunc: PostTaskCancel,
},
Action{
Method: http.MethodGet,
Path: "/:id/logs",
HandlerFunc: GetTaskLogs,
},
Action{
Method: http.MethodGet,
Path: "/:id/data",
HandlerFunc: GetTaskData,
},
))
RegisterController(groups.AuthGroup, "/tokens", NewControllerV2[models.TokenV2](
Action{
Method: http.MethodPost,
Path: "",
HandlerFunc: PostToken,
},
))
RegisterController(groups.AuthGroup, "/users", NewControllerV2[models.UserV2](
Action{
Method: http.MethodPost,
Path: "",
HandlerFunc: PostUser,
},
Action{
Method: http.MethodPost,
Path: "/:id/change-password",
HandlerFunc: PostUserChangePassword,
},
Action{
Method: http.MethodGet,
Path: "/me",
HandlerFunc: GetUserMe,
},
Action{
Method: http.MethodPut,
Path: "/me",
HandlerFunc: PutUserById,
},
))
RegisterActions(groups.AuthGroup, "/results", []Action{
{
Method: http.MethodGet,
Path: "/:id",
HandlerFunc: GetResultList,
},
})
RegisterActions(groups.AuthGroup, "/export", []Action{
{
Method: http.MethodPost,
Path: "/:type",
HandlerFunc: PostExport,
},
{
Method: http.MethodGet,
Path: "/:type/:id",
HandlerFunc: GetExport,
},
{
Method: http.MethodGet,
Path: "/:type/:id/download",
HandlerFunc: GetExportDownload,
},
})
RegisterActions(groups.AuthGroup, "/filters", []Action{
{
Method: http.MethodGet,
Path: "/:col",
HandlerFunc: GetFilterColFieldOptions,
},
{
Method: http.MethodGet,
Path: "/:col/:value",
HandlerFunc: GetFilterColFieldOptions,
},
{
Method: http.MethodGet,
Path: "/:col/:value/:label",
HandlerFunc: GetFilterColFieldOptions,
},
})
RegisterActions(groups.AuthGroup, "/settings", []Action{
{
Method: http.MethodGet,
Path: "/:id",
HandlerFunc: GetSetting,
},
{
Method: http.MethodPut,
Path: "/:id",
HandlerFunc: PutSetting,
},
})
RegisterActions(groups.AuthGroup, "/stats", []Action{
{
Method: http.MethodGet,
Path: "/overview",
HandlerFunc: GetStatsOverview,
},
{
Method: http.MethodGet,
Path: "/daily",
HandlerFunc: GetStatsDaily,
},
{
Method: http.MethodGet,
Path: "/tasks",
HandlerFunc: GetStatsTasks,
},
})
RegisterActions(groups.AnonymousGroup, "/system-info", []Action{
{
Path: "",
Method: http.MethodGet,
HandlerFunc: GetSystemInfo,
},
})
RegisterActions(groups.AnonymousGroup, "/version", []Action{
{
Method: http.MethodGet,
Path: "",
HandlerFunc: GetVersion,
},
})
RegisterActions(groups.AnonymousGroup, "/", []Action{
{
Method: http.MethodPost,
Path: "/login",
HandlerFunc: PostLogin,
},
{
Method: http.MethodPost,
Path: "/logout",
HandlerFunc: PostLogout,
},
})
return nil
}
|
2302_79757062/crawlab
|
core/controllers/router_v2.go
|
Go
|
bsd-3-clause
| 10,025
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"net/http"
)
var ScheduleController *scheduleController
func getScheduleActions() []Action {
scheduleCtx := newScheduleContext()
return []Action{
{
Method: http.MethodPost,
Path: "/:id/enable",
HandlerFunc: scheduleCtx.enable,
},
{
Method: http.MethodPost,
Path: "/:id/disable",
HandlerFunc: scheduleCtx.disable,
},
}
}
type scheduleController struct {
ListActionControllerDelegate
d ListActionControllerDelegate
ctx *scheduleContext
}
func (ctr *scheduleController) Post(c *gin.Context) {
var s models.Schedule
if err := c.ShouldBindJSON(&s); err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := delegate.NewModelDelegate(&s, GetUserFromContext(c)).Add(); err != nil {
HandleErrorInternalServerError(c, err)
return
}
if s.Enabled {
if err := ctr.ctx.scheduleSvc.Enable(&s, GetUserFromContext(c)); err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
HandleSuccessWithData(c, s)
}
func (ctr *scheduleController) Put(c *gin.Context) {
id := c.Param("id")
oid, err := primitive.ObjectIDFromHex(id)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
var s models.Schedule
if err := c.ShouldBindJSON(&s); err != nil {
HandleErrorBadRequest(c, err)
return
}
if s.GetId() != oid {
HandleErrorBadRequest(c, errors.ErrorHttpBadRequest)
return
}
if err := delegate.NewModelDelegate(&s).Save(); err != nil {
HandleErrorInternalServerError(c, err)
return
}
if s.Enabled {
if err := ctr.ctx.scheduleSvc.Disable(&s, GetUserFromContext(c)); err != nil {
HandleErrorInternalServerError(c, err)
return
}
if err := ctr.ctx.scheduleSvc.Enable(&s, GetUserFromContext(c)); err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
HandleSuccessWithData(c, s)
}
func (ctr *scheduleController) Delete(c *gin.Context) {
id := c.Param("id")
oid, err := primitive.ObjectIDFromHex(id)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
s, err := ctr.ctx.modelSvc.GetScheduleById(oid)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
if err := ctr.ctx.scheduleSvc.Disable(s); err != nil {
HandleErrorInternalServerError(c, err)
return
}
if err := delegate.NewModelDelegate(s, GetUserFromContext(c)).Delete(); err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
func (ctr *scheduleController) DeleteList(c *gin.Context) {
payload, err := NewJsonBinder(interfaces.ModelIdSchedule).BindBatchRequestPayload(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
for _, id := range payload.Ids {
s, err := ctr.ctx.modelSvc.GetScheduleById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
if err := ctr.ctx.scheduleSvc.Disable(s); err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
if err := ctr.ctx.modelSvc.GetBaseService(interfaces.ModelIdSchedule).DeleteList(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *scheduleContext) enable(c *gin.Context) {
s, err := ctx._getSchedule(c)
if err != nil {
return
}
if err := ctx.scheduleSvc.Enable(s, GetUserFromContext(c)); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *scheduleContext) disable(c *gin.Context) {
s, err := ctx._getSchedule(c)
if err != nil {
return
}
if err := ctx.scheduleSvc.Disable(s, GetUserFromContext(c)); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *scheduleContext) _getSchedule(c *gin.Context) (s *models.Schedule, err error) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
s, err = ctx.modelSvc.GetScheduleById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
return s, nil
}
type scheduleContext struct {
modelSvc service.ModelService
scheduleSvc interfaces.ScheduleService
}
func newScheduleContext() *scheduleContext {
// context
ctx := &scheduleContext{}
// dependency injection
if err := container.GetContainer().Invoke(func(
modelSvc service.ModelService,
scheduleSvc interfaces.ScheduleService,
) {
ctx.modelSvc = modelSvc
ctx.scheduleSvc = scheduleSvc
}); err != nil {
panic(err)
}
return ctx
}
func newScheduleController() *scheduleController {
actions := getScheduleActions()
modelSvc, err := service.GetService()
if err != nil {
panic(err)
}
ctr := NewListPostActionControllerDelegate(ControllerIdSchedule, modelSvc.GetBaseService(interfaces.ModelIdSchedule), actions)
d := NewListPostActionControllerDelegate(ControllerIdSchedule, modelSvc.GetBaseService(interfaces.ModelIdSchedule), actions)
ctx := newScheduleContext()
return &scheduleController{
ListActionControllerDelegate: *ctr,
d: *d,
ctx: ctx,
}
}
|
2302_79757062/crawlab
|
core/controllers/schedule.go
|
Go
|
bsd-3-clause
| 5,423
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/schedule"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func PostSchedule(c *gin.Context) {
var s models.ScheduleV2
if err := c.ShouldBindJSON(&s); err != nil {
HandleErrorBadRequest(c, err)
return
}
u := GetUserFromContextV2(c)
modelSvc := service.NewModelServiceV2[models.ScheduleV2]()
s.SetCreated(u.Id)
s.SetUpdated(u.Id)
id, err := modelSvc.InsertOne(s)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
s.Id = id
if s.Enabled {
scheduleSvc, err := schedule.GetScheduleServiceV2()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
if err := scheduleSvc.Enable(s, u.Id); err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
HandleSuccessWithData(c, s)
}
func PutScheduleById(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
var s models.ScheduleV2
if err := c.ShouldBindJSON(&s); err != nil {
HandleErrorBadRequest(c, err)
return
}
if s.Id != id {
HandleErrorBadRequest(c, errors.ErrorHttpBadRequest)
return
}
modelSvc := service.NewModelServiceV2[models.ScheduleV2]()
err = modelSvc.ReplaceById(id, s)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
scheduleSvc, err := schedule.GetScheduleServiceV2()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
u := GetUserFromContextV2(c)
if s.Enabled {
if err := scheduleSvc.Enable(s, u.Id); err != nil {
HandleErrorInternalServerError(c, err)
return
}
} else {
if err := scheduleSvc.Disable(s, u.Id); err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
HandleSuccessWithData(c, s)
}
func PostScheduleEnable(c *gin.Context) {
postScheduleEnableDisableFunc(true)(c)
}
func PostScheduleDisable(c *gin.Context) {
postScheduleEnableDisableFunc(false)(c)
}
func postScheduleEnableDisableFunc(isEnable bool) func(c *gin.Context) {
return func(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
svc, err := schedule.GetScheduleServiceV2()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
s, err := service.NewModelServiceV2[models.ScheduleV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
u := GetUserFromContextV2(c)
if isEnable {
err = svc.Enable(*s, u.Id)
} else {
err = svc.Disable(*s, u.Id)
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
}
|
2302_79757062/crawlab
|
core/controllers/schedule_v2.go
|
Go
|
bsd-3-clause
| 2,840
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/gin-gonic/gin"
)
var SettingController *settingController
type settingController struct {
ListControllerDelegate
}
func (ctr *settingController) Get(c *gin.Context) {
// key
key := c.Param("id")
// model service
modelSvc, err := service.NewService()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// setting
s, err := modelSvc.GetSettingByKey(key, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, s)
}
func (ctr *settingController) Put(c *gin.Context) {
// key
key := c.Param("id")
// settings
var s models.Setting
if err := c.ShouldBindJSON(&s); err != nil {
HandleErrorInternalServerError(c, err)
return
}
// model service
modelSvc, err := service.NewService()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// setting
_s, err := modelSvc.GetSettingByKey(key, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// save
_s.Value = s.Value
if err := delegate.NewModelDelegate(_s).Save(); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func newSettingController() *settingController {
modelSvc, err := service.GetService()
if err != nil {
panic(err)
}
ctr := NewListControllerDelegate(ControllerIdSetting, modelSvc.GetBaseService(interfaces.ModelIdSetting))
return &settingController{
ListControllerDelegate: *ctr,
}
}
|
2302_79757062/crawlab
|
core/controllers/setting.go
|
Go
|
bsd-3-clause
| 1,687
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
)
func GetSetting(c *gin.Context) {
// key
key := c.Param("id")
// setting
s, err := service.NewModelServiceV2[models.SettingV2]().GetOne(bson.M{"key": key}, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, s)
}
func PutSetting(c *gin.Context) {
// key
key := c.Param("id")
// settings
var s models.Setting
if err := c.ShouldBindJSON(&s); err != nil {
HandleErrorInternalServerError(c, err)
return
}
modelSvc := service.NewModelServiceV2[models.SettingV2]()
// setting
_s, err := modelSvc.GetOne(bson.M{"key": key}, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
u := GetUserFromContextV2(c)
// save
_s.Value = s.Value
_s.SetUpdated(u.Id)
err = modelSvc.ReplaceOne(bson.M{"key": key}, *_s)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
|
2302_79757062/crawlab
|
core/controllers/setting_v2.go
|
Go
|
bsd-3-clause
| 1,095
|
package controllers
import (
"bytes"
"fmt"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
fs2 "github.com/crawlab-team/crawlab/core/fs"
"github.com/crawlab-team/crawlab/core/interfaces"
delegate2 "github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/crawlab-team/crawlab/trace"
"github.com/crawlab-team/crawlab/vcs"
"github.com/gin-gonic/gin"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/config"
"github.com/spf13/viper"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"io"
"math"
"net/http"
"os"
"path/filepath"
"strings"
)
var SpiderController *spiderController
func getSpiderActions() []Action {
ctx := newSpiderContext()
return []Action{
{
Method: http.MethodGet,
Path: "/:id/files/list",
HandlerFunc: ctx.listDir,
},
{
Method: http.MethodGet,
Path: "/:id/files/get",
HandlerFunc: ctx.getFile,
},
{
Method: http.MethodGet,
Path: "/:id/files/info",
HandlerFunc: ctx.getFileInfo,
},
{
Method: http.MethodPost,
Path: "/:id/files/save",
HandlerFunc: ctx.saveFile,
},
{
Method: http.MethodPost,
Path: "/:id/files/save/dir",
HandlerFunc: ctx.saveDir,
},
{
Method: http.MethodPost,
Path: "/:id/files/rename",
HandlerFunc: ctx.renameFile,
},
{
Method: http.MethodPost,
Path: "/:id/files/delete",
HandlerFunc: ctx.deleteFile,
},
{
Method: http.MethodPost,
Path: "/:id/files/copy",
HandlerFunc: ctx.copyFile,
},
{
Path: "/:id/files/export",
Method: http.MethodPost,
HandlerFunc: ctx.postExport,
},
{
Method: http.MethodPost,
Path: "/:id/run",
HandlerFunc: ctx.run,
},
{
Method: http.MethodGet,
Path: "/:id/git",
HandlerFunc: ctx.getGit,
},
{
Method: http.MethodGet,
Path: "/:id/git/remote-refs",
HandlerFunc: ctx.getGitRemoteRefs,
},
{
Method: http.MethodPost,
Path: "/:id/git/checkout",
HandlerFunc: ctx.gitCheckout,
},
{
Method: http.MethodPost,
Path: "/:id/git/pull",
HandlerFunc: ctx.gitPull,
},
{
Method: http.MethodPost,
Path: "/:id/git/commit",
HandlerFunc: ctx.gitCommit,
},
//{
// Method: http.MethodPost,
// Path: "/:id/clone",
// HandlerFunc: ctx.clone,
//},
{
Path: "/:id/data-source",
Method: http.MethodGet,
HandlerFunc: ctx.getDataSource,
},
{
Path: "/:id/data-source/:ds_id",
Method: http.MethodPost,
HandlerFunc: ctx.postDataSource,
},
}
}
type spiderController struct {
ListActionControllerDelegate
d ListActionControllerDelegate
ctx *spiderContext
}
func (ctr *spiderController) Get(c *gin.Context) {
ctr.ctx._get(c)
}
func (ctr *spiderController) Post(c *gin.Context) {
s, err := ctr.ctx._post(c)
if err != nil {
return
}
HandleSuccessWithData(c, s)
}
func (ctr *spiderController) Put(c *gin.Context) {
s, err := ctr.ctx._put(c)
if err != nil {
return
}
HandleSuccessWithData(c, s)
}
func (ctr *spiderController) Delete(c *gin.Context) {
if err := ctr.ctx._delete(c); err != nil {
return
}
HandleSuccess(c)
}
func (ctr *spiderController) GetList(c *gin.Context) {
withStats := c.Query("stats")
if withStats == "" {
ctr.d.GetList(c)
return
}
ctr.ctx._getListWithStats(c)
}
func (ctr *spiderController) DeleteList(c *gin.Context) {
if err := ctr.ctx._deleteList(c); err != nil {
return
}
HandleSuccess(c)
}
type spiderContext struct {
modelSvc service.ModelService
modelSpiderSvc interfaces.ModelBaseService
modelSpiderStatSvc interfaces.ModelBaseService
modelTaskSvc interfaces.ModelBaseService
modelTaskStatSvc interfaces.ModelBaseService
adminSvc interfaces.SpiderAdminService
}
func (ctx *spiderContext) listDir(c *gin.Context) {
_, payload, fsSvc, err := ctx._processFileRequest(c, http.MethodGet)
if err != nil {
return
}
files, err := fsSvc.List(payload.Path)
if err != nil {
if err.Error() != "response status code: 404" {
HandleErrorInternalServerError(c, err)
return
}
}
HandleSuccessWithData(c, files)
}
func (ctx *spiderContext) getFile(c *gin.Context) {
_, payload, fsSvc, err := ctx._processFileRequest(c, http.MethodGet)
if err != nil {
return
}
data, err := fsSvc.GetFile(payload.Path)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
data = utils.TrimFileData(data)
HandleSuccessWithData(c, string(data))
}
func (ctx *spiderContext) getFileInfo(c *gin.Context) {
_, payload, fsSvc, err := ctx._processFileRequest(c, http.MethodGet)
if err != nil {
return
}
info, err := fsSvc.GetFileInfo(payload.Path)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, info)
}
func (ctx *spiderContext) saveFile(c *gin.Context) {
_, payload, fsSvc, err := ctx._processFileRequest(c, http.MethodPost)
if err != nil {
return
}
if err := fsSvc.Save(payload.Path, []byte(payload.Data)); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *spiderContext) saveDir(c *gin.Context) {
_, payload, fsSvc, err := ctx._processFileRequest(c, http.MethodPost)
if err != nil {
return
}
if err := fsSvc.CreateDir(payload.Path); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *spiderContext) renameFile(c *gin.Context) {
_, payload, fsSvc, err := ctx._processFileRequest(c, http.MethodPost)
if err != nil {
return
}
if err := fsSvc.Rename(payload.Path, payload.NewPath); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *spiderContext) deleteFile(c *gin.Context) {
_, payload, fsSvc, err := ctx._processFileRequest(c, http.MethodPost)
if err != nil {
return
}
if err := fsSvc.Delete(payload.Path); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *spiderContext) copyFile(c *gin.Context) {
_, payload, fsSvc, err := ctx._processFileRequest(c, http.MethodPost)
if err != nil {
return
}
if err := fsSvc.Copy(payload.Path, payload.NewPath); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *spiderContext) run(c *gin.Context) {
// spider id
id, err := ctx._processActionRequest(c)
if err != nil {
return
}
// options
var opts interfaces.SpiderRunOptions
if err := c.ShouldBindJSON(&opts); err != nil {
HandleErrorInternalServerError(c, err)
return
}
// user
if u := GetUserFromContext(c); u != nil {
opts.UserId = u.GetId()
}
// schedule
taskIds, err := ctx.adminSvc.Schedule(id, &opts)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, taskIds)
}
func (ctx *spiderContext) getGit(c *gin.Context) {
// spider id
id, err := ctx._processActionRequest(c)
if err != nil {
return
}
// git client
gitClient, err := ctx._getGitClient(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// return null if git client is empty
if gitClient == nil {
HandleSuccess(c)
return
}
// current branch
currentBranch, err := gitClient.GetCurrentBranch()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// branches
branches, err := gitClient.GetBranches()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
if branches == nil || len(branches) == 0 && currentBranch != "" {
branches = []vcs.GitRef{{Name: currentBranch}}
}
// changes
changes, err := gitClient.GetStatus()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// logs
logs, err := gitClient.GetLogsWithRefs()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// ignore
ignore, err := ctx._getGitIgnore(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// git
_git, err := ctx.modelSvc.GetGitById(id)
if err != nil {
if err.Error() != mongo2.ErrNoDocuments.Error() {
HandleErrorInternalServerError(c, err)
return
}
}
// response
res := bson.M{
"current_branch": currentBranch,
"branches": branches,
"changes": changes,
"logs": logs,
"ignore": ignore,
"git": _git,
}
HandleSuccessWithData(c, res)
}
func (ctx *spiderContext) getGitRemoteRefs(c *gin.Context) {
// spider id
id, err := ctx._processActionRequest(c)
if err != nil {
return
}
// remote name
remoteName := c.Query("remote")
if remoteName == "" {
remoteName = vcs.GitRemoteNameOrigin
}
// git client
gitClient, err := ctx._getGitClient(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// return null if git client is empty
if gitClient == nil {
HandleSuccess(c)
return
}
// refs
refs, err := gitClient.GetRemoteRefs(remoteName)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, refs)
}
func (ctx *spiderContext) gitCheckout(c *gin.Context) {
// payload
var payload entity.GitPayload
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
// spider id
id, err := ctx._processActionRequest(c)
if err != nil {
return
}
// git client
gitClient, err := ctx._getGitClient(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// return null if git client is empty
if gitClient == nil {
HandleSuccess(c)
return
}
// branch to pull
var branch string
if payload.Branch == "" {
// by default current branch
branch, err = gitClient.GetCurrentBranch()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
} else {
// payload branch
branch = payload.Branch
}
// checkout
if err := ctx._gitCheckout(gitClient, constants.GitRemoteNameOrigin, branch); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *spiderContext) gitPull(c *gin.Context) {
// payload
var payload entity.GitPayload
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
// spider id
id, err := ctx._processActionRequest(c)
if err != nil {
return
}
// git
g, err := ctx.modelSvc.GetGitById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// attempt to sync git
_ = ctx.adminSvc.SyncGitOne(g)
HandleSuccess(c)
}
func (ctx *spiderContext) gitCommit(c *gin.Context) {
// payload
var payload entity.GitPayload
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
// spider id
id, err := ctx._processActionRequest(c)
if err != nil {
return
}
// git client
gitClient, err := ctx._getGitClient(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// return null if git client is empty
if gitClient == nil {
HandleSuccess(c)
return
}
// add
for _, p := range payload.Paths {
if err := gitClient.Add(p); err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
// commit
if err := gitClient.Commit(payload.CommitMessage); err != nil {
HandleErrorInternalServerError(c, err)
return
}
// push
if err := gitClient.Push(
vcs.WithRemoteNamePush(vcs.GitRemoteNameOrigin),
); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *spiderContext) getDataSource(c *gin.Context) {
// spider id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// spider
s, err := ctx.modelSvc.GetSpiderById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// data source
ds, err := ctx.modelSvc.GetDataSourceById(s.DataSourceId)
if err != nil {
if err.Error() == mongo2.ErrNoDocuments.Error() {
HandleSuccess(c)
return
}
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, ds)
}
func (ctx *spiderContext) postDataSource(c *gin.Context) {
// spider id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// data source id
dsId, err := primitive.ObjectIDFromHex(c.Param("ds_id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// spider
s, err := ctx.modelSvc.GetSpiderById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// data source
if !dsId.IsZero() {
_, err = ctx.modelSvc.GetDataSourceById(dsId)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
// save data source id
s.DataSourceId = dsId
if err := delegate2.NewModelDelegate(s).Save(); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *spiderContext) postExport(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// zip file path
zipFilePath, err := ctx.adminSvc.Export(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// download
c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", zipFilePath))
c.File(zipFilePath)
}
func (ctx *spiderContext) _get(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
s, err := ctx.modelSvc.GetSpiderById(id)
if err == mongo2.ErrNoDocuments {
HandleErrorNotFound(c, err)
return
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// stat
s.Stat, err = ctx.modelSvc.GetSpiderStatById(s.GetId())
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// data collection
if !s.ColId.IsZero() {
col, err := ctx.modelSvc.GetDataCollectionById(s.ColId)
if err != nil {
if err != mongo2.ErrNoDocuments {
HandleErrorInternalServerError(c, err)
return
}
} else {
s.ColName = col.Name
}
}
HandleSuccessWithData(c, s)
}
func (ctx *spiderContext) _post(c *gin.Context) (s *models.Spider, err error) {
// bind
s = &models.Spider{}
if err := c.ShouldBindJSON(&s); err != nil {
HandleErrorBadRequest(c, err)
return nil, err
}
// upsert data collection
if err := ctx._upsertDataCollection(c, s); err != nil {
HandleErrorInternalServerError(c, err)
return nil, err
}
// add
if err := delegate2.NewModelDelegate(s, GetUserFromContext(c)).Add(); err != nil {
HandleErrorInternalServerError(c, err)
return nil, err
}
// add stat
st := &models.SpiderStat{
Id: s.GetId(),
}
if err := delegate2.NewModelDelegate(st, GetUserFromContext(c)).Add(); err != nil {
HandleErrorInternalServerError(c, err)
return nil, err
}
return s, nil
}
func (ctx *spiderContext) _put(c *gin.Context) (s *models.Spider, err error) {
// bind
s = &models.Spider{}
if err := c.ShouldBindJSON(&s); err != nil {
HandleErrorBadRequest(c, err)
return nil, err
}
// upsert data collection
if err := ctx._upsertDataCollection(c, s); err != nil {
HandleErrorInternalServerError(c, err)
return nil, err
}
// save
if err := delegate2.NewModelDelegate(s, GetUserFromContext(c)).Save(); err != nil {
HandleErrorInternalServerError(c, err)
return nil, err
}
return s, nil
}
func (ctx *spiderContext) _delete(c *gin.Context) (err error) {
id := c.Param("id")
oid, err := primitive.ObjectIDFromHex(id)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := mongo.RunTransaction(func(context mongo2.SessionContext) (err error) {
// delete spider
s, err := ctx.modelSvc.GetSpiderById(oid)
if err != nil {
return err
}
if err := delegate2.NewModelDelegate(s, GetUserFromContext(c)).Delete(); err != nil {
return err
}
// delete spider stat
ss, err := ctx.modelSvc.GetSpiderStatById(oid)
if err != nil {
return err
}
if err := delegate2.NewModelDelegate(ss, GetUserFromContext(c)).Delete(); err != nil {
return err
}
// related tasks
tasks, err := ctx.modelSvc.GetTaskList(bson.M{"spider_id": oid}, nil)
if err != nil {
return err
}
// task ids
var taskIds []primitive.ObjectID
for _, t := range tasks {
taskIds = append(taskIds, t.Id)
}
// delete related tasks
if err := ctx.modelTaskSvc.DeleteList(bson.M{"_id": bson.M{"$in": taskIds}}); err != nil {
return err
}
// delete related task stats
if err := ctx.modelTaskStatSvc.DeleteList(bson.M{"_id": bson.M{"$in": taskIds}}); err != nil {
return err
}
return nil
}); err != nil {
HandleErrorInternalServerError(c, err)
return err
}
return nil
}
func (ctx *spiderContext) _getListWithStats(c *gin.Context) {
// params
pagination := MustGetPagination(c)
query := MustGetFilterQuery(c)
sort := MustGetSortOption(c)
// get list
l, err := ctx.modelSpiderSvc.GetList(query, &mongo.FindOptions{
Sort: sort,
Skip: pagination.Size * (pagination.Page - 1),
Limit: pagination.Size,
})
if err != nil {
if err.Error() == mongo2.ErrNoDocuments.Error() {
HandleErrorNotFound(c, err)
} else {
HandleErrorInternalServerError(c, err)
}
return
}
// check empty list
if len(l.GetModels()) == 0 {
HandleSuccessWithListData(c, nil, 0)
return
}
// ids
var ids []primitive.ObjectID
for _, d := range l.GetModels() {
s := d.(*models.Spider)
ids = append(ids, s.GetId())
}
// total count
total, err := ctx.modelSpiderSvc.Count(query)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// stat list
query = bson.M{
"_id": bson.M{
"$in": ids,
},
}
stats, err := ctx.modelSvc.GetSpiderStatList(query, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// cache stat list to dict
dict := map[primitive.ObjectID]models.SpiderStat{}
var tids []primitive.ObjectID
for _, st := range stats {
if st.Tasks > 0 {
taskCount := int64(st.Tasks)
st.AverageWaitDuration = int64(math.Round(float64(st.WaitDuration) / float64(taskCount)))
st.AverageRuntimeDuration = int64(math.Round(float64(st.RuntimeDuration) / float64(taskCount)))
st.AverageTotalDuration = int64(math.Round(float64(st.TotalDuration) / float64(taskCount)))
}
dict[st.GetId()] = st
if !st.LastTaskId.IsZero() {
tids = append(tids, st.LastTaskId)
}
}
// task list and stats
var tasks []models.Task
dictTask := map[primitive.ObjectID]models.Task{}
dictTaskStat := map[primitive.ObjectID]models.TaskStat{}
if len(tids) > 0 {
// task list
queryTask := bson.M{
"_id": bson.M{
"$in": tids,
},
}
tasks, err = ctx.modelSvc.GetTaskList(queryTask, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// task stats list
taskStats, err := ctx.modelSvc.GetTaskStatList(queryTask, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// cache task stats to dict
for _, st := range taskStats {
dictTaskStat[st.GetId()] = st
}
// cache task list to dict
for _, t := range tasks {
st, ok := dictTaskStat[t.GetId()]
if ok {
t.Stat = &st
}
dictTask[t.GetSpiderId()] = t
}
}
// iterate list again
var data []interface{}
for _, d := range l.GetModels() {
s := d.(*models.Spider)
// spider stat
st, ok := dict[s.GetId()]
if ok {
s.Stat = &st
// last task
t, ok := dictTask[s.GetId()]
if ok {
s.Stat.LastTask = &t
}
}
// add to list
data = append(data, *s)
}
// response
HandleSuccessWithListData(c, data, total)
}
func (ctx *spiderContext) _deleteList(c *gin.Context) (err error) {
payload, err := NewJsonBinder(ControllerIdSpider).BindBatchRequestPayload(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := mongo.RunTransaction(func(context mongo2.SessionContext) (err error) {
// delete spiders
if err := ctx.modelSpiderSvc.DeleteList(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}); err != nil {
return err
}
// delete spider stats
if err := ctx.modelSpiderStatSvc.DeleteList(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}); err != nil {
return err
}
// related tasks
tasks, err := ctx.modelSvc.GetTaskList(bson.M{"spider_id": bson.M{"$in": payload.Ids}}, nil)
if err != nil {
return err
}
// task ids
var taskIds []primitive.ObjectID
for _, t := range tasks {
taskIds = append(taskIds, t.Id)
}
// delete related tasks
if err := ctx.modelTaskSvc.DeleteList(bson.M{"_id": bson.M{"$in": taskIds}}); err != nil {
return err
}
// delete related task stats
if err := ctx.modelTaskStatSvc.DeleteList(bson.M{"_id": bson.M{"$in": taskIds}}); err != nil {
return err
}
return nil
}); err != nil {
HandleErrorInternalServerError(c, err)
return err
}
return nil
}
func (ctx *spiderContext) _processFileRequest(c *gin.Context, method string) (id primitive.ObjectID, payload entity.FileRequestPayload, fsSvc interfaces.FsServiceV2, err error) {
// id
id, err = primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// payload
contentType := c.GetHeader("Content-Type")
if strings.HasPrefix(contentType, "multipart/form-data") {
// multipart/form-data
payload, err = ctx._getFileRequestMultipartPayload(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
} else {
// query or application/json
switch method {
case http.MethodGet:
err = c.ShouldBindQuery(&payload)
default:
err = c.ShouldBindJSON(&payload)
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
// fs service
workspacePath := viper.GetString("workspace")
fsSvc = fs2.NewFsServiceV2(filepath.Join(workspacePath, id.Hex()))
return
}
func (ctx *spiderContext) _getFileRequestMultipartPayload(c *gin.Context) (payload entity.FileRequestPayload, err error) {
fh, err := c.FormFile("file")
if err != nil {
return
}
f, err := fh.Open()
if err != nil {
return
}
buf := bytes.NewBuffer(nil)
if _, err = io.Copy(buf, f); err != nil {
return
}
payload.Path = c.PostForm("path")
payload.Data = buf.String()
return
}
func (ctx *spiderContext) _processActionRequest(c *gin.Context) (id primitive.ObjectID, err error) {
// id
id, err = primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
return
}
func (ctx *spiderContext) _upsertDataCollection(c *gin.Context, s *models.Spider) (err error) {
if s.ColId.IsZero() {
// validate
if s.ColName == "" {
return trace.TraceError(errors.ErrorControllerMissingRequestFields)
}
// no id
dc, err := ctx.modelSvc.GetDataCollectionByName(s.ColName, nil)
if err != nil {
if err == mongo2.ErrNoDocuments {
// not exists, add new
dc = &models.DataCollection{Name: s.ColName}
if err := delegate2.NewModelDelegate(dc, GetUserFromContext(c)).Add(); err != nil {
return err
}
} else {
// error
return err
}
}
s.ColId = dc.Id
// create index
_ = mongo.GetMongoCol(dc.Name).CreateIndex(mongo2.IndexModel{Keys: bson.M{constants.TaskKey: 1}})
_ = mongo.GetMongoCol(dc.Name).CreateIndex(mongo2.IndexModel{Keys: bson.M{constants.HashKey: 1}})
} else {
// with id
dc, err := ctx.modelSvc.GetDataCollectionById(s.ColId)
if err != nil {
return err
}
s.ColId = dc.Id
}
return nil
}
func (ctx *spiderContext) _getGitIgnore(id primitive.ObjectID) (ignore []string, err error) {
workspacePath := viper.GetString("workspace")
filePath := filepath.Join(workspacePath, id.Hex(), ".gitignore")
if !utils.Exists(filePath) {
return nil, nil
}
data, err := os.ReadFile(filePath)
if err != nil {
return nil, trace.TraceError(err)
}
ignore = strings.Split(string(data), "\n")
return ignore, nil
}
func (ctx *spiderContext) _gitCheckout(gitClient *vcs.GitClient, remote, branch string) (err error) {
if err := gitClient.CheckoutBranch(branch, vcs.WithBranch(branch)); err != nil {
return trace.TraceError(err)
}
// pull
return ctx._gitPull(gitClient, remote, branch)
}
func (ctx *spiderContext) _gitPull(gitClient *vcs.GitClient, remote, branch string) (err error) {
// pull
if err := gitClient.Pull(
vcs.WithRemoteNamePull(remote),
vcs.WithBranchNamePull(branch),
); err != nil {
return trace.TraceError(err)
}
// reset
if err := gitClient.Reset(); err != nil {
return trace.TraceError(err)
}
return nil
}
func (ctx *spiderContext) _getGitClient(id primitive.ObjectID) (gitClient *vcs.GitClient, err error) {
// git
g, err := ctx.modelSvc.GetGitById(id)
if err != nil {
if err != mongo2.ErrNoDocuments {
return nil, trace.TraceError(err)
}
return nil, nil
}
// git client
workspacePath := viper.GetString("workspace")
gitClient, err = vcs.NewGitClient(vcs.WithPath(filepath.Join(workspacePath, id.Hex())))
if err != nil {
return nil, err
}
// set auth
utils.InitGitClientAuth(g, gitClient)
// remote name
remoteName := vcs.GitRemoteNameOrigin
// update remote
r, err := gitClient.GetRemote(remoteName)
if err == git.ErrRemoteNotFound {
// remote not exists, create
if _, err := gitClient.CreateRemote(&config.RemoteConfig{
Name: remoteName,
URLs: []string{g.Url},
}); err != nil {
return nil, trace.TraceError(err)
}
} else if err == nil {
// remote exists, update if different
if g.Url != r.Config().URLs[0] {
if err := gitClient.DeleteRemote(remoteName); err != nil {
return nil, trace.TraceError(err)
}
if _, err := gitClient.CreateRemote(&config.RemoteConfig{
Name: remoteName,
URLs: []string{g.Url},
}); err != nil {
return nil, trace.TraceError(err)
}
}
gitClient.SetRemoteUrl(g.Url)
} else {
// error
return nil, trace.TraceError(err)
}
// check if head reference exists
_, err = gitClient.GetRepository().Head()
if err == nil {
return gitClient, nil
}
// align master/main branch
ctx._alignBranch(gitClient)
return gitClient, nil
}
func (ctx *spiderContext) _alignBranch(gitClient *vcs.GitClient) {
// current branch
currentBranch, err := gitClient.GetCurrentBranch()
if err != nil {
trace.PrintError(err)
return
}
// skip if current branch is not master
if currentBranch != vcs.GitBranchNameMaster {
return
}
// remote refs
refs, err := gitClient.GetRemoteRefs(vcs.GitRemoteNameOrigin)
if err != nil {
trace.PrintError(err)
return
}
// main branch
defaultRemoteBranch, err := ctx._getDefaultRemoteBranch(refs)
if err != nil || defaultRemoteBranch == "" {
return
}
// move branch
if err := gitClient.MoveBranch(vcs.GitBranchNameMaster, defaultRemoteBranch); err != nil {
trace.PrintError(err)
}
}
func (ctx *spiderContext) _getDefaultRemoteBranch(refs []vcs.GitRef) (defaultRemoteBranchName string, err error) {
// remote branch name
for _, r := range refs {
if r.Type != vcs.GitRefTypeBranch {
continue
}
if r.Name == vcs.GitBranchNameMain {
defaultRemoteBranchName = r.Name
break
}
if r.Name == vcs.GitBranchNameMaster {
defaultRemoteBranchName = r.Name
continue
}
if defaultRemoteBranchName == "" {
defaultRemoteBranchName = r.Name
continue
}
}
return defaultRemoteBranchName, nil
}
var _spiderCtx *spiderContext
func newSpiderContext() *spiderContext {
if _spiderCtx != nil {
return _spiderCtx
}
// context
ctx := &spiderContext{}
// dependency injection
if err := container.GetContainer().Invoke(func(
modelSvc service.ModelService,
adminSvc interfaces.SpiderAdminService,
) {
ctx.modelSvc = modelSvc
ctx.adminSvc = adminSvc
}); err != nil {
panic(err)
}
// model spider service
ctx.modelSpiderSvc = ctx.modelSvc.GetBaseService(interfaces.ModelIdSpider)
// model spider stat service
ctx.modelSpiderStatSvc = ctx.modelSvc.GetBaseService(interfaces.ModelIdSpiderStat)
// model task service
ctx.modelTaskSvc = ctx.modelSvc.GetBaseService(interfaces.ModelIdTask)
// model task stat service
ctx.modelTaskStatSvc = ctx.modelSvc.GetBaseService(interfaces.ModelIdTaskStat)
_spiderCtx = ctx
return ctx
}
func newSpiderController() *spiderController {
actions := getSpiderActions()
modelSvc, err := service.GetService()
if err != nil {
panic(err)
}
ctr := NewListPostActionControllerDelegate(ControllerIdSpider, modelSvc.GetBaseService(interfaces.ModelIdSpider), actions)
d := NewListPostActionControllerDelegate(ControllerIdSpider, modelSvc.GetBaseService(interfaces.ModelIdSpider), actions)
ctx := newSpiderContext()
return &spiderController{
ListActionControllerDelegate: *ctr,
d: *d,
ctx: ctx,
}
}
|
2302_79757062/crawlab
|
core/controllers/spider.go
|
Go
|
bsd-3-clause
| 29,005
|
package controllers
import (
"errors"
"fmt"
log2 "github.com/apex/log"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/fs"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/spider/admin"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/crawlab-team/crawlab/trace"
"github.com/crawlab-team/crawlab/vcs"
"github.com/gin-gonic/gin"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/config"
"github.com/spf13/viper"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"io"
"math"
"os"
"path/filepath"
"strings"
"sync"
)
func GetSpiderById(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
s, err := service.NewModelServiceV2[models.SpiderV2]().GetById(id)
if errors.Is(err, mongo2.ErrNoDocuments) {
HandleErrorNotFound(c, err)
return
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// stat
s.Stat, err = service.NewModelServiceV2[models.SpiderStatV2]().GetById(s.Id)
if err != nil {
if !errors.Is(err, mongo2.ErrNoDocuments) {
HandleErrorInternalServerError(c, err)
return
}
}
// data collection
if !s.ColId.IsZero() {
col, err := service.NewModelServiceV2[models.DataCollectionV2]().GetById(s.ColId)
if err != nil {
if !errors.Is(err, mongo2.ErrNoDocuments) {
HandleErrorInternalServerError(c, err)
return
}
} else {
s.ColName = col.Name
}
}
HandleSuccessWithData(c, s)
}
func GetSpiderList(c *gin.Context) {
withStats := c.Query("stats")
if withStats == "" {
NewControllerV2[models.SpiderV2]().GetList(c)
return
}
// params
pagination := MustGetPagination(c)
query := MustGetFilterQuery(c)
sort := MustGetSortOption(c)
// get list
spiders, err := service.NewModelServiceV2[models.SpiderV2]().GetMany(query, &mongo.FindOptions{
Sort: sort,
Skip: pagination.Size * (pagination.Page - 1),
Limit: pagination.Size,
})
if err != nil {
if err.Error() != mongo2.ErrNoDocuments.Error() {
HandleErrorInternalServerError(c, err)
}
return
}
if len(spiders) == 0 {
HandleSuccessWithListData(c, []models.SpiderV2{}, 0)
return
}
// ids
var ids []primitive.ObjectID
for _, s := range spiders {
ids = append(ids, s.Id)
}
// total count
total, err := service.NewModelServiceV2[models.SpiderV2]().Count(query)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// stat list
spiderStats, err := service.NewModelServiceV2[models.SpiderStatV2]().GetMany(bson.M{"_id": bson.M{"$in": ids}}, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// cache stat list to dict
dict := map[primitive.ObjectID]models.SpiderStatV2{}
var taskIds []primitive.ObjectID
for _, st := range spiderStats {
if st.Tasks > 0 {
taskCount := int64(st.Tasks)
st.AverageWaitDuration = int64(math.Round(float64(st.WaitDuration) / float64(taskCount)))
st.AverageRuntimeDuration = int64(math.Round(float64(st.RuntimeDuration) / float64(taskCount)))
st.AverageTotalDuration = int64(math.Round(float64(st.TotalDuration) / float64(taskCount)))
}
dict[st.Id] = st
if !st.LastTaskId.IsZero() {
taskIds = append(taskIds, st.LastTaskId)
}
}
// task list and stats
var tasks []models.TaskV2
dictTask := map[primitive.ObjectID]models.TaskV2{}
dictTaskStat := map[primitive.ObjectID]models.TaskStatV2{}
if len(taskIds) > 0 {
// task list
queryTask := bson.M{
"_id": bson.M{
"$in": taskIds,
},
}
tasks, err = service.NewModelServiceV2[models.TaskV2]().GetMany(queryTask, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// task stats list
taskStats, err := service.NewModelServiceV2[models.TaskStatV2]().GetMany(queryTask, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// cache task stats to dict
for _, st := range taskStats {
dictTaskStat[st.Id] = st
}
// cache task list to dict
for _, t := range tasks {
st, ok := dictTaskStat[t.Id]
if ok {
t.Stat = &st
}
dictTask[t.SpiderId] = t
}
}
// iterate list again
var data []models.SpiderV2
for _, s := range spiders {
// spider stat
st, ok := dict[s.Id]
if ok {
s.Stat = &st
// last task
t, ok := dictTask[s.Id]
if ok {
s.Stat.LastTask = &t
}
}
// add to list
data = append(data, s)
}
// response
HandleSuccessWithListData(c, data, total)
}
func PostSpider(c *gin.Context) {
// bind
var s models.SpiderV2
if err := c.ShouldBindJSON(&s); err != nil {
HandleErrorBadRequest(c, err)
return
}
// upsert data collection
if err := upsertSpiderDataCollection(&s); err != nil {
HandleErrorInternalServerError(c, err)
return
}
u := GetUserFromContextV2(c)
// add
s.SetCreated(u.Id)
s.SetUpdated(u.Id)
id, err := service.NewModelServiceV2[models.SpiderV2]().InsertOne(s)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
s.SetId(id)
// add stat
st := models.SpiderStatV2{}
st.SetId(id)
st.SetCreated(u.Id)
st.SetUpdated(u.Id)
_, err = service.NewModelServiceV2[models.SpiderStatV2]().InsertOne(st)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// create folder
err = getSpiderFsSvcById(id).CreateDir(".")
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, s)
}
func PutSpiderById(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// bind
var s models.SpiderV2
if err := c.ShouldBindJSON(&s); err != nil {
HandleErrorBadRequest(c, err)
return
}
// upsert data collection
if err := upsertSpiderDataCollection(&s); err != nil {
HandleErrorInternalServerError(c, err)
return
}
u := GetUserFromContextV2(c)
modelSvc := service.NewModelServiceV2[models.SpiderV2]()
// save
s.SetUpdated(u.Id)
err = modelSvc.ReplaceById(id, s)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
_s, err := modelSvc.GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
s = *_s
HandleSuccessWithData(c, s)
}
func DeleteSpiderById(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := mongo.RunTransaction(func(context mongo2.SessionContext) (err error) {
// delete spider
err = service.NewModelServiceV2[models.SpiderV2]().DeleteById(id)
if err != nil {
return err
}
// delete spider stat
err = service.NewModelServiceV2[models.SpiderStatV2]().DeleteById(id)
if err != nil {
return err
}
// related tasks
tasks, err := service.NewModelServiceV2[models.TaskV2]().GetMany(bson.M{"spider_id": id}, nil)
if err != nil {
return err
}
if len(tasks) == 0 {
return nil
}
// task ids
var taskIds []primitive.ObjectID
for _, t := range tasks {
taskIds = append(taskIds, t.Id)
}
// delete related tasks
err = service.NewModelServiceV2[models.TaskV2]().DeleteMany(bson.M{"_id": bson.M{"$in": taskIds}})
if err != nil {
return err
}
// delete related task stats
err = service.NewModelServiceV2[models.TaskStatV2]().DeleteMany(bson.M{"_id": bson.M{"$in": taskIds}})
if err != nil {
return err
}
// delete tasks logs
wg := sync.WaitGroup{}
wg.Add(len(taskIds))
for _, id := range taskIds {
go func(id string) {
// delete task logs
logPath := filepath.Join(viper.GetString("log.path"), id)
if err := os.RemoveAll(logPath); err != nil {
log2.Warnf("failed to remove task log directory: %s", logPath)
}
wg.Done()
}(id.Hex())
}
wg.Wait()
return nil
}); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func DeleteSpiderList(c *gin.Context) {
var payload struct {
Ids []primitive.ObjectID `json:"ids"`
}
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := mongo.RunTransaction(func(context mongo2.SessionContext) (err error) {
// delete spiders
if err := service.NewModelServiceV2[models.SpiderV2]().DeleteMany(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}); err != nil {
return err
}
// delete spider stats
if err := service.NewModelServiceV2[models.SpiderStatV2]().DeleteMany(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}); err != nil {
return err
}
// related tasks
tasks, err := service.NewModelServiceV2[models.TaskV2]().GetMany(bson.M{"spider_id": bson.M{"$in": payload.Ids}}, nil)
if err != nil {
return err
}
if len(tasks) == 0 {
return nil
}
// task ids
var taskIds []primitive.ObjectID
for _, t := range tasks {
taskIds = append(taskIds, t.Id)
}
// delete related tasks
if err := service.NewModelServiceV2[models.TaskV2]().DeleteMany(bson.M{"_id": bson.M{"$in": taskIds}}); err != nil {
return err
}
// delete related task stats
if err := service.NewModelServiceV2[models.TaskStatV2]().DeleteMany(bson.M{"_id": bson.M{"$in": taskIds}}); err != nil {
return err
}
// delete tasks logs
wg := sync.WaitGroup{}
wg.Add(len(taskIds))
for _, id := range taskIds {
go func(id string) {
// delete task logs
logPath := filepath.Join(viper.GetString("log.path"), id)
if err := os.RemoveAll(logPath); err != nil {
log2.Warnf("failed to remove task log directory: %s", logPath)
}
wg.Done()
}(id.Hex())
}
wg.Wait()
return nil
}); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func GetSpiderListDir(c *gin.Context) {
path := c.Query("path")
fsSvc, err := getSpiderFsSvc(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
files, err := fsSvc.List(path)
if err != nil {
if !errors.Is(err, os.ErrNotExist) {
HandleErrorInternalServerError(c, err)
return
}
}
HandleSuccessWithData(c, files)
}
func GetSpiderFile(c *gin.Context) {
path := c.Query("path")
fsSvc, err := getSpiderFsSvc(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
data, err := fsSvc.GetFile(path)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, string(data))
}
func GetSpiderFileInfo(c *gin.Context) {
path := c.Query("path")
fsSvc, err := getSpiderFsSvc(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
info, err := fsSvc.GetFileInfo(path)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, info)
}
func PostSpiderSaveFile(c *gin.Context) {
fsSvc, err := getSpiderFsSvc(c)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
if c.GetHeader("Content-Type") == "application/json" {
var payload struct {
Path string `json:"path"`
Data string `json:"data"`
}
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := fsSvc.Save(payload.Path, []byte(payload.Data)); err != nil {
HandleErrorInternalServerError(c, err)
return
}
} else {
path, ok := c.GetPostForm("path")
if !ok {
HandleErrorBadRequest(c, errors.New("missing required field 'path'"))
return
}
file, err := c.FormFile("file")
if err != nil {
HandleErrorBadRequest(c, err)
return
}
f, err := file.Open()
if err != nil {
HandleErrorBadRequest(c, err)
return
}
fileData, err := io.ReadAll(f)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := fsSvc.Save(path, fileData); err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
HandleSuccess(c)
}
func PostSpiderSaveFiles(c *gin.Context) {
fsSvc, err := getSpiderFsSvc(c)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
form, err := c.MultipartForm()
if err != nil {
HandleErrorBadRequest(c, err)
return
}
wg := sync.WaitGroup{}
wg.Add(len(form.File))
for path := range form.File {
go func(path string) {
file, err := c.FormFile(path)
if err != nil {
log2.Warnf("invalid file header: %s", path)
log2.Error(err.Error())
wg.Done()
return
}
f, err := file.Open()
if err != nil {
log2.Warnf("unable to open file: %s", path)
log2.Error(err.Error())
wg.Done()
return
}
fileData, err := io.ReadAll(f)
if err != nil {
log2.Warnf("unable to read file: %s", path)
log2.Error(err.Error())
wg.Done()
return
}
if err := fsSvc.Save(path, fileData); err != nil {
log2.Warnf("unable to save file: %s", path)
log2.Error(err.Error())
wg.Done()
return
}
wg.Done()
}(path)
}
wg.Wait()
HandleSuccess(c)
}
func PostSpiderSaveDir(c *gin.Context) {
var payload struct {
Path string `json:"path"`
NewPath string `json:"new_path"`
Data string `json:"data"`
}
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
fsSvc, err := getSpiderFsSvc(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := fsSvc.CreateDir(payload.Path); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func PostSpiderRenameFile(c *gin.Context) {
var payload struct {
Path string `json:"path"`
NewPath string `json:"new_path"`
}
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
fsSvc, err := getSpiderFsSvc(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := fsSvc.Rename(payload.Path, payload.NewPath); err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
func DeleteSpiderFile(c *gin.Context) {
var payload struct {
Path string `json:"path"`
}
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
if payload.Path == "~" {
payload.Path = "."
}
fsSvc, err := getSpiderFsSvc(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := fsSvc.Delete(payload.Path); err != nil {
HandleErrorInternalServerError(c, err)
return
}
_, err = fsSvc.GetFileInfo(".")
if err != nil {
_ = fsSvc.CreateDir("/")
}
HandleSuccess(c)
}
func PostSpiderCopyFile(c *gin.Context) {
var payload struct {
Path string `json:"path"`
NewPath string `json:"new_path"`
}
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
fsSvc, err := getSpiderFsSvc(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := fsSvc.Copy(payload.Path, payload.NewPath); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func PostSpiderExport(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
adminSvc, err := admin.GetSpiderAdminServiceV2()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// zip file path
zipFilePath, err := adminSvc.Export(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// download
c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", zipFilePath))
c.File(zipFilePath)
}
func PostSpiderRun(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// options
var opts interfaces.SpiderRunOptions
if err := c.ShouldBindJSON(&opts); err != nil {
HandleErrorInternalServerError(c, err)
return
}
// user
if u := GetUserFromContext(c); u != nil {
opts.UserId = u.GetId()
}
adminSvc, err := admin.GetSpiderAdminServiceV2()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// schedule
taskIds, err := adminSvc.Schedule(id, &opts)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, taskIds)
}
func GetSpiderGit(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// git client
gitClient, err := getSpiderGitClient(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// return null if git client is empty
if gitClient == nil {
HandleSuccess(c)
return
}
// current branch
currentBranch, err := gitClient.GetCurrentBranch()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// branches
branches, err := gitClient.GetBranches()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
if branches == nil || len(branches) == 0 && currentBranch != "" {
branches = []vcs.GitRef{{Name: currentBranch}}
}
// changes
changes, err := gitClient.GetStatus()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// logs
logs, err := gitClient.GetLogsWithRefs()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// ignore
ignore, err := getSpiderGitIgnore(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// git
_git, err := service.NewModelServiceV2[models.GitV2]().GetById(id)
if err != nil {
if err.Error() != mongo2.ErrNoDocuments.Error() {
HandleErrorInternalServerError(c, err)
return
}
}
// response
res := bson.M{
"current_branch": currentBranch,
"branches": branches,
"changes": changes,
"logs": logs,
"ignore": ignore,
"git": _git,
}
HandleSuccessWithData(c, res)
}
func GetSpiderGitRemoteRefs(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// remote name
remoteName := c.Query("remote")
if remoteName == "" {
remoteName = vcs.GitRemoteNameOrigin
}
// git client
gitClient, err := getSpiderGitClient(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// return null if git client is empty
if gitClient == nil {
HandleSuccess(c)
return
}
// refs
refs, err := gitClient.GetRemoteRefs(remoteName)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, refs)
}
func PostSpiderGitCheckout(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// payload
var payload struct {
Paths []string `json:"paths"`
CommitMessage string `json:"commit_message"`
Branch string `json:"branch"`
Tag string `json:"tag"`
}
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
// git client
gitClient, err := getSpiderGitClient(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// return null if git client is empty
if gitClient == nil {
HandleSuccess(c)
return
}
// branch to pull
var branch string
if payload.Branch == "" {
// by default current branch
branch, err = gitClient.GetCurrentBranch()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
} else {
// payload branch
branch = payload.Branch
}
// checkout
if err := gitSpiderCheckout(gitClient, constants.GitRemoteNameOrigin, branch); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func PostSpiderGitPull(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// payload
var payload struct {
Paths []string `json:"paths"`
CommitMessage string `json:"commit_message"`
Branch string `json:"branch"`
Tag string `json:"tag"`
}
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
// git
g, err := service.NewModelServiceV2[models.GitV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// attempt to sync git
adminSvc, err := admin.GetSpiderAdminServiceV2()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
_ = adminSvc.SyncGitOne(g)
HandleSuccess(c)
}
func PostSpiderGitCommit(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// payload
var payload entity.GitPayload
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
// git client
gitClient, err := getSpiderGitClient(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// return null if git client is empty
if gitClient == nil {
HandleSuccess(c)
return
}
// add
for _, p := range payload.Paths {
if err := gitClient.Add(p); err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
// commit
if err := gitClient.Commit(payload.CommitMessage); err != nil {
HandleErrorInternalServerError(c, err)
return
}
// push
if err := gitClient.Push(
vcs.WithRemoteNamePush(vcs.GitRemoteNameOrigin),
); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func GetSpiderDataSource(c *gin.Context) {
// spider id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// spider
s, err := service.NewModelServiceV2[models.SpiderV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// data source
ds, err := service.NewModelServiceV2[models.DataSourceV2]().GetById(s.DataSourceId)
if err != nil {
if err.Error() == mongo2.ErrNoDocuments.Error() {
HandleSuccess(c)
return
}
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, ds)
}
func PostSpiderDataSource(c *gin.Context) {
// spider id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// data source id
dsId, err := primitive.ObjectIDFromHex(c.Param("ds_id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// spider
s, err := service.NewModelServiceV2[models.SpiderV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// data source
if !dsId.IsZero() {
_, err = service.NewModelServiceV2[models.DataSourceV2]().GetById(dsId)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
}
// save data source id
u := GetUserFromContextV2(c)
s.DataSourceId = dsId
s.SetUpdatedBy(u.Id)
_, err = service.NewModelServiceV2[models.SpiderV2]().InsertOne(*s)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func getSpiderFsSvc(c *gin.Context) (svc interfaces.FsServiceV2, err error) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
return nil, err
}
workspacePath := viper.GetString("workspace")
fsSvc := fs.NewFsServiceV2(filepath.Join(workspacePath, id.Hex()))
return fsSvc, nil
}
func getSpiderFsSvcById(id primitive.ObjectID) interfaces.FsServiceV2 {
workspacePath := viper.GetString("workspace")
fsSvc := fs.NewFsServiceV2(filepath.Join(workspacePath, id.Hex()))
return fsSvc
}
func getSpiderGitClient(id primitive.ObjectID) (client *vcs.GitClient, err error) {
// git
g, err := service.NewModelServiceV2[models.GitV2]().GetById(id)
if err != nil {
if !errors.Is(err, mongo2.ErrNoDocuments) {
return nil, trace.TraceError(err)
}
return nil, nil
}
// git client
workspacePath := viper.GetString("workspace")
client, err = vcs.NewGitClient(vcs.WithPath(filepath.Join(workspacePath, id.Hex())))
if err != nil {
return nil, err
}
// set auth
utils.InitGitClientAuthV2(g, client)
// remote name
remoteName := vcs.GitRemoteNameOrigin
// update remote
r, err := client.GetRemote(remoteName)
if errors.Is(err, git.ErrRemoteNotFound) {
// remote not exists, create
if _, err := client.CreateRemote(&config.RemoteConfig{
Name: remoteName,
URLs: []string{g.Url},
}); err != nil {
return nil, trace.TraceError(err)
}
} else if err == nil {
// remote exists, update if different
if g.Url != r.Config().URLs[0] {
if err := client.DeleteRemote(remoteName); err != nil {
return nil, trace.TraceError(err)
}
if _, err := client.CreateRemote(&config.RemoteConfig{
Name: remoteName,
URLs: []string{g.Url},
}); err != nil {
return nil, trace.TraceError(err)
}
}
client.SetRemoteUrl(g.Url)
} else {
// error
return nil, trace.TraceError(err)
}
// check if head reference exists
_, err = client.GetRepository().Head()
if err == nil {
return client, nil
}
// align master/main branch
alignSpiderGitBranch(client)
return client, nil
}
func alignSpiderGitBranch(gitClient *vcs.GitClient) {
// current branch
currentBranch, err := gitClient.GetCurrentBranch()
if err != nil {
trace.PrintError(err)
return
}
// skip if current branch is not master
if currentBranch != vcs.GitBranchNameMaster {
return
}
// remote refs
refs, err := gitClient.GetRemoteRefs(vcs.GitRemoteNameOrigin)
if err != nil {
trace.PrintError(err)
return
}
// main branch
defaultRemoteBranch, err := getSpiderDefaultRemoteBranch(refs)
if err != nil || defaultRemoteBranch == "" {
return
}
// move branch
if err := gitClient.MoveBranch(vcs.GitBranchNameMaster, defaultRemoteBranch); err != nil {
trace.PrintError(err)
}
}
func getSpiderDefaultRemoteBranch(refs []vcs.GitRef) (defaultRemoteBranchName string, err error) {
// remote branch name
for _, r := range refs {
if r.Type != vcs.GitRefTypeBranch {
continue
}
if r.Name == vcs.GitBranchNameMain {
defaultRemoteBranchName = r.Name
break
}
if r.Name == vcs.GitBranchNameMaster {
defaultRemoteBranchName = r.Name
continue
}
if defaultRemoteBranchName == "" {
defaultRemoteBranchName = r.Name
continue
}
}
return defaultRemoteBranchName, nil
}
func getSpiderGitIgnore(id primitive.ObjectID) (ignore []string, err error) {
workspacePath := viper.GetString("workspace")
filePath := filepath.Join(workspacePath, id.Hex(), ".gitignore")
if !utils.Exists(filePath) {
return nil, nil
}
data, err := os.ReadFile(filePath)
if err != nil {
return nil, trace.TraceError(err)
}
ignore = strings.Split(string(data), "\n")
return ignore, nil
}
func gitSpiderCheckout(gitClient *vcs.GitClient, remote, branch string) (err error) {
if err := gitClient.CheckoutBranch(branch, vcs.WithBranch(branch)); err != nil {
return trace.TraceError(err)
}
// pull
return spiderGitPull(gitClient, remote, branch)
}
func spiderGitPull(gitClient *vcs.GitClient, remote, branch string) (err error) {
// pull
if err := gitClient.Pull(
vcs.WithRemoteNamePull(remote),
vcs.WithBranchNamePull(branch),
); err != nil {
return trace.TraceError(err)
}
// reset
if err := gitClient.Reset(); err != nil {
return trace.TraceError(err)
}
return nil
}
func upsertSpiderDataCollection(s *models.SpiderV2) (err error) {
modelSvc := service.NewModelServiceV2[models.DataCollectionV2]()
if s.ColId.IsZero() {
// validate
if s.ColName == "" {
return errors.New("data collection name is required")
}
// no id
dc, err := modelSvc.GetOne(bson.M{"name": s.ColName}, nil)
if err != nil {
if errors.Is(err, mongo2.ErrNoDocuments) {
// not exists, add new
dc = &models.DataCollectionV2{Name: s.ColName}
dcId, err := modelSvc.InsertOne(*dc)
if err != nil {
return err
}
dc.SetId(dcId)
} else {
// error
return err
}
}
s.ColId = dc.Id
// create index
_ = mongo.GetMongoCol(dc.Name).CreateIndex(mongo2.IndexModel{Keys: bson.M{constants.TaskKey: 1}})
_ = mongo.GetMongoCol(dc.Name).CreateIndex(mongo2.IndexModel{Keys: bson.M{constants.HashKey: 1}})
} else {
// with id
dc, err := modelSvc.GetById(s.ColId)
if err != nil {
return err
}
s.ColId = dc.Id
}
return nil
}
|
2302_79757062/crawlab
|
core/controllers/spider_v2.go
|
Go
|
bsd-3-clause
| 28,079
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"net/http"
"time"
)
var StatsController ActionController
func getStatsActions() []Action {
statsCtx := newStatsContext()
return []Action{
{
Method: http.MethodGet,
Path: "/overview",
HandlerFunc: statsCtx.getOverview,
},
{
Method: http.MethodGet,
Path: "/daily",
HandlerFunc: statsCtx.getDaily,
},
{
Method: http.MethodGet,
Path: "/tasks",
HandlerFunc: statsCtx.getTasks,
},
}
}
type statsContext struct {
statsSvc interfaces.StatsService
defaultQuery bson.M
}
func (svc *statsContext) getOverview(c *gin.Context) {
data, err := svc.statsSvc.GetOverviewStats(svc.defaultQuery)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, data)
}
func (svc *statsContext) getDaily(c *gin.Context) {
data, err := svc.statsSvc.GetDailyStats(svc.defaultQuery)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, data)
}
func (svc *statsContext) getTasks(c *gin.Context) {
data, err := svc.statsSvc.GetTaskStats(svc.defaultQuery)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, data)
}
func newStatsContext() *statsContext {
// context
ctx := &statsContext{
defaultQuery: bson.M{
"create_ts": bson.M{
"$gte": time.Now().Add(-30 * 24 * time.Hour),
},
},
}
// dependency injection
if err := container.GetContainer().Invoke(func(
statsSvc interfaces.StatsService,
) {
ctx.statsSvc = statsSvc
}); err != nil {
panic(err)
}
return ctx
}
|
2302_79757062/crawlab
|
core/controllers/stats.go
|
Go
|
bsd-3-clause
| 1,776
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/stats"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"time"
)
var statsDefaultQuery = bson.M{
"create_ts": bson.M{
"$gte": time.Now().Add(-30 * 24 * time.Hour),
},
}
func GetStatsOverview(c *gin.Context) {
data, err := stats.GetStatsService().GetOverviewStats(statsDefaultQuery)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, data)
}
func GetStatsDaily(c *gin.Context) {
data, err := stats.GetStatsService().GetDailyStats(statsDefaultQuery)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, data)
}
func GetStatsTasks(c *gin.Context) {
data, err := stats.GetStatsService().GetTaskStats(statsDefaultQuery)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, data)
}
|
2302_79757062/crawlab
|
core/controllers/stats_v2.go
|
Go
|
bsd-3-clause
| 903
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/utils"
"github.com/gin-gonic/gin"
"github.com/spf13/viper"
"net/http"
"path/filepath"
)
var SyncController ActionController
func getSyncActions() []Action {
var ctx = newSyncContext()
return []Action{
{
Method: http.MethodGet,
Path: "/:id/scan",
HandlerFunc: ctx.scan,
},
{
Method: http.MethodGet,
Path: "/:id/download",
HandlerFunc: ctx.download,
},
}
}
type syncContext struct {
}
func (ctx *syncContext) scan(c *gin.Context) {
id := c.Param("id")
dir := ctx._getDir(id)
files, err := utils.ScanDirectory(dir)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
c.AbortWithStatusJSON(http.StatusOK, files)
}
func (ctx *syncContext) download(c *gin.Context) {
id := c.Param("id")
filePath := c.Query("path")
dir := ctx._getDir(id)
c.File(filepath.Join(dir, filePath))
}
func (ctx *syncContext) _getDir(id string) string {
workspacePath := viper.GetString("workspace")
return filepath.Join(workspacePath, id)
}
func newSyncContext() syncContext {
return syncContext{}
}
|
2302_79757062/crawlab
|
core/controllers/sync.go
|
Go
|
bsd-3-clause
| 1,132
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/entity"
"github.com/gin-gonic/gin"
"github.com/spf13/viper"
"net/http"
)
func getSystemInfo(c *gin.Context) {
info := &entity.SystemInfo{
Edition: viper.GetString("info.edition"),
Version: viper.GetString("info.version"),
}
HandleSuccessWithData(c, info)
}
func getSystemInfoActions() []Action {
return []Action{
{
Path: "",
Method: http.MethodGet,
HandlerFunc: getSystemInfo,
},
}
}
var SystemInfoController ActionController
|
2302_79757062/crawlab
|
core/controllers/system_info.go
|
Go
|
bsd-3-clause
| 535
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/entity"
"github.com/gin-gonic/gin"
"github.com/spf13/viper"
)
func GetSystemInfo(c *gin.Context) {
info := &entity.SystemInfo{
Edition: viper.GetString("info.edition"),
Version: viper.GetString("info.version"),
}
HandleSuccessWithData(c, info)
}
|
2302_79757062/crawlab
|
core/controllers/system_info_v2.go
|
Go
|
bsd-3-clause
| 325
|
package controllers
var TagController ListController
|
2302_79757062/crawlab
|
core/controllers/tag.go
|
Go
|
bsd-3-clause
| 54
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
delegate2 "github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/result"
"github.com/crawlab-team/crawlab/core/task/log"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/db/generic"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"net/http"
"strings"
)
var TaskController *taskController
func getTaskActions() []Action {
taskCtx := newTaskContext()
return []Action{
{
Method: http.MethodPost,
Path: "/run",
HandlerFunc: taskCtx.run,
},
{
Method: http.MethodPost,
Path: "/:id/restart",
HandlerFunc: taskCtx.restart,
},
{
Method: http.MethodPost,
Path: "/:id/cancel",
HandlerFunc: taskCtx.cancel,
},
{
Method: http.MethodGet,
Path: "/:id/logs",
HandlerFunc: taskCtx.getLogs,
},
{
Method: http.MethodGet,
Path: "/:id/data",
HandlerFunc: taskCtx.getData,
},
}
}
type taskController struct {
ListActionControllerDelegate
d ListActionControllerDelegate
ctx *taskContext
}
func (ctr *taskController) Get(c *gin.Context) {
ctr.ctx.getWithStatsSpider(c)
}
func (ctr *taskController) Delete(c *gin.Context) {
if err := ctr.ctx._delete(c); err != nil {
return
}
HandleSuccess(c)
}
func (ctr *taskController) GetList(c *gin.Context) {
withStats := c.Query("stats")
if withStats == "" {
ctr.d.GetList(c)
return
}
ctr.ctx.getListWithStats(c)
}
func (ctr *taskController) DeleteList(c *gin.Context) {
if err := ctr.ctx._deleteList(c); err != nil {
return
}
HandleSuccess(c)
}
type taskContext struct {
modelSvc service.ModelService
modelTaskSvc interfaces.ModelBaseService
modelTaskStatSvc interfaces.ModelBaseService
adminSvc interfaces.SpiderAdminService
schedulerSvc interfaces.TaskSchedulerService
l log.Driver
}
func (ctx *taskContext) run(c *gin.Context) {
// task
var t models.Task
if err := c.ShouldBindJSON(&t); err != nil {
HandleErrorBadRequest(c, err)
return
}
// validate spider id
if t.GetSpiderId().IsZero() {
HandleErrorBadRequest(c, errors.ErrorTaskEmptySpiderId)
return
}
// spider
s, err := ctx.modelSvc.GetSpiderById(t.GetSpiderId())
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// options
opts := &interfaces.SpiderRunOptions{
Mode: t.Mode,
NodeIds: t.NodeIds,
Cmd: t.Cmd,
Param: t.Param,
Priority: t.Priority,
}
// user
if u := GetUserFromContext(c); u != nil {
opts.UserId = u.GetId()
}
// run
taskIds, err := ctx.adminSvc.Schedule(s.GetId(), opts)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, taskIds)
}
func (ctx *taskContext) restart(c *gin.Context) {
// id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// task
t, err := ctx.modelSvc.GetTaskById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// options
opts := &interfaces.SpiderRunOptions{
Mode: t.Mode,
NodeIds: t.NodeIds,
Cmd: t.Cmd,
Param: t.Param,
Priority: t.Priority,
}
// user
if u := GetUserFromContext(c); u != nil {
opts.UserId = u.GetId()
}
// run
taskIds, err := ctx.adminSvc.Schedule(t.SpiderId, opts)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, taskIds)
}
func (ctx *taskContext) cancel(c *gin.Context) {
// id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// task
t, err := ctx.modelSvc.GetTaskById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// validate
if !utils.IsCancellable(t.Status) {
HandleErrorInternalServerError(c, errors.ErrorControllerNotCancellable)
return
}
// cancel
if err := ctx.schedulerSvc.Cancel(id, GetUserFromContext(c)); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *taskContext) getLogs(c *gin.Context) {
// id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// pagination
p, err := GetPagination(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// logs
logs, err := ctx.l.Find(id.Hex(), "", (p.Page-1)*p.Size, p.Size)
if err != nil {
if strings.HasSuffix(err.Error(), "Status:404 Not Found") {
HandleSuccess(c)
return
}
HandleErrorInternalServerError(c, err)
return
}
total, err := ctx.l.Count(id.Hex(), "")
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithListData(c, logs, total)
}
func (ctx *taskContext) getListWithStats(c *gin.Context) {
// params
pagination := MustGetPagination(c)
query := MustGetFilterQuery(c)
sort := MustGetSortOption(c)
// get list
list, err := ctx.modelTaskSvc.GetList(query, &mongo.FindOptions{
Sort: sort,
Skip: pagination.Size * (pagination.Page - 1),
Limit: pagination.Size,
})
if err != nil {
if err == mongo2.ErrNoDocuments {
HandleErrorNotFound(c, err)
} else {
HandleErrorInternalServerError(c, err)
}
return
}
// check empty list
if len(list.GetModels()) == 0 {
HandleSuccessWithListData(c, nil, 0)
return
}
// ids
var ids []primitive.ObjectID
for _, d := range list.GetModels() {
t := d.(interfaces.Model)
ids = append(ids, t.GetId())
}
// total count
total, err := ctx.modelTaskSvc.Count(query)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// stat list
query = bson.M{
"_id": bson.M{
"$in": ids,
},
}
stats, err := ctx.modelSvc.GetTaskStatList(query, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// cache stat list to dict
dict := map[primitive.ObjectID]models.TaskStat{}
for _, s := range stats {
dict[s.GetId()] = s
}
// iterate list again
var data []interface{}
for _, d := range list.GetModels() {
t := d.(*models.Task)
s, ok := dict[t.GetId()]
if ok {
t.Stat = &s
}
data = append(data, *t)
}
// response
HandleSuccessWithListData(c, data, total)
}
func (ctx *taskContext) getWithStatsSpider(c *gin.Context) {
// id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// task
t, err := ctx.modelSvc.GetTaskById(id)
if err == mongo2.ErrNoDocuments {
HandleErrorNotFound(c, err)
return
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// spider
t.Spider, _ = ctx.modelSvc.GetSpiderById(t.SpiderId)
// skip if task status is pending
if t.Status == constants.TaskStatusPending {
HandleSuccessWithData(c, t)
return
}
// task stat
t.Stat, _ = ctx.modelSvc.GetTaskStatById(id)
HandleSuccessWithData(c, t)
}
func (ctx *taskContext) getData(c *gin.Context) {
// id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// pagination
p, err := GetPagination(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// task
t, err := ctx.modelSvc.GetTaskById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// result service
resultSvc, err := result.GetResultService(t.SpiderId)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// query
query := generic.ListQuery{
generic.ListQueryCondition{
Key: constants.TaskKey,
Op: generic.OpEqual,
Value: t.Id,
},
}
// list
data, err := resultSvc.List(query, &generic.ListOptions{
Skip: (p.Page - 1) * p.Size,
Limit: p.Size,
Sort: []generic.ListSort{{"_id", generic.SortDirectionDesc}},
})
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// total
total, err := resultSvc.Count(query)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithListData(c, data, total)
}
func (ctx *taskContext) _delete(c *gin.Context) (err error) {
id := c.Param("id")
oid, err := primitive.ObjectIDFromHex(id)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := mongo.RunTransaction(func(context mongo2.SessionContext) (err error) {
// delete task
task, err := ctx.modelSvc.GetTaskById(oid)
if err != nil {
return err
}
if err := delegate2.NewModelDelegate(task, GetUserFromContext(c)).Delete(); err != nil {
return err
}
// delete task stat
taskStat, err := ctx.modelSvc.GetTaskStatById(oid)
if err != nil {
return err
}
if err := delegate2.NewModelDelegate(taskStat, GetUserFromContext(c)).Delete(); err != nil {
return err
}
return nil
}); err != nil {
HandleErrorInternalServerError(c, err)
return err
}
return nil
}
func (ctx *taskContext) _deleteList(c *gin.Context) (err error) {
payload, err := NewJsonBinder(ControllerIdTask).BindBatchRequestPayload(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := mongo.RunTransaction(func(context mongo2.SessionContext) error {
// delete tasks
if err := ctx.modelTaskSvc.DeleteList(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}); err != nil {
return err
}
// delete task stats
if err := ctx.modelTaskStatSvc.DeleteList(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}); err != nil {
return err
}
return nil
}); err != nil {
HandleErrorInternalServerError(c, err)
return err
}
return nil
}
func newTaskContext() *taskContext {
// context
ctx := &taskContext{}
// dependency injection
if err := container.GetContainer().Invoke(func(
modelSvc service.ModelService,
adminSvc interfaces.SpiderAdminService,
schedulerSvc interfaces.TaskSchedulerService,
) {
ctx.modelSvc = modelSvc
ctx.adminSvc = adminSvc
ctx.schedulerSvc = schedulerSvc
}); err != nil {
panic(err)
}
// model task service
ctx.modelTaskSvc = ctx.modelSvc.GetBaseService(interfaces.ModelIdTask)
// model task stat service
ctx.modelTaskStatSvc = ctx.modelSvc.GetBaseService(interfaces.ModelIdTaskStat)
// log driver
l, err := log.GetLogDriver(log.DriverTypeFile)
if err != nil {
panic(err)
}
ctx.l = l
return ctx
}
func newTaskController() *taskController {
actions := getTaskActions()
modelSvc, err := service.GetService()
if err != nil {
panic(err)
}
ctr := NewListPostActionControllerDelegate(ControllerIdTask, modelSvc.GetBaseService(interfaces.ModelIdTask), actions)
d := NewListPostActionControllerDelegate(ControllerIdTask, modelSvc.GetBaseService(interfaces.ModelIdTask), actions)
ctx := newTaskContext()
return &taskController{
ListActionControllerDelegate: *ctr,
d: *d,
ctx: ctx,
}
}
|
2302_79757062/crawlab
|
core/controllers/task.go
|
Go
|
bsd-3-clause
| 11,200
|
package controllers
import (
"errors"
log2 "github.com/apex/log"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/result"
"github.com/crawlab-team/crawlab/core/spider/admin"
"github.com/crawlab-team/crawlab/core/task/log"
"github.com/crawlab-team/crawlab/core/task/scheduler"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/db/generic"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/gin-gonic/gin"
"github.com/spf13/viper"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"os"
"path/filepath"
"strings"
"sync"
)
func GetTaskById(c *gin.Context) {
// id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// task
t, err := service.NewModelServiceV2[models.TaskV2]().GetById(id)
if errors.Is(err, mongo2.ErrNoDocuments) {
HandleErrorNotFound(c, err)
return
}
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// spider
t.Spider, _ = service.NewModelServiceV2[models.SpiderV2]().GetById(t.SpiderId)
// skip if task status is pending
if t.Status == constants.TaskStatusPending {
HandleSuccessWithData(c, t)
return
}
// task stat
t.Stat, _ = service.NewModelServiceV2[models.TaskStatV2]().GetById(id)
HandleSuccessWithData(c, t)
}
func GetTaskList(c *gin.Context) {
withStats := c.Query("stats")
if withStats == "" {
NewControllerV2[models.TaskV2]().GetList(c)
return
}
// params
pagination := MustGetPagination(c)
query := MustGetFilterQuery(c)
sort := MustGetSortOption(c)
// get list
list, err := service.NewModelServiceV2[models.TaskV2]().GetMany(query, &mongo.FindOptions{
Sort: sort,
Skip: pagination.Size * (pagination.Page - 1),
Limit: pagination.Size,
})
if err != nil {
if errors.Is(err, mongo2.ErrNoDocuments) {
HandleErrorNotFound(c, err)
} else {
HandleErrorInternalServerError(c, err)
}
return
}
// check empty list
if len(list) == 0 {
HandleSuccessWithListData(c, nil, 0)
return
}
// ids
var ids []primitive.ObjectID
for _, t := range list {
ids = append(ids, t.Id)
}
// total count
total, err := service.NewModelServiceV2[models.TaskV2]().Count(query)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// stat list
query = bson.M{
"_id": bson.M{
"$in": ids,
},
}
stats, err := service.NewModelServiceV2[models.TaskStatV2]().GetMany(query, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// cache stat list to dict
dict := map[primitive.ObjectID]models.TaskStatV2{}
for _, s := range stats {
dict[s.Id] = s
}
// iterate list again
for i, t := range list {
ts, ok := dict[t.Id]
if ok {
list[i].Stat = &ts
}
}
// response
HandleSuccessWithListData(c, list, total)
}
func DeleteTaskById(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// delete in db
if err := mongo.RunTransaction(func(context mongo2.SessionContext) (err error) {
// delete task
_, err = service.NewModelServiceV2[models.TaskV2]().GetById(id)
if err != nil {
return err
}
err = service.NewModelServiceV2[models.TaskV2]().DeleteById(id)
if err != nil {
return err
}
// delete task stat
_, err = service.NewModelServiceV2[models.TaskStatV2]().GetById(id)
if err != nil {
log2.Warnf("delete task stat error: %s", err.Error())
return nil
}
err = service.NewModelServiceV2[models.TaskStatV2]().DeleteById(id)
if err != nil {
log2.Warnf("delete task stat error: %s", err.Error())
return nil
}
return nil
}); err != nil {
HandleErrorInternalServerError(c, err)
return
}
// delete task logs
logPath := filepath.Join(viper.GetString("log.path"), id.Hex())
if err := os.RemoveAll(logPath); err != nil {
log2.Warnf("failed to remove task log directory: %s", logPath)
}
HandleSuccess(c)
}
func DeleteList(c *gin.Context) {
var payload struct {
Ids []primitive.ObjectID `json:"ids"`
}
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := mongo.RunTransaction(func(context mongo2.SessionContext) error {
// delete tasks
if err := service.NewModelServiceV2[models.TaskV2]().DeleteMany(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}); err != nil {
return err
}
// delete task stats
if err := service.NewModelServiceV2[models.TaskV2]().DeleteMany(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}); err != nil {
log2.Warnf("delete task stat error: %s", err.Error())
return nil
}
return nil
}); err != nil {
HandleErrorInternalServerError(c, err)
return
}
// delete tasks logs
wg := sync.WaitGroup{}
wg.Add(len(payload.Ids))
for _, id := range payload.Ids {
go func(id string) {
// delete task logs
logPath := filepath.Join(viper.GetString("log.path"), id)
if err := os.RemoveAll(logPath); err != nil {
log2.Warnf("failed to remove task log directory: %s", logPath)
}
wg.Done()
}(id.Hex())
}
wg.Wait()
HandleSuccess(c)
}
func PostTaskRun(c *gin.Context) {
// task
var t models.TaskV2
if err := c.ShouldBindJSON(&t); err != nil {
HandleErrorBadRequest(c, err)
return
}
// validate spider id
if t.SpiderId.IsZero() {
HandleErrorBadRequest(c, errors.New("spider id is required"))
return
}
// spider
s, err := service.NewModelServiceV2[models.SpiderV2]().GetById(t.SpiderId)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// options
opts := &interfaces.SpiderRunOptions{
Mode: t.Mode,
NodeIds: t.NodeIds,
Cmd: t.Cmd,
Param: t.Param,
Priority: t.Priority,
}
// user
if u := GetUserFromContextV2(c); u != nil {
opts.UserId = u.Id
}
// run
adminSvc, err := admin.GetSpiderAdminServiceV2()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
taskIds, err := adminSvc.Schedule(s.Id, opts)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, taskIds)
}
func PostTaskRestart(c *gin.Context) {
// id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// task
t, err := service.NewModelServiceV2[models.TaskV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// options
opts := &interfaces.SpiderRunOptions{
Mode: t.Mode,
NodeIds: t.NodeIds,
Cmd: t.Cmd,
Param: t.Param,
Priority: t.Priority,
}
// user
if u := GetUserFromContextV2(c); u != nil {
opts.UserId = u.Id
}
// run
adminSvc, err := admin.GetSpiderAdminServiceV2()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
taskIds, err := adminSvc.Schedule(t.SpiderId, opts)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, taskIds)
}
func PostTaskCancel(c *gin.Context) {
// id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// task
t, err := service.NewModelServiceV2[models.TaskV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// validate
if !utils.IsCancellable(t.Status) {
HandleErrorInternalServerError(c, errors.New("task is not cancellable"))
return
}
u := GetUserFromContextV2(c)
// cancel
schedulerSvc, err := scheduler.GetTaskSchedulerServiceV2()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
if err := schedulerSvc.Cancel(id, u.Id); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func GetTaskLogs(c *gin.Context) {
// id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// pagination
p, err := GetPagination(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// logs
logDriver, err := log.GetFileLogDriver()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
logs, err := logDriver.Find(id.Hex(), "", (p.Page-1)*p.Size, p.Size)
if err != nil {
if strings.HasSuffix(err.Error(), "Status:404 Not Found") {
HandleSuccess(c)
return
}
HandleErrorInternalServerError(c, err)
return
}
total, err := logDriver.Count(id.Hex(), "")
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithListData(c, logs, total)
}
func GetTaskData(c *gin.Context) {
// id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// pagination
p, err := GetPagination(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// task
t, err := service.NewModelServiceV2[models.TaskV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// result service
resultSvc, err := result.GetResultService(t.SpiderId)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// query
query := generic.ListQuery{
generic.ListQueryCondition{
Key: constants.TaskKey,
Op: generic.OpEqual,
Value: t.Id,
},
}
// list
data, err := resultSvc.List(query, &generic.ListOptions{
Skip: (p.Page - 1) * p.Size,
Limit: p.Size,
Sort: []generic.ListSort{{"_id", generic.SortDirectionDesc}},
})
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
// total
total, err := resultSvc.Count(query)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithListData(c, data, total)
}
|
2302_79757062/crawlab
|
core/controllers/task_v2.go
|
Go
|
bsd-3-clause
| 9,813
|
package test
import (
"github.com/crawlab-team/crawlab/core/controllers"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/routes"
"github.com/crawlab-team/crawlab/trace"
"github.com/gavv/httpexpect/v2"
"github.com/gin-gonic/gin"
"github.com/stretchr/testify/require"
"go.uber.org/dig"
"net/http/httptest"
"testing"
"time"
)
func init() {
var err error
T, err = NewTest()
if err != nil {
panic(err)
}
}
type Test struct {
// dependencies
modelSvc service.ModelService
// internals
app *gin.Engine
svr *httptest.Server
// test data
TestUsername string
TestPassword string
TestToken string
}
func (t *Test) Setup(t2 *testing.T) {
//if err := controllers.InitControllers(); err != nil {
// panic(err)
//}
//t2.Cleanup(t.Cleanup)
}
func (t *Test) Cleanup() {
_ = t.modelSvc.DropAll()
time.Sleep(200 * time.Millisecond)
}
func (t *Test) NewExpect(t2 *testing.T) (e *httpexpect.Expect) {
e = httpexpect.New(t2, t.svr.URL)
res := e.POST("/login").WithJSON(map[string]string{
"username": t.TestUsername,
"password": t.TestPassword,
}).Expect().JSON().Object()
t.TestToken = res.Path("$.data").String().Raw()
require.NotEmpty(t2, t.TestToken)
return e
}
func (t *Test) WithAuth(req *httpexpect.Request) *httpexpect.Request {
return req.WithHeader("Authorization", t.TestToken)
}
var T *Test
func NewTest() (res *Test, err error) {
// test
t := &Test{}
// gin app
t.app = gin.New()
// http test server
t.svr = httptest.NewServer(t.app)
// init controllers
if err := controllers.InitControllers(); err != nil {
return nil, err
}
// init routes
if err := routes.InitRoutes(t.app); err != nil {
return nil, err
}
// dependency injection
c := dig.New()
if err := c.Provide(service.NewService); err != nil {
return nil, trace.TraceError(err)
}
if err := c.Invoke(func(modelSvc service.ModelService) {
t.modelSvc = modelSvc
}); err != nil {
return nil, trace.TraceError(err)
}
// test data
t.TestUsername = "admin"
t.TestPassword = "admin"
return t, nil
}
|
2302_79757062/crawlab
|
core/controllers/test/base.go
|
Go
|
bsd-3-clause
| 2,079
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/gin-gonic/gin"
)
var TokenController *tokenController
var TokenActions []Action
type tokenController struct {
ListActionControllerDelegate
d ListActionControllerDelegate
ctx *tokenContext
}
func (ctr *tokenController) Post(c *gin.Context) {
var err error
var t models.Token
if err := c.ShouldBindJSON(&t); err != nil {
HandleErrorBadRequest(c, err)
return
}
u, err := ctr.ctx.userSvc.GetCurrentUser(c)
if err != nil {
HandleErrorUnauthorized(c, err)
return
}
t.Token, err = ctr.ctx.userSvc.MakeToken(u)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
if err := delegate.NewModelDelegate(&t, GetUserFromContext(c)).Add(); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
type tokenContext struct {
modelSvc service.ModelService
userSvc interfaces.UserService
}
func newTokenContext() *tokenContext {
// context
ctx := &tokenContext{}
// dependency injection
if err := container.GetContainer().Invoke(func(
modelSvc service.ModelService,
userSvc interfaces.UserService,
) {
ctx.modelSvc = modelSvc
ctx.userSvc = userSvc
}); err != nil {
panic(err)
}
return ctx
}
func newTokenController() *tokenController {
modelSvc, err := service.GetService()
if err != nil {
panic(err)
}
ctr := NewListPostActionControllerDelegate(ControllerIdToken, modelSvc.GetBaseService(interfaces.ModelIdToken), TokenActions)
d := NewListPostActionControllerDelegate(ControllerIdToken, modelSvc.GetBaseService(interfaces.ModelIdToken), TokenActions)
ctx := newTokenContext()
return &tokenController{
ListActionControllerDelegate: *ctr,
d: *d,
ctx: ctx,
}
}
|
2302_79757062/crawlab
|
core/controllers/token.go
|
Go
|
bsd-3-clause
| 2,020
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/user"
"github.com/gin-gonic/gin"
)
func PostToken(c *gin.Context) {
var t models.TokenV2
if err := c.ShouldBindJSON(&t); err != nil {
HandleErrorBadRequest(c, err)
return
}
svc, err := user.GetUserServiceV2()
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
u := GetUserFromContextV2(c)
t.SetCreated(u.Id)
t.SetUpdated(u.Id)
t.Token, err = svc.MakeToken(u)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
_, err = service.NewModelServiceV2[models.TokenV2]().InsertOne(t)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
|
2302_79757062/crawlab
|
core/controllers/token_v2.go
|
Go
|
bsd-3-clause
| 797
|
package controllers
import (
"encoding/json"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
delegate2 "github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/trace"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"net/http"
)
var UserController *userController
func getUserActions() []Action {
userCtx := newUserContext()
return []Action{
{
Method: http.MethodPost,
Path: "/:id/change-password",
HandlerFunc: userCtx.changePassword,
},
{
Method: http.MethodGet,
Path: "/me",
HandlerFunc: userCtx.getMe,
},
{
Method: http.MethodPut,
Path: "/me",
HandlerFunc: userCtx.putMe,
},
}
}
type userController struct {
ListActionControllerDelegate
d ListActionControllerDelegate
ctx *userContext
}
func (ctr *userController) Post(c *gin.Context) {
var u models.User
if err := c.ShouldBindJSON(&u); err != nil {
HandleErrorBadRequest(c, err)
return
}
if err := ctr.ctx.userSvc.Create(&interfaces.UserCreateOptions{
Username: u.Username,
Password: u.Password,
Email: u.Email,
Role: u.Role,
}); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctr *userController) PostList(c *gin.Context) {
// users
var users []models.User
if err := c.ShouldBindJSON(&users); err != nil {
HandleErrorBadRequest(c, err)
return
}
for _, u := range users {
if err := ctr.ctx.userSvc.Create(&interfaces.UserCreateOptions{
Username: u.Username,
Password: u.Password,
Email: u.Email,
Role: u.Role,
}); err != nil {
trace.PrintError(err)
}
}
HandleSuccess(c)
}
func (ctr *userController) PutList(c *gin.Context) {
// payload
var payload entity.BatchRequestPayloadWithStringData
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
// doc to update
var doc models.User
if err := json.Unmarshal([]byte(payload.Data), &doc); err != nil {
HandleErrorBadRequest(c, err)
return
}
// query
query := bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}
// update users
if err := ctr.ctx.modelSvc.GetBaseService(interfaces.ModelIdUser).UpdateDoc(query, &doc, payload.Fields); err != nil {
HandleErrorInternalServerError(c, err)
return
}
// update passwords
if utils.Contains(payload.Fields, "password") {
for _, id := range payload.Ids {
if err := ctr.ctx.userSvc.ChangePassword(id, doc.Password); err != nil {
trace.PrintError(err)
}
}
}
HandleSuccess(c)
}
type userContext struct {
modelSvc service.ModelService
userSvc interfaces.UserService
}
func (ctx *userContext) changePassword(c *gin.Context) {
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
var payload map[string]string
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
password, ok := payload["password"]
if !ok {
HandleErrorBadRequest(c, errors.ErrorUserMissingRequiredFields)
return
}
if len(password) < 5 {
HandleErrorBadRequest(c, errors.ErrorUserInvalidPassword)
return
}
if err := ctx.userSvc.ChangePassword(id, password); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccess(c)
}
func (ctx *userContext) getMe(c *gin.Context) {
u, err := ctx._getMe(c)
if err != nil {
HandleErrorUnauthorized(c, errors.ErrorUserUnauthorized)
return
}
HandleSuccessWithData(c, u)
}
func (ctx *userContext) putMe(c *gin.Context) {
// current user
u, err := ctx._getMe(c)
if err != nil {
HandleErrorUnauthorized(c, errors.ErrorUserUnauthorized)
return
}
// payload
doc, err := NewJsonBinder(ControllerIdUser).Bind(c)
if err != nil {
HandleErrorBadRequest(c, err)
return
}
if doc.GetId() != u.GetId() {
HandleErrorBadRequest(c, errors.ErrorHttpBadRequest)
return
}
// save to db
if err := delegate2.NewModelDelegate(doc, GetUserFromContext(c)).Save(); err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, doc)
}
func (ctx *userContext) _getMe(c *gin.Context) (u interfaces.User, err error) {
res, ok := c.Get(constants.UserContextKey)
if !ok {
return nil, trace.TraceError(errors.ErrorUserNotExistsInContext)
}
u, ok = res.(interfaces.User)
if !ok {
return nil, trace.TraceError(errors.ErrorUserInvalidType)
}
return u, nil
}
func newUserContext() *userContext {
// context
ctx := &userContext{}
// dependency injection
if err := container.GetContainer().Invoke(func(
modelSvc service.ModelService,
userSvc interfaces.UserService,
) {
ctx.modelSvc = modelSvc
ctx.userSvc = userSvc
}); err != nil {
panic(err)
}
return ctx
}
func newUserController() *userController {
modelSvc, err := service.GetService()
if err != nil {
panic(err)
}
ctr := NewListPostActionControllerDelegate(ControllerIdUser, modelSvc.GetBaseService(interfaces.ModelIdUser), getUserActions())
d := NewListPostActionControllerDelegate(ControllerIdUser, modelSvc.GetBaseService(interfaces.ModelIdUser), getUserActions())
ctx := newUserContext()
return &userController{
ListActionControllerDelegate: *ctr,
d: *d,
ctx: ctx,
}
}
|
2302_79757062/crawlab
|
core/controllers/user.go
|
Go
|
bsd-3-clause
| 5,675
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func PostUser(c *gin.Context) {
var payload struct {
Username string `json:"username"`
Password string `json:"password"`
Role string `json:"role"`
Email string `json:"email"`
}
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
u := GetUserFromContextV2(c)
model := models.UserV2{
Username: payload.Username,
Password: utils.EncryptMd5(payload.Password),
Role: payload.Role,
Email: payload.Email,
}
model.SetCreated(u.Id)
model.SetUpdated(u.Id)
id, err := service.NewModelServiceV2[models.UserV2]().InsertOne(model)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
result, err := service.NewModelServiceV2[models.UserV2]().GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, result)
}
func PostUserChangePassword(c *gin.Context) {
// get id
id, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
HandleErrorBadRequest(c, err)
return
}
// get payload
var payload struct {
Password string `json:"password"`
}
if err := c.ShouldBindJSON(&payload); err != nil {
HandleErrorBadRequest(c, err)
return
}
// get user
u := GetUserFromContextV2(c)
modelSvc := service.NewModelServiceV2[models.UserV2]()
// update password
user, err := modelSvc.GetById(id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
user.SetUpdated(u.Id)
user.Password = utils.EncryptMd5(payload.Password)
if err := modelSvc.ReplaceById(user.Id, *user); err != nil {
HandleErrorInternalServerError(c, err)
return
}
// handle success
HandleSuccess(c)
}
func GetUserMe(c *gin.Context) {
u := GetUserFromContextV2(c)
_u, err := service.NewModelServiceV2[models.UserV2]().GetById(u.Id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
HandleSuccessWithData(c, _u)
}
func PutUserById(c *gin.Context) {
// get payload
var user models.UserV2
if err := c.ShouldBindJSON(&user); err != nil {
HandleErrorBadRequest(c, err)
return
}
// get user
u := GetUserFromContextV2(c)
modelSvc := service.NewModelServiceV2[models.UserV2]()
// update user
userDb, err := modelSvc.GetById(u.Id)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
user.Password = userDb.Password
user.SetUpdated(u.Id)
if user.Id.IsZero() {
user.Id = u.Id
}
if err := modelSvc.ReplaceById(u.Id, user); err != nil {
HandleErrorInternalServerError(c, err)
return
}
// handle success
HandleSuccess(c)
}
|
2302_79757062/crawlab
|
core/controllers/user_v2.go
|
Go
|
bsd-3-clause
| 2,794
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/gin-gonic/gin"
)
func GetUserFromContext(c *gin.Context) (u interfaces.User) {
value, ok := c.Get(constants.UserContextKey)
if !ok {
return nil
}
u, ok = value.(interfaces.User)
if !ok {
return nil
}
return u
}
func GetUserFromContextV2(c *gin.Context) (u *models.UserV2) {
value, ok := c.Get(constants.UserContextKey)
if !ok {
return nil
}
u, ok = value.(*models.UserV2)
if !ok {
return nil
}
return u
}
|
2302_79757062/crawlab
|
core/controllers/utils_context.go
|
Go
|
bsd-3-clause
| 627
|
package controllers
import (
"encoding/json"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"reflect"
"strings"
)
// GetFilter Get entity.Filter from gin.Context
func GetFilter(c *gin.Context) (f *entity.Filter, err error) {
// bind
condStr := c.Query(constants.FilterQueryFieldConditions)
var conditions []*entity.Condition
if err := json.Unmarshal([]byte(condStr), &conditions); err != nil {
return nil, err
}
// attempt to convert object id
for i, cond := range conditions {
v := reflect.ValueOf(cond.Value)
switch v.Kind() {
case reflect.String:
item := cond.Value.(string)
id, err := primitive.ObjectIDFromHex(item)
if err == nil {
conditions[i].Value = id
} else {
conditions[i].Value = item
}
case reflect.Slice, reflect.Array:
var items []interface{}
for i := 0; i < v.Len(); i++ {
vItem := v.Index(i)
item := vItem.Interface()
// string
stringItem, ok := item.(string)
if ok {
id, err := primitive.ObjectIDFromHex(stringItem)
if err == nil {
items = append(items, id)
} else {
items = append(items, stringItem)
}
continue
}
// default
items = append(items, item)
}
conditions[i].Value = items
}
}
return &entity.Filter{
IsOr: false,
Conditions: conditions,
}, nil
}
// GetFilterQuery Get bson.M from gin.Context
func GetFilterQuery(c *gin.Context) (q bson.M, err error) {
f, err := GetFilter(c)
if err != nil {
return nil, err
}
if f == nil {
return nil, nil
}
// TODO: implement logic OR
return utils.FilterToQuery(f)
}
func MustGetFilterQuery(c *gin.Context) (q bson.M) {
q, err := GetFilterQuery(c)
if err != nil {
return nil
}
return q
}
// GetFilterAll Get all from gin.Context
func GetFilterAll(c *gin.Context) (res bool, err error) {
resStr := c.Query(constants.FilterQueryFieldAll)
switch strings.ToUpper(resStr) {
case "1":
return true, nil
case "0":
return false, nil
case "Y":
return true, nil
case "N":
return false, nil
case "T":
return true, nil
case "F":
return false, nil
case "TRUE":
return true, nil
case "FALSE":
return false, nil
default:
return false, errors.ErrorFilterInvalidOperation
}
}
func MustGetFilterAll(c *gin.Context) (res bool) {
res, err := GetFilterAll(c)
if err != nil {
return false
}
return res
}
|
2302_79757062/crawlab
|
core/controllers/utils_filter.go
|
Go
|
bsd-3-clause
| 2,602
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/trace"
"github.com/gin-gonic/gin"
"net/http"
)
func handleError(statusCode int, c *gin.Context, err error, print bool) {
if print {
trace.PrintError(err)
}
c.AbortWithStatusJSON(statusCode, entity.Response{
Status: constants.HttpResponseStatusOk,
Message: constants.HttpResponseMessageError,
Error: err.Error(),
})
}
func HandleError(statusCode int, c *gin.Context, err error) {
handleError(statusCode, c, err, true)
}
func HandleErrorNoPrint(statusCode int, c *gin.Context, err error) {
handleError(statusCode, c, err, false)
}
func HandleErrorBadRequest(c *gin.Context, err error) {
HandleError(http.StatusBadRequest, c, err)
}
func HandleErrorUnauthorized(c *gin.Context, err error) {
HandleError(http.StatusUnauthorized, c, err)
}
func HandleErrorNotFound(c *gin.Context, err error) {
HandleError(http.StatusNotFound, c, err)
}
func HandleErrorNotFoundNoPrint(c *gin.Context, err error) {
HandleErrorNoPrint(http.StatusNotFound, c, err)
}
func HandleErrorInternalServerError(c *gin.Context, err error) {
HandleError(http.StatusInternalServerError, c, err)
}
func HandleSuccess(c *gin.Context) {
c.AbortWithStatusJSON(http.StatusOK, entity.Response{
Status: constants.HttpResponseStatusOk,
Message: constants.HttpResponseMessageSuccess,
})
}
func HandleSuccessWithData(c *gin.Context, data interface{}) {
c.AbortWithStatusJSON(http.StatusOK, entity.Response{
Status: constants.HttpResponseStatusOk,
Message: constants.HttpResponseMessageSuccess,
Data: data,
})
}
func HandleSuccessWithListData(c *gin.Context, data interface{}, total int) {
c.AbortWithStatusJSON(http.StatusOK, entity.ListResponse{
Status: constants.HttpResponseStatusOk,
Message: constants.HttpResponseMessageSuccess,
Data: data,
Total: total,
})
}
|
2302_79757062/crawlab
|
core/controllers/utils_http.go
|
Go
|
bsd-3-clause
| 1,951
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/gin-gonic/gin"
)
func GetDefaultPagination() (p *entity.Pagination) {
return &entity.Pagination{
Page: constants.PaginationDefaultPage,
Size: constants.PaginationDefaultSize,
}
}
func GetPagination(c *gin.Context) (p *entity.Pagination, err error) {
var _p entity.Pagination
if err := c.ShouldBindQuery(&_p); err != nil {
return GetDefaultPagination(), err
}
return &_p, nil
}
func MustGetPagination(c *gin.Context) (p *entity.Pagination) {
p, err := GetPagination(c)
if err != nil || p == nil {
return GetDefaultPagination()
}
return p
}
|
2302_79757062/crawlab
|
core/controllers/utils_pagination.go
|
Go
|
bsd-3-clause
| 700
|
package controllers
import (
"encoding/json"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
)
// GetSorts Get entity.Sort from gin.Context
func GetSorts(c *gin.Context) (sorts []entity.Sort, err error) {
// bind
sortStr := c.Query(constants.SortQueryField)
if err := json.Unmarshal([]byte(sortStr), &sorts); err != nil {
return nil, err
}
return sorts, nil
}
// GetSortsOption Get entity.Sort from gin.Context
func GetSortsOption(c *gin.Context) (sort bson.D, err error) {
sorts, err := GetSorts(c)
if err != nil {
return nil, err
}
if sorts == nil || len(sorts) == 0 {
return bson.D{{"_id", -1}}, nil
}
return SortsToOption(sorts)
}
func MustGetSortOption(c *gin.Context) (sort bson.D) {
sort, err := GetSortsOption(c)
if err != nil {
return nil
}
return sort
}
// SortsToOption Translate entity.Sort to bson.D
func SortsToOption(sorts []entity.Sort) (sort bson.D, err error) {
sort = bson.D{}
for _, s := range sorts {
switch s.Direction {
case constants.ASCENDING:
sort = append(sort, bson.E{Key: s.Key, Value: 1})
case constants.DESCENDING:
sort = append(sort, bson.E{Key: s.Key, Value: -1})
}
}
if len(sort) == 0 {
sort = bson.D{{"_id", -1}}
}
return sort, nil
}
|
2302_79757062/crawlab
|
core/controllers/utils_sort.go
|
Go
|
bsd-3-clause
| 1,335
|
package controllers
import (
"github.com/crawlab-team/crawlab/core/config"
"github.com/gin-gonic/gin"
"net/http"
)
func GetVersion(c *gin.Context) {
HandleSuccessWithData(c, config.GetVersion())
}
func getVersionActions() []Action {
return []Action{
{
Method: http.MethodGet,
Path: "",
HandlerFunc: GetVersion,
},
}
}
var VersionController ActionController
|
2302_79757062/crawlab
|
core/controllers/version.go
|
Go
|
bsd-3-clause
| 392
|
package data
const ColorsDataText = `[
{
"name": "Absolute Zero",
"hex": "#0048BA"
},
{
"name": "Acid Green",
"hex": "#B0BF1A"
},
{
"name": "Aero",
"hex": "#7CB9E8"
},
{
"name": "Aero Blue",
"hex": "#C9FFE5"
},
{
"name": "African Violet",
"hex": "#B284BE"
},
{
"name": "Air Force Blue (RAF)",
"hex": "#5D8AA8"
},
{
"name": "Air Force Blue (USAF)",
"hex": "#00308F"
},
{
"name": "Air Superiority Blue",
"hex": "#72A0C1"
},
{
"name": "Alabama Crimson",
"hex": "#AF002A"
},
{
"name": "Alabaster",
"hex": "#F2F0E6"
},
{
"name": "Alice Blue",
"hex": "#F0F8FF"
},
{
"name": "Alien Armpit",
"hex": "#84DE02"
},
{
"name": "Alizarin Crimson",
"hex": "#E32636"
},
{
"name": "Alloy Orange",
"hex": "#C46210"
},
{
"name": "Almond",
"hex": "#EFDECD"
},
{
"name": "Amaranth",
"hex": "#E52B50"
},
{
"name": "Amaranth Deep Purple",
"hex": "#9F2B68"
},
{
"name": "Amaranth Pink",
"hex": "#F19CBB"
},
{
"name": "Amaranth Purple",
"hex": "#AB274F"
},
{
"name": "Amaranth Red",
"hex": "#D3212D"
},
{
"name": "Amazon Store",
"hex": "#3B7A57"
},
{
"name": "Amazonite",
"hex": "#00C4B0"
},
{
"name": "Amber",
"hex": "#FFBF00"
},
{
"name": "Amber (SAE/ECE)",
"hex": "#FF7E00"
},
{
"name": "American Rose",
"hex": "#FF033E"
},
{
"name": "Amethyst",
"hex": "#9966CC"
},
{
"name": "Android Green",
"hex": "#A4C639"
},
{
"name": "Anti-Flash White",
"hex": "#F2F3F4"
},
{
"name": "Antique Brass",
"hex": "#CD9575"
},
{
"name": "Antique Bronze",
"hex": "#665D1E"
},
{
"name": "Antique Fuchsia",
"hex": "#915C83"
},
{
"name": "Antique Ruby",
"hex": "#841B2D"
},
{
"name": "Antique White",
"hex": "#FAEBD7"
},
{
"name": "Ao (English)",
"hex": "#008000"
},
{
"name": "Apple Green",
"hex": "#8DB600"
},
{
"name": "Apricot",
"hex": "#FBCEB1"
},
{
"name": "Aqua",
"hex": "#00FFFF"
},
{
"name": "Aquamarine",
"hex": "#7FFFD4"
},
{
"name": "Arctic Lime",
"hex": "#D0FF14"
},
{
"name": "Army Green",
"hex": "#4B5320"
},
{
"name": "Arsenic",
"hex": "#3B444B"
},
{
"name": "Artichoke",
"hex": "#8F9779"
},
{
"name": "Arylide Yellow",
"hex": "#E9D66B"
},
{
"name": "Ash Gray",
"hex": "#B2BEB5"
},
{
"name": "Asparagus",
"hex": "#87A96B"
},
{
"name": "Atomic Tangerine",
"hex": "#FF9966"
},
{
"name": "Auburn",
"hex": "#A52A2A"
},
{
"name": "Aureolin",
"hex": "#FDEE00"
},
{
"name": "AuroMetalSaurus",
"hex": "#6E7F80"
},
{
"name": "Avocado",
"hex": "#568203"
},
{
"name": "Awesome",
"hex": "#FF2052"
},
{
"name": "Aztec Gold",
"hex": "#C39953"
},
{
"name": "Azure",
"hex": "#007FFF"
},
{
"name": "Azure (Web Color)",
"hex": "#F0FFFF"
},
{
"name": "Azure Mist",
"hex": "#F0FFFF"
},
{
"name": "Azureish White",
"hex": "#DBE9F4"
},
{
"name": "Baby Blue",
"hex": "#89CFF0"
},
{
"name": "Baby Blue Eyes",
"hex": "#A1CAF1"
},
{
"name": "Baby Pink",
"hex": "#F4C2C2"
},
{
"name": "Baby Powder",
"hex": "#FEFEFA"
},
{
"name": "Baker-Miller Pink",
"hex": "#FF91AF"
},
{
"name": "Ball Blue",
"hex": "#21ABCD"
},
{
"name": "Banana Mania",
"hex": "#FAE7B5"
},
{
"name": "Banana Yellow",
"hex": "#FFE135"
},
{
"name": "Bangladesh Green",
"hex": "#006A4E"
},
{
"name": "Barbie Pink",
"hex": "#E0218A"
},
{
"name": "Barn Red",
"hex": "#7C0A02"
},
{
"name": "Battery Charged Blue",
"hex": "#1DACD6"
},
{
"name": "Battleship Grey",
"hex": "#848482"
},
{
"name": "Bazaar",
"hex": "#98777B"
},
{
"name": "Beau Blue",
"hex": "#BCD4E6"
},
{
"name": "Beaver",
"hex": "#9F8170"
},
{
"name": "Begonia",
"hex": "#FA6E79"
},
{
"name": "Beige",
"hex": "#F5F5DC"
},
{
"name": "B'dazzled Blue",
"hex": "#2E5894"
},
{
"name": "Big Dip O'ruby",
"hex": "#9C2542"
},
{
"name": "Big Foot Feet",
"hex": "#E88E5A"
},
{
"name": "Bisque",
"hex": "#FFE4C4"
},
{
"name": "Bistre",
"hex": "#3D2B1F"
},
{
"name": "Bistre Brown",
"hex": "#967117"
},
{
"name": "Bitter Lemon",
"hex": "#CAE00D"
},
{
"name": "Bitter Lime",
"hex": "#BFFF00"
},
{
"name": "Bittersweet",
"hex": "#FE6F5E"
},
{
"name": "Bittersweet Shimmer",
"hex": "#BF4F51"
},
{
"name": "Black",
"hex": "#000000"
},
{
"name": "Black Bean",
"hex": "#3D0C02"
},
{
"name": "Black Coral",
"hex": "#54626F"
},
{
"name": "Black Leather Jacket",
"hex": "#253529"
},
{
"name": "Black Olive",
"hex": "#3B3C36"
},
{
"name": "Black Shadows",
"hex": "#BFAFB2"
},
{
"name": "Blanched Almond",
"hex": "#FFEBCD"
},
{
"name": "Blast-Off Bronze",
"hex": "#A57164"
},
{
"name": "Bleu De France",
"hex": "#318CE7"
},
{
"name": "Blizzard Blue",
"hex": "#ACE5EE"
},
{
"name": "Blond",
"hex": "#FAF0BE"
},
{
"name": "Blue",
"hex": "#0000FF"
},
{
"name": "Blue (Crayola)",
"hex": "#1F75FE"
},
{
"name": "Blue (Munsell)",
"hex": "#0093AF"
},
{
"name": "Blue (NCS)",
"hex": "#0087BD"
},
{
"name": "Blue (Pantone)",
"hex": "#0018A8"
},
{
"name": "Blue (Pigment)",
"hex": "#333399"
},
{
"name": "Blue (RYB)",
"hex": "#0247FE"
},
{
"name": "Blue Bell",
"hex": "#A2A2D0"
},
{
"name": "Blue Bolt",
"hex": "#00B9FB"
},
{
"name": "Blue-Gray",
"hex": "#6699CC"
},
{
"name": "Blue-Green",
"hex": "#0D98BA"
},
{
"name": "Blue Jeans",
"hex": "#5DADEC"
},
{
"name": "Blue Lagoon",
"hex": "#ACE5EE"
},
{
"name": "Blue-Magenta Violet",
"hex": "#553592"
},
{
"name": "Blue Sapphire",
"hex": "#126180"
},
{
"name": "Blue-Violet",
"hex": "#8A2BE2"
},
{
"name": "Blue Yonder",
"hex": "#5072A7"
},
{
"name": "Blueberry",
"hex": "#4F86F7"
},
{
"name": "Bluebonnet",
"hex": "#1C1CF0"
},
{
"name": "Blush",
"hex": "#DE5D83"
},
{
"name": "Bole",
"hex": "#79443B"
},
{
"name": "Bondi Blue",
"hex": "#0095B6"
},
{
"name": "Bone",
"hex": "#E3DAC9"
},
{
"name": "Booger Buster",
"hex": "#DDE26A"
},
{
"name": "Boston University Red",
"hex": "#CC0000"
},
{
"name": "Bottle Green",
"hex": "#006A4E"
},
{
"name": "Boysenberry",
"hex": "#873260"
},
{
"name": "Brandeis Blue",
"hex": "#0070FF"
},
{
"name": "Brass",
"hex": "#B5A642"
},
{
"name": "Brick Red",
"hex": "#CB4154"
},
{
"name": "Bright Cerulean",
"hex": "#1DACD6"
},
{
"name": "Bright Green",
"hex": "#66FF00"
},
{
"name": "Bright Lavender",
"hex": "#BF94E4"
},
{
"name": "Bright Lilac",
"hex": "#D891EF"
},
{
"name": "Bright Maroon",
"hex": "#C32148"
},
{
"name": "Bright Navy Blue",
"hex": "#1974D2"
},
{
"name": "Bright Pink",
"hex": "#FF007F"
},
{
"name": "Bright Turquoise",
"hex": "#08E8DE"
},
{
"name": "Bright Ube",
"hex": "#D19FE8"
},
{
"name": "Bright Yellow (Crayola)",
"hex": "#FFAA1D"
},
{
"name": "Brilliant Azure",
"hex": "#3399FF"
},
{
"name": "Brilliant Lavender",
"hex": "#F4BBFF"
},
{
"name": "Brilliant Rose",
"hex": "#FF55A3"
},
{
"name": "Brink Pink",
"hex": "#FB607F"
},
{
"name": "British Racing Green",
"hex": "#004225"
},
{
"name": "Bronze",
"hex": "#CD7F32"
},
{
"name": "Bronze Yellow",
"hex": "#737000"
},
{
"name": "Brown (Traditional)",
"hex": "#964B00"
},
{
"name": "Brown (Web)",
"hex": "#A52A2A"
},
{
"name": "Brown-Nose",
"hex": "#6B4423"
},
{
"name": "Brown Sugar",
"hex": "#AF6E4D"
},
{
"name": "Brown Yellow",
"hex": "#cc9966"
},
{
"name": "Brunswick Green",
"hex": "#1B4D3E"
},
{
"name": "Bubble Gum",
"hex": "#FFC1CC"
},
{
"name": "Bubbles",
"hex": "#E7FEFF"
},
{
"name": "Bud Green",
"hex": "#7BB661"
},
{
"name": "Buff",
"hex": "#F0DC82"
},
{
"name": "Bulgarian Rose",
"hex": "#480607"
},
{
"name": "Burgundy",
"hex": "#800020"
},
{
"name": "Burlywood",
"hex": "#DEB887"
},
{
"name": "Burnished Brown",
"hex": "#A17A74"
},
{
"name": "Burnt Orange",
"hex": "#CC5500"
},
{
"name": "Burnt Sienna",
"hex": "#E97451"
},
{
"name": "Burnt Umber",
"hex": "#8A3324"
},
{
"name": "Button Blue",
"hex": "#24A0ED"
},
{
"name": "Byzantine",
"hex": "#BD33A4"
},
{
"name": "Byzantium",
"hex": "#702963"
},
{
"name": "Cadet",
"hex": "#536872"
},
{
"name": "Cadet Blue",
"hex": "#5F9EA0"
},
{
"name": "Cadet Grey",
"hex": "#91A3B0"
},
{
"name": "Cadmium Green",
"hex": "#006B3C"
},
{
"name": "Cadmium Orange",
"hex": "#ED872D"
},
{
"name": "Cadmium Red",
"hex": "#E30022"
},
{
"name": "Cadmium Yellow",
"hex": "#FFF600"
},
{
"name": "Cafe Au Lait",
"hex": "#A67B5B"
},
{
"name": "Cafe Noir",
"hex": "#4B3621"
},
{
"name": "Cal Poly Pomona Green",
"hex": "#1E4D2B"
},
{
"name": "Cambridge Blue",
"hex": "#A3C1AD"
},
{
"name": "Camel",
"hex": "#C19A6B"
},
{
"name": "Cameo Pink",
"hex": "#EFBBCC"
},
{
"name": "Camouflage Green",
"hex": "#78866B"
},
{
"name": "Canary",
"hex": "#FFFF99"
},
{
"name": "Canary Yellow",
"hex": "#FFEF00"
},
{
"name": "Candy Apple Red",
"hex": "#FF0800"
},
{
"name": "Candy Pink",
"hex": "#E4717A"
},
{
"name": "Capri",
"hex": "#00BFFF"
},
{
"name": "Caput Mortuum",
"hex": "#592720"
},
{
"name": "Cardinal",
"hex": "#C41E3A"
},
{
"name": "Caribbean Green",
"hex": "#00CC99"
},
{
"name": "Carmine",
"hex": "#960018"
},
{
"name": "Carmine (M&P)",
"hex": "#D70040"
},
{
"name": "Carmine Pink",
"hex": "#EB4C42"
},
{
"name": "Carmine Red",
"hex": "#FF0038"
},
{
"name": "Carnation Pink",
"hex": "#FFA6C9"
},
{
"name": "Carnelian",
"hex": "#B31B1B"
},
{
"name": "Carolina Blue",
"hex": "#56A0D3"
},
{
"name": "Carrot Orange",
"hex": "#ED9121"
},
{
"name": "Castleton Green",
"hex": "#00563F"
},
{
"name": "Catalina Blue",
"hex": "#062A78"
},
{
"name": "Catawba",
"hex": "#703642"
},
{
"name": "Cedar Chest",
"hex": "#C95A49"
},
{
"name": "Ceil",
"hex": "#92A1CF"
},
{
"name": "Celadon",
"hex": "#ACE1AF"
},
{
"name": "Celadon Blue",
"hex": "#007BA7"
},
{
"name": "Celadon Green",
"hex": "#2F847C"
},
{
"name": "Celeste",
"hex": "#B2FFFF"
},
{
"name": "Celestial Blue",
"hex": "#4997D0"
},
{
"name": "Cerise",
"hex": "#DE3163"
},
{
"name": "Cerise Pink",
"hex": "#EC3B83"
},
{
"name": "Cerulean",
"hex": "#007BA7"
},
{
"name": "Cerulean Blue",
"hex": "#2A52BE"
},
{
"name": "Cerulean Frost",
"hex": "#6D9BC3"
},
{
"name": "CG Blue",
"hex": "#007AA5"
},
{
"name": "CG Red",
"hex": "#E03C31"
},
{
"name": "Chamoisee",
"hex": "#A0785A"
},
{
"name": "Champagne",
"hex": "#F7E7CE"
},
{
"name": "Champagne Pink",
"hex": "#F1DDCF"
},
{
"name": "Charcoal",
"hex": "#36454F"
},
{
"name": "Charleston Green",
"hex": "#232B2B"
},
{
"name": "Charm Pink",
"hex": "#E68FAC"
},
{
"name": "Chartreuse (Traditional)",
"hex": "#DFFF00"
},
{
"name": "Chartreuse (Web)",
"hex": "#7FFF00"
},
{
"name": "Cherry",
"hex": "#DE3163"
},
{
"name": "Cherry Blossom Pink",
"hex": "#FFB7C5"
},
{
"name": "Chestnut",
"hex": "#954535"
},
{
"name": "China Pink",
"hex": "#DE6FA1"
},
{
"name": "China Rose",
"hex": "#A8516E"
},
{
"name": "Chinese Red",
"hex": "#AA381E"
},
{
"name": "Chinese Violet",
"hex": "#856088"
},
{
"name": "Chlorophyll Green",
"hex": "#4AFF00"
},
{
"name": "Chocolate (Traditional)",
"hex": "#7B3F00"
},
{
"name": "Chocolate (Web)",
"hex": "#D2691E"
},
{
"name": "Chrome Yellow",
"hex": "#FFA700"
},
{
"name": "Cinereous",
"hex": "#98817B"
},
{
"name": "Cinnabar",
"hex": "#E34234"
},
{
"name": "Cinnamon",
"hex": "#D2691E"
},
{
"name": "Cinnamon Satin",
"hex": "#CD607E"
},
{
"name": "Citrine",
"hex": "#E4D00A"
},
{
"name": "Citron",
"hex": "#9FA91F"
},
{
"name": "Claret",
"hex": "#7F1734"
},
{
"name": "Classic Rose",
"hex": "#FBCCE7"
},
{
"name": "Cobalt Blue",
"hex": "#0047AB"
},
{
"name": "Cocoa Brown",
"hex": "#D2691E"
},
{
"name": "Coconut",
"hex": "#965A3E"
},
{
"name": "Coffee",
"hex": "#6F4E37"
},
{
"name": "Columbia Blue",
"hex": "#C4D8E2"
},
{
"name": "Congo Pink",
"hex": "#F88379"
},
{
"name": "Cool Black",
"hex": "#002E63"
},
{
"name": "Cool Grey",
"hex": "#8C92AC"
},
{
"name": "Copper",
"hex": "#B87333"
},
{
"name": "Copper (Crayola)",
"hex": "#DA8A67"
},
{
"name": "Copper Penny",
"hex": "#AD6F69"
},
{
"name": "Copper Red",
"hex": "#CB6D51"
},
{
"name": "Copper Rose",
"hex": "#996666"
},
{
"name": "Coquelicot",
"hex": "#FF3800"
},
{
"name": "Coral",
"hex": "#FF7F50"
},
{
"name": "Coral Pink",
"hex": "#F88379"
},
{
"name": "Coral Red",
"hex": "#FF4040"
},
{
"name": "Coral Reef",
"hex": "#FD7C6E"
},
{
"name": "Cordovan",
"hex": "#893F45"
},
{
"name": "Corn",
"hex": "#FBEC5D"
},
{
"name": "Cornell Red",
"hex": "#B31B1B"
},
{
"name": "Cornflower Blue",
"hex": "#6495ED"
},
{
"name": "Cornsilk",
"hex": "#FFF8DC"
},
{
"name": "Cosmic Cobalt",
"hex": "#2E2D88"
},
{
"name": "Cosmic Latte",
"hex": "#FFF8E7"
},
{
"name": "Coyote Brown",
"hex": "#81613C"
},
{
"name": "Cotton Candy",
"hex": "#FFBCD9"
},
{
"name": "Cream",
"hex": "#FFFDD0"
},
{
"name": "Crimson",
"hex": "#DC143C"
},
{
"name": "Crimson Glory",
"hex": "#BE0032"
},
{
"name": "Crimson Red",
"hex": "#990000"
},
{
"name": "Cultured",
"hex": "#F5F5F5"
},
{
"name": "Cyan",
"hex": "#00FFFF"
},
{
"name": "Cyan Azure",
"hex": "#4E82B4"
},
{
"name": "Cyan-Blue Azure",
"hex": "#4682BF"
},
{
"name": "Cyan Cobalt Blue",
"hex": "#28589C"
},
{
"name": "Cyan Cornflower Blue",
"hex": "#188BC2"
},
{
"name": "Cyan (Process)",
"hex": "#00B7EB"
},
{
"name": "Cyber Grape",
"hex": "#58427C"
},
{
"name": "Cyber Yellow",
"hex": "#FFD300"
},
{
"name": "Cyclamen",
"hex": "#F56FA1"
},
{
"name": "Daffodil",
"hex": "#FFFF31"
},
{
"name": "Dandelion",
"hex": "#F0E130"
},
{
"name": "Dark Blue",
"hex": "#00008B"
},
{
"name": "Dark Blue-Gray",
"hex": "#666699"
},
{
"name": "Dark Brown",
"hex": "#654321"
},
{
"name": "Dark Brown-Tangelo",
"hex": "#88654E"
},
{
"name": "Dark Byzantium",
"hex": "#5D3954"
},
{
"name": "Dark Candy Apple Red",
"hex": "#A40000"
},
{
"name": "Dark Cerulean",
"hex": "#08457E"
},
{
"name": "Dark Chestnut",
"hex": "#986960"
},
{
"name": "Dark Coral",
"hex": "#CD5B45"
},
{
"name": "Dark Cyan",
"hex": "#008B8B"
},
{
"name": "Dark Electric Blue",
"hex": "#536878"
},
{
"name": "Dark Goldenrod",
"hex": "#B8860B"
},
{
"name": "Dark Gray (X11)",
"hex": "#A9A9A9"
},
{
"name": "Dark Green",
"hex": "#013220"
},
{
"name": "Dark Green (X11)",
"hex": "#006400"
},
{
"name": "Dark Gunmetal",
"hex": "#1F262A"
},
{
"name": "Dark Imperial Blue",
"hex": "#00416A"
},
{
"name": "Dark Imperial Blue",
"hex": "#00147E"
},
{
"name": "Dark Jungle Green",
"hex": "#1A2421"
},
{
"name": "Dark Khaki",
"hex": "#BDB76B"
},
{
"name": "Dark Lava",
"hex": "#483C32"
},
{
"name": "Dark Lavender",
"hex": "#734F96"
},
{
"name": "Dark Liver",
"hex": "#534B4F"
},
{
"name": "Dark Liver (Horses)",
"hex": "#543D37"
},
{
"name": "Dark Magenta",
"hex": "#8B008B"
},
{
"name": "Dark Medium Gray",
"hex": "#A9A9A9"
},
{
"name": "Dark Midnight Blue",
"hex": "#003366"
},
{
"name": "Dark Moss Green",
"hex": "#4A5D23"
},
{
"name": "Dark Olive Green",
"hex": "#556B2F"
},
{
"name": "Dark Orange",
"hex": "#FF8C00"
},
{
"name": "Dark Orchid",
"hex": "#9932CC"
},
{
"name": "Dark Pastel Blue",
"hex": "#779ECB"
},
{
"name": "Dark Pastel Green",
"hex": "#03C03C"
},
{
"name": "Dark Pastel Purple",
"hex": "#966FD6"
},
{
"name": "Dark Pastel Red",
"hex": "#C23B22"
},
{
"name": "Dark Pink",
"hex": "#E75480"
},
{
"name": "Dark Powder Blue",
"hex": "#003399"
},
{
"name": "Dark Puce",
"hex": "#4F3A3C"
},
{
"name": "Dark Purple",
"hex": "#301934"
},
{
"name": "Dark Raspberry",
"hex": "#872657"
},
{
"name": "Dark Red",
"hex": "#8B0000"
},
{
"name": "Dark Salmon",
"hex": "#E9967A"
},
{
"name": "Dark Scarlet",
"hex": "#560319"
},
{
"name": "Dark Sea Green",
"hex": "#8FBC8F"
},
{
"name": "Dark Sienna",
"hex": "#3C1414"
},
{
"name": "Dark Sky Blue",
"hex": "#8CBED6"
},
{
"name": "Dark Slate Blue",
"hex": "#483D8B"
},
{
"name": "Dark Slate Gray",
"hex": "#2F4F4F"
},
{
"name": "Dark Spring Green",
"hex": "#177245"
},
{
"name": "Dark Tan",
"hex": "#918151"
},
{
"name": "Dark Tangerine",
"hex": "#FFA812"
},
{
"name": "Dark Taupe",
"hex": "#483C32"
},
{
"name": "Dark Terra Cotta",
"hex": "#CC4E5C"
},
{
"name": "Dark Turquoise",
"hex": "#00CED1"
},
{
"name": "Dark Vanilla",
"hex": "#D1BEA8"
},
{
"name": "Dark Violet",
"hex": "#9400D3"
},
{
"name": "Dark Yellow",
"hex": "#9B870C"
},
{
"name": "Dartmouth Green",
"hex": "#00703C"
},
{
"name": "Davy's Grey",
"hex": "#555555"
},
{
"name": "Debian Red",
"hex": "#D70A53"
},
{
"name": "Deep Aquamarine",
"hex": "#40826D"
},
{
"name": "Deep Carmine",
"hex": "#A9203E"
},
{
"name": "Deep Carmine Pink",
"hex": "#EF3038"
},
{
"name": "Deep Carrot Orange",
"hex": "#E9692C"
},
{
"name": "Deep Cerise",
"hex": "#DA3287"
},
{
"name": "Deep Champagne",
"hex": "#FAD6A5"
},
{
"name": "Deep Chestnut",
"hex": "#B94E48"
},
{
"name": "Deep Coffee",
"hex": "#704241"
},
{
"name": "Deep Fuchsia",
"hex": "#C154C1"
},
{
"name": "Deep Green",
"hex": "#056608"
},
{
"name": "Deep Green-Cyan Turquoise",
"hex": "#0E7C61"
},
{
"name": "Deep Jungle Green",
"hex": "#004B49"
},
{
"name": "Deep Koamaru",
"hex": "#333366"
},
{
"name": "Deep Lemon",
"hex": "#F5C71A"
},
{
"name": "Deep Lilac",
"hex": "#9955BB"
},
{
"name": "Deep Magenta",
"hex": "#CC00CC"
},
{
"name": "Deep Maroon",
"hex": "#820000"
},
{
"name": "Deep Mauve",
"hex": "#D473D4"
},
{
"name": "Deep Moss Green",
"hex": "#355E3B"
},
{
"name": "Deep Peach",
"hex": "#FFCBA4"
},
{
"name": "Deep Pink",
"hex": "#FF1493"
},
{
"name": "Deep Puce",
"hex": "#A95C68"
},
{
"name": "Deep Red",
"hex": "#850101"
},
{
"name": "Deep Ruby",
"hex": "#843F5B"
},
{
"name": "Deep Saffron",
"hex": "#FF9933"
},
{
"name": "Deep Sky Blue",
"hex": "#00BFFF"
},
{
"name": "Deep Space Sparkle",
"hex": "#4A646C"
},
{
"name": "Deep Spring Bud",
"hex": "#556B2F"
},
{
"name": "Deep Taupe",
"hex": "#7E5E60"
},
{
"name": "Deep Tuscan Red",
"hex": "#66424D"
},
{
"name": "Deep Violet",
"hex": "#330066"
},
{
"name": "Deer",
"hex": "#BA8759"
},
{
"name": "Denim",
"hex": "#1560BD"
},
{
"name": "Denim Blue",
"hex": "#2243B6"
},
{
"name": "Desaturated Cyan",
"hex": "#669999"
},
{
"name": "Desert",
"hex": "#C19A6B"
},
{
"name": "Desert Sand",
"hex": "#EDC9AF"
},
{
"name": "Desire",
"hex": "#EA3C53"
},
{
"name": "Diamond",
"hex": "#B9F2FF"
},
{
"name": "Dim Gray",
"hex": "#696969"
},
{
"name": "Dingy Dungeon",
"hex": "#C53151"
},
{
"name": "Dirt",
"hex": "#9B7653"
},
{
"name": "Dodger Blue",
"hex": "#1E90FF"
},
{
"name": "Dodie Yellow",
"hex": "#FEF65B"
},
{
"name": "Dogwood Rose",
"hex": "#D71868"
},
{
"name": "Dollar Bill",
"hex": "#85BB65"
},
{
"name": "Dolphin Gray",
"hex": "#828E84"
},
{
"name": "Donkey Brown",
"hex": "#664C28"
},
{
"name": "Drab",
"hex": "#967117"
},
{
"name": "Duke Blue",
"hex": "#00009C"
},
{
"name": "Dust Storm",
"hex": "#E5CCC9"
},
{
"name": "Dutch White",
"hex": "#EFDFBB"
},
{
"name": "Earth Yellow",
"hex": "#E1A95F"
},
{
"name": "Ebony",
"hex": "#555D50"
},
{
"name": "Ecru",
"hex": "#C2B280"
},
{
"name": "Eerie Black",
"hex": "#1B1B1B"
},
{
"name": "Eggplant",
"hex": "#614051"
},
{
"name": "Eggshell",
"hex": "#F0EAD6"
},
{
"name": "Egyptian Blue",
"hex": "#1034A6"
},
{
"name": "Electric Blue",
"hex": "#7DF9FF"
},
{
"name": "Electric Crimson",
"hex": "#FF003F"
},
{
"name": "Electric Cyan",
"hex": "#00FFFF"
},
{
"name": "Electric Green",
"hex": "#00FF00"
},
{
"name": "Electric Indigo",
"hex": "#6F00FF"
},
{
"name": "Electric Lavender",
"hex": "#F4BBFF"
},
{
"name": "Electric Lime",
"hex": "#CCFF00"
},
{
"name": "Electric Purple",
"hex": "#BF00FF"
},
{
"name": "Electric Ultramarine",
"hex": "#3F00FF"
},
{
"name": "Electric Violet",
"hex": "#8F00FF"
},
{
"name": "Electric Yellow",
"hex": "#FFFF33"
},
{
"name": "Emerald",
"hex": "#50C878"
},
{
"name": "Eminence",
"hex": "#6C3082"
},
{
"name": "English Green",
"hex": "#1B4D3E"
},
{
"name": "English Lavender",
"hex": "#B48395"
},
{
"name": "English Red",
"hex": "#AB4B52"
},
{
"name": "English Vermillion",
"hex": "#CC474B"
},
{
"name": "English Violet",
"hex": "#563C5C"
},
{
"name": "Eton Blue",
"hex": "#96C8A2"
},
{
"name": "Eucalyptus",
"hex": "#44D7A8"
},
{
"name": "Fallow",
"hex": "#C19A6B"
},
{
"name": "Falu Red",
"hex": "#801818"
},
{
"name": "Fandango",
"hex": "#B53389"
},
{
"name": "Fandango Pink",
"hex": "#DE5285"
},
{
"name": "Fashion Fuchsia",
"hex": "#F400A1"
},
{
"name": "Fawn",
"hex": "#E5AA70"
},
{
"name": "Feldgrau",
"hex": "#4D5D53"
},
{
"name": "Feldspar",
"hex": "#FDD5B1"
},
{
"name": "Fern Green",
"hex": "#4F7942"
},
{
"name": "Ferrari Red",
"hex": "#FF2800"
},
{
"name": "Field Drab",
"hex": "#6C541E"
},
{
"name": "Fiery Rose",
"hex": "#FF5470"
},
{
"name": "Firebrick",
"hex": "#B22222"
},
{
"name": "Fire Engine Red",
"hex": "#CE2029"
},
{
"name": "Flame",
"hex": "#E25822"
},
{
"name": "Flamingo Pink",
"hex": "#FC8EAC"
},
{
"name": "Flattery",
"hex": "#6B4423"
},
{
"name": "Flavescent",
"hex": "#F7E98E"
},
{
"name": "Flax",
"hex": "#EEDC82"
},
{
"name": "Flirt",
"hex": "#A2006D"
},
{
"name": "Floral White",
"hex": "#FFFAF0"
},
{
"name": "Fluorescent Orange",
"hex": "#FFBF00"
},
{
"name": "Fluorescent Pink",
"hex": "#FF1493"
},
{
"name": "Fluorescent Yellow",
"hex": "#CCFF00"
},
{
"name": "Folly",
"hex": "#FF004F"
},
{
"name": "Forest Green (Traditional)",
"hex": "#014421"
},
{
"name": "Forest Green (Web)",
"hex": "#228B22"
},
{
"name": "French Beige",
"hex": "#A67B5B"
},
{
"name": "French Bistre",
"hex": "#856D4D"
},
{
"name": "French Blue",
"hex": "#0072BB"
},
{
"name": "French Fuchsia",
"hex": "#FD3F92"
},
{
"name": "French Lilac",
"hex": "#86608E"
},
{
"name": "French Lime",
"hex": "#9EFD38"
},
{
"name": "French Mauve",
"hex": "#D473D4"
},
{
"name": "French Pink",
"hex": "#FD6C9E"
},
{
"name": "French Plum",
"hex": "#811453"
},
{
"name": "French Puce",
"hex": "#4E1609"
},
{
"name": "French Raspberry",
"hex": "#C72C48"
},
{
"name": "French Rose",
"hex": "#F64A8A"
},
{
"name": "French Sky Blue",
"hex": "#77B5FE"
},
{
"name": "French Violet",
"hex": "#8806CE"
},
{
"name": "French Wine",
"hex": "#AC1E44"
},
{
"name": "Fresh Air",
"hex": "#A6E7FF"
},
{
"name": "Frogert",
"hex": "#E936A7"
},
{
"name": "Fuchsia",
"hex": "#FF00FF"
},
{
"name": "Fuchsia (Crayola)",
"hex": "#C154C1"
},
{
"name": "Fuchsia Pink",
"hex": "#FF77FF"
},
{
"name": "Fuchsia Purple",
"hex": "#CC397B"
},
{
"name": "Fuchsia Rose",
"hex": "#C74375"
},
{
"name": "Fulvous",
"hex": "#E48400"
},
{
"name": "Fuzzy Wuzzy",
"hex": "#CC6666"
},
{
"name": "Gainsboro",
"hex": "#DCDCDC"
},
{
"name": "Gamboge",
"hex": "#E49B0F"
},
{
"name": "Gamboge Orange (Brown)",
"hex": "#996600"
},
{
"name": "Gargoyle Gas",
"hex": "#FFDF46"
},
{
"name": "Generic Viridian",
"hex": "#007F66"
},
{
"name": "Ghost White",
"hex": "#F8F8FF"
},
{
"name": "Giant's Club",
"hex": "#B05C52"
},
{
"name": "Giants Orange",
"hex": "#FE5A1D"
},
{
"name": "Ginger",
"hex": "#B06500"
},
{
"name": "Glaucous",
"hex": "#6082B6"
},
{
"name": "Glitter",
"hex": "#E6E8FA"
},
{
"name": "Glossy Grape",
"hex": "#AB92B3"
},
{
"name": "GO Green",
"hex": "#00AB66"
},
{
"name": "Gold (Metallic)",
"hex": "#D4AF37"
},
{
"name": "Gold (Web) (Golden)",
"hex": "#FFD700"
},
{
"name": "Gold Fusion",
"hex": "#85754E"
},
{
"name": "Golden Brown",
"hex": "#996515"
},
{
"name": "Golden Poppy",
"hex": "#FCC200"
},
{
"name": "Golden Yellow",
"hex": "#FFDF00"
},
{
"name": "Goldenrod",
"hex": "#DAA520"
},
{
"name": "Granite Gray",
"hex": "#676767"
},
{
"name": "Granny Smith Apple",
"hex": "#A8E4A0"
},
{
"name": "Grape",
"hex": "#6F2DA8"
},
{
"name": "Gray",
"hex": "#808080"
},
{
"name": "Gray (HTML/CSS Gray)",
"hex": "#808080"
},
{
"name": "Gray (X11 Gray)",
"hex": "#BEBEBE"
},
{
"name": "Gray-Asparagus",
"hex": "#465945"
},
{
"name": "Gray-Blue",
"hex": "#8C92AC"
},
{
"name": "Green (Color Wheel) (X11 Green)",
"hex": "#00FF00"
},
{
"name": "Green (Crayola)",
"hex": "#1CAC78"
},
{
"name": "Green (HTML/CSS Color)",
"hex": "#008000"
},
{
"name": "Green (Munsell)",
"hex": "#00A877"
},
{
"name": "Green (NCS)",
"hex": "#009F6B"
},
{
"name": "Green (Pantone)",
"hex": "#00AD43"
},
{
"name": "Green (Pigment)",
"hex": "#00A550"
},
{
"name": "Green (RYB)",
"hex": "#66B032"
},
{
"name": "Green-Blue",
"hex": "#1164B4"
},
{
"name": "Green-Cyan",
"hex": "#009966"
},
{
"name": "Green Lizard",
"hex": "#A7F432"
},
{
"name": "Green Sheen",
"hex": "#6EAEA1"
},
{
"name": "Green-Yellow",
"hex": "#ADFF2F"
},
{
"name": "Grizzly",
"hex": "#885818"
},
{
"name": "Grullo",
"hex": "#A99A86"
},
{
"name": "Guppie Green",
"hex": "#00FF7F"
},
{
"name": "Gunmetal",
"hex": "#2a3439"
},
{
"name": "Halaya Ube",
"hex": "#663854"
},
{
"name": "Han Blue",
"hex": "#446CCF"
},
{
"name": "Han Purple",
"hex": "#5218FA"
},
{
"name": "Hansa Yellow",
"hex": "#E9D66B"
},
{
"name": "Harlequin",
"hex": "#3FFF00"
},
{
"name": "Harlequin Green",
"hex": "#46CB18"
},
{
"name": "Harvard Crimson",
"hex": "#C90016"
},
{
"name": "Harvest Gold",
"hex": "#DA9100"
},
{
"name": "Heart Gold",
"hex": "#808000"
},
{
"name": "Heat Wave",
"hex": "#FF7A00"
},
{
"name": "Heidelberg Red",
"hex": "#960018"
},
{
"name": "Heliotrope",
"hex": "#DF73FF"
},
{
"name": "Heliotrope Gray",
"hex": "#AA98A9"
},
{
"name": "Heliotrope Magenta",
"hex": "#AA00BB"
},
{
"name": "Hollywood Cerise",
"hex": "#F400A1"
},
{
"name": "Honeydew",
"hex": "#F0FFF0"
},
{
"name": "Honolulu Blue",
"hex": "#006DB0"
},
{
"name": "Hooker's Green",
"hex": "#49796B"
},
{
"name": "Hot Magenta",
"hex": "#FF1DCE"
},
{
"name": "Hot Pink",
"hex": "#FF69B4"
},
{
"name": "Hunter Green",
"hex": "#355E3B"
},
{
"name": "Iceberg",
"hex": "#71A6D2"
},
{
"name": "Icterine",
"hex": "#FCF75E"
},
{
"name": "Iguana Green",
"hex": "#71BC78"
},
{
"name": "Illuminating Emerald",
"hex": "#319177"
},
{
"name": "Imperial",
"hex": "#602F6B"
},
{
"name": "Imperial Blue",
"hex": "#002395"
},
{
"name": "Imperial Purple",
"hex": "#66023C"
},
{
"name": "Imperial Red",
"hex": "#ED2939"
},
{
"name": "Inchworm",
"hex": "#B2EC5D"
},
{
"name": "Independence",
"hex": "#4C516D"
},
{
"name": "India Green",
"hex": "#138808"
},
{
"name": "Indian Red",
"hex": "#CD5C5C"
},
{
"name": "Indian Yellow",
"hex": "#E3A857"
},
{
"name": "Indigo",
"hex": "#4B0082"
},
{
"name": "Indigo Dye",
"hex": "#091F92"
},
{
"name": "Indigo (Web)",
"hex": "#4B0082"
},
{
"name": "Infra Red",
"hex": "#FF496C"
},
{
"name": "Interdimensional Blue",
"hex": "#360CCC"
},
{
"name": "International Klein Blue",
"hex": "#002FA7"
},
{
"name": "International Orange (Aerospace)",
"hex": "#FF4F00"
},
{
"name": "International Orange (Engineering)",
"hex": "#BA160C"
},
{
"name": "International Orange (Golden Gate Bridge)",
"hex": "#C0362C"
},
{
"name": "Iris",
"hex": "#5A4FCF"
},
{
"name": "Irresistible",
"hex": "#B3446C"
},
{
"name": "Isabelline",
"hex": "#F4F0EC"
},
{
"name": "Islamic Green",
"hex": "#009000"
},
{
"name": "Italian Sky Blue",
"hex": "#B2FFFF"
},
{
"name": "Ivory",
"hex": "#FFFFF0"
},
{
"name": "Jade",
"hex": "#00A86B"
},
{
"name": "Japanese Carmine",
"hex": "#9D2933"
},
{
"name": "Japanese Indigo",
"hex": "#264348"
},
{
"name": "Japanese Violet",
"hex": "#5B3256"
},
{
"name": "Jasmine",
"hex": "#F8DE7E"
},
{
"name": "Jasper",
"hex": "#D73B3E"
},
{
"name": "Jazzberry Jam",
"hex": "#A50B5E"
},
{
"name": "Jelly Bean",
"hex": "#DA614E"
},
{
"name": "Jet",
"hex": "#343434"
},
{
"name": "Jonquil",
"hex": "#F4CA16"
},
{
"name": "Jordy Blue",
"hex": "#8AB9F1"
},
{
"name": "June Bud",
"hex": "#BDDA57"
},
{
"name": "Jungle Green",
"hex": "#29AB87"
},
{
"name": "Kelly Green",
"hex": "#4CBB17"
},
{
"name": "Kenyan Copper",
"hex": "#7C1C05"
},
{
"name": "Keppel",
"hex": "#3AB09E"
},
{
"name": "Key Lime",
"hex": "#E8F48C"
},
{
"name": "Khaki (HTML/CSS) (Khaki)",
"hex": "#C3B091"
},
{
"name": "Khaki (X11) (Light Khaki)",
"hex": "#F0E68C"
},
{
"name": "Kiwi",
"hex": "#8EE53F"
},
{
"name": "Kobe",
"hex": "#882D17"
},
{
"name": "Kobi",
"hex": "#E79FC4"
},
{
"name": "Kobicha",
"hex": "#6B4423"
},
{
"name": "Kombu Green",
"hex": "#354230"
},
{
"name": "KSU Purple",
"hex": "#512888"
},
{
"name": "KU Crimson",
"hex": "#E8000D"
},
{
"name": "La Salle Green",
"hex": "#087830"
},
{
"name": "Languid Lavender",
"hex": "#D6CADD"
},
{
"name": "Lapis Lazuli",
"hex": "#26619C"
},
{
"name": "Laser Lemon",
"hex": "#FFFF66"
},
{
"name": "Laurel Green",
"hex": "#A9BA9D"
},
{
"name": "Lava",
"hex": "#CF1020"
},
{
"name": "Lavender (Floral)",
"hex": "#B57EDC"
},
{
"name": "Lavender (Web)",
"hex": "#E6E6FA"
},
{
"name": "Lavender Blue",
"hex": "#CCCCFF"
},
{
"name": "Lavender Blush",
"hex": "#FFF0F5"
},
{
"name": "Lavender Gray",
"hex": "#C4C3D0"
},
{
"name": "Lavender Indigo",
"hex": "#9457EB"
},
{
"name": "Lavender Magenta",
"hex": "#EE82EE"
},
{
"name": "Lavender Mist",
"hex": "#E6E6FA"
},
{
"name": "Lavender Pink",
"hex": "#FBAED2"
},
{
"name": "Lavender Purple",
"hex": "#967BB6"
},
{
"name": "Lavender Rose",
"hex": "#FBA0E3"
},
{
"name": "Lawn Green",
"hex": "#7CFC00"
},
{
"name": "Lemon",
"hex": "#FFF700"
},
{
"name": "Lemon Chiffon",
"hex": "#FFFACD"
},
{
"name": "Lemon Curry",
"hex": "#CCA01D"
},
{
"name": "Lemon Glacier",
"hex": "#FDFF00"
},
{
"name": "Lemon Lime",
"hex": "#E3FF00"
},
{
"name": "Lemon Meringue",
"hex": "#F6EABE"
},
{
"name": "Lemon Yellow",
"hex": "#FFF44F"
},
{
"name": "Licorice",
"hex": "#1A1110"
},
{
"name": "Liberty",
"hex": "#545AA7"
},
{
"name": "Light Apricot",
"hex": "#FDD5B1"
},
{
"name": "Light Blue",
"hex": "#ADD8E6"
},
{
"name": "Light Brown",
"hex": "#B5651D"
},
{
"name": "Light Carmine Pink",
"hex": "#E66771"
},
{
"name": "Light Cobalt Blue",
"hex": "#88ACE0"
},
{
"name": "Light Coral",
"hex": "#F08080"
},
{
"name": "Light Cornflower Blue",
"hex": "#93CCEA"
},
{
"name": "Light Crimson",
"hex": "#F56991"
},
{
"name": "Light Cyan",
"hex": "#E0FFFF"
},
{
"name": "Light Deep Pink",
"hex": "#FF5CCD"
},
{
"name": "Light French Beige",
"hex": "#C8AD7F"
},
{
"name": "Light Fuchsia Pink",
"hex": "#F984EF"
},
{
"name": "Light Goldenrod Yellow",
"hex": "#FAFAD2"
},
{
"name": "Light Gray",
"hex": "#D3D3D3"
},
{
"name": "Light Grayish Magenta",
"hex": "#CC99CC"
},
{
"name": "Light Green",
"hex": "#90EE90"
},
{
"name": "Light Hot Pink",
"hex": "#FFB3DE"
},
{
"name": "Light Khaki",
"hex": "#F0E68C"
},
{
"name": "Light Medium Orchid",
"hex": "#D39BCB"
},
{
"name": "Light Moss Green",
"hex": "#ADDFAD"
},
{
"name": "Light Orange",
"hex": "#FED8B1"
},
{
"name": "Light Orchid",
"hex": "#E6A8D7"
},
{
"name": "Light Pastel Purple",
"hex": "#B19CD9"
},
{
"name": "Light Pink",
"hex": "#FFB6C1"
},
{
"name": "Light Red Ochre",
"hex": "#E97451"
},
{
"name": "Light Salmon",
"hex": "#FFA07A"
},
{
"name": "Light Salmon Pink",
"hex": "#FF9999"
},
{
"name": "Light Sea Green",
"hex": "#20B2AA"
},
{
"name": "Light Sky Blue",
"hex": "#87CEFA"
},
{
"name": "Light Slate Gray",
"hex": "#778899"
},
{
"name": "Light Steel Blue",
"hex": "#B0C4DE"
},
{
"name": "Light Taupe",
"hex": "#B38B6D"
},
{
"name": "Light Thulian Pink",
"hex": "#E68FAC"
},
{
"name": "Light Yellow",
"hex": "#FFFFE0"
},
{
"name": "Lilac",
"hex": "#C8A2C8"
},
{
"name": "Lilac Luster",
"hex": "#AE98AA"
},
{
"name": "Lime (Color Wheel)",
"hex": "#BFFF00"
},
{
"name": "Lime (Web) (X11 Green)",
"hex": "#00FF00"
},
{
"name": "Lime Green",
"hex": "#32CD32"
},
{
"name": "Limerick",
"hex": "#9DC209"
},
{
"name": "Lincoln Green",
"hex": "#195905"
},
{
"name": "Linen",
"hex": "#FAF0E6"
},
{
"name": "Loeen (Lopen) Look",
"hex": "#15F2FD"
},
{
"name": "Liseran Purple",
"hex": "#DE6FA1"
},
{
"name": "Little Boy Blue",
"hex": "#6CA0DC"
},
{
"name": "Liver",
"hex": "#674C47"
},
{
"name": "Liver (Dogs)",
"hex": "#B86D29"
},
{
"name": "Liver (Organ)",
"hex": "#6C2E1F"
},
{
"name": "Liver Chestnut",
"hex": "#987456"
},
{
"name": "Livid",
"hex": "#6699CC"
},
{
"name": "Lumber",
"hex": "#FFE4CD"
},
{
"name": "Lust",
"hex": "#E62020"
},
{
"name": "Maastricht Blue",
"hex": "#001C3D"
},
{
"name": "Macaroni And Cheese",
"hex": "#FFBD88"
},
{
"name": "Madder Lake",
"hex": "#CC3336"
},
{
"name": "Magenta",
"hex": "#FF00FF"
},
{
"name": "Magenta (Crayola)",
"hex": "#FF55A3"
},
{
"name": "Magenta (Dye)",
"hex": "#CA1F7B"
},
{
"name": "Magenta (Pantone)",
"hex": "#D0417E"
},
{
"name": "Magenta (Process)",
"hex": "#FF0090"
},
{
"name": "Magenta Haze",
"hex": "#9F4576"
},
{
"name": "Magenta-Pink",
"hex": "#CC338B"
},
{
"name": "Magic Mint",
"hex": "#AAF0D1"
},
{
"name": "Magic Potion",
"hex": "#FF4466"
},
{
"name": "Magnolia",
"hex": "#F8F4FF"
},
{
"name": "Mahogany",
"hex": "#C04000"
},
{
"name": "Maize",
"hex": "#FBEC5D"
},
{
"name": "Majorelle Blue",
"hex": "#6050DC"
},
{
"name": "Malachite",
"hex": "#0BDA51"
},
{
"name": "Manatee",
"hex": "#979AAA"
},
{
"name": "Mandarin",
"hex": "#F37A48"
},
{
"name": "Mango Tango",
"hex": "#FF8243"
},
{
"name": "Mantis",
"hex": "#74C365"
},
{
"name": "Mardi Gras",
"hex": "#880085"
},
{
"name": "Marigold",
"hex": "#EAA221"
},
{
"name": "Maroon (Crayola)",
"hex": "#C32148"
},
{
"name": "Maroon (HTML/CSS)",
"hex": "#800000"
},
{
"name": "Maroon (X11)",
"hex": "#B03060"
},
{
"name": "Mauve",
"hex": "#E0B0FF"
},
{
"name": "Mauve Taupe",
"hex": "#915F6D"
},
{
"name": "Mauvelous",
"hex": "#EF98AA"
},
{
"name": "Maximum Blue",
"hex": "#47ABCC"
},
{
"name": "Maximum Blue Green",
"hex": "#30BFBF"
},
{
"name": "Maximum Blue Purple",
"hex": "#ACACE6"
},
{
"name": "Maximum Green",
"hex": "#5E8C31"
},
{
"name": "Maximum Green Yellow",
"hex": "#D9E650"
},
{
"name": "Maximum Purple",
"hex": "#733380"
},
{
"name": "Maximum Red",
"hex": "#D92121"
},
{
"name": "Maximum Red Purple",
"hex": "#A63A79"
},
{
"name": "Maximum Yellow",
"hex": "#FAFA37"
},
{
"name": "Maximum Yellow Red",
"hex": "#F2BA49"
},
{
"name": "May Green",
"hex": "#4C9141"
},
{
"name": "Maya Blue",
"hex": "#73C2FB"
},
{
"name": "Meat Brown",
"hex": "#E5B73B"
},
{
"name": "Medium Aquamarine",
"hex": "#66DDAA"
},
{
"name": "Medium Blue",
"hex": "#0000CD"
},
{
"name": "Medium Candy Apple Red",
"hex": "#E2062C"
},
{
"name": "Medium Carmine",
"hex": "#AF4035"
},
{
"name": "Medium Champagne",
"hex": "#F3E5AB"
},
{
"name": "Medium Electric Blue",
"hex": "#035096"
},
{
"name": "Medium Jungle Green",
"hex": "#1C352D"
},
{
"name": "Medium Lavender Magenta",
"hex": "#DDA0DD"
},
{
"name": "Medium Orchid",
"hex": "#BA55D3"
},
{
"name": "Medium Persian Blue",
"hex": "#0067A5"
},
{
"name": "Medium Purple",
"hex": "#9370DB"
},
{
"name": "Medium Red-Violet",
"hex": "#BB3385"
},
{
"name": "Medium Ruby",
"hex": "#AA4069"
},
{
"name": "Medium Sea Green",
"hex": "#3CB371"
},
{
"name": "Medium Sky Blue",
"hex": "#80DAEB"
},
{
"name": "Medium Slate Blue",
"hex": "#7B68EE"
},
{
"name": "Medium Spring Bud",
"hex": "#C9DC87"
},
{
"name": "Medium Spring Green",
"hex": "#00FA9A"
},
{
"name": "Medium Taupe",
"hex": "#674C47"
},
{
"name": "Medium Turquoise",
"hex": "#48D1CC"
},
{
"name": "Medium Tuscan Red",
"hex": "#79443B"
},
{
"name": "Medium Vermilion",
"hex": "#D9603B"
},
{
"name": "Medium Violet-Red",
"hex": "#C71585"
},
{
"name": "Mellow Apricot",
"hex": "#F8B878"
},
{
"name": "Mellow Yellow",
"hex": "#F8DE7E"
},
{
"name": "Melon",
"hex": "#FDBCB4"
},
{
"name": "Metallic Seaweed",
"hex": "#0A7E8C"
},
{
"name": "Metallic Sunburst",
"hex": "#9C7C38"
},
{
"name": "Mexican Pink",
"hex": "#E4007C"
},
{
"name": "Middle Blue",
"hex": "#7ED4E6"
},
{
"name": "Middle Blue Green",
"hex": "#8DD9CC"
},
{
"name": "Middle Blue Purple",
"hex": "#8B72BE"
},
{
"name": "Middle Red Purple",
"hex": "#210837"
},
{
"name": "Middle Green",
"hex": "#4D8C57"
},
{
"name": "Middle Green Yellow",
"hex": "#ACBF60"
},
{
"name": "Middle Purple",
"hex": "#D982B5"
},
{
"name": "Middle Red",
"hex": "#E58E73"
},
{
"name": "Middle Red Purple",
"hex": "#A55353"
},
{
"name": "Middle Yellow",
"hex": "#FFEB00"
},
{
"name": "Middle Yellow Red",
"hex": "#ECB176"
},
{
"name": "Midnight",
"hex": "#702670"
},
{
"name": "Midnight Blue",
"hex": "#191970"
},
{
"name": "Midnight Green (Eagle Green)",
"hex": "#004953"
},
{
"name": "Mikado Yellow",
"hex": "#FFC40C"
},
{
"name": "Milk",
"hex": "#FDFFF5"
},
{
"name": "Mimi Pink",
"hex": "#FFDAE9"
},
{
"name": "Mindaro",
"hex": "#E3F988"
},
{
"name": "Ming",
"hex": "#36747D"
},
{
"name": "Minion Yellow",
"hex": "#F5E050"
},
{
"name": "Mint",
"hex": "#3EB489"
},
{
"name": "Mint Cream",
"hex": "#F5FFFA"
},
{
"name": "Mint Green",
"hex": "#98FF98"
},
{
"name": "Misty Moss",
"hex": "#BBB477"
},
{
"name": "Misty Rose",
"hex": "#FFE4E1"
},
{
"name": "Moccasin",
"hex": "#FAEBD7"
},
{
"name": "Mode Beige",
"hex": "#967117"
},
{
"name": "Moonstone Blue",
"hex": "#73A9C2"
},
{
"name": "Mordant Red 19",
"hex": "#AE0C00"
},
{
"name": "Morning Blue",
"hex": "#8DA399"
},
{
"name": "Moss Green",
"hex": "#8A9A5B"
},
{
"name": "Mountain Meadow",
"hex": "#30BA8F"
},
{
"name": "Mountbatten Pink",
"hex": "#997A8D"
},
{
"name": "MSU Green",
"hex": "#18453B"
},
{
"name": "Mughal Green",
"hex": "#306030"
},
{
"name": "Mulberry",
"hex": "#C54B8C"
},
{
"name": "Mummy's Tomb",
"hex": "#828E84"
},
{
"name": "Mustard",
"hex": "#FFDB58"
},
{
"name": "Myrtle Green",
"hex": "#317873"
},
{
"name": "Mystic",
"hex": "#D65282"
},
{
"name": "Mystic Maroon",
"hex": "#AD4379"
},
{
"name": "Nadeshiko Pink",
"hex": "#F6ADC6"
},
{
"name": "Napier Green",
"hex": "#2A8000"
},
{
"name": "Naples Yellow",
"hex": "#FADA5E"
},
{
"name": "Navajo White",
"hex": "#FFDEAD"
},
{
"name": "Navy",
"hex": "#000080"
},
{
"name": "Navy Purple",
"hex": "#9457EB"
},
{
"name": "Neon Carrot",
"hex": "#FFA343"
},
{
"name": "Neon Fuchsia",
"hex": "#FE4164"
},
{
"name": "Neon Green",
"hex": "#39FF14"
},
{
"name": "New Car",
"hex": "#214FC6"
},
{
"name": "New York Pink",
"hex": "#D7837F"
},
{
"name": "Nickel",
"hex": "#727472"
},
{
"name": "Non-Photo Blue",
"hex": "#A4DDED"
},
{
"name": "North Texas Green",
"hex": "#059033"
},
{
"name": "Nyanza",
"hex": "#E9FFDB"
},
{
"name": "Ocean Blue",
"hex": "#4F42B5"
},
{
"name": "Ocean Boat Blue",
"hex": "#0077BE"
},
{
"name": "Ocean Green",
"hex": "#48BF91"
},
{
"name": "Ochre",
"hex": "#CC7722"
},
{
"name": "Office Green",
"hex": "#008000"
},
{
"name": "Ogre Odor",
"hex": "#FD5240"
},
{
"name": "Old Burgundy",
"hex": "#43302E"
},
{
"name": "Old Gold",
"hex": "#CFB53B"
},
{
"name": "Old Heliotrope",
"hex": "#563C5C"
},
{
"name": "Old Lace",
"hex": "#FDF5E6"
},
{
"name": "Old Lavender",
"hex": "#796878"
},
{
"name": "Old Mauve",
"hex": "#673147"
},
{
"name": "Old Moss Green",
"hex": "#867E36"
},
{
"name": "Old Rose",
"hex": "#C08081"
},
{
"name": "Old Silver",
"hex": "#848482"
},
{
"name": "Olive",
"hex": "#808000"
},
{
"name": "Olive Drab (#3)",
"hex": "#6B8E23"
},
{
"name": "Olive Drab #7",
"hex": "#3C341F"
},
{
"name": "Olivine",
"hex": "#9AB973"
},
{
"name": "Onyx",
"hex": "#353839"
},
{
"name": "Opera Mauve",
"hex": "#B784A7"
},
{
"name": "Orange (Color Wheel)",
"hex": "#FF7F00"
},
{
"name": "Orange (Crayola)",
"hex": "#FF7538"
},
{
"name": "Orange (Pantone)",
"hex": "#FF5800"
},
{
"name": "Orange (RYB)",
"hex": "#FB9902"
},
{
"name": "Orange (Web)",
"hex": "#FFA500"
},
{
"name": "Orange Peel",
"hex": "#FF9F00"
},
{
"name": "Orange-Red",
"hex": "#FF4500"
},
{
"name": "Orange Soda",
"hex": "#FA5B3D"
},
{
"name": "Orange-Yellow",
"hex": "#F8D568"
},
{
"name": "Orchid",
"hex": "#DA70D6"
},
{
"name": "Orchid Pink",
"hex": "#F2BDCD"
},
{
"name": "Orioles Orange",
"hex": "#FB4F14"
},
{
"name": "Otter Brown",
"hex": "#654321"
},
{
"name": "Outer Space",
"hex": "#414A4C"
},
{
"name": "Outrageous Orange",
"hex": "#FF6E4A"
},
{
"name": "Oxford Blue",
"hex": "#002147"
},
{
"name": "OU Crimson Red",
"hex": "#990000"
},
{
"name": "Pacific Blue",
"hex": "#1CA9C9"
},
{
"name": "Pakistan Green",
"hex": "#006600"
},
{
"name": "Palatinate Blue",
"hex": "#273BE2"
},
{
"name": "Palatinate Purple",
"hex": "#682860"
},
{
"name": "Pale Aqua",
"hex": "#BCD4E6"
},
{
"name": "Pale Blue",
"hex": "#AFEEEE"
},
{
"name": "Pale Brown",
"hex": "#987654"
},
{
"name": "Pale Carmine",
"hex": "#AF4035"
},
{
"name": "Pale Cerulean",
"hex": "#9BC4E2"
},
{
"name": "Pale Chestnut",
"hex": "#DDADAF"
},
{
"name": "Pale Copper",
"hex": "#DA8A67"
},
{
"name": "Pale Cornflower Blue",
"hex": "#ABCDEF"
},
{
"name": "Pale Cyan",
"hex": "#87D3F8"
},
{
"name": "Pale Gold",
"hex": "#E6BE8A"
},
{
"name": "Pale Goldenrod",
"hex": "#EEE8AA"
},
{
"name": "Pale Green",
"hex": "#98FB98"
},
{
"name": "Pale Lavender",
"hex": "#DCD0FF"
},
{
"name": "Pale Magenta",
"hex": "#F984E5"
},
{
"name": "Pale Magenta-Pink",
"hex": "#FF99CC"
},
{
"name": "Pale Pink",
"hex": "#FADADD"
},
{
"name": "Pale Plum",
"hex": "#DDA0DD"
},
{
"name": "Pale Red-Violet",
"hex": "#DB7093"
},
{
"name": "Pale Robin Egg Blue",
"hex": "#96DED1"
},
{
"name": "Pale Silver",
"hex": "#C9C0BB"
},
{
"name": "Pale Spring Bud",
"hex": "#ECEBBD"
},
{
"name": "Pale Taupe",
"hex": "#BC987E"
},
{
"name": "Pale Turquoise",
"hex": "#AFEEEE"
},
{
"name": "Pale Violet",
"hex": "#CC99FF"
},
{
"name": "Pale Violet-Red",
"hex": "#DB7093"
},
{
"name": "Palm Leaf",
"hex": "#6F9940"
},
{
"name": "Pansy Purple",
"hex": "#78184A"
},
{
"name": "Paolo Veronese Green",
"hex": "#009B7D"
},
{
"name": "Papaya Whip",
"hex": "#FFEFD5"
},
{
"name": "Paradise Pink",
"hex": "#E63E62"
},
{
"name": "Paris Green",
"hex": "#50C878"
},
{
"name": "Parrot Pink",
"hex": "#D998A0"
},
{
"name": "Pastel Blue",
"hex": "#AEC6CF"
},
{
"name": "Pastel Brown",
"hex": "#836953"
},
{
"name": "Pastel Gray",
"hex": "#CFCFC4"
},
{
"name": "Pastel Green",
"hex": "#77DD77"
},
{
"name": "Pastel Magenta",
"hex": "#F49AC2"
},
{
"name": "Pastel Orange",
"hex": "#FFB347"
},
{
"name": "Pastel Pink",
"hex": "#DEA5A4"
},
{
"name": "Pastel Purple",
"hex": "#B39EB5"
},
{
"name": "Pastel Red",
"hex": "#FF6961"
},
{
"name": "Pastel Violet",
"hex": "#CB99C9"
},
{
"name": "Pastel Yellow",
"hex": "#FDFD96"
},
{
"name": "Patriarch",
"hex": "#800080"
},
{
"name": "Payne's Grey",
"hex": "#536878"
},
{
"name": "Peach",
"hex": "#FFE5B4"
},
{
"name": "Peach",
"hex": "#FFCBA4"
},
{
"name": "Peach-Orange",
"hex": "#FFCC99"
},
{
"name": "Peach Puff",
"hex": "#FFDAB9"
},
{
"name": "Peach-Yellow",
"hex": "#FADFAD"
},
{
"name": "Pear",
"hex": "#D1E231"
},
{
"name": "Pearl",
"hex": "#EAE0C8"
},
{
"name": "Pearl Aqua",
"hex": "#88D8C0"
},
{
"name": "Pearly Purple",
"hex": "#B768A2"
},
{
"name": "Peridot",
"hex": "#E6E200"
},
{
"name": "Periwinkle",
"hex": "#CCCCFF"
},
{
"name": "Permanent Geranium Lake",
"hex": "#E12C2C"
},
{
"name": "Persian Blue",
"hex": "#1C39BB"
},
{
"name": "Persian Green",
"hex": "#00A693"
},
{
"name": "Persian Indigo",
"hex": "#32127A"
},
{
"name": "Persian Orange",
"hex": "#D99058"
},
{
"name": "Persian Pink",
"hex": "#F77FBE"
},
{
"name": "Persian Plum",
"hex": "#701C1C"
},
{
"name": "Persian Red",
"hex": "#CC3333"
},
{
"name": "Persian Rose",
"hex": "#FE28A2"
},
{
"name": "Persimmon",
"hex": "#EC5800"
},
{
"name": "Peru",
"hex": "#CD853F"
},
{
"name": "Pewter Blue",
"hex": "#8BA8B7"
},
{
"name": "Phlox",
"hex": "#DF00FF"
},
{
"name": "Phthalo Blue",
"hex": "#000F89"
},
{
"name": "Phthalo Green",
"hex": "#123524"
},
{
"name": "Picton Blue",
"hex": "#45B1E8"
},
{
"name": "Pictorial Carmine",
"hex": "#C30B4E"
},
{
"name": "Piggy Pink",
"hex": "#FDDDE6"
},
{
"name": "Pine Green",
"hex": "#01796F"
},
{
"name": "Pineapple",
"hex": "#563C0D"
},
{
"name": "Pink",
"hex": "#FFC0CB"
},
{
"name": "Pink (Pantone)",
"hex": "#D74894"
},
{
"name": "Pink Flamingo",
"hex": "#FC74FD"
},
{
"name": "Pink Lace",
"hex": "#FFDDF4"
},
{
"name": "Pink Lavender",
"hex": "#D8B2D1"
},
{
"name": "Pink-Orange",
"hex": "#FF9966"
},
{
"name": "Pink Pearl",
"hex": "#E7ACCF"
},
{
"name": "Pink Raspberry",
"hex": "#980036"
},
{
"name": "Pink Sherbet",
"hex": "#F78FA7"
},
{
"name": "Pistachio",
"hex": "#93C572"
},
{
"name": "Pixie Powder",
"hex": "#391285"
},
{
"name": "Platinum",
"hex": "#E5E4E2"
},
{
"name": "Plum",
"hex": "#8E4585"
},
{
"name": "Plum (Web)",
"hex": "#DDA0DD"
},
{
"name": "Plump Purple",
"hex": "#5946B2"
},
{
"name": "Polished Pine",
"hex": "#5DA493"
},
{
"name": "Pomp And Power",
"hex": "#86608E"
},
{
"name": "Popstar",
"hex": "#BE4F62"
},
{
"name": "Portland Orange",
"hex": "#FF5A36"
},
{
"name": "Powder Blue",
"hex": "#B0E0E6"
},
{
"name": "Princess Perfume",
"hex": "#FF85CF"
},
{
"name": "Princeton Orange",
"hex": "#F58025"
},
{
"name": "Prune",
"hex": "#701C1C"
},
{
"name": "Prussian Blue",
"hex": "#003153"
},
{
"name": "Psychedelic Purple",
"hex": "#DF00FF"
},
{
"name": "Puce",
"hex": "#CC8899"
},
{
"name": "Puce Red",
"hex": "#722F37"
},
{
"name": "Pullman Brown (UPS Brown)",
"hex": "#644117"
},
{
"name": "Pullman Green",
"hex": "#3B331C"
},
{
"name": "Pumpkin",
"hex": "#FF7518"
},
{
"name": "Purple (HTML)",
"hex": "#800080"
},
{
"name": "Purple (Munsell)",
"hex": "#9F00C5"
},
{
"name": "Purple (X11)",
"hex": "#A020F0"
},
{
"name": "Purple Heart",
"hex": "#69359C"
},
{
"name": "Purple Mountain Majesty",
"hex": "#9678B6"
},
{
"name": "Purple Navy",
"hex": "#4E5180"
},
{
"name": "Purple Pizzazz",
"hex": "#FE4EDA"
},
{
"name": "Purple Plum",
"hex": "#9C51B6"
},
{
"name": "Purple Taupe",
"hex": "#50404D"
},
{
"name": "Purpureus",
"hex": "#9A4EAE"
},
{
"name": "Quartz",
"hex": "#51484F"
},
{
"name": "Queen Blue",
"hex": "#436B95"
},
{
"name": "Queen Pink",
"hex": "#E8CCD7"
},
{
"name": "Quick Silver",
"hex": "#A6A6A6"
},
{
"name": "Quinacridone Magenta",
"hex": "#8E3A59"
},
{
"name": "Rackley",
"hex": "#5D8AA8"
},
{
"name": "Radical Red",
"hex": "#FF355E"
},
{
"name": "Raisin Black",
"hex": "#242124"
},
{
"name": "Rajah",
"hex": "#FBAB60"
},
{
"name": "Raspberry",
"hex": "#E30B5D"
},
{
"name": "Raspberry Glace",
"hex": "#915F6D"
},
{
"name": "Raspberry Pink",
"hex": "#E25098"
},
{
"name": "Raspberry Rose",
"hex": "#B3446C"
},
{
"name": "Raw Sienna",
"hex": "#D68A59"
},
{
"name": "Raw Umber",
"hex": "#826644"
},
{
"name": "Razzle Dazzle Rose",
"hex": "#FF33CC"
},
{
"name": "Razzmatazz",
"hex": "#E3256B"
},
{
"name": "Razzmic Berry",
"hex": "#8D4E85"
},
{
"name": "Rebecca Purple",
"hex": "#663399"
},
{
"name": "Red",
"hex": "#FF0000"
},
{
"name": "Red (Crayola)",
"hex": "#EE204D"
},
{
"name": "Red (Munsell)",
"hex": "#F2003C"
},
{
"name": "Red (NCS)",
"hex": "#C40233"
},
{
"name": "Red (Pantone)",
"hex": "#ED2939"
},
{
"name": "Red (Pigment)",
"hex": "#ED1C24"
},
{
"name": "Red (RYB)",
"hex": "#FE2712"
},
{
"name": "Red-Brown",
"hex": "#A52A2A"
},
{
"name": "Red Devil",
"hex": "#860111"
},
{
"name": "Red-Orange",
"hex": "#FF5349"
},
{
"name": "Red-Purple",
"hex": "#E40078"
},
{
"name": "Red Salsa",
"hex": "#FD3A4A"
},
{
"name": "Red-Violet",
"hex": "#C71585"
},
{
"name": "Redwood",
"hex": "#A45A52"
},
{
"name": "Regalia",
"hex": "#522D80"
},
{
"name": "Registration Black",
"hex": "#000000"
},
{
"name": "Resolution Blue",
"hex": "#002387"
},
{
"name": "Rhythm",
"hex": "#777696"
},
{
"name": "Rich Black",
"hex": "#004040"
},
{
"name": "Rich Black (FOGRA29)",
"hex": "#010B13"
},
{
"name": "Rich Black (FOGRA39)",
"hex": "#010203"
},
{
"name": "Rich Brilliant Lavender",
"hex": "#F1A7FE"
},
{
"name": "Rich Carmine",
"hex": "#D70040"
},
{
"name": "Rich Electric Blue",
"hex": "#0892D0"
},
{
"name": "Rich Lavender",
"hex": "#A76BCF"
},
{
"name": "Rich Lilac",
"hex": "#B666D2"
},
{
"name": "Rich Maroon",
"hex": "#B03060"
},
{
"name": "Rifle Green",
"hex": "#444C38"
},
{
"name": "Roast Coffee",
"hex": "#704241"
},
{
"name": "Robin Egg Blue",
"hex": "#00CCCC"
},
{
"name": "Rocket Metallic",
"hex": "#8A7F80"
},
{
"name": "Roman Silver",
"hex": "#838996"
},
{
"name": "Rose",
"hex": "#FF007F"
},
{
"name": "Rose Bonbon",
"hex": "#F9429E"
},
{
"name": "Rose Dust",
"hex": "#9E5E6F"
},
{
"name": "Rose Ebony",
"hex": "#674846"
},
{
"name": "Rose Gold",
"hex": "#B76E79"
},
{
"name": "Rose Madder",
"hex": "#E32636"
},
{
"name": "Rose Pink",
"hex": "#FF66CC"
},
{
"name": "Rose Quartz",
"hex": "#AA98A9"
},
{
"name": "Rose Red",
"hex": "#C21E56"
},
{
"name": "Rose Taupe",
"hex": "#905D5D"
},
{
"name": "Rose Vale",
"hex": "#AB4E52"
},
{
"name": "Rosewood",
"hex": "#65000B"
},
{
"name": "Rosso Corsa",
"hex": "#D40000"
},
{
"name": "Rosy Brown",
"hex": "#BC8F8F"
},
{
"name": "Royal Azure",
"hex": "#0038A8"
},
{
"name": "Royal Blue",
"hex": "#002366"
},
{
"name": "Royal Blue",
"hex": "#4169E1"
},
{
"name": "Royal Fuchsia",
"hex": "#CA2C92"
},
{
"name": "Royal Purple",
"hex": "#7851A9"
},
{
"name": "Royal Yellow",
"hex": "#FADA5E"
},
{
"name": "Ruber",
"hex": "#CE4676"
},
{
"name": "Rubine Red",
"hex": "#D10056"
},
{
"name": "Ruby",
"hex": "#E0115F"
},
{
"name": "Ruby Red",
"hex": "#9B111E"
},
{
"name": "Ruddy",
"hex": "#FF0028"
},
{
"name": "Ruddy Brown",
"hex": "#BB6528"
},
{
"name": "Ruddy Pink",
"hex": "#E18E96"
},
{
"name": "Rufous",
"hex": "#A81C07"
},
{
"name": "Russet",
"hex": "#80461B"
},
{
"name": "Russian Green",
"hex": "#679267"
},
{
"name": "Russian Violet",
"hex": "#32174D"
},
{
"name": "Rust",
"hex": "#B7410E"
},
{
"name": "Rusty Red",
"hex": "#DA2C43"
},
{
"name": "Sacramento State Green",
"hex": "#00563F"
},
{
"name": "Saddle Brown",
"hex": "#8B4513"
},
{
"name": "Safety Orange",
"hex": "#FF7800"
},
{
"name": "Safety Orange (Blaze Orange)",
"hex": "#FF6700"
},
{
"name": "Safety Yellow",
"hex": "#EED202"
},
{
"name": "Saffron",
"hex": "#F4C430"
},
{
"name": "Sage",
"hex": "#BCB88A"
},
{
"name": "St. Patrick's Blue",
"hex": "#23297A"
},
{
"name": "Salmon",
"hex": "#FA8072"
},
{
"name": "Salmon Pink",
"hex": "#FF91A4"
},
{
"name": "Sand",
"hex": "#C2B280"
},
{
"name": "Sand Dune",
"hex": "#967117"
},
{
"name": "Sandstorm",
"hex": "#ECD540"
},
{
"name": "Sandy Brown",
"hex": "#F4A460"
},
{
"name": "Sandy Tan",
"hex": "#FDD9B5"
},
{
"name": "Sandy Taupe",
"hex": "#967117"
},
{
"name": "Sangria",
"hex": "#92000A"
},
{
"name": "Sap Green",
"hex": "#507D2A"
},
{
"name": "Sapphire",
"hex": "#0F52BA"
},
{
"name": "Sapphire Blue",
"hex": "#0067A5"
},
{
"name": "Sasquatch Socks",
"hex": "#FF4681"
},
{
"name": "Satin Sheen Gold",
"hex": "#CBA135"
},
{
"name": "Scarlet",
"hex": "#FF2400"
},
{
"name": "Scarlet",
"hex": "#FD0E35"
},
{
"name": "Schauss Pink",
"hex": "#FF91AF"
},
{
"name": "School Bus Yellow",
"hex": "#FFD800"
},
{
"name": "Screamin' Green",
"hex": "#66FF66"
},
{
"name": "Sea Blue",
"hex": "#006994"
},
{
"name": "Sea Foam Green",
"hex": "#9FE2BF"
},
{
"name": "Sea Green",
"hex": "#2E8B57"
},
{
"name": "Sea Serpent",
"hex": "#4BC7CF"
},
{
"name": "Seal Brown",
"hex": "#59260B"
},
{
"name": "Seashell",
"hex": "#FFF5EE"
},
{
"name": "Selective Yellow",
"hex": "#FFBA00"
},
{
"name": "Sepia",
"hex": "#704214"
},
{
"name": "Shadow",
"hex": "#8A795D"
},
{
"name": "Shadow Blue",
"hex": "#778BA5"
},
{
"name": "Shampoo",
"hex": "#FFCFF1"
},
{
"name": "Shamrock Green",
"hex": "#009E60"
},
{
"name": "Sheen Green",
"hex": "#8FD400"
},
{
"name": "Shimmering Blush",
"hex": "#D98695"
},
{
"name": "Shiny Shamrock",
"hex": "#5FA778"
},
{
"name": "Shocking Pink",
"hex": "#FC0FC0"
},
{
"name": "Shocking Pink (Crayola)",
"hex": "#FF6FFF"
},
{
"name": "Sienna",
"hex": "#882D17"
},
{
"name": "Silver",
"hex": "#C0C0C0"
},
{
"name": "Silver Chalice",
"hex": "#ACACAC"
},
{
"name": "Silver Lake Blue",
"hex": "#5D89BA"
},
{
"name": "Silver Pink",
"hex": "#C4AEAD"
},
{
"name": "Silver Sand",
"hex": "#BFC1C2"
},
{
"name": "Sinopia",
"hex": "#CB410B"
},
{
"name": "Sizzling Red",
"hex": "#FF3855"
},
{
"name": "Sizzling Sunrise",
"hex": "#FFDB00"
},
{
"name": "Skobeloff",
"hex": "#007474"
},
{
"name": "Sky Blue",
"hex": "#87CEEB"
},
{
"name": "Sky Magenta",
"hex": "#CF71AF"
},
{
"name": "Slate Blue",
"hex": "#6A5ACD"
},
{
"name": "Slate Gray",
"hex": "#708090"
},
{
"name": "Smalt (Dark Powder Blue)",
"hex": "#003399"
},
{
"name": "Slimy Green",
"hex": "#299617"
},
{
"name": "Smashed Pumpkin",
"hex": "#FF6D3A"
},
{
"name": "Smitten",
"hex": "#C84186"
},
{
"name": "Smoke",
"hex": "#738276"
},
{
"name": "Smokey Topaz",
"hex": "#832A0D"
},
{
"name": "Smoky Black",
"hex": "#100C08"
},
{
"name": "Smoky Topaz",
"hex": "#933D41"
},
{
"name": "Snow",
"hex": "#FFFAFA"
},
{
"name": "Soap",
"hex": "#CEC8EF"
},
{
"name": "Solid Pink",
"hex": "#893843"
},
{
"name": "Sonic Silver",
"hex": "#757575"
},
{
"name": "Spartan Crimson",
"hex": "#9E1316"
},
{
"name": "Space Cadet",
"hex": "#1D2951"
},
{
"name": "Spanish Bistre",
"hex": "#807532"
},
{
"name": "Spanish Blue",
"hex": "#0070B8"
},
{
"name": "Spanish Carmine",
"hex": "#D10047"
},
{
"name": "Spanish Crimson",
"hex": "#E51A4C"
},
{
"name": "Spanish Gray",
"hex": "#989898"
},
{
"name": "Spanish Green",
"hex": "#009150"
},
{
"name": "Spanish Orange",
"hex": "#E86100"
},
{
"name": "Spanish Pink",
"hex": "#F7BFBE"
},
{
"name": "Spanish Red",
"hex": "#E60026"
},
{
"name": "Spanish Sky Blue",
"hex": "#00FFFF"
},
{
"name": "Spanish Violet",
"hex": "#4C2882"
},
{
"name": "Spanish Viridian",
"hex": "#007F5C"
},
{
"name": "Spicy Mix",
"hex": "#8B5f4D"
},
{
"name": "Spiro Disco Ball",
"hex": "#0FC0FC"
},
{
"name": "Spring Bud",
"hex": "#A7FC00"
},
{
"name": "Spring Frost",
"hex": "#87FF2A"
},
{
"name": "Spring Green",
"hex": "#00FF7F"
},
{
"name": "Star Command Blue",
"hex": "#007BB8"
},
{
"name": "Steel Blue",
"hex": "#4682B4"
},
{
"name": "Steel Pink",
"hex": "#CC33CC"
},
{
"name": "Steel Teal",
"hex": "#5F8A8B"
},
{
"name": "Stil De Grain Yellow",
"hex": "#FADA5E"
},
{
"name": "Stizza",
"hex": "#990000"
},
{
"name": "Stormcloud",
"hex": "#4F666A"
},
{
"name": "Straw",
"hex": "#E4D96F"
},
{
"name": "Strawberry",
"hex": "#FC5A8D"
},
{
"name": "Sugar Plum",
"hex": "#914E75"
},
{
"name": "Sunburnt Cyclops",
"hex": "#FF404C"
},
{
"name": "Sunglow",
"hex": "#FFCC33"
},
{
"name": "Sunny",
"hex": "#F2F27A"
},
{
"name": "Sunray",
"hex": "#E3AB57"
},
{
"name": "Sunset",
"hex": "#FAD6A5"
},
{
"name": "Sunset Orange",
"hex": "#FD5E53"
},
{
"name": "Super Pink",
"hex": "#CF6BA9"
},
{
"name": "Sweet Brown",
"hex": "#A83731"
},
{
"name": "Tan",
"hex": "#D2B48C"
},
{
"name": "Tangelo",
"hex": "#F94D00"
},
{
"name": "Tangerine",
"hex": "#F28500"
},
{
"name": "Tangerine Yellow",
"hex": "#FFCC00"
},
{
"name": "Tango Pink",
"hex": "#E4717A"
},
{
"name": "Tart Orange",
"hex": "#FB4D46"
},
{
"name": "Taupe",
"hex": "#483C32"
},
{
"name": "Taupe Gray",
"hex": "#8B8589"
},
{
"name": "Tea Green",
"hex": "#D0F0C0"
},
{
"name": "Tea Rose",
"hex": "#F88379"
},
{
"name": "Tea Rose",
"hex": "#F4C2C2"
},
{
"name": "Teal",
"hex": "#008080"
},
{
"name": "Teal Blue",
"hex": "#367588"
},
{
"name": "Teal Deer",
"hex": "#99E6B3"
},
{
"name": "Teal Green",
"hex": "#00827F"
},
{
"name": "Telemagenta",
"hex": "#CF3476"
},
{
"name": "Tenne (Tawny)",
"hex": "#CD5700"
},
{
"name": "Terra Cotta",
"hex": "#E2725B"
},
{
"name": "Thistle",
"hex": "#D8BFD8"
},
{
"name": "Thulian Pink",
"hex": "#DE6FA1"
},
{
"name": "Tickle Me Pink",
"hex": "#FC89AC"
},
{
"name": "Tiffany Blue",
"hex": "#0ABAB5"
},
{
"name": "Tiger's Eye",
"hex": "#E08D3C"
},
{
"name": "Timberwolf",
"hex": "#DBD7D2"
},
{
"name": "Titanium Yellow",
"hex": "#EEE600"
},
{
"name": "Tomato",
"hex": "#FF6347"
},
{
"name": "Toolbox",
"hex": "#746CC0"
},
{
"name": "Topaz",
"hex": "#FFC87C"
},
{
"name": "Tractor Red",
"hex": "#FD0E35"
},
{
"name": "Trolley Grey",
"hex": "#808080"
},
{
"name": "Tropical Rain Forest",
"hex": "#00755E"
},
{
"name": "Tropical Violet",
"hex": "#CDA4DE"
},
{
"name": "True Blue",
"hex": "#0073CF"
},
{
"name": "Tufts Blue",
"hex": "#3E8EDE"
},
{
"name": "Tulip",
"hex": "#FF878D"
},
{
"name": "Tumbleweed",
"hex": "#DEAA88"
},
{
"name": "Turkish Rose",
"hex": "#B57281"
},
{
"name": "Turquoise",
"hex": "#40E0D0"
},
{
"name": "Turquoise Blue",
"hex": "#00FFEF"
},
{
"name": "Turquoise Green",
"hex": "#A0D6B4"
},
{
"name": "Turquoise Surf",
"hex": "#00C5CD"
},
{
"name": "Turtle Green",
"hex": "#8A9A5B"
},
{
"name": "Tuscan",
"hex": "#FAD6A5"
},
{
"name": "Tuscan Brown",
"hex": "#6F4E37"
},
{
"name": "Tuscan Red",
"hex": "#7C4848"
},
{
"name": "Tuscan Tan",
"hex": "#A67B5B"
},
{
"name": "Tuscany",
"hex": "#C09999"
},
{
"name": "Twilight Lavender",
"hex": "#8A496B"
},
{
"name": "Tyrian Purple",
"hex": "#66023C"
},
{
"name": "UA Blue",
"hex": "#0033AA"
},
{
"name": "UA Red",
"hex": "#D9004C"
},
{
"name": "Ube",
"hex": "#8878C3"
},
{
"name": "UCLA Blue",
"hex": "#536895"
},
{
"name": "UCLA Gold",
"hex": "#FFB300"
},
{
"name": "UFO Green",
"hex": "#3CD070"
},
{
"name": "Ultramarine",
"hex": "#3F00FF"
},
{
"name": "Ultramarine Blue",
"hex": "#4166F5"
},
{
"name": "Ultra Pink",
"hex": "#FF6FFF"
},
{
"name": "Ultra Red",
"hex": "#FC6C85"
},
{
"name": "Umber",
"hex": "#635147"
},
{
"name": "Unbleached Silk",
"hex": "#FFDDCA"
},
{
"name": "United Nations Blue",
"hex": "#5B92E5"
},
{
"name": "University Of California Gold",
"hex": "#B78727"
},
{
"name": "Unmellow Yellow",
"hex": "#FFFF66"
},
{
"name": "UP Forest Green",
"hex": "#014421"
},
{
"name": "UP Maroon",
"hex": "#7B1113"
},
{
"name": "Upsdell Red",
"hex": "#AE2029"
},
{
"name": "Urobilin",
"hex": "#E1AD21"
},
{
"name": "USAFA Blue",
"hex": "#004F98"
},
{
"name": "USC Cardinal",
"hex": "#990000"
},
{
"name": "USC Gold",
"hex": "#FFCC00"
},
{
"name": "University Of Tennessee Orange",
"hex": "#F77F00"
},
{
"name": "Utah Crimson",
"hex": "#D3003F"
},
{
"name": "Van Dyke Brown",
"hex": "#664228"
},
{
"name": "Vanilla",
"hex": "#F3E5AB"
},
{
"name": "Vanilla Ice",
"hex": "#F38FA9"
},
{
"name": "Vegas Gold",
"hex": "#C5B358"
},
{
"name": "Venetian Red",
"hex": "#C80815"
},
{
"name": "Verdigris",
"hex": "#43B3AE"
},
{
"name": "Vermilion",
"hex": "#E34234"
},
{
"name": "Vermilion",
"hex": "#D9381E"
},
{
"name": "Veronica",
"hex": "#A020F0"
},
{
"name": "Very Light Azure",
"hex": "#74BBFB"
},
{
"name": "Very Light Blue",
"hex": "#6666FF"
},
{
"name": "Very Light Malachite Green",
"hex": "#64E986"
},
{
"name": "Very Light Tangelo",
"hex": "#FFB077"
},
{
"name": "Very Pale Orange",
"hex": "#FFDFBF"
},
{
"name": "Very Pale Yellow",
"hex": "#FFFFBF"
},
{
"name": "Violet",
"hex": "#8F00FF"
},
{
"name": "Violet (Color Wheel)",
"hex": "#7F00FF"
},
{
"name": "Violet (RYB)",
"hex": "#8601AF"
},
{
"name": "Violet (Web)",
"hex": "#EE82EE"
},
{
"name": "Violet-Blue",
"hex": "#324AB2"
},
{
"name": "Violet-Red",
"hex": "#F75394"
},
{
"name": "Viridian",
"hex": "#40826D"
},
{
"name": "Viridian Green",
"hex": "#009698"
},
{
"name": "Vista Blue",
"hex": "#7C9ED9"
},
{
"name": "Vivid Amber",
"hex": "#CC9900"
},
{
"name": "Vivid Auburn",
"hex": "#922724"
},
{
"name": "Vivid Burgundy",
"hex": "#9F1D35"
},
{
"name": "Vivid Cerise",
"hex": "#DA1D81"
},
{
"name": "Vivid Cerulean",
"hex": "#00AAEE"
},
{
"name": "Vivid Crimson",
"hex": "#CC0033"
},
{
"name": "Vivid Gamboge",
"hex": "#FF9900"
},
{
"name": "Vivid Lime Green",
"hex": "#A6D608"
},
{
"name": "Vivid Malachite",
"hex": "#00CC33"
},
{
"name": "Vivid Mulberry",
"hex": "#B80CE3"
},
{
"name": "Vivid Orange",
"hex": "#FF5F00"
},
{
"name": "Vivid Orange Peel",
"hex": "#FFA000"
},
{
"name": "Vivid Orchid",
"hex": "#CC00FF"
},
{
"name": "Vivid Raspberry",
"hex": "#FF006C"
},
{
"name": "Vivid Red",
"hex": "#F70D1A"
},
{
"name": "Vivid Red-Tangelo",
"hex": "#DF6124"
},
{
"name": "Vivid Sky Blue",
"hex": "#00CCFF"
},
{
"name": "Vivid Tangelo",
"hex": "#F07427"
},
{
"name": "Vivid Tangerine",
"hex": "#FFA089"
},
{
"name": "Vivid Vermilion",
"hex": "#E56024"
},
{
"name": "Vivid Violet",
"hex": "#9F00FF"
},
{
"name": "Vivid Yellow",
"hex": "#FFE302"
},
{
"name": "Volt",
"hex": "#CEFF00"
},
{
"name": "Wageningen Green",
"hex": "#34B233"
},
{
"name": "Warm Black",
"hex": "#004242"
},
{
"name": "Waterspout",
"hex": "#A4F4F9"
},
{
"name": "Weldon Blue",
"hex": "#7C98AB"
},
{
"name": "Wenge",
"hex": "#645452"
},
{
"name": "Wheat",
"hex": "#F5DEB3"
},
{
"name": "White",
"hex": "#FFFFFF"
},
{
"name": "White Smoke",
"hex": "#F5F5F5"
},
{
"name": "Wild Blue Yonder",
"hex": "#A2ADD0"
},
{
"name": "Wild Orchid",
"hex": "#D470A2"
},
{
"name": "Wild Strawberry",
"hex": "#FF43A4"
},
{
"name": "Wild Watermelon",
"hex": "#FC6C85"
},
{
"name": "Willpower Orange",
"hex": "#FD5800"
},
{
"name": "Windsor Tan",
"hex": "#A75502"
},
{
"name": "Wine",
"hex": "#722F37"
},
{
"name": "Wine Dregs",
"hex": "#673147"
},
{
"name": "Winter Sky",
"hex": "#FF007C"
},
{
"name": "Winter Wizard",
"hex": "#A0E6FF"
},
{
"name": "Wintergreen Dream",
"hex": "#56887D"
},
{
"name": "Wisteria",
"hex": "#C9A0DC"
},
{
"name": "Wood Brown",
"hex": "#C19A6B"
},
{
"name": "Xanadu",
"hex": "#738678"
},
{
"name": "Yale Blue",
"hex": "#0F4D92"
},
{
"name": "Yankees Blue",
"hex": "#1C2841"
},
{
"name": "Yellow",
"hex": "#FFFF00"
},
{
"name": "Yellow (Crayola)",
"hex": "#FCE883"
},
{
"name": "Yellow (Munsell)",
"hex": "#EFCC00"
},
{
"name": "Yellow (NCS)",
"hex": "#FFD300"
},
{
"name": "Yellow (Pantone)",
"hex": "#FEDF00"
},
{
"name": "Yellow (Process)",
"hex": "#FFEF00"
},
{
"name": "Yellow (RYB)",
"hex": "#FEFE33"
},
{
"name": "Yellow-Green",
"hex": "#9ACD32"
},
{
"name": "Yellow Orange",
"hex": "#FFAE42"
},
{
"name": "Yellow Rose",
"hex": "#FFF000"
},
{
"name": "Yellow Sunshine",
"hex": "#FFF700"
},
{
"name": "Zaffre",
"hex": "#0014A8"
},
{
"name": "Zinnwaldite Brown",
"hex": "#2C1608"
},
{
"name": "Zomp",
"hex": "#39A78E"
}
]`
|
2302_79757062/crawlab
|
core/data/colors.go
|
Go
|
bsd-3-clause
| 75,246
|