github.com/sacloud/iaas-api-go@v1.12.0/internal/define/mobile_gateway.go (about)

     1  // Copyright 2022-2023 The sacloud/iaas-api-go Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //      http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package define
    16  
    17  import (
    18  	"net/http"
    19  
    20  	"github.com/sacloud/iaas-api-go/internal/define/names"
    21  	"github.com/sacloud/iaas-api-go/internal/define/ops"
    22  	"github.com/sacloud/iaas-api-go/internal/dsl"
    23  	"github.com/sacloud/iaas-api-go/internal/dsl/meta"
    24  	"github.com/sacloud/iaas-api-go/naked"
    25  )
    26  
    27  const (
    28  	mobileGatewayAPIName     = "MobileGateway"
    29  	mobileGatewayAPIPathName = "appliance"
    30  )
    31  
    32  var mobileGatewayAPI = &dsl.Resource{
    33  	Name:       mobileGatewayAPIName,
    34  	PathName:   mobileGatewayAPIPathName,
    35  	PathSuffix: dsl.CloudAPISuffix,
    36  	Operations: dsl.Operations{
    37  		// find
    38  		ops.FindAppliance(mobileGatewayAPIName, mobileGatewayNakedType, findParameter, mobileGatewayView),
    39  
    40  		// create
    41  		ops.CreateAppliance(mobileGatewayAPIName, mobileGatewayNakedType, mobileGatewayCreateParam, mobileGatewayView),
    42  
    43  		// read
    44  		ops.ReadAppliance(mobileGatewayAPIName, mobileGatewayNakedType, mobileGatewayView),
    45  
    46  		// update
    47  		ops.UpdateAppliance(mobileGatewayAPIName, mobileGatewayNakedType, mobileGatewayUpdateParam, mobileGatewayView),
    48  		// updateSettings
    49  		ops.UpdateApplianceSettings(mobileGatewayAPIName, mobileGatewayUpdateSettingsNakedType, mobileGatewayUpdateSettingsParam, mobileGatewayView),
    50  
    51  		// delete
    52  		ops.Delete(mobileGatewayAPIName),
    53  
    54  		// config
    55  		ops.Config(mobileGatewayAPIName),
    56  
    57  		// power management(boot/shutdown/reset)
    58  		ops.Boot(mobileGatewayAPIName),
    59  		ops.Shutdown(mobileGatewayAPIName),
    60  		ops.Reset(mobileGatewayAPIName),
    61  
    62  		// connect to switch
    63  		ops.WithIDAction(
    64  			mobileGatewayAPIName, "ConnectToSwitch", http.MethodPut, "interface/1/to/switch/{{.switchID}}",
    65  			&dsl.Argument{
    66  				Name: "switchID",
    67  				Type: meta.TypeID,
    68  			},
    69  		),
    70  
    71  		// disconnect from switch
    72  		ops.WithIDAction(
    73  			mobileGatewayAPIName, "DisconnectFromSwitch", http.MethodDelete, "interface/1/to/switch",
    74  		),
    75  
    76  		// DNS
    77  		{
    78  			ResourceName: mobileGatewayAPIName,
    79  			Name:         "GetDNS",
    80  			PathFormat:   dsl.IDAndSuffixPathFormat("mobilegateway/dnsresolver"),
    81  			Method:       http.MethodGet,
    82  			Arguments: dsl.Arguments{
    83  				dsl.ArgumentID,
    84  			},
    85  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
    86  				Name: "SIMGroup",
    87  				Type: meta.Static(naked.MobileGatewaySIMGroup{}),
    88  				Tags: &dsl.FieldTags{
    89  					JSON: "sim_group",
    90  				},
    91  			}),
    92  			Results: dsl.Results{
    93  				{
    94  					SourceField: "SIMGroup",
    95  					DestField:   "SIMGroup",
    96  					IsPlural:    false,
    97  					Model:       mobileGatewayDNSModel,
    98  				},
    99  			},
   100  		},
   101  		{
   102  			ResourceName: mobileGatewayAPIName,
   103  			Name:         "SetDNS",
   104  			PathFormat:   dsl.IDAndSuffixPathFormat("mobilegateway/dnsresolver"),
   105  			Method:       http.MethodPut,
   106  			Arguments: dsl.Arguments{
   107  				dsl.ArgumentID,
   108  				dsl.MappableArgument("param", mobileGatewayDNSModel, "SIMGroup"),
   109  			},
   110  			RequestEnvelope: dsl.RequestEnvelope(&dsl.EnvelopePayloadDesc{
   111  				Type: meta.Static(naked.MobileGatewaySIMGroup{}),
   112  				Name: "SIMGroup",
   113  				Tags: &dsl.FieldTags{
   114  					JSON: "sim_group",
   115  				},
   116  			}),
   117  		},
   118  
   119  		// SIM Route
   120  		{
   121  			ResourceName: mobileGatewayAPIName,
   122  			Name:         "GetSIMRoutes",
   123  			PathFormat:   dsl.IDAndSuffixPathFormat("mobilegateway/simroutes"),
   124  			Method:       http.MethodGet,
   125  			Arguments: dsl.Arguments{
   126  				dsl.ArgumentID,
   127  			},
   128  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   129  				Name: "SIMRoutes",
   130  				Type: meta.Static([]*naked.MobileGatewaySIMRoute{}),
   131  				Tags: &dsl.FieldTags{
   132  					JSON: "sim_routes",
   133  				},
   134  			}),
   135  			Results: dsl.Results{
   136  				{
   137  					SourceField: "SIMRoutes",
   138  					DestField:   "SIMRoutes",
   139  					IsPlural:    true,
   140  					Model:       mobileGatewaySIMRouteView,
   141  				},
   142  			},
   143  		},
   144  		{
   145  			ResourceName: mobileGatewayAPIName,
   146  			Name:         "SetSIMRoutes",
   147  			PathFormat:   dsl.IDAndSuffixPathFormat("mobilegateway/simroutes"),
   148  			Method:       http.MethodPut,
   149  			RequestEnvelope: dsl.RequestEnvelope(&dsl.EnvelopePayloadDesc{
   150  				Type: meta.Static([]*naked.MobileGatewaySIMRoute{}),
   151  				Name: "SIMRoutes",
   152  				Tags: &dsl.FieldTags{
   153  					JSON: "sim_routes",
   154  				},
   155  			}),
   156  			Arguments: dsl.Arguments{
   157  				dsl.ArgumentID,
   158  				dsl.MappableArgument("param", mobileGatewaySIMRouteParam, "[]SIMRoutes"),
   159  			},
   160  		},
   161  
   162  		// list SIM
   163  		{
   164  			ResourceName: mobileGatewayAPIName,
   165  			Name:         "ListSIM",
   166  			PathFormat:   dsl.IDAndSuffixPathFormat("mobilegateway/sims"),
   167  			Method:       http.MethodGet,
   168  			Arguments: dsl.Arguments{
   169  				dsl.ArgumentID,
   170  			},
   171  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   172  				Name: "SIM",
   173  				Type: meta.Static([]*naked.SIMInfo{}),
   174  				Tags: &dsl.FieldTags{
   175  					JSON: "sim",
   176  				},
   177  			}),
   178  			Results: dsl.Results{
   179  				{
   180  					SourceField: "SIM",
   181  					DestField:   "SIM",
   182  					IsPlural:    true,
   183  					Model:       models.simInfoList(),
   184  				},
   185  			},
   186  		},
   187  		// add SIM
   188  		{
   189  			ResourceName: mobileGatewayAPIName,
   190  			Name:         "AddSIM",
   191  			PathFormat:   dsl.IDAndSuffixPathFormat("mobilegateway/sims"),
   192  			Method:       http.MethodPost,
   193  			RequestEnvelope: dsl.RequestEnvelope(&dsl.EnvelopePayloadDesc{
   194  				Type: meta.Static(naked.SIMInfo{}),
   195  				Name: "SIM",
   196  				Tags: &dsl.FieldTags{
   197  					JSON: "sim",
   198  				},
   199  			}),
   200  			Arguments: dsl.Arguments{
   201  				dsl.ArgumentID,
   202  				dsl.MappableArgument("param", mobileGatewayAddSIMParam, "SIM"),
   203  			},
   204  		},
   205  		// delete SIM
   206  		{
   207  			ResourceName: mobileGatewayAPIName,
   208  			Name:         "DeleteSIM",
   209  			PathFormat:   dsl.IDAndSuffixPathFormat("mobilegateway/sims/{{.simID}}"),
   210  			Method:       http.MethodDelete,
   211  			Arguments: dsl.Arguments{
   212  				dsl.ArgumentID,
   213  				{
   214  					Name: "simID",
   215  					Type: meta.TypeID,
   216  				},
   217  			},
   218  		},
   219  
   220  		// session logs
   221  		{
   222  			ResourceName: mobileGatewayAPIName,
   223  			Name:         "Logs",
   224  			PathFormat:   dsl.IDAndSuffixPathFormat("mobilegateway/sessionlog"),
   225  			Method:       http.MethodGet,
   226  			Arguments: dsl.Arguments{
   227  				dsl.ArgumentID,
   228  			},
   229  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   230  				Name: "Logs",
   231  				Type: meta.Static([]*naked.SIMLog{}),
   232  				Tags: &dsl.FieldTags{
   233  					JSON: "logs",
   234  				},
   235  			}),
   236  			Results: dsl.Results{
   237  				{
   238  					SourceField: "Logs",
   239  					DestField:   "Logs",
   240  					IsPlural:    true,
   241  					Model:       mobileGatewaySIMLogsModel,
   242  				},
   243  			},
   244  		},
   245  
   246  		// get traffic config
   247  		{
   248  			ResourceName: mobileGatewayAPIName,
   249  			Name:         "GetTrafficConfig",
   250  			PathFormat:   dsl.IDAndSuffixPathFormat("mobilegateway/traffic_monitoring"),
   251  			Method:       http.MethodGet,
   252  			Arguments: dsl.Arguments{
   253  				dsl.ArgumentID,
   254  			},
   255  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   256  				Name: "TrafficMonitoring",
   257  				Type: meta.Static(naked.TrafficMonitoringConfig{}),
   258  				Tags: &dsl.FieldTags{
   259  					JSON: "traffic_monitoring_config",
   260  				},
   261  			}),
   262  			Results: dsl.Results{
   263  				{
   264  					SourceField: "TrafficMonitoring",
   265  					DestField:   "TrafficMonitoring",
   266  					IsPlural:    false,
   267  					Model:       mobileGatewayTrafficConfigModel,
   268  				},
   269  			},
   270  		},
   271  		// set traffic config
   272  		{
   273  			ResourceName: mobileGatewayAPIName,
   274  			Name:         "SetTrafficConfig",
   275  			PathFormat:   dsl.IDAndSuffixPathFormat("mobilegateway/traffic_monitoring"),
   276  			Method:       http.MethodPut,
   277  			RequestEnvelope: dsl.RequestEnvelope(&dsl.EnvelopePayloadDesc{
   278  				Name: "TrafficMonitoring",
   279  				Type: meta.Static(naked.TrafficMonitoringConfig{}),
   280  				Tags: &dsl.FieldTags{
   281  					JSON: "traffic_monitoring_config",
   282  				},
   283  			}),
   284  			Arguments: dsl.Arguments{
   285  				dsl.ArgumentID,
   286  				dsl.MappableArgument("param", mobileGatewayTrafficConfigModel, "TrafficMonitoring"),
   287  			},
   288  		},
   289  		// delete SIM
   290  		{
   291  			ResourceName: mobileGatewayAPIName,
   292  			Name:         "DeleteTrafficConfig",
   293  			PathFormat:   dsl.IDAndSuffixPathFormat("mobilegateway/traffic_monitoring"),
   294  			Method:       http.MethodDelete,
   295  			Arguments: dsl.Arguments{
   296  				dsl.ArgumentID,
   297  			},
   298  		},
   299  
   300  		// traffic status
   301  		{
   302  			ResourceName: mobileGatewayAPIName,
   303  			Name:         "TrafficStatus",
   304  			PathFormat:   dsl.IDAndSuffixPathFormat("mobilegateway/traffic_status"),
   305  			Method:       http.MethodGet,
   306  			Arguments: dsl.Arguments{
   307  				dsl.ArgumentID,
   308  			},
   309  			ResponseEnvelope: dsl.ResponseEnvelope(&dsl.EnvelopePayloadDesc{
   310  				Name: "TrafficStatus",
   311  				Type: meta.Static(naked.TrafficStatus{}),
   312  				Tags: &dsl.FieldTags{
   313  					JSON: "traffic_status",
   314  				},
   315  			}),
   316  			Results: dsl.Results{
   317  				{
   318  					SourceField: "TrafficStatus",
   319  					DestField:   "TrafficStatus",
   320  					IsPlural:    false,
   321  					Model:       mobileGatewayTrafficStatusModel,
   322  				},
   323  			},
   324  		},
   325  
   326  		// monitor
   327  		ops.MonitorChildBy(mobileGatewayAPIName, "Interface", "interface",
   328  			monitorParameter, monitors.interfaceModel()),
   329  	},
   330  }
   331  
   332  var (
   333  	mobileGatewayNakedType               = meta.Static(naked.MobileGateway{})
   334  	mobileGatewayUpdateSettingsNakedType = meta.Static(naked.MobileGatewaySettingsUpdate{})
   335  
   336  	mobileGatewayView = &dsl.Model{
   337  		Name:      mobileGatewayAPIName,
   338  		NakedType: mobileGatewayNakedType,
   339  		Fields: []*dsl.FieldDesc{
   340  			fields.ID(),
   341  			fields.Name(),
   342  			fields.Description(),
   343  			fields.Tags(),
   344  			fields.Availability(),
   345  			fields.Class(),
   346  			fields.IconID(),
   347  			fields.CreatedAt(),
   348  			// instance
   349  			fields.InstanceHostName(),
   350  			fields.InstanceHostInfoURL(),
   351  			fields.InstanceStatus(),
   352  			fields.InstanceStatusChangedAt(),
   353  			// interfaces
   354  			fields.MobileGatewayInterfaces(),
   355  			// remark
   356  			fields.RemarkZoneID(),
   357  			{
   358  				Name: "GlobalAddress",
   359  				Type: meta.TypeString,
   360  				Tags: &dsl.FieldTags{
   361  					MapConv: "Remark.MobileGateway.GlobalAddress",
   362  				},
   363  			},
   364  			// settings
   365  			{
   366  				Name: "InterfaceSettings",
   367  				Type: models.mobileGatewayInterface(),
   368  				Tags: &dsl.FieldTags{
   369  					MapConv: "Settings.MobileGateway.[]Interfaces,recursive",
   370  				},
   371  			},
   372  			{
   373  				Name: "StaticRoutes",
   374  				Type: models.mobileGatewayStaticRoute(),
   375  				Tags: &dsl.FieldTags{
   376  					MapConv: "Settings.MobileGateway.[]StaticRoutes,recursive",
   377  				},
   378  			},
   379  			{
   380  				Name: "InternetConnectionEnabled",
   381  				Type: meta.TypeStringFlag,
   382  				Tags: &dsl.FieldTags{
   383  					MapConv: "Settings.MobileGateway.InternetConnection.Enabled",
   384  				},
   385  			},
   386  			{
   387  				Name: "InterDeviceCommunicationEnabled",
   388  				Type: meta.TypeStringFlag,
   389  				Tags: &dsl.FieldTags{
   390  					MapConv: "Settings.MobileGateway.InterDeviceCommunication.Enabled",
   391  				},
   392  			},
   393  			fields.SettingsHash(),
   394  		},
   395  	}
   396  
   397  	mobileGatewayCreateParam = &dsl.Model{
   398  		Name:      names.CreateParameterName(mobileGatewayAPIName),
   399  		NakedType: mobileGatewayNakedType,
   400  		ConstFields: []*dsl.ConstFieldDesc{
   401  			{
   402  				Name:  "Class",
   403  				Type:  meta.TypeString,
   404  				Value: `"mobilegateway"`,
   405  			},
   406  			{
   407  				Name: "PlanID",
   408  				Tags: &dsl.FieldTags{
   409  					MapConv: "Remark.Plan.ID/Plan.ID",
   410  				},
   411  				Type:  meta.TypeID,
   412  				Value: `types.ID(2)`,
   413  			},
   414  			{
   415  				Name: "SwitchID",
   416  				Tags: &dsl.FieldTags{
   417  					MapConv: "Remark.Switch.Scope",
   418  				},
   419  				Type:  meta.TypeString,
   420  				Value: `"shared"`,
   421  			},
   422  		},
   423  		Fields: []*dsl.FieldDesc{
   424  			fields.Name(),
   425  			fields.Description(),
   426  			fields.Tags(),
   427  			fields.IconID(),
   428  			{
   429  				Name: "StaticRoutes",
   430  				Type: models.mobileGatewayStaticRoute(),
   431  				Tags: &dsl.FieldTags{
   432  					JSON:    ",omitempty",
   433  					MapConv: "Settings.MobileGateway.[]StaticRoutes,omitempty,recursive",
   434  				},
   435  			},
   436  			{
   437  				Name: "InternetConnectionEnabled",
   438  				Type: meta.TypeStringFlag,
   439  				Tags: &dsl.FieldTags{
   440  					MapConv: "Settings.MobileGateway.InternetConnection.Enabled",
   441  				},
   442  			},
   443  			{
   444  				Name: "InterDeviceCommunicationEnabled",
   445  				Type: meta.TypeStringFlag,
   446  				Tags: &dsl.FieldTags{
   447  					MapConv: "Settings.MobileGateway.InterDeviceCommunication.Enabled",
   448  				},
   449  			},
   450  		},
   451  	}
   452  
   453  	mobileGatewayUpdateParam = &dsl.Model{
   454  		Name:      names.UpdateParameterName(mobileGatewayAPIName),
   455  		NakedType: mobileGatewayNakedType,
   456  		Fields: []*dsl.FieldDesc{
   457  			fields.Name(),
   458  			fields.Description(),
   459  			fields.Tags(),
   460  			fields.IconID(),
   461  			{
   462  				Name: "InterfaceSettings",
   463  				Type: models.mobileGatewayInterface(),
   464  				Tags: &dsl.FieldTags{
   465  					MapConv: "Settings.MobileGateway.[]Interfaces,recursive",
   466  				},
   467  			},
   468  			{
   469  				Name: "StaticRoutes",
   470  				Type: models.mobileGatewayStaticRoute(),
   471  				Tags: &dsl.FieldTags{
   472  					MapConv: "Settings.MobileGateway.[]StaticRoutes,recursive",
   473  				},
   474  			},
   475  			{
   476  				Name: "InternetConnectionEnabled",
   477  				Type: meta.TypeStringFlag,
   478  				Tags: &dsl.FieldTags{
   479  					MapConv: "Settings.MobileGateway.InternetConnection.Enabled",
   480  				},
   481  			},
   482  			{
   483  				Name: "InterDeviceCommunicationEnabled",
   484  				Type: meta.TypeStringFlag,
   485  				Tags: &dsl.FieldTags{
   486  					MapConv: "Settings.MobileGateway.InterDeviceCommunication.Enabled",
   487  				},
   488  			},
   489  			// settings hash
   490  			fields.SettingsHash(),
   491  		},
   492  	}
   493  	mobileGatewayUpdateSettingsParam = &dsl.Model{
   494  		Name:      names.UpdateSettingsParameterName(mobileGatewayAPIName),
   495  		NakedType: mobileGatewayNakedType,
   496  		Fields: []*dsl.FieldDesc{
   497  			{
   498  				Name: "InterfaceSettings",
   499  				Type: models.mobileGatewayInterface(),
   500  				Tags: &dsl.FieldTags{
   501  					MapConv: "Settings.MobileGateway.[]Interfaces,recursive",
   502  				},
   503  			},
   504  			{
   505  				Name: "StaticRoutes",
   506  				Type: models.mobileGatewayStaticRoute(),
   507  				Tags: &dsl.FieldTags{
   508  					MapConv: "Settings.MobileGateway.[]StaticRoutes,recursive",
   509  				},
   510  			},
   511  			{
   512  				Name: "InternetConnectionEnabled",
   513  				Type: meta.TypeStringFlag,
   514  				Tags: &dsl.FieldTags{
   515  					MapConv: "Settings.MobileGateway.InternetConnection.Enabled",
   516  				},
   517  			},
   518  			{
   519  				Name: "InterDeviceCommunicationEnabled",
   520  				Type: meta.TypeStringFlag,
   521  				Tags: &dsl.FieldTags{
   522  					MapConv: "Settings.MobileGateway.InterDeviceCommunication.Enabled",
   523  				},
   524  			},
   525  			// settings hash
   526  			fields.SettingsHash(),
   527  		},
   528  	}
   529  
   530  	mobileGatewayDNSModel = &dsl.Model{
   531  		Name:      "MobileGatewayDNSSetting",
   532  		NakedType: meta.Static(naked.MobileGatewaySIMGroup{}),
   533  		Fields: []*dsl.FieldDesc{
   534  			fields.Def("DNS1", meta.TypeString),
   535  			fields.Def("DNS2", meta.TypeString),
   536  		},
   537  	}
   538  
   539  	mobileGatewaySIMRouteParam = &dsl.Model{
   540  		Name:      "MobileGatewaySIMRouteParam",
   541  		NakedType: meta.Static(naked.MobileGatewaySIMRoute{}),
   542  		IsArray:   true,
   543  		Fields: []*dsl.FieldDesc{
   544  			fields.Def("ResourceID", meta.TypeString),
   545  			fields.Def("Prefix", meta.TypeString),
   546  		},
   547  	}
   548  	mobileGatewaySIMRouteView = &dsl.Model{
   549  		Name:      "MobileGatewaySIMRoute",
   550  		NakedType: meta.Static(naked.MobileGatewaySIMRoute{}),
   551  		Alias:     "MobileGatewaySIMRoutes",
   552  		Fields: []*dsl.FieldDesc{
   553  			fields.Def("ResourceID", meta.TypeString),
   554  			fields.Def("Prefix", meta.TypeString),
   555  			fields.Def("ICCID", meta.TypeString),
   556  		},
   557  	}
   558  
   559  	mobileGatewayAddSIMParam = &dsl.Model{
   560  		Name:      mobileGatewayAPIName + "AddSIMRequest",
   561  		NakedType: meta.Static(naked.SIMInfo{}),
   562  		Fields: []*dsl.FieldDesc{
   563  			{
   564  				Name: "SIMID",
   565  				Type: meta.TypeString,
   566  				Tags: &dsl.FieldTags{
   567  					MapConv: "ResourceID",
   568  					JSON:    "resource_id",
   569  				},
   570  			},
   571  		},
   572  	}
   573  
   574  	mobileGatewaySIMLogsModel = &dsl.Model{
   575  		Name:      mobileGatewayAPIName + "SIMLogs",
   576  		NakedType: meta.Static(naked.SIMLog{}),
   577  		IsArray:   true,
   578  		Fields: []*dsl.FieldDesc{
   579  			fields.Def("Date", meta.TypeTime),
   580  			fields.Def("SessionStatus", meta.TypeString),
   581  			fields.Def("ResourceID", meta.TypeString),
   582  			fields.Def("IMEI", meta.TypeString),
   583  			fields.Def("IMSI", meta.TypeString),
   584  		},
   585  	}
   586  
   587  	mobileGatewayTrafficConfigModel = &dsl.Model{
   588  		Name:      mobileGatewayAPIName + "TrafficControl",
   589  		NakedType: meta.Static(naked.TrafficMonitoringConfig{}),
   590  		Fields: []*dsl.FieldDesc{
   591  			fields.Def("TrafficQuotaInMB", meta.TypeInt),
   592  			fields.Def("BandWidthLimitInKbps", meta.TypeInt),
   593  			fields.Def("EmailNotifyEnabled", meta.TypeFlag, mapConvTag("EMailConfig.Enabled")),
   594  			fields.Def("SlackNotifyEnabled", meta.TypeFlag, mapConvTag("SlackConfig.Enabled")),
   595  			fields.Def("SlackNotifyWebhooksURL", meta.TypeString, mapConvTag("SlackConfig.IncomingWebhooksURL")),
   596  			fields.Def("AutoTrafficShaping", meta.TypeFlag),
   597  		},
   598  	}
   599  
   600  	mobileGatewayTrafficStatusModel = &dsl.Model{
   601  		Name:      mobileGatewayAPIName + "TrafficStatus",
   602  		NakedType: meta.Static(naked.TrafficStatus{}),
   603  		Fields: []*dsl.FieldDesc{
   604  			fields.Def("UplinkBytes", meta.TypeStringNumber),
   605  			fields.Def("DownlinkBytes", meta.TypeStringNumber),
   606  			fields.Def("TrafficShaping", meta.TypeFlag),
   607  		},
   608  	}
   609  )