1# --------------------------------------------------------------------------------------------
2# Copyright (c) Microsoft Corporation. All rights reserved.
3# Licensed under the MIT License. See License.txt in the project root for license information.
4# --------------------------------------------------------------------------------------------
5
6
7def transform_ip_addresses(result):
8    from collections import OrderedDict
9    transformed = []
10    for r in result:
11        network = r['virtualMachine']['network']
12        public = network.get('publicIpAddresses')
13        public_ip_addresses = ','.join([p['ipAddress'] for p in public if p['ipAddress']]) if public else None
14        private = network.get('privateIpAddresses')
15        private_ip_addresses = ','.join(private) if private else None
16        entry = OrderedDict([('virtualMachine', r['virtualMachine']['name']),
17                             ('publicIPAddresses', public_ip_addresses),
18                             ('privateIPAddresses', private_ip_addresses)])
19        transformed.append(entry)
20
21    return transformed
22
23
24def transform_vm(vm):
25    from collections import OrderedDict
26    result = OrderedDict([('name', vm['name']),
27                          ('resourceGroup', vm['resourceGroup']),
28                          ('powerState', vm.get('powerState')),
29                          ('publicIps', vm.get('publicIps')),
30                          ('fqdns', vm.get('fqdns')),
31                          ('location', vm['location'])])
32    if 'zones' in vm:
33        result['zones'] = ','.join(vm['zones']) if vm['zones'] else ''
34    return result
35
36
37def transform_vm_create_output(result):
38    from msrestazure.tools import parse_resource_id
39    from collections import OrderedDict
40    try:
41        resource_group = getattr(result, 'resource_group', None) or parse_resource_id(result.id)['resource_group']
42        output = OrderedDict([('id', result.id),
43                              ('resourceGroup', resource_group),
44                              ('powerState', result.power_state),
45                              ('publicIpAddress', result.public_ips),
46                              ('fqdns', result.fqdns),
47                              ('privateIpAddress', result.private_ips),
48                              ('macAddress', result.mac_addresses),
49                              ('location', result.location)])
50        if getattr(result, 'identity', None):
51            output['identity'] = result.identity
52        if hasattr(result, 'zones'):  # output 'zones' column even the property value is None
53            output['zones'] = result.zones[0] if result.zones else ''
54        return output
55    except AttributeError:
56        from msrest.pipeline import ClientRawResponse
57        return None if isinstance(result, ClientRawResponse) else result
58
59
60def transform_vm_usage_list(result):
61    result = list(result)
62    for item in result:
63        item.current_value = str(item.current_value)
64        item.limit = str(item.limit)
65        item.local_name = item.name.localized_value
66    return result
67
68
69def transform_vm_list(vm_list):
70    return [transform_vm(v) for v in vm_list]
71
72
73# flattern out important fields (single member arrays) to be displayed in the table output
74def transform_sku_for_table_output(skus):
75    from collections import OrderedDict
76    result = []
77    for k in skus:
78        order_dict = OrderedDict()
79        order_dict['resourceType'] = k['resourceType']
80        order_dict['locations'] = str(k['locations']) if len(k['locations']) > 1 else k['locations'][0]
81        order_dict['name'] = k['name']
82        if k.get('locationInfo'):
83            order_dict['zones'] = ','.join(sorted(k['locationInfo'][0].get('zones', [])))
84        else:
85            order_dict['zones'] = 'None'
86        if k['restrictions']:
87            reasons = []
88            for x in k['restrictions']:
89                reason = x['reasonCode']
90                if x['type']:
91                    reason += ', type: ' + x['type']
92                if x['restrictionInfo']['locations']:
93                    reason += ', locations: ' + ','.join(x['restrictionInfo']['locations'])
94                if x['restrictionInfo']['zones']:
95                    reason += ', zones: ' + ','.join(x['restrictionInfo']['zones'])
96                reasons.append(reason)
97            order_dict['restrictions'] = str(reasons) if len(reasons) > 1 else reasons[0]
98        else:
99            order_dict['restrictions'] = 'None'
100        for k2 in order_dict:
101            order_dict[k2] = order_dict[k2] if order_dict[k2] is not None else 'None'
102        result.append(order_dict)
103    return result
104
105
106transform_extension_show_table_output = '{Name:name, ProvisioningState:provisioningState, Publisher:publisher, ' \
107                                        'Version:typeHandlerVersion, AutoUpgradeMinorVersion:autoUpgradeMinorVersion}'
108
109
110transform_disk_show_table_output = '{Name:name, ResourceGroup:resourceGroup, Location:location, Zones: ' \
111                                   '(!zones && \' \') || join(` `, zones), Sku:sku.name, OsType:osType, ' \
112                                   'SizeGb:diskSizeGb, ProvisioningState:provisioningState}'
113
114
115def get_vmss_table_output_transformer(loader, for_list=True):
116    transform = '{Name:name, ResourceGroup:resourceGroup, Location:location, $zone$Capacity:sku.capacity, ' \
117                'Overprovision:overprovision, UpgradePolicy:upgradePolicy.mode}'
118    transform = transform.replace('$zone$', 'Zones: (!zones && \' \') || join(\' \', zones), '
119                                  if loader.supported_api_version(min_api='2017-03-30') else ' ')
120    return transform if not for_list else '[].' + transform
121
122
123def transform_vm_encryption_show_table_output(result):
124    from collections import OrderedDict
125    if result.get("status", []):
126        status_dict = result["status"][0]
127        return OrderedDict([("status", status_dict.get("displayStatus", "N/A")),
128                            ("message", status_dict.get("message", "N/A"))])
129    return result
130
131
132def transform_log_analytics_query_output(result):
133    from collections import OrderedDict
134    tables_output = []
135
136    def _transform_query_output(table):
137        columns = table.columns
138        name = table.name
139        rows = table.rows
140
141        column_names = []
142        table_output = []
143        for column in columns:
144            column_names.append(column.name)
145        for row in rows:
146            item = OrderedDict()
147            item['TableName'] = name
148            for index, value in enumerate(row):
149                item[column_names[index]] = str(value)
150            table_output.append(item)
151        return table_output
152
153    for table in result.tables:
154        table_output = _transform_query_output(table)
155        tables_output.extend(table_output)
156
157    return tables_output
158