mirror of
https://github.com/TeaOSLab/EdgeAPI.git
synced 2025-11-04 07:50:25 +08:00
718 lines
22 KiB
Go
718 lines
22 KiB
Go
// Copyright 2022 GoEdge CDN goedge.cdn@gmail.com. All rights reserved. Official site: https://goedge.cloud .
|
|
|
|
package services
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
|
|
"github.com/TeaOSLab/EdgeAPI/internal/db/models"
|
|
"github.com/TeaOSLab/EdgeAPI/internal/db/models/regions"
|
|
"github.com/TeaOSLab/EdgeCommon/pkg/rpc/pb"
|
|
"github.com/iwind/TeaGo/lists"
|
|
"github.com/iwind/TeaGo/types"
|
|
)
|
|
|
|
// IPLibraryFileService IP库文件管理
|
|
type IPLibraryFileService struct {
|
|
BaseService
|
|
}
|
|
|
|
// FindAllFinishedIPLibraryFiles 查找所有已完成的IP库文件
|
|
func (this *IPLibraryFileService) FindAllFinishedIPLibraryFiles(ctx context.Context, req *pb.FindAllFinishedIPLibraryFilesRequest) (*pb.FindAllFinishedIPLibraryFilesResponse, error) {
|
|
_, err := this.ValidateAdmin(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var tx = this.NullTx()
|
|
libraryFiles, err := models.SharedIPLibraryFileDAO.FindAllFinishedLibraryFiles(tx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var pbLibraryFiles = []*pb.IPLibraryFile{}
|
|
for _, libraryFile := range libraryFiles {
|
|
var pbCountryNames = libraryFile.DecodeCountries()
|
|
var pbProviderNames = libraryFile.DecodeProviders()
|
|
|
|
var pbProvinces = []*pb.IPLibraryFile_Province{}
|
|
for _, province := range libraryFile.DecodeProvinces() {
|
|
pbProvinces = append(pbProvinces, &pb.IPLibraryFile_Province{
|
|
CountryName: province[0],
|
|
ProvinceName: province[1],
|
|
})
|
|
}
|
|
|
|
var pbCities = []*pb.IPLibraryFile_City{}
|
|
for _, city := range libraryFile.DecodeCities() {
|
|
pbCities = append(pbCities, &pb.IPLibraryFile_City{
|
|
CountryName: city[0],
|
|
ProvinceName: city[1],
|
|
CityName: city[2],
|
|
})
|
|
}
|
|
|
|
var pbTowns = []*pb.IPLibraryFile_Town{}
|
|
for _, town := range libraryFile.DecodeTowns() {
|
|
pbTowns = append(pbTowns, &pb.IPLibraryFile_Town{
|
|
CountryName: town[0],
|
|
ProvinceName: town[1],
|
|
CityName: town[2],
|
|
TownName: town[3],
|
|
})
|
|
}
|
|
|
|
pbLibraryFiles = append(pbLibraryFiles, &pb.IPLibraryFile{
|
|
Id: int64(libraryFile.Id),
|
|
Name: libraryFile.Name,
|
|
FileId: int64(libraryFile.FileId),
|
|
IsFinished: libraryFile.IsFinished,
|
|
CreatedAt: int64(libraryFile.CreatedAt),
|
|
GeneratedFileId: int64(libraryFile.GeneratedFileId),
|
|
GeneratedAt: int64(libraryFile.GeneratedAt),
|
|
Password: libraryFile.Password,
|
|
CountryNames: pbCountryNames,
|
|
Provinces: pbProvinces,
|
|
Cities: pbCities,
|
|
Towns: pbTowns,
|
|
ProviderNames: pbProviderNames,
|
|
})
|
|
}
|
|
|
|
return &pb.FindAllFinishedIPLibraryFilesResponse{
|
|
IpLibraryFiles: pbLibraryFiles,
|
|
}, nil
|
|
}
|
|
|
|
// FindAllUnfinishedIPLibraryFiles 查找所有未完成的IP库文件
|
|
func (this *IPLibraryFileService) FindAllUnfinishedIPLibraryFiles(ctx context.Context, req *pb.FindAllUnfinishedIPLibraryFilesRequest) (*pb.FindAllUnfinishedIPLibraryFilesResponse, error) {
|
|
_, err := this.ValidateAdmin(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var tx = this.NullTx()
|
|
libraryFiles, err := models.SharedIPLibraryFileDAO.FindAllUnfinishedLibraryFiles(tx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var pbLibraryFiles = []*pb.IPLibraryFile{}
|
|
for _, libraryFile := range libraryFiles {
|
|
var pbCountryNames = libraryFile.DecodeCountries()
|
|
var pbProviderNames = libraryFile.DecodeProviders()
|
|
|
|
var pbProvinces = []*pb.IPLibraryFile_Province{}
|
|
for _, province := range libraryFile.DecodeProvinces() {
|
|
pbProvinces = append(pbProvinces, &pb.IPLibraryFile_Province{
|
|
CountryName: province[0],
|
|
ProvinceName: province[1],
|
|
})
|
|
}
|
|
|
|
var pbCities = []*pb.IPLibraryFile_City{}
|
|
for _, city := range libraryFile.DecodeCities() {
|
|
pbCities = append(pbCities, &pb.IPLibraryFile_City{
|
|
CountryName: city[0],
|
|
ProvinceName: city[1],
|
|
CityName: city[2],
|
|
})
|
|
}
|
|
|
|
var pbTowns = []*pb.IPLibraryFile_Town{}
|
|
for _, town := range libraryFile.DecodeTowns() {
|
|
pbTowns = append(pbTowns, &pb.IPLibraryFile_Town{
|
|
CountryName: town[0],
|
|
ProvinceName: town[1],
|
|
CityName: town[2],
|
|
TownName: town[3],
|
|
})
|
|
}
|
|
|
|
pbLibraryFiles = append(pbLibraryFiles, &pb.IPLibraryFile{
|
|
Id: int64(libraryFile.Id),
|
|
Name: libraryFile.Name,
|
|
FileId: int64(libraryFile.FileId),
|
|
IsFinished: libraryFile.IsFinished,
|
|
CreatedAt: int64(libraryFile.CreatedAt),
|
|
Password: libraryFile.Password,
|
|
CountryNames: pbCountryNames,
|
|
Provinces: pbProvinces,
|
|
Cities: pbCities,
|
|
Towns: pbTowns,
|
|
ProviderNames: pbProviderNames,
|
|
})
|
|
}
|
|
|
|
return &pb.FindAllUnfinishedIPLibraryFilesResponse{
|
|
IpLibraryFiles: pbLibraryFiles,
|
|
}, nil
|
|
}
|
|
|
|
// FindIPLibraryFile 查找单个IP库文件
|
|
func (this *IPLibraryFileService) FindIPLibraryFile(ctx context.Context, req *pb.FindIPLibraryFileRequest) (*pb.FindIPLibraryFileResponse, error) {
|
|
_, err := this.ValidateAdmin(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var tx = this.NullTx()
|
|
libraryFile, err := models.SharedIPLibraryFileDAO.FindEnabledIPLibraryFile(tx, req.IpLibraryFileId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if libraryFile == nil {
|
|
return &pb.FindIPLibraryFileResponse{
|
|
IpLibraryFile: nil,
|
|
}, nil
|
|
}
|
|
|
|
var pbCountryNames = libraryFile.DecodeCountries()
|
|
var pbProviderNames = libraryFile.DecodeProviders()
|
|
|
|
var pbProvinces = []*pb.IPLibraryFile_Province{}
|
|
for _, province := range libraryFile.DecodeProvinces() {
|
|
pbProvinces = append(pbProvinces, &pb.IPLibraryFile_Province{
|
|
CountryName: province[0],
|
|
ProvinceName: province[1],
|
|
})
|
|
}
|
|
|
|
var pbCities = []*pb.IPLibraryFile_City{}
|
|
for _, city := range libraryFile.DecodeCities() {
|
|
pbCities = append(pbCities, &pb.IPLibraryFile_City{
|
|
CountryName: city[0],
|
|
ProvinceName: city[1],
|
|
CityName: city[2],
|
|
})
|
|
}
|
|
|
|
var pbTowns = []*pb.IPLibraryFile_Town{}
|
|
for _, town := range libraryFile.DecodeTowns() {
|
|
pbTowns = append(pbTowns, &pb.IPLibraryFile_Town{
|
|
CountryName: town[0],
|
|
ProvinceName: town[1],
|
|
CityName: town[2],
|
|
TownName: town[3],
|
|
})
|
|
}
|
|
|
|
return &pb.FindIPLibraryFileResponse{
|
|
IpLibraryFile: &pb.IPLibraryFile{
|
|
Id: int64(libraryFile.Id),
|
|
Name: libraryFile.Name,
|
|
Template: libraryFile.Template,
|
|
EmptyValues: libraryFile.DecodeEmptyValues(),
|
|
FileId: int64(libraryFile.FileId),
|
|
IsFinished: libraryFile.IsFinished,
|
|
CreatedAt: int64(libraryFile.CreatedAt),
|
|
GeneratedFileId: int64(libraryFile.GeneratedFileId),
|
|
Password: libraryFile.Password,
|
|
CountryNames: pbCountryNames,
|
|
Provinces: pbProvinces,
|
|
Cities: pbCities,
|
|
Towns: pbTowns,
|
|
ProviderNames: pbProviderNames,
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// CreateIPLibraryFile 创建IP库文件
|
|
func (this *IPLibraryFileService) CreateIPLibraryFile(ctx context.Context, req *pb.CreateIPLibraryFileRequest) (*pb.CreateIPLibraryFileResponse, error) {
|
|
_, err := this.ValidateAdmin(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var countries = []string{}
|
|
var provinces = [][2]string{}
|
|
var cities = [][3]string{}
|
|
var towns = [][4]string{}
|
|
var providers = []string{}
|
|
|
|
err = json.Unmarshal(req.CountriesJSON, &countries)
|
|
if err != nil {
|
|
return nil, errors.New("decode countries failed: " + err.Error())
|
|
}
|
|
|
|
err = json.Unmarshal(req.ProvincesJSON, &provinces)
|
|
if err != nil {
|
|
return nil, errors.New("decode provinces failed: " + err.Error())
|
|
}
|
|
|
|
err = json.Unmarshal(req.CitiesJSON, &cities)
|
|
if err != nil {
|
|
return nil, errors.New("decode cities failed: " + err.Error())
|
|
}
|
|
|
|
err = json.Unmarshal(req.TownsJSON, &towns)
|
|
if err != nil {
|
|
return nil, errors.New("decode towns failed: " + err.Error())
|
|
}
|
|
|
|
err = json.Unmarshal(req.ProvidersJSON, &providers)
|
|
if err != nil {
|
|
return nil, errors.New("decode providers failed: " + err.Error())
|
|
}
|
|
|
|
var tx = this.NullTx()
|
|
libraryFileId, err := models.SharedIPLibraryFileDAO.CreateLibraryFile(tx, req.Name, req.Template, req.EmptyValues, req.Password, req.FileId, countries, provinces, cities, towns, providers)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &pb.CreateIPLibraryFileResponse{
|
|
IpLibraryFileId: libraryFileId,
|
|
}, nil
|
|
}
|
|
|
|
// CheckCountriesWithIPLibraryFileId 检查国家/地区
|
|
func (this *IPLibraryFileService) CheckCountriesWithIPLibraryFileId(ctx context.Context, req *pb.CheckCountriesWithIPLibraryFileIdRequest) (*pb.CheckCountriesWithIPLibraryFileIdResponse, error) {
|
|
_, err := this.ValidateAdmin(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var tx = this.NullTx()
|
|
|
|
allCountries, err := regions.SharedRegionCountryDAO.FindAllCountries(tx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
countryNames, err := models.SharedIPLibraryFileDAO.FindLibraryFileCountries(tx, req.IpLibraryFileId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var pbMissingCountries = []*pb.CheckCountriesWithIPLibraryFileIdResponse_MissingCountry{}
|
|
for _, countryName := range countryNames {
|
|
if len(countryName) == 0 {
|
|
continue
|
|
}
|
|
|
|
// 检查是否存在
|
|
countryId, err := regions.SharedRegionCountryDAO.FindCountryIdWithName(tx, countryName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if countryId > 0 {
|
|
continue
|
|
}
|
|
|
|
var pbMissingCountry = &pb.CheckCountriesWithIPLibraryFileIdResponse_MissingCountry{
|
|
CountryName: countryName,
|
|
SimilarCountries: nil,
|
|
}
|
|
|
|
// 查找相似
|
|
var similarCountries = regions.SharedRegionCountryDAO.FindSimilarCountries(allCountries, countryName, 5)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, similarCountry := range similarCountries {
|
|
pbMissingCountry.SimilarCountries = append(pbMissingCountry.SimilarCountries, &pb.RegionCountry{
|
|
Id: int64(similarCountry.ValueId),
|
|
Name: similarCountry.Name,
|
|
DisplayName: similarCountry.DisplayName(),
|
|
})
|
|
}
|
|
|
|
pbMissingCountries = append(pbMissingCountries, pbMissingCountry)
|
|
}
|
|
|
|
return &pb.CheckCountriesWithIPLibraryFileIdResponse{
|
|
MissingCountries: pbMissingCountries,
|
|
}, nil
|
|
}
|
|
|
|
// CheckProvincesWithIPLibraryFileId 检查省份/州
|
|
func (this *IPLibraryFileService) CheckProvincesWithIPLibraryFileId(ctx context.Context, req *pb.CheckProvincesWithIPLibraryFileIdRequest) (*pb.CheckProvincesWithIPLibraryFileIdResponse, error) {
|
|
_, err := this.ValidateAdmin(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var tx = this.NullTx()
|
|
|
|
provinces, err := models.SharedIPLibraryFileDAO.FindLibraryFileProvinces(tx, req.IpLibraryFileId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var countryMap = map[string]int64{} // countryName => countryId
|
|
var provinceNamesMap = map[int64][][2]string{} // countryId => [][2]{countryName, provinceName}
|
|
var countryIds = []int64{}
|
|
for _, province := range provinces {
|
|
var countryName = province[0]
|
|
var provinceName = province[1]
|
|
|
|
countryId, ok := countryMap[countryName]
|
|
if ok {
|
|
provinceNamesMap[countryId] = append(provinceNamesMap[countryId], [2]string{countryName, provinceName})
|
|
continue
|
|
}
|
|
|
|
countryId, err := regions.SharedRegionCountryDAO.FindCountryIdWithName(tx, countryName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
countryMap[countryName] = countryId
|
|
|
|
provinceNamesMap[countryId] = append(provinceNamesMap[countryId], [2]string{countryName, provinceName})
|
|
|
|
if countryId > 0 && !lists.ContainsInt64(countryIds, countryId) {
|
|
countryIds = append(countryIds, countryId)
|
|
}
|
|
}
|
|
|
|
var pbMissingProvinces = []*pb.CheckProvincesWithIPLibraryFileIdResponse_MissingProvince{}
|
|
for _, countryId := range countryIds {
|
|
allProvinces, err := regions.SharedRegionProvinceDAO.FindAllEnabledProvincesWithCountryId(tx, countryId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, province := range provinceNamesMap[countryId] {
|
|
var countryName = province[0]
|
|
var provinceName = province[1]
|
|
provinceId, err := regions.SharedRegionProvinceDAO.FindProvinceIdWithName(tx, countryId, provinceName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if provinceId > 0 {
|
|
continue
|
|
}
|
|
|
|
var similarProvinces = regions.SharedRegionProvinceDAO.FindSimilarProvinces(allProvinces, provinceName, 5)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var pbMissingProvince = &pb.CheckProvincesWithIPLibraryFileIdResponse_MissingProvince{}
|
|
pbMissingProvince.CountryName = countryName
|
|
pbMissingProvince.ProvinceName = provinceName
|
|
|
|
for _, similarProvince := range similarProvinces {
|
|
pbMissingProvince.SimilarProvinces = append(pbMissingProvince.SimilarProvinces, &pb.RegionProvince{
|
|
Id: int64(similarProvince.ValueId),
|
|
Name: similarProvince.Name,
|
|
DisplayName: similarProvince.DisplayName(),
|
|
})
|
|
}
|
|
pbMissingProvinces = append(pbMissingProvinces, pbMissingProvince)
|
|
}
|
|
}
|
|
|
|
return &pb.CheckProvincesWithIPLibraryFileIdResponse{MissingProvinces: pbMissingProvinces}, nil
|
|
}
|
|
|
|
// CheckCitiesWithIPLibraryFileId 检查城市/市
|
|
func (this *IPLibraryFileService) CheckCitiesWithIPLibraryFileId(ctx context.Context, req *pb.CheckCitiesWithIPLibraryFileIdRequest) (*pb.CheckCitiesWithIPLibraryFileIdResponse, error) {
|
|
_, err := this.ValidateAdmin(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var tx = this.NullTx()
|
|
|
|
cities, err := models.SharedIPLibraryFileDAO.FindLibraryFileCities(tx, req.IpLibraryFileId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var countryMap = map[string]int64{} // countryName => countryId
|
|
var provinceMap = map[string]int64{} // countryId_provinceName => provinceId
|
|
var cityNamesMap = map[int64][][3]string{} // provinceId => [][3]{countryName, provinceName, cityName}
|
|
var provinceIds = []int64{}
|
|
for _, city := range cities {
|
|
var countryName = city[0]
|
|
var provinceName = city[1]
|
|
var cityName = city[2]
|
|
|
|
countryId, ok := countryMap[countryName]
|
|
if !ok {
|
|
countryId, err = regions.SharedRegionCountryDAO.FindCountryIdWithName(tx, countryName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
countryMap[countryName] = countryId
|
|
|
|
var key = types.String(countryId) + "_" + provinceName
|
|
provinceId, ok := provinceMap[key]
|
|
if ok {
|
|
cityNamesMap[provinceId] = append(cityNamesMap[provinceId], [3]string{countryName, provinceName, cityName})
|
|
} else {
|
|
provinceId, err := regions.SharedRegionProvinceDAO.FindProvinceIdWithName(tx, countryId, provinceName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
provinceMap[key] = provinceId
|
|
cityNamesMap[provinceId] = append(cityNamesMap[provinceId], [3]string{countryName, provinceName, cityName})
|
|
if provinceId > 0 {
|
|
provinceIds = append(provinceIds, provinceId)
|
|
}
|
|
}
|
|
}
|
|
|
|
var pbMissingCities = []*pb.CheckCitiesWithIPLibraryFileIdResponse_MissingCity{}
|
|
for _, provinceId := range provinceIds {
|
|
allCities, err := regions.SharedRegionCityDAO.FindAllEnabledCitiesWithProvinceId(tx, provinceId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, city := range cityNamesMap[provinceId] {
|
|
var countryName = city[0]
|
|
var provinceName = city[1]
|
|
var cityName = city[2]
|
|
cityId, err := regions.SharedRegionCityDAO.FindCityIdWithName(tx, provinceId, cityName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if cityId > 0 {
|
|
continue
|
|
}
|
|
|
|
var similarCities = regions.SharedRegionCityDAO.FindSimilarCities(allCities, cityName, 5)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var pbMissingCity = &pb.CheckCitiesWithIPLibraryFileIdResponse_MissingCity{}
|
|
pbMissingCity.CountryName = countryName
|
|
pbMissingCity.ProvinceName = provinceName
|
|
pbMissingCity.CityName = cityName
|
|
|
|
for _, similarCity := range similarCities {
|
|
pbMissingCity.SimilarCities = append(pbMissingCity.SimilarCities, &pb.RegionCity{
|
|
Id: int64(similarCity.ValueId),
|
|
Name: similarCity.Name,
|
|
DisplayName: similarCity.DisplayName(),
|
|
})
|
|
}
|
|
pbMissingCities = append(pbMissingCities, pbMissingCity)
|
|
}
|
|
}
|
|
|
|
return &pb.CheckCitiesWithIPLibraryFileIdResponse{MissingCities: pbMissingCities}, nil
|
|
}
|
|
|
|
// CheckTownsWithIPLibraryFileId 检查区县
|
|
func (this *IPLibraryFileService) CheckTownsWithIPLibraryFileId(ctx context.Context, req *pb.CheckTownsWithIPLibraryFileIdRequest) (*pb.CheckTownsWithIPLibraryFileIdResponse, error) {
|
|
_, err := this.ValidateAdmin(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var tx = this.NullTx()
|
|
|
|
towns, err := models.SharedIPLibraryFileDAO.FindLibraryFileTowns(tx, req.IpLibraryFileId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var countryMap = map[string]int64{} // countryName => countryId
|
|
var provinceMap = map[string]int64{} // countryId_provinceName => provinceId
|
|
var cityMap = map[string]int64{} // province_cityName => cityId
|
|
|
|
var townNamesMap = map[int64][][4]string{} // cityId => [][4]{countryName, provinceName, cityName, townName}
|
|
var cityIds = []int64{}
|
|
for _, town := range towns {
|
|
var countryName = town[0]
|
|
var provinceName = town[1]
|
|
var cityName = town[2]
|
|
var townName = town[3]
|
|
|
|
// country
|
|
countryId, ok := countryMap[countryName]
|
|
if !ok {
|
|
countryId, err = regions.SharedRegionCountryDAO.FindCountryIdWithName(tx, countryName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
countryMap[countryName] = countryId
|
|
|
|
// province
|
|
var provinceKey = types.String(countryId) + "_" + provinceName
|
|
provinceId, ok := provinceMap[provinceKey]
|
|
if !ok {
|
|
if countryId > 0 {
|
|
provinceId, err = regions.SharedRegionProvinceDAO.FindProvinceIdWithName(tx, countryId, provinceName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
provinceMap[provinceKey] = provinceId
|
|
}
|
|
|
|
// city
|
|
var cityKey = types.String(provinceId) + "_" + cityName
|
|
cityId, ok := cityMap[cityKey]
|
|
if !ok {
|
|
if provinceId > 0 {
|
|
cityId, err = regions.SharedRegionCityDAO.FindCityIdWithName(tx, provinceId, cityName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
cityMap[cityKey] = cityId
|
|
if cityId > 0 {
|
|
cityIds = append(cityIds, cityId)
|
|
}
|
|
}
|
|
|
|
// town
|
|
townNamesMap[cityId] = append(townNamesMap[cityId], [4]string{countryName, provinceName, cityName, townName})
|
|
}
|
|
|
|
var pbMissingTowns = []*pb.CheckTownsWithIPLibraryFileIdResponse_MissingTown{}
|
|
for _, cityId := range cityIds {
|
|
allTowns, err := regions.SharedRegionTownDAO.FindAllRegionTownsWithCityId(tx, cityId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, town := range townNamesMap[cityId] {
|
|
var countryName = town[0]
|
|
var provinceName = town[1]
|
|
var cityName = town[2]
|
|
var townName = town[3]
|
|
|
|
townId, err := regions.SharedRegionTownDAO.FindTownIdWithName(tx, cityId, townName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if townId > 0 {
|
|
// 已存在，则跳过
|
|
continue
|
|
}
|
|
|
|
var similarTowns = regions.SharedRegionTownDAO.FindSimilarTowns(allTowns, townName, 5)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var pbMissingTown = &pb.CheckTownsWithIPLibraryFileIdResponse_MissingTown{}
|
|
pbMissingTown.CountryName = countryName
|
|
pbMissingTown.ProvinceName = provinceName
|
|
pbMissingTown.CityName = cityName
|
|
pbMissingTown.TownName = townName
|
|
|
|
for _, similarTown := range similarTowns {
|
|
pbMissingTown.SimilarTowns = append(pbMissingTown.SimilarTowns, &pb.RegionTown{
|
|
Id: int64(similarTown.ValueId),
|
|
Name: similarTown.Name,
|
|
DisplayName: similarTown.DisplayName(),
|
|
})
|
|
}
|
|
pbMissingTowns = append(pbMissingTowns, pbMissingTown)
|
|
}
|
|
}
|
|
|
|
return &pb.CheckTownsWithIPLibraryFileIdResponse{MissingTowns: pbMissingTowns}, nil
|
|
}
|
|
|
|
// CheckProvidersWithIPLibraryFileId 检查ISP运营商
|
|
func (this *IPLibraryFileService) CheckProvidersWithIPLibraryFileId(ctx context.Context, req *pb.CheckProvidersWithIPLibraryFileIdRequest) (*pb.CheckProvidersWithIPLibraryFileIdResponse, error) {
|
|
_, err := this.ValidateAdmin(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var tx = this.NullTx()
|
|
|
|
allProviders, err := regions.SharedRegionProviderDAO.FindAllEnabledProviders(tx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
providerNames, err := models.SharedIPLibraryFileDAO.FindLibraryFileProviders(tx, req.IpLibraryFileId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var pbMissingProviders = []*pb.CheckProvidersWithIPLibraryFileIdResponse_MissingProvider{}
|
|
for _, providerName := range providerNames {
|
|
if len(providerName) == 0 {
|
|
continue
|
|
}
|
|
|
|
// 检查是否存在
|
|
providerId, err := regions.SharedRegionProviderDAO.FindProviderIdWithName(tx, providerName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if providerId > 0 {
|
|
continue
|
|
}
|
|
|
|
var pbMissingProvider = &pb.CheckProvidersWithIPLibraryFileIdResponse_MissingProvider{
|
|
ProviderName: providerName,
|
|
SimilarProviders: nil,
|
|
}
|
|
|
|
// 查找相似
|
|
var similarProviders = regions.SharedRegionProviderDAO.FindSimilarProviders(allProviders, providerName, 5)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, similarProvider := range similarProviders {
|
|
pbMissingProvider.SimilarProviders = append(pbMissingProvider.SimilarProviders, &pb.RegionProvider{
|
|
Id: int64(similarProvider.ValueId),
|
|
Name: similarProvider.Name,
|
|
DisplayName: similarProvider.DisplayName(),
|
|
})
|
|
}
|
|
|
|
pbMissingProviders = append(pbMissingProviders, pbMissingProvider)
|
|
}
|
|
|
|
return &pb.CheckProvidersWithIPLibraryFileIdResponse{
|
|
MissingProviders: pbMissingProviders,
|
|
}, nil
|
|
}
|
|
|
|
// GenerateIPLibraryFile 生成IP库文件
|
|
func (this *IPLibraryFileService) GenerateIPLibraryFile(ctx context.Context, req *pb.GenerateIPLibraryFileRequest) (*pb.RPCSuccess, error) {
|
|
_, err := this.ValidateAdmin(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var tx = this.NullTx()
|
|
err = models.SharedIPLibraryFileDAO.GenerateIPLibrary(tx, req.IpLibraryFileId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return this.Success()
|
|
}
|
|
|
|
// UpdateIPLibraryFileFinished 设置某个IP库为已完成
|
|
func (this *IPLibraryFileService) UpdateIPLibraryFileFinished(ctx context.Context, req *pb.UpdateIPLibraryFileFinishedRequest) (*pb.RPCSuccess, error) {
|
|
_, err := this.ValidateAdmin(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var tx = this.NullTx()
|
|
err = models.SharedIPLibraryFileDAO.UpdateLibraryFileIsFinished(tx, req.IpLibraryFileId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return this.Success()
|
|
}
|
|
|
|
// DeleteIPLibraryFile 删除IP库文件
|
|
func (this *IPLibraryFileService) DeleteIPLibraryFile(ctx context.Context, req *pb.DeleteIPLibraryFileRequest) (*pb.RPCSuccess, error) {
|
|
_, err := this.ValidateAdmin(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var tx = this.NullTx()
|
|
err = models.SharedIPLibraryFileDAO.DisableIPLibraryFile(tx, req.IpLibraryFileId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return this.Success()
|
|
}
|