diff --git a/common/const_var.go b/common/const_var.go index 57fa850f..dc468469 100644 --- a/common/const_var.go +++ b/common/const_var.go @@ -111,6 +111,7 @@ const ( APPLICATION_TYPE = "applicationType" ACCOUNT_ID = "accountId" ACCOUNT_HASH = "accountHash" + ACCOUNT_PRODUCTS = "accountProducts" CONFIG_SET_HASH = "configSetHash" SYNDICATION_PARTNER = "SyndicationPartner" MAC = "mac" diff --git a/config/sample_xconfwebconfig.conf b/config/sample_xconfwebconfig.conf index 1e4dd606..a6674665 100644 --- a/config/sample_xconfwebconfig.conf +++ b/config/sample_xconfwebconfig.conf @@ -189,6 +189,7 @@ xconfwebconfig { enable_rfc_penetration_metrics = false // Enable RFC penetration metrics enable_device_service = false // Enable device service integration enable_account_service = false // Enable account service integration + enable_account_data_service = true enable_tagging_service = false // Enable tagging service integration enable_device_db_lookup = false // Enable device DB lookup enable_group_service = false // Enable group service integration diff --git a/dataapi/dataapi_common.go b/dataapi/dataapi_common.go index b87aab5d..2b2f78cc 100644 --- a/dataapi/dataapi_common.go +++ b/dataapi/dataapi_common.go @@ -161,18 +161,17 @@ func GetPartnerFromAccountServiceByHostMac(ws *xhttp.XconfServer, macAddress str } var partnerId string - if Xc.EnableAccountService { - var accountObject xhttp.AccountServiceDevices - var err error - if util.IsValidMacAddress(macAddress) { - accountObject, err = ws.AccountServiceConnector.GetDevices(common.HOST_MAC_PARAM, macAddress, satToken, fields) - } - if err != nil { - log.WithFields(log.Fields{"error": err}).Error("Error getting account information") - } else { - partnerId = strings.ToUpper(accountObject.DeviceData.Partner) - } + var accountObject xhttp.AccountServiceDevices + var err error + if util.IsValidMacAddress(macAddress) { + accountObject, err = ws.AccountServiceConnector.GetDevices(common.HOST_MAC_PARAM, macAddress, satToken, fields) } + if err != nil { + log.WithFields(log.Fields{"error": err}).Error("Error getting account information") + } else { + partnerId = strings.ToUpper(accountObject.DeviceData.Partner) + } + return partnerId } diff --git a/dataapi/estb_firmware_context.go b/dataapi/estb_firmware_context.go index 7340b21a..c2357cf1 100644 --- a/dataapi/estb_firmware_context.go +++ b/dataapi/estb_firmware_context.go @@ -230,12 +230,53 @@ func AddEstbFirmwareContext(ws *xhttp.XconfServer, r *http.Request, contextMap m return err } satToken := localToken.Token + if Xc.EnableAccountService { + if util.IsUnknownValue(contextMap[common.PARTNER_ID]) { + partnerId := GetPartnerFromAccountServiceByHostMac(ws, contextMap[common.ESTB_MAC], satToken, fields) + if partnerId != "" { + contextMap[common.PARTNER_ID] = partnerId + } + } + } else if Xc.EnableAccountDataService { + // Only call XAC/ADA if partner is unknown or empty + if util.IsUnknownValue(contextMap[common.PARTNER_ID]) || contextMap[common.PARTNER_ID] == "" { + macValue := contextMap[common.ESTB_MAC] + if macValue != "" { + // Remove colons from MAC for XAC call + macValueWithoutColons := strings.ReplaceAll(macValue, ":", "") + + xAccountId, err := ws.GroupServiceConnector.GetAccountIdData(macValueWithoutColons, fields) + if err != nil { + log.WithFields(fields).Warn(fmt.Sprintf("XAC call failed for MAC='%s': %v", macValue, err)) + } - if util.IsUnknownValue(contextMap[common.PARTNER_ID]) { - partnerId := GetPartnerFromAccountServiceByHostMac(ws, contextMap[common.ESTB_MAC], satToken, fields) - if partnerId != "" { - contextMap[common.PARTNER_ID] = partnerId + if xAccountId != nil && xAccountId.GetAccountId() != "" { + accountId := xAccountId.GetAccountId() + accountProducts, err := ws.GroupServiceConnector.GetAccountProducts(accountId, fields) + if err != nil { + log.WithFields(fields).Warn(fmt.Sprintf("ADA call failed for AccountId='%s': %v", accountId, err)) + } else { + if partner, ok := accountProducts["Partner"]; ok && partner != "" { + contextMap[common.PARTNER_ID] = partner + log.WithFields(fields).Info(fmt.Sprintf("Partner='%s' retrieved from ADA", partner)) + } + } + } + } + + // Fallback to old Account Service logic if XAC/ADA didn't return partner + if util.IsUnknownValue(contextMap[common.PARTNER_ID]) { + log.WithFields(fields).Info("Trying fallback Account Service for partner retrieval") + partnerId := GetPartnerFromAccountServiceByHostMac(ws, contextMap[common.ESTB_MAC], satToken, fields) + if partnerId != "" { + contextMap[common.PARTNER_ID] = partnerId + log.WithFields(fields).Info(fmt.Sprintf("Partner='%s' retrieved from fallback Account Service", partnerId)) + } + } } + } else { + //err both the service + log.Error("Both the Account Service calls have been disabled") } AddContextFromTaggingService(ws, contextMap, satToken, "", false, fields) AddGroupServiceFTContext(Ws, common.ESTB_MAC, contextMap, true, fields) diff --git a/dataapi/feature_control_context.go b/dataapi/feature_control_context.go index 8b702800..61f35579 100644 --- a/dataapi/feature_control_context.go +++ b/dataapi/feature_control_context.go @@ -117,6 +117,69 @@ func CompareHashWithXDAS(contextMap map[string]string, xdasHash string, tags []s return calculatedHash == xdasHash, nil } +// getPartnerFromAccountDataService attempts to retrieve account data using XAC → ADA flow +func getPartnerFromAccountDataService(ws *xhttp.XconfServer, contextMap map[string]string, fields log.Fields) (*PodData, *AccountServiceData) { + var podData *PodData + var td *AccountServiceData + + // Try ECM MAC first, then fall back to ESTB MAC + var macAddress string + if util.IsValidMacAddress(contextMap[common.ESTB_MAC_ADDRESS]) { + macAddress = util.GetEcmMacAddress(util.AlphaNumericMacAddress(strings.TrimSpace(contextMap[common.ESTB_MAC_ADDRESS]))) + } else if util.IsValidMacAddress(contextMap[common.ECM_MAC_ADDRESS]) { + macAddress = contextMap[common.ECM_MAC_ADDRESS] + } + + // Remove colons from MAC for XAC call + macValueWithoutColons := strings.ReplaceAll(macAddress, ":", "") + + // Call XAC to get AccountId + xAccountId, err := ws.GroupServiceConnector.GetAccountIdData(macValueWithoutColons, fields) + if err != nil { + log.WithFields(fields).Warn(fmt.Sprintf("XAC call failed for MAC='%s': %v", macValueWithoutColons, err)) + return nil, nil + } + + if xAccountId == nil || xAccountId.GetAccountId() == "" { + return nil, nil + } + + accountId := xAccountId.GetAccountId() + + // Call ADA to get account products + accountProducts, err := ws.GroupServiceConnector.GetAccountProducts(accountId, fields) + if err != nil { + log.WithFields(fields).Warn(fmt.Sprintf("ADA call failed for AccountId='%s': %v", accountId, err)) + return nil, nil + } + + // Extract Partner and TimeZone from ADA response + var partnerId, timeZone string + if partner, ok := accountProducts["Partner"]; ok && partner != "" { + partnerId = strings.ToUpper(partner) + log.WithFields(fields).Info(fmt.Sprintf("Partner='%s' retrieved from ADA for pods", partnerId)) + } + if tz, ok := accountProducts["TimeZone"]; ok && tz != "" { + timeZone = tz + log.WithFields(fields).Info(fmt.Sprintf("TimeZone='%s' retrieved from ADA for pods", timeZone)) + } + + // Create PodData and AccountServiceData with retrieved information + podData = &PodData{ + AccountId: accountId, + PartnerId: partnerId, + TimeZone: timeZone, + } + + td = &AccountServiceData{ + AccountId: accountId, + PartnerId: partnerId, + TimeZone: timeZone, + } + + return podData, td +} + func AddContextForPods(ws *xhttp.XconfServer, contextMap map[string]string, satToken string, vargs ...log.Fields) (*PodData, *AccountServiceData) { var fields log.Fields var podData *PodData @@ -130,6 +193,17 @@ func AddContextForPods(ws *xhttp.XconfServer, contextMap map[string]string, satT tfields := common.FilterLogFields(fields) if Xc.EnableMacAccountServiceCall && strings.HasPrefix(strings.ToUpper(contextMap[common.SERIAL_NUM]), Xc.AccountServiceMacPrefix) { + if Xc.EnableAccountDataService { + podData, td = getPartnerFromAccountDataService(ws, contextMap, fields) + if podData != nil && podData.AccountId != "" { + if util.IsUnknownValue(contextMap[common.ACCOUNT_ID]) && podData.AccountId != "" { + contextMap[common.ACCOUNT_ID] = podData.AccountId + } + return podData, td + } + } + + // Fallback: Old AccountService logic AccountServiceDeviceObject, err := ws.AccountServiceConnector.GetDevices(common.SERIAL_NUMBER_PARAM, contextMap[common.SERIAL_NUM], satToken, fields) if err != nil { log.WithFields(log.Fields{"error": err}).Errorf("Error getting AccountService device information: serialNum=%s", contextMap[common.SERIAL_NUM]) @@ -167,6 +241,18 @@ func AddContextForPods(ws *xhttp.XconfServer, contextMap map[string]string, satT podData.TimeZone = AccountServiceAccountObject.AccountData.AccountAttributes.TimeZone log.WithFields(tfields).Infof("Successfully got AccountService information for XLE device: accountId=%s, serialNum=%s", AccountServiceDeviceObject.DeviceData.ServiceAccountUri, contextMap[common.SERIAL_NUM]) } else if Xc.EnableDeviceDBLookup && contextMap[common.SERIAL_NUM] != "" && !strings.HasPrefix(contextMap[common.MODEL], GR_PREFIX) { + // Try XAC → ADA flow first if enabled + if Xc.EnableAccountDataService { + podData, td = getPartnerFromAccountDataService(ws, contextMap, fields) + if podData != nil && podData.AccountId != "" { + if util.IsUnknownValue(contextMap[common.ACCOUNT_ID]) && podData.AccountId != "" { + contextMap[common.ACCOUNT_ID] = podData.AccountId + } + return podData, td + } + } + + // Fallback: Old AccountService logic ecmMacAddress, err := ws.GetEcmMacFromPodTable(contextMap[common.SERIAL_NUM]) if err != nil { log.WithFields(log.Fields{"error": err}).Errorf("Error looking up pod information from odp db: serialNum=%s", contextMap[common.SERIAL_NUM]) @@ -213,6 +299,18 @@ func AddContextForPods(ws *xhttp.XconfServer, contextMap map[string]string, satT } podData.TimeZone = accountServiceAccountObject.AccountData.AccountAttributes.TimeZone } else if Xc.EnableDeviceService && contextMap[common.SERIAL_NUM] != "" && !strings.HasPrefix(contextMap[common.MODEL], GR_PREFIX) { + // Try XAC → ADA flow first if enabled + if Xc.EnableAccountDataService { + podData, td = getPartnerFromAccountDataService(ws, contextMap, fields) + if podData != nil && podData.AccountId != "" { + if util.IsUnknownValue(contextMap[common.ACCOUNT_ID]) && podData.AccountId != "" { + contextMap[common.ACCOUNT_ID] = podData.AccountId + } + return podData, td + } + } + + // Fallback: Old Device Service (Titan) logic deviceServiceObject, err := ws.DeviceServiceConnector.GetMeshPodAccountBySerialNum(contextMap[common.SERIAL_NUM], fields) if err != nil { log.WithFields(log.Fields{"error": err}).Errorf("Error getting Device Service information: serialNum=%s", contextMap[common.SERIAL_NUM]) @@ -234,16 +332,16 @@ func AddContextForPods(ws *xhttp.XconfServer, contextMap map[string]string, satT func AddFeatureControlContextFromAccountService(ws *xhttp.XconfServer, contextMap map[string]string, satToken string, vargs ...log.Fields) *AccountServiceData { var td *AccountServiceData - + var accountId string var fields log.Fields if len(vargs) > 0 { fields = vargs[0] } else { fields = log.Fields{} } + var err error if Xc.EnableAccountService { var accountServiceObject xhttp.AccountServiceDevices - var err error if util.IsValidMacAddress(contextMap[common.ESTB_MAC_ADDRESS]) { accountServiceObject, err = ws.AccountServiceConnector.GetDevices(common.HOST_MAC_PARAM, contextMap[common.ESTB_MAC_ADDRESS], satToken, fields) if err == nil { @@ -297,6 +395,56 @@ func AddFeatureControlContextFromAccountService(ws *xhttp.XconfServer, contextMa } } } + } else if Xc.EnableAccountDataService { + if util.IsValidMacAddress(contextMap[common.ESTB_MAC_ADDRESS]) || util.IsValidMacAddress(contextMap[common.ECM_MAC_ADDRESS]) { + var macAddress string + if contextMap[common.ESTB_MAC_ADDRESS] != "" { + macAddress = util.GetEcmMacAddress(util.AlphaNumericMacAddress(strings.TrimSpace(contextMap[common.ESTB_MAC_ADDRESS]))) + } else { + macAddress = contextMap[common.ECM_MAC_ADDRESS] + } + // Normalize MAC (remove colons) before calling XAC + macValue := strings.ReplaceAll(macAddress, ":", "") + xboAccount, err := ws.GroupServiceConnector.GetAccountIdData(macValue, fields) + if err != nil { + log.WithFields(log.Fields{"error": err}).Error("Error getting accountId information") + xhttp.IncreaseAccountServiceEmptyResponseCounter(contextMap[common.MODEL]) + return td + } + if xboAccount != nil && xboAccount.GetAccountId() != "" { + accountId = xboAccount.GetAccountId() + contextMap[common.ACCOUNT_ID] = accountId + } else { + xhttp.IncreaseAccountServiceEmptyResponseCounter(contextMap[common.MODEL]) + return td + } + + td = &AccountServiceData{ + AccountId: accountId, + } + accountProducts, err := ws.GroupServiceConnector.GetAccountProducts(accountId, fields) + if err != nil { + log.WithFields(log.Fields{"error": err}).Error("Error getting accountProducts information") + } else { + if partner, ok := accountProducts["Partner"]; ok && partner != "" { + contextMap[common.PARTNER_ID] = strings.ToUpper(partner) + } + + contextMap[common.ACCOUNT_HASH] = util.CalculateHash(accountId) + + if accountProductsVal, ok := accountProducts["AccountProducts"]; ok { + contextMap[common.ACCOUNT_PRODUCTS] = accountProductsVal + } + + if countryCode, ok := accountProducts["CountryCode"]; ok { + contextMap[common.COUNTRY_CODE] = countryCode + } + + } + } + } else { + //error both service not enabled + log.WithFields(log.Fields{"error": err}).Error("Both the Account Service calls have been disabled") } return td } diff --git a/dataapi/router.go b/dataapi/router.go index 9d17f51f..fa62baa6 100644 --- a/dataapi/router.go +++ b/dataapi/router.go @@ -51,6 +51,7 @@ type XconfConfigs struct { EnableMacAccountServiceCall bool AccountServiceMacPrefix string EnableAccountService bool + EnableAccountDataService bool EnableTaggingService bool EnableTaggingServiceRFC bool IPv4NetworkMaskPrefixLength int32 @@ -298,6 +299,7 @@ func GetXconfConfigs(conf *conf.Config) *XconfConfigs { EnableDeviceDBLookup: conf.GetBoolean("xconfwebconfig.xconf.enable_device_db_lookup"), EnableMacAccountServiceCall: conf.GetBoolean("xconfwebconfig.xconf.enable_mac_accountservice_call"), EnableAccountService: conf.GetBoolean("xconfwebconfig.xconf.enable_account_service"), + EnableAccountDataService: conf.GetBoolean("xconfwebconfig.xconf.enable_account_data_service"), EnableTaggingService: conf.GetBoolean("xconfwebconfig.xconf.enable_tagging_service"), EnableTaggingServiceRFC: conf.GetBoolean("xconfwebconfig.xconf.enable_tagging_service_rfc"), ReturnAccountId: conf.GetBoolean("xconfwebconfig.xconf.return_account_id"), diff --git a/http/group_service_connector.go b/http/group_service_connector.go index 96afe570..6d9e9a14 100644 --- a/http/group_service_connector.go +++ b/http/group_service_connector.go @@ -20,6 +20,7 @@ package http import ( "crypto/tls" "fmt" + "net/http" "reflect" conversion "github.com/rdkcentral/xconfwebconfig/protobuf" @@ -35,6 +36,8 @@ const ( getRfcPrecookUrlTemplate = "%s/v2/xd/%s" getHashesUrlTemplate = "%s/v2/ft/%s" getSecurityTokenUrlTemplate = "%s/v2/st/%s" + getAccountIdTemplate = "%s/v2/xac/%s" + getAccountProductsTemplate = "%s/v2/ada/%s" ) type GroupServiceConnector interface { @@ -47,6 +50,8 @@ type GroupServiceConnector interface { CreateListFromGroupServiceProto(cpeGroup *conversion.CpeGroup) []string GetFeatureTagsHashedItems(name string, fields log.Fields) (map[string]string, error) GetSecurityTokenInfo(securityIdentifier string, fields log.Fields) (map[string]string, error) + GetAccountIdData(ecmMac string, fields log.Fields) (*conversion.XBOAccount, error) + GetAccountProducts(name string, fields log.Fields) (map[string]string, error) } type DefaultGroupService struct { @@ -171,3 +176,34 @@ func (c *DefaultGroupService) GetSecurityTokenInfo(securityIdentifier string, fi } return message.Fields, nil } + +func (c *DefaultGroupService) GetAccountIdData(ecmMac string, fields log.Fields) (*conversion.XBOAccount, error) { + url := fmt.Sprintf(getAccountIdTemplate, c.host, ecmMac) + rbytes, err := c.DoWithRetries(http.MethodGet, url, nil, nil, fields, groupServiceName) + if err != nil { + return nil, err + } + + var xboAccount conversion.XBOAccount + err = proto.Unmarshal(rbytes, &xboAccount) + if err != nil { + return nil, err + } + + return &xboAccount, nil +} + +func (c *DefaultGroupService) GetAccountProducts(name string, fields log.Fields) (map[string]string, error) { + url := fmt.Sprintf(getAccountProductsTemplate, c.GroupServiceHost(), name) + rbytes, err := c.DoWithRetries(http.MethodGet, url, nil, nil, fields, groupServiceName) + if err != nil { + return nil, err + } + message := conversion.XdasHashes{} + message.ProtoMessage() + err = proto.Unmarshal(rbytes, &message) + if err != nil { + return nil, err + } + return message.Fields, nil +} diff --git a/protobuf/xboaccount.pb.go b/protobuf/xboaccount.pb.go new file mode 100644 index 00000000..b1dc5a78 --- /dev/null +++ b/protobuf/xboaccount.pb.go @@ -0,0 +1,146 @@ +// keyspace xac + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.33.0 +// protoc v5.26.1 +// source: xboaccount.proto + +package conversion + +import ( + reflect "reflect" + sync "sync" + + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type XBOAccount struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AccountId string `protobuf:"bytes,1,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"` +} + +func (x *XBOAccount) Reset() { + *x = XBOAccount{} + if protoimpl.UnsafeEnabled { + mi := &file_xboaccount_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *XBOAccount) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*XBOAccount) ProtoMessage() {} + +func (x *XBOAccount) ProtoReflect() protoreflect.Message { + mi := &file_xboaccount_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use XBOAccount.ProtoReflect.Descriptor instead. +func (*XBOAccount) Descriptor() ([]byte, []int) { + return file_xboaccount_proto_rawDescGZIP(), []int{0} +} + +func (x *XBOAccount) GetAccountId() string { + if x != nil { + return x.AccountId + } + return "" +} + +var File_xboaccount_proto protoreflect.FileDescriptor + +var file_xboaccount_proto_rawDesc = []byte{ + 0x0a, 0x10, 0x78, 0x62, 0x6f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x0e, 0x78, 0x70, 0x63, 0x2e, 0x78, 0x64, 0x61, 0x73, 0x2e, 0x6d, 0x6f, 0x64, + 0x65, 0x6c, 0x22, 0x2b, 0x0a, 0x0a, 0x58, 0x42, 0x4f, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x64, 0x42, + 0x0e, 0x5a, 0x0c, 0x2e, 0x3b, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_xboaccount_proto_rawDescOnce sync.Once + file_xboaccount_proto_rawDescData = file_xboaccount_proto_rawDesc +) + +func file_xboaccount_proto_rawDescGZIP() []byte { + file_xboaccount_proto_rawDescOnce.Do(func() { + file_xboaccount_proto_rawDescData = protoimpl.X.CompressGZIP(file_xboaccount_proto_rawDescData) + }) + return file_xboaccount_proto_rawDescData +} + +var file_xboaccount_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_xboaccount_proto_goTypes = []interface{}{ + (*XBOAccount)(nil), // 0: xpc.xdas.model.XBOAccount +} +var file_xboaccount_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_xboaccount_proto_init() } +func file_xboaccount_proto_init() { + if File_xboaccount_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_xboaccount_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*XBOAccount); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_xboaccount_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_xboaccount_proto_goTypes, + DependencyIndexes: file_xboaccount_proto_depIdxs, + MessageInfos: file_xboaccount_proto_msgTypes, + }.Build() + File_xboaccount_proto = out.File + file_xboaccount_proto_rawDesc = nil + file_xboaccount_proto_goTypes = nil + file_xboaccount_proto_depIdxs = nil +}