| 1 |  |  | import xml.dom.minidom | 
            
                                                                                                            
                            
            
                                    
            
            
                | 2 |  |  | import xml.etree.ElementTree as ET | 
            
                                                                                                            
                            
            
                                    
            
            
                | 3 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 4 |  |  | from Doc import Doc | 
            
                                                                                                            
                            
            
                                    
            
            
                | 5 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 6 |  |  | class Request(Doc): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 7 |  |  |     def __init__(self, data): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 8 |  |  |         self.data       = data | 
            
                                                                                                            
                            
            
                                    
            
            
                | 9 |  |  |         self.raw        = None | 
            
                                                                                                            
                            
            
                                    
            
            
                | 10 |  |  |         self.epp        = None | 
            
                                                                                                            
                            
            
                                    
            
            
                | 11 |  |  |         self.command    = None | 
            
                                                                                                            
                            
            
                                    
            
            
                | 12 |  |  |         self.extension  = None | 
            
                                                                                                            
                            
            
                                    
            
            
                | 13 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 14 |  |  |     def __str__(self, encoding='UTF-8', method='xml'): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 15 |  |  |         if self.raw is None: | 
            
                                                                                                            
                            
            
                                    
            
            
                | 16 |  |  |             return ET.tostring(self.epp, encoding, method) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 17 |  |  |         else: | 
            
                                                                                                            
                            
            
                                    
            
            
                | 18 |  |  |             return self.raw | 
            
                                                                                                            
                            
            
                                    
            
            
                | 19 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 20 |  |  |     def element(self, tag, attrs = {}, text = None): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 21 |  |  |         res = ET.Element(tag, attrs) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 22 |  |  |         if text is not None: | 
            
                                                                                                            
                            
            
                                    
            
            
                | 23 |  |  |             res.text = str(text) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 24 |  |  |         return res | 
            
                                                                                                            
                            
            
                                    
            
            
                | 25 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 26 |  |  |     def sub(self, parent, tag, attrs = {}, text = None): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 27 |  |  |         res = ET.SubElement(parent, tag, attrs) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 28 |  |  |         if text is not None: | 
            
                                                                                                            
                            
            
                                    
            
            
                | 29 |  |  |             res.text = str(text) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 30 |  |  |         return res | 
            
                                                                                                            
                                                                
            
                                    
            
            
                | 31 |  |  |  | 
            
                                                                        
                            
            
                                    
            
            
                | 32 |  |  |     def subfields(self, parent, fields, values = None): | 
            
                                                                        
                            
            
                                    
            
            
                | 33 |  |  |         name = parent.tag.split(':')[0] | 
            
                                                                        
                            
            
                                    
            
            
                | 34 |  |  |         for field, attrs in fields.iteritems(): | 
            
                                                                        
                            
            
                                    
            
            
                | 35 |  |  |             value = self.get(field) if values is None else values.get(field) | 
            
                                                                        
                            
            
                                    
            
            
                | 36 |  |  |             if value: | 
            
                                                                        
                            
            
                                    
            
            
                | 37 |  |  |                 self.sub(parent, name + ':' + field, attrs, value) | 
            
                                                                        
                            
            
                                    
            
            
                | 38 |  |  |         return parent | 
            
                                                                                                            
                            
            
                                    
            
            
                | 39 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 40 |  |  |     @staticmethod | 
            
                                                                                                            
                            
            
                                    
            
            
                | 41 |  |  |     def build(command, data, extensions = {}): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 42 |  |  |         request = Request(data) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 43 |  |  |         request.render(command) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 44 |  |  |         for ext in extensions.itervalues(): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 45 |  |  |             request.render(ext) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 46 |  |  |         request.render('epp:clTRID') | 
            
                                                                                                            
                            
            
                                    
            
            
                | 47 |  |  |         return request | 
            
                                                                                                            
                            
            
                                    
            
            
                | 48 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 49 |  |  |     @staticmethod | 
            
                                                                                                            
                            
            
                                    
            
            
                | 50 |  |  |     def buildFromArgs(args): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 51 |  |  |         extensions = args.get('extensions') or {} | 
            
                                                                                                            
                            
            
                                    
            
            
                | 52 |  |  |         if extensions == {} and 'extension' in args: | 
            
                                                                                                            
                            
            
                                    
            
            
                | 53 |  |  |             extensions = {'0': args.get('extension')} | 
            
                                                                                                            
                            
            
                                    
            
            
                | 54 |  |  |         return Request.build(args.get('command'), args, extensions) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 55 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 56 |  |  |     def render(self, command): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 57 |  |  |         ns = command.split(':')[0] | 
            
                                                                                                            
                            
            
                                    
            
            
                | 58 |  |  |         name = command.split(':')[1] | 
            
                                                                                                            
                            
            
                                    
            
            
                | 59 |  |  |         module = self.get_module(ns) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 60 |  |  |         method = 'render_' + name | 
            
                                                                                                            
                            
            
                                    
            
            
                | 61 |  |  |         if not hasattr(module, method): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 62 |  |  |             raise Exception('unknown command', ns + ':' + name) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 63 |  |  |         getattr(module, method)(self) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 64 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 65 |  |  |     @staticmethod | 
            
                                                                                                            
                            
            
                                    
            
            
                | 66 |  |  |     def prettifyxml(request): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 67 |  |  |         string = str(request) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 68 |  |  |         if string[0] != '<': | 
            
                                                                                                            
                            
            
                                    
            
            
                | 69 |  |  |             return string | 
            
                                                                                                            
                            
            
                                    
            
            
                | 70 |  |  |         dom = xml.dom.minidom.parseString(string) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 71 |  |  |         return dom.toprettyxml(indent='    ') | 
            
                                                                                                            
                                                                
            
                                    
            
            
                | 72 |  |  |  | 
            
                                                        
            
                                    
            
            
                | 73 |  |  |  |