github.com/weplanx/server@v0.2.6-0.20240318110640-f7e75155779a/bootstrap/wire_gen.go (about)

     1  // Code generated by Wire. DO NOT EDIT.
     2  
     3  //go:generate go run -mod=mod github.com/google/wire/cmd/wire
     4  //go:build !wireinject
     5  // +build !wireinject
     6  
     7  package bootstrap
     8  
     9  import (
    10  	"github.com/weplanx/go/rest"
    11  	"github.com/weplanx/go/sessions"
    12  	"github.com/weplanx/go/values"
    13  	"github.com/weplanx/server/api"
    14  	"github.com/weplanx/server/api/acc_tasks"
    15  	"github.com/weplanx/server/api/builders"
    16  	"github.com/weplanx/server/api/clusters"
    17  	"github.com/weplanx/server/api/datasets"
    18  	"github.com/weplanx/server/api/endpoints"
    19  	"github.com/weplanx/server/api/imessages"
    20  	"github.com/weplanx/server/api/index"
    21  	"github.com/weplanx/server/api/lark"
    22  	"github.com/weplanx/server/api/monitor"
    23  	"github.com/weplanx/server/api/projects"
    24  	"github.com/weplanx/server/api/queues"
    25  	"github.com/weplanx/server/api/tencent"
    26  	"github.com/weplanx/server/api/workflows"
    27  	"github.com/weplanx/server/common"
    28  	"github.com/weplanx/server/openapi"
    29  	index3 "github.com/weplanx/server/openapi/index"
    30  	"github.com/weplanx/server/xapi"
    31  	"github.com/weplanx/server/xapi/emqx"
    32  	index2 "github.com/weplanx/server/xapi/index"
    33  )
    34  
    35  // Injectors from wire.go:
    36  
    37  func NewAPI(values2 *common.Values) (*api.API, error) {
    38  	client, err := UseMongoDB(values2)
    39  	if err != nil {
    40  		return nil, err
    41  	}
    42  	database := UseDatabase(values2, client)
    43  	redisClient, err := UseRedis(values2)
    44  	if err != nil {
    45  		return nil, err
    46  	}
    47  	conn, err := UseNats(values2)
    48  	if err != nil {
    49  		return nil, err
    50  	}
    51  	jetStreamContext, err := UseJetStream(conn)
    52  	if err != nil {
    53  		return nil, err
    54  	}
    55  	keyValue, err := UseKeyValue(values2, jetStreamContext)
    56  	if err != nil {
    57  		return nil, err
    58  	}
    59  	cipher, err := UseCipher(values2)
    60  	if err != nil {
    61  		return nil, err
    62  	}
    63  	captcha := UseCaptcha(redisClient)
    64  	locker := UseLocker(redisClient)
    65  	clientClient, err := UseTransfer(jetStreamContext)
    66  	if err != nil {
    67  		return nil, err
    68  	}
    69  	inject := &common.Inject{
    70  		V:         values2,
    71  		Mgo:       client,
    72  		Db:        database,
    73  		RDb:       redisClient,
    74  		Nats:      conn,
    75  		JetStream: jetStreamContext,
    76  		KeyValue:  keyValue,
    77  		Cipher:    cipher,
    78  		Captcha:   captcha,
    79  		Locker:    locker,
    80  		Transfer:  clientClient,
    81  	}
    82  	hertz, err := UseHertz(values2)
    83  	if err != nil {
    84  		return nil, err
    85  	}
    86  	csrf := UseCsrf(values2)
    87  	service := UseValues(keyValue, cipher)
    88  	controller := &values.Controller{
    89  		Service: service,
    90  	}
    91  	sessionsService := UseSessions(values2, redisClient)
    92  	sessionsController := &sessions.Controller{
    93  		Service: sessionsService,
    94  	}
    95  	restService := UseRest(values2, client, database, redisClient, jetStreamContext, keyValue, cipher)
    96  	restController := &rest.Controller{
    97  		Service: restService,
    98  	}
    99  	passport := UseAPIPassport(values2)
   100  	tencentService := &tencent.Service{
   101  		Inject: inject,
   102  	}
   103  	indexService := &index.Service{
   104  		Inject:   inject,
   105  		Sessions: sessionsService,
   106  		Passport: passport,
   107  		TencentX: tencentService,
   108  	}
   109  	indexController := &index.Controller{
   110  		V:      values2,
   111  		Csrf:   csrf,
   112  		IndexX: indexService,
   113  	}
   114  	tencentController := &tencent.Controller{
   115  		TencentX: tencentService,
   116  	}
   117  	larkService := &lark.Service{
   118  		Inject:   inject,
   119  		Sessions: sessionsService,
   120  		Locker:   locker,
   121  		Passport: passport,
   122  		IndexX:   indexService,
   123  	}
   124  	larkController := &lark.Controller{
   125  		V:        values2,
   126  		Passport: passport,
   127  		LarkX:    larkService,
   128  		IndexX:   indexService,
   129  	}
   130  	clustersService := &clusters.Service{
   131  		Inject: inject,
   132  	}
   133  	projectsService := &projects.Service{
   134  		Inject:    inject,
   135  		ClustersX: clustersService,
   136  	}
   137  	projectsController := &projects.Controller{
   138  		ProjectsX: projectsService,
   139  	}
   140  	clustersController := &clusters.Controller{
   141  		ClustersX: clustersService,
   142  	}
   143  	endpointsService := &endpoints.Service{
   144  		Inject: inject,
   145  	}
   146  	endpointsController := &endpoints.Controller{
   147  		EndpointsX: endpointsService,
   148  	}
   149  	workflowsService := &workflows.Service{
   150  		Inject:     inject,
   151  		EndpointsX: endpointsService,
   152  	}
   153  	workflowsController := &workflows.Controller{
   154  		WorkflowsX: workflowsService,
   155  	}
   156  	queuesService := &queues.Service{
   157  		Inject:    inject,
   158  		ProjectsX: projectsService,
   159  	}
   160  	queuesController := &queues.Controller{
   161  		QueuesX: queuesService,
   162  	}
   163  	imessagesService := &imessages.Service{
   164  		Inject: inject,
   165  	}
   166  	imessagesController := &imessages.Controller{
   167  		ImessagesX: imessagesService,
   168  	}
   169  	acc_tasksService := &acc_tasks.Service{
   170  		Inject:   inject,
   171  		TencentX: tencentService,
   172  	}
   173  	acc_tasksController := &acc_tasks.Controller{
   174  		AccTasksX: acc_tasksService,
   175  	}
   176  	datasetsService := &datasets.Service{
   177  		Inject: inject,
   178  		Values: service,
   179  	}
   180  	datasetsController := &datasets.Controller{
   181  		DatasetsX: datasetsService,
   182  	}
   183  	influxdb2Client := UseInflux(values2)
   184  	monitorService := &monitor.Service{
   185  		Inject: inject,
   186  		Flux:   influxdb2Client,
   187  	}
   188  	monitorController := &monitor.Controller{
   189  		MonitorX: monitorService,
   190  	}
   191  	buildersService := &builders.Service{
   192  		Inject: inject,
   193  	}
   194  	buildersController := &builders.Controller{
   195  		BuildersX: buildersService,
   196  	}
   197  	apiAPI := &api.API{
   198  		Inject:     inject,
   199  		Hertz:      hertz,
   200  		Csrf:       csrf,
   201  		Values:     controller,
   202  		Sessions:   sessionsController,
   203  		Rest:       restController,
   204  		Index:      indexController,
   205  		IndexX:     indexService,
   206  		Tencent:    tencentController,
   207  		TencentX:   tencentService,
   208  		Lark:       larkController,
   209  		LarkX:      larkService,
   210  		Projects:   projectsController,
   211  		ProjectsX:  projectsService,
   212  		Clusters:   clustersController,
   213  		ClustersX:  clustersService,
   214  		Endpoints:  endpointsController,
   215  		EndpointsX: endpointsService,
   216  		Workflows:  workflowsController,
   217  		WorkflowsX: workflowsService,
   218  		Queues:     queuesController,
   219  		QueuesX:    queuesService,
   220  		Imessages:  imessagesController,
   221  		ImessagesX: imessagesService,
   222  		AccTasks:   acc_tasksController,
   223  		AccTasksX:  acc_tasksService,
   224  		Datasets:   datasetsController,
   225  		DatasetsX:  datasetsService,
   226  		Monitor:    monitorController,
   227  		MonitorX:   monitorService,
   228  		Builders:   buildersController,
   229  		BuildersX:  buildersService,
   230  	}
   231  	return apiAPI, nil
   232  }
   233  
   234  func NewXAPI(values2 *common.Values) (*xapi.API, error) {
   235  	client, err := UseMongoDB(values2)
   236  	if err != nil {
   237  		return nil, err
   238  	}
   239  	database := UseDatabase(values2, client)
   240  	redisClient, err := UseRedis(values2)
   241  	if err != nil {
   242  		return nil, err
   243  	}
   244  	conn, err := UseNats(values2)
   245  	if err != nil {
   246  		return nil, err
   247  	}
   248  	jetStreamContext, err := UseJetStream(conn)
   249  	if err != nil {
   250  		return nil, err
   251  	}
   252  	keyValue, err := UseKeyValue(values2, jetStreamContext)
   253  	if err != nil {
   254  		return nil, err
   255  	}
   256  	cipher, err := UseCipher(values2)
   257  	if err != nil {
   258  		return nil, err
   259  	}
   260  	captcha := UseCaptcha(redisClient)
   261  	locker := UseLocker(redisClient)
   262  	clientClient, err := UseTransfer(jetStreamContext)
   263  	if err != nil {
   264  		return nil, err
   265  	}
   266  	inject := &common.Inject{
   267  		V:         values2,
   268  		Mgo:       client,
   269  		Db:        database,
   270  		RDb:       redisClient,
   271  		Nats:      conn,
   272  		JetStream: jetStreamContext,
   273  		KeyValue:  keyValue,
   274  		Cipher:    cipher,
   275  		Captcha:   captcha,
   276  		Locker:    locker,
   277  		Transfer:  clientClient,
   278  	}
   279  	hertz, err := UseHertz(values2)
   280  	if err != nil {
   281  		return nil, err
   282  	}
   283  	service := &index2.Service{
   284  		Inject: inject,
   285  	}
   286  	controller := &index2.Controller{
   287  		IndexService: service,
   288  	}
   289  	emqxService := &emqx.Service{
   290  		Inject: inject,
   291  	}
   292  	emqxController := &emqx.Controller{
   293  		EmqxService: emqxService,
   294  	}
   295  	xapiAPI := &xapi.API{
   296  		Inject:       inject,
   297  		Hertz:        hertz,
   298  		Index:        controller,
   299  		IndexService: service,
   300  		Emqx:         emqxController,
   301  		EmqxService:  emqxService,
   302  	}
   303  	return xapiAPI, nil
   304  }
   305  
   306  func NewOpenAPI(values2 *common.Values) (*openapi.API, error) {
   307  	client, err := UseMongoDB(values2)
   308  	if err != nil {
   309  		return nil, err
   310  	}
   311  	database := UseDatabase(values2, client)
   312  	redisClient, err := UseRedis(values2)
   313  	if err != nil {
   314  		return nil, err
   315  	}
   316  	conn, err := UseNats(values2)
   317  	if err != nil {
   318  		return nil, err
   319  	}
   320  	jetStreamContext, err := UseJetStream(conn)
   321  	if err != nil {
   322  		return nil, err
   323  	}
   324  	keyValue, err := UseKeyValue(values2, jetStreamContext)
   325  	if err != nil {
   326  		return nil, err
   327  	}
   328  	cipher, err := UseCipher(values2)
   329  	if err != nil {
   330  		return nil, err
   331  	}
   332  	captcha := UseCaptcha(redisClient)
   333  	locker := UseLocker(redisClient)
   334  	clientClient, err := UseTransfer(jetStreamContext)
   335  	if err != nil {
   336  		return nil, err
   337  	}
   338  	inject := &common.Inject{
   339  		V:         values2,
   340  		Mgo:       client,
   341  		Db:        database,
   342  		RDb:       redisClient,
   343  		Nats:      conn,
   344  		JetStream: jetStreamContext,
   345  		KeyValue:  keyValue,
   346  		Cipher:    cipher,
   347  		Captcha:   captcha,
   348  		Locker:    locker,
   349  		Transfer:  clientClient,
   350  	}
   351  	hertz, err := UseHertz(values2)
   352  	if err != nil {
   353  		return nil, err
   354  	}
   355  	service := &index3.Service{
   356  		Inject: inject,
   357  	}
   358  	controller := &index3.Controller{
   359  		IndexService: service,
   360  	}
   361  	openapiAPI := &openapi.API{
   362  		Inject:       inject,
   363  		Hertz:        hertz,
   364  		Index:        controller,
   365  		IndexService: service,
   366  	}
   367  	return openapiAPI, nil
   368  }