Coverage for scripts / get_request_type_fields.py: 0%

1#!/usr/bin/env python3 

2""" 

3Get fields for a JSM request type. 

4 

5Usage: 

6 python get_request_type_fields.py 1 25 

7 python get_request_type_fields.py 1 25 --output json 

8 python get_request_type_fields.py 1 25 --required-only 

9 python get_request_type_fields.py 1 25 --show-valid-values 

10""" 

11 

12import sys 

13import os 

14import argparse 

15import json 

16from pathlib import Path 

17 

18sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent / 'shared' / 'scripts' / 'lib')) 

19 

20from config_manager import get_jira_client 

21from error_handler import print_error, JiraError 

22from formatters import format_json 

23 

24 

25def get_request_type_fields(service_desk_id: str, request_type_id: str, profile: str = None) -> dict: 

26 """ 

27 Get fields for a request type. 

28 

29 Args: 

30 service_desk_id: Service desk ID 

31 request_type_id: Request type ID 

32 profile: JIRA profile to use 

33 

34 Returns: 

35 Fields data 

36 """ 

37 client = get_jira_client(profile) 

38 fields = client.get_request_type_fields(service_desk_id, request_type_id) 

39 client.close() 

40 

41 return fields 

42 

43 

44def filter_fields(fields_data: dict, required_only: bool = False) -> dict: 

45 """ 

46 Filter fields by required status. 

47 

48 Args: 

49 fields_data: Fields data 

50 required_only: Show only required fields 

51 

52 Returns: 

53 Filtered fields data 

54 """ 

55 if not required_only: 

56 return fields_data 

57 

58 filtered_fields = [ 

59 field for field in fields_data.get('requestTypeFields', []) 

60 if field.get('required', False) 

61 ] 

62 

63 return { 

64 **fields_data, 

65 'requestTypeFields': filtered_fields 

66 } 

67 

68 

69def format_fields_text(fields_data: dict, request_type_name: str = "Request Type", show_valid_values: bool = False) -> None: 

70 """ 

71 Format fields as human-readable text. 

72 

73 Args: 

74 fields_data: Fields data 

75 request_type_name: Request type name for display 

76 show_valid_values: Show valid values for fields 

77 """ 

78 all_fields = fields_data.get('requestTypeFields', []) 

79 required_fields = [f for f in all_fields if f.get('required', False)] 

80 optional_fields = [f for f in all_fields if not f.get('required', False)] 

81 

82 print(f"Request Type Fields: {request_type_name}") 

83 print() 

84 

85 if required_fields: 

86 print("Required Fields:") 

87 print("─" * 80) 

88 print(f"{'Field ID':<20} {'Name':<20} {'Type':<15}") 

89 print(f"{'────────':<20} {'────':<20} {'────':<15}") 

90 

91 for field in required_fields: 

92 field_id = field.get('fieldId', '') 

93 name = field.get('name', '')[:18] 

94 field_type = field.get('jiraSchema', {}).get('type', 'unknown') 

95 

96 print(f"{field_id:<20} {name:<20} {field_type:<15}") 

97 

98 if show_valid_values and 'validValues' in field: 

99 valid_values = field.get('validValues', []) 

100 if valid_values: 

101 values_str = ', '.join([v.get('label', v.get('value', '')) for v in valid_values[:5]]) 

102 if len(valid_values) > 5: 

103 values_str += f" (+{len(valid_values) - 5} more)" 

104 print(f" Valid values: {values_str}") 

105 

106 print() 

107 

108 if optional_fields: 

109 print("Optional Fields:") 

110 print("─" * 80) 

111 print(f"{'Field ID':<20} {'Name':<20} {'Type':<15}") 

112 print(f"{'────────':<20} {'────':<20} {'────':<15}") 

113 

114 for field in optional_fields: 

115 field_id = field.get('fieldId', '') 

116 name = field.get('name', '')[:18] 

117 field_type = field.get('jiraSchema', {}).get('type', 'unknown') 

118 

119 print(f"{field_id:<20} {name:<20} {field_type:<15}") 

120 

121 if show_valid_values and 'validValues' in field: 

122 valid_values = field.get('validValues', []) 

123 if valid_values: 

124 values_str = ', '.join([v.get('label', v.get('value', '')) for v in valid_values[:5]]) 

125 if len(valid_values) > 5: 

126 values_str += f" (+{len(valid_values) - 5} more)" 

127 print(f" Valid values: {values_str}") 

128 

129 print() 

130 

131 print("Configuration:") 

132 print(f" Can raise on behalf of: {'Yes' if fields_data.get('canRaiseOnBehalfOf', False) else 'No'}") 

133 print(f" Can add participants: {'Yes' if fields_data.get('canAddRequestParticipants', False) else 'No'}") 

134 print() 

135 print(f"Total: {len(required_fields)} required field{'s' if len(required_fields) != 1 else ''}, {len(optional_fields)} optional field{'s' if len(optional_fields) != 1 else ''}") 

136 

137 

138def format_fields_json(fields_data: dict) -> str: 

139 """ 

140 Format fields as JSON. 

141 

142 Args: 

143 fields_data: Fields data 

144 

145 Returns: 

146 JSON string 

147 """ 

148 return format_json(fields_data) 

149 

150 

151def main(): 

152 parser = argparse.ArgumentParser( 

153 description='Get fields for a JSM request type', 

154 epilog='Example: python get_request_type_fields.py 1 25' 

155 ) 

156 

157 parser.add_argument('service_desk_id', 

158 help='Service desk ID') 

159 parser.add_argument('request_type_id', 

160 help='Request type ID') 

161 parser.add_argument('--output', '-o', 

162 choices=['text', 'json'], 

163 default='text', 

164 help='Output format (default: text)') 

165 parser.add_argument('--required-only', '-r', 

166 action='store_true', 

167 help='Show only required fields') 

168 parser.add_argument('--show-valid-values', '-v', 

169 action='store_true', 

170 help='Show valid values for fields') 

171 parser.add_argument('--profile', 

172 help='JIRA profile to use (default: from config)') 

173 

174 args = parser.parse_args() 

175 

176 try: 

177 # Fetch fields 

178 fields_data = get_request_type_fields( 

179 args.service_desk_id, 

180 args.request_type_id, 

181 profile=args.profile 

182 ) 

183 

184 # Apply filters 

185 if args.required_only: 

186 fields_data = filter_fields(fields_data, required_only=True) 

187 

188 # Get request type name for display 

189 client = get_jira_client(args.profile) 

190 request_type = client.get_request_type(args.service_desk_id, args.request_type_id) 

191 request_type_name = request_type.get('name', 'Request Type') 

192 client.close() 

193 

194 # Output results 

195 if args.output == 'json': 

196 print(format_fields_json(fields_data)) 

197 else: 

198 format_fields_text(fields_data, request_type_name, args.show_valid_values) 

199 

200 except JiraError as e: 

201 print_error(e) 

202 sys.exit(1) 

203 except Exception as e: 

204 print_error(e, debug=True) 

205 sys.exit(1) 

206 

207 

208if __name__ == '__main__': 

209 main()