This repository has been archived by the owner on Oct 2, 2020. It is now read-only.
forked from baidubce/terraform-provider-baiducloud
/
data_source_common_schema.go
125 lines (104 loc) · 2.5 KB
/
data_source_common_schema.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
package baiducloud
import (
"regexp"
"strconv"
"github.com/hashicorp/terraform/helper/schema"
)
type DataSourceFilter map[string][]FilterConfig
type FilterConfig struct {
strFilterValue string
regFilterValue *regexp.Regexp
}
func dataSourceFiltersSchema() *schema.Schema {
return &schema.Schema{
Type: schema.TypeSet,
Description: "only support filter string/int/bool value",
Optional: true,
ForceNew: true,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"name": {
Type: schema.TypeString,
Description: "filter variable name",
Required: true,
},
"values": {
Type: schema.TypeList,
Description: "filter variable value list",
Required: true,
Elem: &schema.Schema{Type: schema.TypeString},
},
},
},
}
}
func NewDataSourceFilter(d *schema.ResourceData) DataSourceFilter {
fConfig, ok := d.GetOk("filter")
if !ok {
return nil
}
fList := fConfig.(*schema.Set).List()
result := make(DataSourceFilter)
for _, f := range fList {
filter := f.(map[string]interface{})
filterValue := filter["values"].([]interface{})
filterConfig := make([]FilterConfig, 0)
for _, v := range filterValue {
fConfigValue := FilterConfig{
strFilterValue: v.(string),
}
reg, err := regexp.Compile(fConfigValue.strFilterValue)
if err == nil {
fConfigValue.regFilterValue = reg
}
filterConfig = append(filterConfig, fConfigValue)
}
result[filter["name"].(string)] = filterConfig
}
return result
}
func (f *DataSourceFilter) checkFilter(data map[string]interface{}) bool {
for key, fValue := range *f {
if d, ok := data[key]; ok {
checkResult := false
for _, fConfig := range fValue {
if fConfig.checkValue(d) {
checkResult = true
break
}
}
if !checkResult {
return false
}
}
}
return true
}
func (c *FilterConfig) checkValue(value interface{}) bool {
checkValue := ""
switch v := value.(type) {
case string:
checkValue = v
case int:
checkValue = strconv.Itoa(v)
case bool:
checkValue = strconv.FormatBool(v)
default:
return true
}
if checkValue == c.strFilterValue {
return true
}
if c.regFilterValue != nil && c.regFilterValue.MatchString(checkValue) {
return true
}
return false
}
func FilterDataSourceResult(d *schema.ResourceData, result *[]map[string]interface{}) {
filter := NewDataSourceFilter(d)
for i, data := range *result {
if !filter.checkFilter(data) {
*result = append((*result)[:i], (*result)[i+1:]...)
}
}
}